CrookedNumber

Removing the last commit

To remove the last commit from git, you can simply run git reset --hard HEAD^ If you are removing multiple commits from the top, you can run git reset --hard HEAD~2 to remove the last two commits. You can increase the number to remove even more commits.

If you want to "uncommit" the commits, but keep the changes around for reworking, remove the "--hard": git reset HEAD^ which will evict the commits from the branch and from the index, but leave the working tree around.

If you want to save the commits on a new branch name, then run git branch newbranchname before doing the git reset.

qoomon

Conventional Commit Messages

See how a minor change to your commit message style can make a difference.

Tip

Take a look at git-conventional-commits , a CLI util to ensure these conventions, determine version and generate changelogs

Commit Message Formats

Default

dusekdan

import win32gui
import re

class WindowMgr:
    """Encapsulates some calls to the winapi for window management"""

    def __init__ (self):
        """Constructor"""
        self._handle = None
        

vtenq

Git workflow with conventional commits and semantic auto release

This is an adoptation of Git flow by Vincent Driessen with conventional commits and semantic release.

The main concepts

At the core, the development model is greatly inspired by existing models out there. The central repo holds two main branches with an infinite lifetime:

Zekfad

Quick examples

• feat: new feature
• fix(scope): bug in scope
• feat!: breaking change / feat(scope)!: rework API
• chore(deps): update dependencies

Commit types

• build: Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)
• ci: Changes to CI configuration files and scripts (example scopes: Travis, Circle, BrowserStack, SauceLabs)
• chore: Changes which doesn't change source code or tests e.g. changes to the build process, auxiliary tools, libraries

HughParsons

import * as React from 'react'

export function HOC<T, P extends {}>(
    Component: React.ForwardRefExoticComponent<React.PropsWithoutRef<P> & React.RefAttributes<T>>
): React.ForwardRefExoticComponent<React.PropsWithoutRef<P> & React.RefAttributes<T>> {
    return React.forwardRef<T, P>(
        function ComponentFromHOC(props, ref) {
            return (
                <Component {...props as React.PropsWithoutRef<P>} ref={ref} />
            );

bennettdams

import { z } from 'zod'

const emptyStringToUndefined = z.literal('').transform(() => undefined)

/**
 * Provide a schema and get a schema that is optional and empty strings are transformed to `undefined`.
 * When someone removes his input of this field, the then empty string is transformed to `undefined`.
 *
 * Example:
 *

martinratinaud

[alias]
  # shortcuts
  c  = commit
  co = checkout
  cp = cherry-pick
  f = fetch

  # enhancements
  d  = diff -- ':!package-lock.json' ':!yarn.lock' # Do not show lock files when diffing
  ds  = diff --staged -- ':!package-lock.json' ':!yarn.lock' # Do not show lock files when diffing staged files

levvsha

function useOnClickOutside(
  ref: React.RefObject<HTMLDivElement>,
  handler: (event: TouchEvent | MouseEvent) => void,
) {
  useEffect(() => {
    const listener = (event: TouchEvent | MouseEvent) => {
      if (!ref.current || ref.current.contains(event.target as HTMLElement)) {
        return;
      }
      handler(event);

palashmon

/**
* A TypeScript type alias called `Prettify`.
* It takes a type as its argument and returns a new type that has the same properties as the original type, 
* but the properties are not intersected. This means that the new type is easier to read and understand.
*/
type Prettify<T> = {
	[K in keyof T]: T[K];
} & {};