@blumintinc/eslint-plugin-blumint 1.20.65 → 1.20.67

package/lib/rules/prefer-union-from-const-array.js

@@ -3,6 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferUnionFromConstArray = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+/**
+ * Matches Prettier's own default. The autofix authors a whole statement that a
+ * formatter owns, so a line it emits past this width is rewritten on the next
+ * `prettier --write` — and fails `prettier --check` in the meantime.
+ */
+const DEFAULT_PRINT_WIDTH = 80;
 /**
  * Mechanically derive an UPPER_SNAKE constant base from a PascalCase/camelCase
  * type name by inserting `_` at every lowercase/digit-to-uppercase boundary and
@@ -43,6 +49,42 @@ function isNameInScope(scope, name) {
     }
     return false;
 }
+/**
+ * The file's own nesting step, taken as the most common indentation increase
+ * between consecutive lines. Reading it from the source keeps emitted code in
+ * the author's units instead of assuming a two-space, space-indented file.
+ */
+function indentUnitOf(text) {
+    const frequencies = new Map();
+    let previous = '';
+    for (const line of text.split('\n')) {
+        if (line.trim() === '') {
+            continue;
+        }
+        // A block comment's continuation lines align on the `*` one column in from
+        // the comment's own indentation. That is comment alignment, not a nesting
+        // step, and counting it makes any JSDoc-heavy file look 1-space indented.
+        if (line.trimStart().startsWith('*')) {
+            continue;
+        }
+        const match = /^[ \t]*/.exec(line);
+        const indent = match ? match[0] : '';
+        if (indent.length > previous.length && indent.startsWith(previous)) {
+            const delta = indent.slice(previous.length);
+            frequencies.set(delta, (frequencies.get(delta) ?? 0) + 1);
+        }
+        previous = indent;
+    }
+    let unit = '  ';
+    let best = 0;
+    for (const [delta, count] of frequencies) {
+        if (count > best) {
+            unit = delta;
+            best = count;
+        }
+    }
+    return unit;
+}
 exports.preferUnionFromConstArray = (0, createRule_1.createRule)({
     name: 'prefer-union-from-const-array',
     meta: {
@@ -52,14 +94,37 @@ exports.preferUnionFromConstArray = (0, createRule_1.createRule)({
             recommended: 'error',
         },
         fixable: 'code',
-        schema: [],
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    printWidth: {
+                        type: 'number',
+                        minimum: 1,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
         messages: {
             preferDerivedUnion: 'Derive this union from an `as const` array: `const {{constName}} = [...] as const; type {{typeName}} = (typeof {{constName}})[number];`. This tethers the type to importable runtime values and prevents silent drift. Consider also naming each literal as its own exported constant so call sites never repeat magic strings.',
         },
     },
-    defaultOptions: [],
-    create(context) {
+    defaultOptions: [{}],
+    create(context, [options]) {
         const sourceCode = context.getSourceCode();
+        const printWidth = typeof options.printWidth === 'number' && options.printWidth > 0
+            ? options.printWidth
+            : DEFAULT_PRINT_WIDTH;
+        // Derived once per file rather than per fix: every fix in a file shares the
+        // author's nesting step.
+        let indentUnit = null;
+        const fileIndentUnit = () => {
+            if (indentUnit === null) {
+                indentUnit = indentUnitOf(sourceCode.getText());
+            }
+            return indentUnit;
+        };
         return {
             TSTypeAliasDeclaration(node) {
                 const { typeAnnotation } = node;
@@ -103,12 +168,10 @@ exports.preferUnionFromConstArray = (0, createRule_1.createRule)({
                     messageId: 'preferDerivedUnion',
                     data: { constName, typeName },
                     fix(fixer) {
-                        const literals = members
-                            .map((member) => {
+                        const literals = members.map((member) => {
                             const literal = member.literal;
                             return literal.raw ?? sourceCode.getText(literal);
-                        })
-                            .join(', ');
+                        });
                         const typeParams = node.typeParameters
                             ? sourceCode.getText(node.typeParameters)
                             : '';
@@ -124,8 +187,39 @@ exports.preferUnionFromConstArray = (0, createRule_1.createRule)({
                             .slice(0, fixNode.loc.start.column)
                             .match(/^\s*/);
                         const indent = indentMatch ? indentMatch[0] : '';
-                        const constDecl = `${constKeyword} ${constName} = [${literals}] as const;`;
-                        const typeDecl = `${typeKeyword} ${typeName}${typeParams} = (typeof ${constName})[number];`;
+                        // A line break the fixer does not add is one Prettier adds later,
+                        // so the fix must decide the same way Prettier does: keep the
+                        // statement on one line while it fits, break it open past the print
+                        // width. Over-wrapping is not the safe direction here — unlike an
+                        // object literal, an array Prettier considers short enough is
+                        // collapsed back onto one line, so a blanket wrap would trade this
+                        // defect for its mirror image on every short union.
+                        //
+                        // The emitted const starts where the replaced node starts, so its
+                        // column is the exact prefix length; the derived alias is emitted on
+                        // a fresh line at `indent`.
+                        const constStartColumn = fixNode.loc.start.column;
+                        const inlineConst = `${constKeyword} ${constName} = [${literals.join(', ')}] as const;`;
+                        // A literal whose raw text spans lines (a string written with a
+                        // backslash line continuation) cannot sit on one line at all, so
+                        // there is no width to compare — such an array always breaks open.
+                        // Its raw text is emitted verbatim, leaving the interior line break
+                        // and everything after it exactly where the author put it: that
+                        // whitespace is string DATA, not layout.
+                        const hasMultilineLiteral = literals.some((literal) => /[\r\n]/.test(literal));
+                        const constDecl = !hasMultilineLiteral &&
+                            constStartColumn + inlineConst.length <= printWidth
+                            ? inlineConst
+                            : `${constKeyword} ${constName} = [\n${literals
+                                .map((literal) => `${indent}${fileIndentUnit()}${literal},`)
+                                .join('\n')}\n${indent}] as const;`;
+                        const inlineType = `${typeKeyword} ${typeName}${typeParams} = (typeof ${constName})[number];`;
+                        // Prettier answers an over-long type alias by breaking after the
+                        // `=`, the only break point the derived form has.
+                        const typeDecl = typeParams.includes('\n') ||
+                            indent.length + inlineType.length <= printWidth
+                            ? inlineType
+                            : `${typeKeyword} ${typeName}${typeParams} =\n${indent}${fileIndentUnit()}(typeof ${constName})[number];`;
                         return fixer.replaceText(fixNode, `${constDecl}\n${indent}${typeDecl}`);
                     },
                 });

package/lib/utils/ruleTester.d.ts

@@ -1,6 +1,32 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
+import type { TSESLint } from '@typescript-eslint/utils';
 import { RuleTester } from 'eslint';
 export declare const ruleTesterTs: ESLintUtils.RuleTester;
 export declare const ruleTesterJsx: ESLintUtils.RuleTester;
 export declare const ruleTesterJson: RuleTester;
 export declare const ruleTesterMarkdown: RuleTester;
+type ParserOptionsCarrier = {
+    parserOptions?: TSESLint.ParserOptions;
+};
+/**
+ * Applies `parserOptions` to every case of a suite.
+ *
+ * The instances above are the only RuleTester instances the suite may use:
+ * corpus-harvesting probes collect cases by stubbing `run` on these exports, so
+ * a test file that constructs its own tester is invisible to every one of them
+ * and its rule silently drops out of the fixer, convergence, collision and
+ * crash sweeps. `src/tests/no-local-rule-tester.test.ts` enforces that.
+ *
+ * A file needing parser options the shared instances do not declare — ES module
+ * scope analysis, a type-aware `project` — attaches them per case rather than
+ * forking a tester. RuleTester deep merges each case's config over the tester's,
+ * and options a case declares itself still win over the ones applied here, so a
+ * case keeps any override it already had. Carrying the options on the case also
+ * means the harvested corpus records the parser configuration a snippet was
+ * written for, which a tester-level setting never exposes to a probe.
+ */
+export declare const withParserOptions: <T extends string | ParserOptionsCarrier>(parserOptions: TSESLint.ParserOptions, cases: readonly T[]) => (Exclude<T, string> | {
+    code: string;
+    parserOptions: TSESLint.ParserOptions;
+})[];
+export {};

package/lib/utils/ruleTester.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ruleTesterMarkdown = exports.ruleTesterJson = exports.ruleTesterJsx = exports.ruleTesterTs = void 0;
+exports.withParserOptions = exports.ruleTesterMarkdown = exports.ruleTesterJson = exports.ruleTesterJsx = exports.ruleTesterTs = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const eslint_1 = require("eslint");
 exports.ruleTesterTs = new utils_1.ESLintUtils.RuleTester({
@@ -23,4 +23,31 @@ exports.ruleTesterJson = new eslint_1.RuleTester({
 exports.ruleTesterMarkdown = new eslint_1.RuleTester({
     parser: require.resolve('markdown-eslint-parser'),
 });
+/**
+ * Applies `parserOptions` to every case of a suite.
+ *
+ * The instances above are the only RuleTester instances the suite may use:
+ * corpus-harvesting probes collect cases by stubbing `run` on these exports, so
+ * a test file that constructs its own tester is invisible to every one of them
+ * and its rule silently drops out of the fixer, convergence, collision and
+ * crash sweeps. `src/tests/no-local-rule-tester.test.ts` enforces that.
+ *
+ * A file needing parser options the shared instances do not declare — ES module
+ * scope analysis, a type-aware `project` — attaches them per case rather than
+ * forking a tester. RuleTester deep merges each case's config over the tester's,
+ * and options a case declares itself still win over the ones applied here, so a
+ * case keeps any override it already had. Carrying the options on the case also
+ * means the harvested corpus records the parser configuration a snippet was
+ * written for, which a tester-level setting never exposes to a probe.
+ */
+const withParserOptions = (parserOptions, cases) => cases.map((testCase) => typeof testCase === 'string'
+    ? { code: testCase, parserOptions }
+    : {
+        ...testCase,
+        parserOptions: {
+            ...parserOptions,
+            ...testCase.parserOptions,
+        },
+    });
+exports.withParserOptions = withParserOptions;
 //# sourceMappingURL=ruleTester.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.20.65",
+  "version": "1.20.67",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

@@ -1,4 +1,89 @@
 [
+  {
+    "version": "1.20.67",
+    "date": "2026-08-01T17:17:30.817Z",
+    "rules": [
+      {
+        "name": "enforce-microdiff",
+        "changeType": "fix",
+        "issues": [
+          1571
+        ],
+        "summary": "guard the zero-argument JSON.stringify comparison (closes #1571)"
+      },
+      {
+        "name": "memo-nested-react-components",
+        "changeType": "fix",
+        "issues": [
+          1567
+        ],
+        "summary": "exempt lowercase-initial render-prop callbacks (closes #1567)"
+      },
+      {
+        "name": "no-compositing-layer-props",
+        "changeType": "fix",
+        "issues": [
+          1570
+        ],
+        "summary": "exempt mix-blend-mode's non-promoting values (closes #1570)"
+      },
+      {
+        "name": "no-jsx-in-hooks",
+        "changeType": "fix",
+        "issues": [
+          1572
+        ],
+        "summary": "guard the zero-argument .map() inside useMemo (closes #1572)"
+      },
+      {
+        "name": "optimize-object-boolean-conditions",
+        "changeType": "fix",
+        "issues": [
+          1569
+        ],
+        "summary": "stop calling boolean-prefixed and primitive identifiers objects (closes #1569)"
+      },
+      {
+        "name": "prefer-getter-over-parameterless-method",
+        "changeType": "fix",
+        "issues": [
+          1568
+        ],
+        "summary": "prescribe a remedy that clears preferGetterSideEffect (closes #1568)"
+      },
+      {
+        "name": "prefer-sx-prop-over-system-props",
+        "changeType": "fix",
+        "issues": [
+          1565,
+          1574
+        ],
+        "summary": "ignore block-comment lines when inferring the indent unit (closes #1574); wrap emitted sx object when it overflows the print width (closes #1565)"
+      },
+      {
+        "name": "prefer-union-from-const-array",
+        "changeType": "fix",
+        "issues": [
+          1566
+        ],
+        "summary": "wrap the authored as-const array when it exceeds the print width (closes #1566)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.66",
+    "date": "2026-08-01T13:53:31.680Z",
+    "rules": [
+      {
+        "name": "enforce-firestore-doc-ref-generic",
+        "changeType": "fix",
+        "issues": [
+          1564
+        ],
+        "summary": "trace compat receivers through annotated lets and seeding callbacks (closes #1564)"
+      }
+    ]
+  },
   {
     "version": "1.20.65",
     "date": "2026-08-01T13:35:40.762Z",