@blumintinc/eslint-plugin-blumint 1.20.119 → 1.20.120

package/lib/index.js

@@ -223,7 +223,7 @@ function noFrontendImportsFromFunctionsPatterns(pattern) {
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.20.119',
+        version: '1.20.120',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/enforce-microdiff.js

@@ -37,6 +37,58 @@ const DIFF_FUNCTION_NAMES = new Set([
     'detailedDiff',
     // 'fastDeepEqual' and 'isEqual' stay out: they are allowed alternatives.
 ]);
+/**
+ * The names a hand-rolled comparison function is conventionally given. One
+ * shared set answers for both spellings of such a function — a `function`
+ * declaration and an arrow bound to a `const` — so neither can drift into
+ * recognising a name the other misses.
+ */
+const COMPARISON_FUNCTION_NAMES = new Set([
+    'detectChanges',
+    'hasConfigChanged',
+    'compareObjects',
+    'compareArrays',
+    'findChanges',
+    'detectDifferences',
+    'hasStateChanged',
+    'stateHasUpdated',
+    'arrayHasChanged',
+    'settingsChanged',
+]);
+/**
+ * The comparison function whose body the fix rewrites. A name alone does not
+ * fix what such a function returns — a boolean, the changed keys, the changes
+ * themselves — and a change list swapped in for the wrong one of those
+ * compiles, so the rest of the set is reported and left to its authors.
+ */
+const REWRITABLE_COMPARISON_NAME = 'hasConfigChanged';
+/**
+ * The markers that make a body look like a hand-rolled comparison. Text is
+ * enough to raise the report because the report says only that the body should
+ * be using microdiff; nothing is rewritten off these.
+ */
+function hasComparisonMarkers(bodyText) {
+    return (bodyText.includes('JSON.stringify') ||
+        bodyText.includes('Object.keys') ||
+        bodyText.includes('for (') ||
+        bodyText.includes('.some(') ||
+        bodyText.includes('.every('));
+}
+/**
+ * Whether a comparison function is one whose body the fix attempts. The gate is
+ * a text-level pre-filter over the name and the body: `collectStringifyComparisons`
+ * reads the AST afterwards and has the last word on whether a rewrite exists,
+ * so a body that clears this gate is still routinely left alone.
+ *
+ * The `!==` marker keeps the rewrite to bodies that phrase the question the way
+ * the name does — "has it changed?" — while an all-`===` body is reported and
+ * left for its author in either spelling.
+ */
+function isRewritableComparison(name, bodyText) {
+    return (name === REWRITABLE_COMPARISON_NAME &&
+        bodyText.includes('JSON.stringify') &&
+        bodyText.includes('!=='));
+}
 /**
  * The exports of a competing library whose call sites this rule rewrites,
  * whatever local name the import binds them to.
@@ -457,6 +509,62 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
             const emptiness = comparison.isEqual ? '.length === 0' : '.length > 0';
             return `${DIFF_NAME}(${left}, ${right})${emptiness}`;
         }
+        /**
+         * The rewrite of a comparison function's body, or null when the body offers
+         * no single expression to replace or the emitted `diff` would not reach
+         * microdiff at `fn`.
+         *
+         * Exactly one comparison is the condition for a fix. With none there is no
+         * expression to rewrite, and with several the rule cannot tell which one the
+         * function's answer turns on, so the report stands on its own.
+         *
+         * Only the comparison's own range is rewritten. The signature keeps its type
+         * annotations, its modifiers and any `export` in front of it, and the body
+         * keeps everything the comparison shares it with: side effects, guard
+         * clauses, locals, and the comments around them. Re-emitting the body as a
+         * single return drops all of that silently — the fix compiles, so nothing
+         * downstream flags the loss.
+         *
+         * Replacing the comparison rather than the statement holding it is also what
+         * lets one implementation serve every spelling of the function: an arrow's
+         * concise expression body takes no `return` and no semicolon, and it needs
+         * none, because the text around the comparison is never part of the range.
+         */
+        function buildComparisonBodyFix(fixer, fn, body) {
+            const comparisons = collectStringifyComparisons(body);
+            if (comparisons.length !== 1 || !canEmitDiffAt(fn)) {
+                return null;
+            }
+            const bodyFix = fixer.replaceText(comparisons[0].node, buildDiffComparison(comparisons[0]));
+            const importFix = buildMicrodiffImportFix(fixer);
+            return importFix ? [importFix, bodyFix] : bodyFix;
+        }
+        /**
+         * Reports a hand-rolled comparison function, carrying the rewrite whenever
+         * its body offers one. Both spellings route through here so an identical
+         * violation is auto-remediable however it is written: a report with a fix in
+         * one spelling and without it in the other leaves the same code manual to
+         * resolve for no reason the author can see.
+         */
+        function reportComparisonFunction(node, name, body) {
+            const bodyText = sourceCode.getText(body);
+            if (isRewritableComparison(name, bodyText)) {
+                reportedNodes.add(node);
+                context.report({
+                    node,
+                    messageId: 'enforceMicrodiff',
+                    fix: (fixer) => buildComparisonBodyFix(fixer, node, body),
+                });
+                return;
+            }
+            if (hasComparisonMarkers(bodyText)) {
+                reportedNodes.add(node);
+                context.report({
+                    node,
+                    messageId: 'enforceMicrodiff',
+                });
+            }
+        }
         // Add a specific set to track which import names are used
         const usedImportNames = new Set();
         // Check if a node is an object or array type
@@ -692,71 +800,14 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                 if (reportedNodes.has(node)) {
                     return;
                 }
-                // Look for functions that might be implementing diff logic
-                if (node.id &&
-                    [
-                        'detectChanges',
-                        'hasConfigChanged',
-                        'compareObjects',
-                        'compareArrays',
-                        'findChanges',
-                        'detectDifferences',
-                        'hasStateChanged',
-                        'stateHasUpdated',
-                        'arrayHasChanged',
-                        'settingsChanged',
-                    ].includes(node.id.name)) {
-                    // Check if function has two parameters that might be objects/arrays
-                    if (node.params.length >= 2) {
-                        const body = node.body;
-                        const bodyText = sourceCode.getText(body);
-                        // Check if the function body contains a JSON.stringify comparison
-                        if (node.id.name === 'hasConfigChanged' &&
-                            bodyText.includes('JSON.stringify') &&
-                            bodyText.includes('!==')) {
-                            reportedNodes.add(node);
-                            // Exactly one comparison is the condition for a fix. With none
-                            // there is no expression to rewrite, and with several the rule
-                            // cannot tell which one the function's answer turns on, so the
-                            // report stands on its own.
-                            const comparisons = collectStringifyComparisons(body);
-                            const comparison = comparisons.length === 1 ? comparisons[0] : null;
-                            context.report({
-                                node,
-                                messageId: 'enforceMicrodiff',
-                                fix(fixer) {
-                                    if (!comparison || !canEmitDiffAt(node)) {
-                                        return null;
-                                    }
-                                    // Only the comparison's own range is rewritten. The signature
-                                    // keeps its type annotations, its modifiers and any `export`
-                                    // in front of it, and the body keeps everything the
-                                    // comparison shares it with: side effects, guard clauses,
-                                    // locals, and the comments around them. Re-emitting the body
-                                    // as a single return drops all of that silently — the fix
-                                    // compiles, so nothing downstream flags the loss.
-                                    const bodyFix = fixer.replaceText(comparison.node, buildDiffComparison(comparison));
-                                    const importFix = buildMicrodiffImportFix(fixer);
-                                    return importFix ? [importFix, bodyFix] : bodyFix;
-                                },
-                            });
-                            return;
-                        }
-                        // Look for patterns that suggest object/array comparison
-                        const hasComparisonLogic = bodyText.includes('JSON.stringify') ||
-                            bodyText.includes('Object.keys') ||
-                            bodyText.includes('for (') ||
-                            bodyText.includes('.some(') ||
-                            bodyText.includes('.every(');
-                        if (hasComparisonLogic) {
-                            reportedNodes.add(node);
-                            context.report({
-                                node,
-                                messageId: 'enforceMicrodiff',
-                            });
-                        }
-                    }
+                // Two parameters are what a comparison function needs, and what the
+                // `diff(a, b)` it is rewritten to needs as well.
+                if (!node.id ||
+                    !COMPARISON_FUNCTION_NAMES.has(node.id.name) ||
+                    node.params.length < 2) {
+                    return;
                 }
+                reportComparisonFunction(node, node.id.name, node.body);
             },
             // Check for custom deep comparison in arrow functions
             ArrowFunctionExpression(node) {
@@ -764,42 +815,17 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                 if (reportedNodes.has(node)) {
                     return;
                 }
-                // Only check arrow functions assigned to variables with comparison-like names
+                // The name an arrow answers to is the one its declarator binds, so an
+                // arrow passed straight to a call names nothing and is left alone.
                 const parent = node.parent;
-                if (parent &&
-                    parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
-                    parent.id.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    [
-                        'detectChanges',
-                        'hasConfigChanged',
-                        'compareObjects',
-                        'compareArrays',
-                        'findChanges',
-                        'detectDifferences',
-                        'hasStateChanged',
-                        'stateHasUpdated',
-                        'arrayHasChanged',
-                        'settingsChanged',
-                    ].includes(parent.id.name)) {
-                    // Check if function has two parameters that might be objects/arrays
-                    if (node.params.length >= 2) {
-                        const body = node.body;
-                        // Look for patterns that suggest object/array comparison
-                        const bodyText = sourceCode.getText(body);
-                        const hasComparisonLogic = bodyText.includes('JSON.stringify') ||
-                            bodyText.includes('Object.keys') ||
-                            bodyText.includes('for (') ||
-                            bodyText.includes('.some(') ||
-                            bodyText.includes('.every(');
-                        if (hasComparisonLogic) {
-                            reportedNodes.add(node);
-                            context.report({
-                                node,
-                                messageId: 'enforceMicrodiff',
-                            });
-                        }
-                    }
+                if (!parent ||
+                    parent.type !== utils_1.AST_NODE_TYPES.VariableDeclarator ||
+                    parent.id.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                    !COMPARISON_FUNCTION_NAMES.has(parent.id.name) ||
+                    node.params.length < 2) {
+                    return;
                 }
+                reportComparisonFunction(node, parent.id.name, node.body);
             },
         };
     },

