@razorness/prettier-config weekly downloads statistics

@razorness/prettier-config

Shareable Prettier config plus the printer plugin it needs, in one package.

pnpm add -D @razorness/prettier-config prettier

<!-- prettier-ignore -->

// package.json
{
    "prettier": "@razorness/prettier-config"
}

@ianvs/prettier-plugin-sort-imports, prettier-plugin-tailwindcss (when the project uses Tailwind) and this package's own plugin come along, resolved by absolute path — nothing else to install.

What it does

Prettier's own options, set to semi, singleQuote, printWidth: 160, endOfLine: 'lf', trailingComma: 'all', useTabs with tabWidth: 4, bracketSpacing, htmlWhitespaceSensitivity: 'ignore' and importOrder: ['<THIRD_PARTY_MODULES>', '^[.]'].

On top of that, six rules Prettier has no option for — all six at once, which also shows how they interact:

<!-- prettier-ignore -->

// before
const ids = [0];
const retries = 3;

const config = {
    name: 'widget',
    enabled: true,
};

class Widget {
    private cache = new Map();
    render(id: string) {
        const entry = this.cache.get(id);
        const label = entry ?? 'unknown';
        log(label);
        emit(label);
        return label;
    }
}

<!-- prettier-ignore -->

// after
const ids   = [ 0 ],
    retries = 3;

const config = {
    name   : 'widget',
    enabled: true,
};

class Widget {

    private cache = new Map();

    render(id: string) {

        const entry = this.cache.get(id),
            label   = entry ?? 'unknown';
        log(label);
        emit(label);
        return label;

    }

}

1. [0] became [ 0 ].
2. The adjacent consts became one declaration. config stayed out — its value spans lines.
3. Their = line up, and so do render's — note that ids got two spaces, not four: the padding is measured from the column each name starts in, and retries sits at an indent while ids sits behind const .
4. config's keys line up on the colon.
5. The class body gained a blank line at each end.
6. render runs past four lines, so it gained blank lines around it and inside its braces.

bracketSpacing already covers {foo:true} → { foo: true }, .json included.

What the rules refuse to do

• Array spacing only when the array fits on one line; a broken array is left as Prettier laid it out and [] stays []. Covers array literals, destructuring patterns and TS tuple types.
• Bundling skips mixed kinds, a blank line between, an attached comment, a multi-line initialiser, export/declare/using — and var, unless razMergeDeclarations: "all".
• = alignment only for declarators that are a plain identifier with an initialiser. Type annotations and destructuring make the left-hand width depend on layout, so those are skipped — without disqualifying the declaration and without counting towards the column, the same way key alignment skips shorthand and spread members. It pads the names and never touches indentation: continuation declarators stay at the plain indent Prettier gives them, and the padding is measured from the column each name starts in — keyword.length + 1 for the first, tabWidth for the rest — so the separators still land in one column. Aligning the indentation to the keyword width instead is what an earlier version did, and it cannot be done cleanly under useTabs: the keyword width is no multiple of tabWidth, so it needs spaces, and Prettier emits an align string ahead of the tabs of any nested indent. A declarator whose value spanned lines came out indented ' \t' — spaces before a tab.
• Key alignment only for objects already multi-line in the source — the same signal Prettier itself uses, which is what keeps it stable across runs. Also covers interface bodies and type literals. Shorthand properties, methods and spreads are skipped without splitting a group; computed keys are skipped entirely, since a computed key can contain its own :.
• Class body padding applies regardless of length. Empty bodies stay {}.

Block padding

Two halves, two options, one shared razBlockPaddingMinLines threshold — but they weigh different things, which is visible in the output:

	measures	at the default of 5
razBlockPadding (outside)	the whole statement, braces included	a four-line body still qualifies
razBlockBodyPadding (inside)	only what sits between the braces	needs more than four lines

<!-- prettier-ignore -->

// four lines between the braces: outside padding only
function four() {
    one();
    two();
    three();
    four();
}

// five lines: outside and inside
function five() {

    one();
    two();
    three();
    four();
    five();

}

// too short for either half
function small() {
    return 1;
}
if (x) tiny();

Line counts decide it, never nesting depth. Here the describe body spans six lines and is padded; the for body inside it spans four and stays tight:

<!-- prettier-ignore -->

describe('fixtures', () => {

    for (const name of names) {
        test(name, () => {
            expect(format(name)).toBe(name);
        });
    }

});

Both are measured on the formatted output, not the source, which is what makes the rule idempotent: a three-line function that formats to eight is padded on the first run, so format-on-save never rewrites the same file twice.

Options…