Edit

Pre-commit Hook

You can use Prettier with a pre-commit tool. This can re-format your files that are marked as “staged” via git add before you commit.

Option 1. lint-staged

Use Case: Useful for when you want to use other code quality tools along with Prettier (e.g. ESLint, Stylelint, etc.) or if you need support for partially staged files (git add --patch).

Make sure Prettier is installed and is in your devDependencies before you proceed.

npx mrm@2 lint-staged

This will install husky and lint-staged, then add a configuration to the project’s package.json that will automatically format supported files in a pre-commit hook.

Read more at the lint-staged repo.

Option 2. pre-commit

Use Case: Great when working with multi-language projects.

Copy the following config into your .pre-commit-config.yaml file:

- repo: https://github.com/pre-commit/mirrors-prettier
  rev: "" # Use the sha or tag you want to point at
  hooks:
    - id: prettier

Read more at mirror of prettier package for pre-commit and the pre-commit website.

Option 3. Husky.Net

Use Case: A dotnet solution to use Prettier along with other code quality tools (e.g. dotnet-format, ESLint, Stylelint, etc.). It supports multiple file states (staged - last-commit, git-files etc.)

dotnet new tool-manifest
dotnet tool install husky
dotnet husky install
dotnet husky add pre-commit

after installation you can add prettier task to the task-runner.json.

{
  "command": "npx",
  "args": ["prettier", "--ignore-unknown", "--write", "${staged}"],
  "pathMode": "absolute"
}

Option 4. git-format-staged

Use Case: Great for when you want to format partially-staged files, and other options do not provide a good fit for your project.

Git-format-staged is used to run any formatter that can accept file content via stdin. It operates differently than other tools that format partially-staged files: it applies the formatter directly to objects in the git object database, and merges changes back to the working tree. This procedure provides several guarantees:

1. Changes in commits are always formatted.
2. Unstaged changes are never, under any circumstances staged during the formatting process.
3. If there are conflicts between formatted, staged changes and unstaged changes then your working tree files are left untouched - your work won’t be overwritten, and there are no stashes to clean up.
4. Unstaged changes are not formatted.

Git-format-staged requires Python v3 or v2.7. Python is usually pre-installed on Linux and macOS, but not on Windows. Use git-format-staged with husky:

npm

yarn

pnpm

npx husky-init
npm install --save-dev git-format-staged
npx husky set .husky/pre-commit "git-format-staged -f 'prettier --ignore-unknown --stdin --stdin-filepath \"{}\"' ."

npx husky-init # add --yarn2 for Yarn 2
yarn add --dev git-format-staged
yarn husky set .husky/pre-commit "git-format-staged -f 'prettier --ignore-unknown --stdin --stdin-filepath \"{}\"' ."

pnpm exec husky-init
pnpm add --save-dev git-format-staged
pnpm husky set .husky/pre-commit "git-format-staged -f 'prettier --ignore-unknown --stdin --stdin-filepath \"{}\"' ."

Add or remove file extensions to suit your project. Note that regardless of which extensions you list formatting will respect any .prettierignore files in your project.

To read about how git-format-staged works see Automatic Code Formatting for Partially-Staged Files.

Option 5. Shell script

Alternately you can save this script as .git/hooks/pre-commit and give it execute permission:

#!/bin/sh
FILES=$(git diff --cached --name-only --diff-filter=ACMR | sed 's| |\\ |g')
[ -z "$FILES" ] && exit 0

# Prettify all selected files
echo "$FILES" | xargs ./node_modules/.bin/prettier --ignore-unknown --write

# Add back the modified/prettified files to staging
echo "$FILES" | xargs git add

exit 0

If git is reporting that your prettified files are still modified after committing, you may need to add a post-commit script to update git’s index.

Add something like the following to .git/hooks/post-commit:

#!/bin/sh
git update-index -g