package/lib/rules/prefer-use-base62-id.js

@@ -131,6 +131,30 @@ function hasEmptyDepsArray(callNode) {
     const deps = callNode.arguments[1];
     return (deps.type === utils_1.AST_NODE_TYPES.ArrayExpression && deps.elements.length === 0);
 }
+/**
+ * Wrappers that exist purely at the type level: they leave the wrapped
+ * expression's runtime value untouched, so a value wrapped in them is still the
+ * value the enclosing declarator binds.
+ */
+const TYPE_ONLY_WRAPPERS = new Set([
+    utils_1.AST_NODE_TYPES.TSAsExpression,
+    utils_1.AST_NODE_TYPES.TSSatisfiesExpression,
+    utils_1.AST_NODE_TYPES.TSNonNullExpression,
+    utils_1.AST_NODE_TYPES.TSTypeAssertion,
+]);
+/**
+ * Returns the nearest ancestor that carries runtime meaning, skipping the
+ * type-only wrappers that may sit between an expression and its binding site.
+ * A double assertion (`as unknown as T`) nests two of them, so the climb loops
+ * rather than peeling a single layer.
+ */
+function getRuntimeParent(node) {
+    let current = node.parent;
+    while (current && TYPE_ONLY_WRAPPERS.has(current.type)) {
+        current = current.parent;
+    }
+    return current;
+}
 /**
  * Checks whether the given identifier (the ref variable name) has its
  * `.current` property assigned anywhere in the enclosing function body.
@@ -398,8 +422,13 @@ exports.preferUseBase62Id = (0, createRule_1.createRule)({
                         return;
                     if (!useRefArgContainsUuid(node, trackedUuidNames))
                         return;
-                    // Find the variable name assigned to the ref
-                    const parent = node.parent;
+                    // Find the variable name assigned to the ref. A type assertion
+                    // between the call and its declarator is semantically neutral, so the
+                    // name stays knowable through it and the `.current`-reassignment
+                    // exemption still applies. Genuinely nameless shapes — a destructure,
+                    // a discarded call, a returned ref — leave `refName` null and keep
+                    // the conservative report.
+                    const parent = getRuntimeParent(node);
                     let refName = null;
                     if (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
                         parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {

package/lib/utils/fixtureCorpus.d.ts

@@ -72,9 +72,8 @@ export declare const ruleNameByIdentity: Map<unknown, string>;
  *
  * `RuleTester` passes `undefined` in that situation, which ESLint renders as
  * `<input>` — a name with no extension, under which every path-gated rule is
- * silent and contributes nothing. A bare `file.ts`/`react.tsx` is the smallest
- * departure that keeps those rules reachable, and it matches the extension the
- * fixture's own tester implies.
+ * silent and contributes nothing. A bare `file`/`react` basename is the smallest
+ * departure that keeps those rules reachable.
  */
 export declare const defaultFilenameFor: (testCase: FixtureCase) => string;
 /**

package/lib/utils/fixtureCorpus.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.harvestFixtureCorpus = exports.severityWithOptions = exports.suggestionEditsOf = exports.suggestionRuleNames = exports.parserOptionsFor = exports.FALLBACK_FILENAMES = exports.defaultFilenameFor = exports.ruleNameByIdentity = exports.typeAwareRuleNames = exports.TS_TESTERS = exports.harvestOnce = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const typescript_estree_1 = require("@typescript-eslint/typescript-estree");
 const harvestRuleTesterCases_1 = require("./harvestRuleTesterCases");
 /**
  * The fixture corpus every fixer guard probes, keyed by RULE NAME.
@@ -98,17 +99,65 @@ exports.typeAwareRuleNames = new Set(fs_1.default
  * suites and `../index` resolve to the same module instance under jest.
  */
 exports.ruleNameByIdentity = new Map(Object.entries(plugin.rules).map(([name, rule]) => [rule, name]));
