@blumintinc/eslint-plugin-blumint 1.20.66 → 1.20.68

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,53 @@ 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(sourceCode) {
+    const text = sourceCode.getText();
+    const blockComments = sourceCode
+        .getAllComments()
+        .filter((comment) => comment.type === utils_1.AST_TOKEN_TYPES.Block)
+        .map((comment) => comment.range);
+    // A block comment's interior lines carry whatever alignment the comment uses
+    // — the `*` one column in from its own indentation, or, for commented-out
+    // code, the original code's depths. Neither is a nesting step of the file, and
+    // counting them makes a JSDoc-heavy file look 1-space indented. Keying on the
+    // comment's range rather than a leading `*` also covers a body without them.
+    const continuesBlockComment = (offset) => blockComments.some(([start, end]) => start < offset && offset < end);
+    const frequencies = new Map();
+    let previous = '';
+    let offset = 0;
+    for (const line of text.split('\n')) {
+        const lineStart = offset;
+        offset += line.length + 1;
+        if (line.trim() === '') {
+            continue;
+        }
+        if (continuesBlockComment(lineStart)) {
+            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 +105,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);
+            }
+            return indentUnit;
+        };
         return {
             TSTypeAliasDeclaration(node) {
                 const { typeAnnotation } = node;
@@ -103,12 +179,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 +198,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,34 @@
 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 — a
+ * type-aware `project`, a non-default `ecmaVersion` — attaches them per case
+ * rather than forking a tester. The shared instances already declare ES module
+ * scope analysis, so a case restating `sourceType: 'module'` is redundant but
+ * harmless. 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,14 +1,33 @@
 "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");
+/**
+ * `sourceType: 'module'` matches how the linted codebase actually parses: every
+ * consumer source file is an ES module, so its top-level declarations live in a
+ * module scope nested inside the global one.
+ *
+ * `@typescript-eslint/parser` defaults to `'script'`, under which a top-level
+ * `import`/`const` still binds — the binding hangs off the *global* scope rather
+ * than a module scope. References therefore still resolve either way, but the
+ * scope shape differs: under `'script'` `globalScope.variables` carries the
+ * file's own declarations and there is no module scope at all. A rule that
+ * discriminates on `scope.type`, walks `globalScope.childScopes`, or reads
+ * `globalScope.variables` would otherwise be exercised against a shape no real
+ * file has. `src/tests/rule-tester-parse-mode.test.ts` pins this.
+ */
+const SHARED_PARSER_OPTIONS = {
+    sourceType: 'module',
+};
 exports.ruleTesterTs = new utils_1.ESLintUtils.RuleTester({
     parser: '@typescript-eslint/parser',
+    parserOptions: { ...SHARED_PARSER_OPTIONS },
 });
 exports.ruleTesterJsx = new utils_1.ESLintUtils.RuleTester({
     parser: '@typescript-eslint/parser',
     parserOptions: {
+        ...SHARED_PARSER_OPTIONS,
         ecmaFeatures: {
             jsx: true,
         },
@@ -23,4 +42,33 @@ 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 — a
+ * type-aware `project`, a non-default `ecmaVersion` — attaches them per case
+ * rather than forking a tester. The shared instances already declare ES module
+ * scope analysis, so a case restating `sourceType: 'module'` is redundant but
+ * harmless. 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.66",
+  "version": "1.20.68",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

@@ -1,4 +1,89 @@
 [
+  {
+    "version": "1.20.68",
+    "date": "2026-08-01T18:03:14.950Z",
+    "rules": [
+      {
+        "name": "prefer-union-from-const-array",
+        "changeType": "fix",
+        "issues": [
+          1577
+        ],
+        "summary": "exclude block comments by range when inferring the indent unit (closes #1577)"
+      }
+    ]
+  },
+  {
+    "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",