+const parsesWithJsx = (code, jsx) => {
+    try {
+        // `range`/`loc` are not optional in practice: without them any comment in
+        // the snippet throws, which reads as an unparsable fixture.
+        (0, typescript_estree_1.parse)(code, { jsx, range: true, loc: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+/** Decided once per snippet+preference; the corpus reprobes the same code. */
+const extensionByCode = new Map();
+/**
+ * `.ts` and `.tsx` are not ordered by permissiveness, so neither one can be the
+ * blanket default: only `.ts` accepts the angle-bracket assertion `<T>expr`, and
+ * only `.tsx` accepts JSX. The tester supplies a PREFERENCE, and the snippet
+ * overrides it only when that preference cannot parse the snippet at all.
+ *
+ * Taking the tester's word for it instead makes a JSX fixture in a `ruleTesterTs`
+ * suite a FATAL parse. Every consumer filters messages by `ruleId`, so the fatal
+ * is indistinguishable from the rule staying silent — a false clean over 168
+ * cases, four fifths of some rules' corpora. The converse costs one case: an
+ * angle-bracket assertion declared in a `ruleTesterJsx` suite.
+ *
+ * Correcting only on a fatal is what keeps this from churning: a snippet legal
+ * both ways stays on the extension it has always been probed under, so no
+ * path-gated rule silently changes which fixtures reach it.
+ */
+const extensionFor = (code, preferred) => {
+    const key = `${preferred}\u0000${code}`;
+    const cached = extensionByCode.get(key);
+    if (cached)
+        return cached;
+    const alternate = preferred === '.tsx' ? '.ts' : '.tsx';
+    // Only a `<` can make the two disagree, so the common case never parses.
+    const extension = !code.includes('<') || parsesWithJsx(code, preferred === '.tsx')
+        ? preferred
+        : parsesWithJsx(code, alternate === '.tsx')
+            ? alternate
+            : preferred;
+    extensionByCode.set(key, extension);
+    return extension;
+};
 /**
  * The filename a case is probed under when it declares none.
  *
  * `RuleTester` passes `undefined` in that situation, which ESLint renders as
  * `<input>` — a name with no extension, under which every path-gated rule is
- * silent and contributes nothing. A bare `file.ts`/`react.tsx` is the smallest
- * departure that keeps those rules reachable, and it matches the extension the
- * fixture's own tester implies.
+ * silent and contributes nothing. A bare `file`/`react` basename is the smallest
+ * departure that keeps those rules reachable.
  */
-const defaultFilenameFor = (testCase) => testCase.filename ??
-    (testCase.tester === 'ruleTesterJsx' ? 'react.tsx' : 'file.ts');
+const defaultFilenameFor = (testCase) => {
+    if (testCase.filename)
+        return testCase.filename;
+    const jsxTester = testCase.tester === 'ruleTesterJsx';
+    const basename = jsxTester ? 'react' : 'file';
+    return `${basename}${extensionFor(testCase.code, jsxTester ? '.tsx' : '.ts')}`;
+};
 exports.defaultFilenameFor = defaultFilenameFor;
 /**
  * Second-chance filenames, used ONLY for a rule that produced no probe at all

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,26 @@
 [
+  {
+    "version": "1.20.120",
+    "date": "2026-08-06T05:46:26.078Z",
+    "rules": [
+      {
+        "name": "enforce-microdiff",
+        "changeType": "fix",
+        "issues": [
+          1784
+        ],
+        "summary": "give the arrow spelling the rewrite its declaration twin carries (closes #1784)"
+      },
+      {
+        "name": "prefer-use-base62-id",
+        "changeType": "fix",
+        "issues": [
+          1782
+        ],
+        "summary": "look through type-only wrappers to the ref name (closes #1782)"
+      }
+    ]
+  },
   {
     "version": "1.20.119",
     "date": "2026-08-06T04:34:04.981Z",