@blumintinc/eslint-plugin-blumint 1.20.30 → 1.20.32

package/lib/rules/enforce-microdiff.js

@@ -3,6 +3,94 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceMicrodiff = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
+const DIFF_NAME = 'diff';
+const MICRODIFF_MODULE = 'microdiff';
+/**
+ * The libraries this rule replaces. Every fix retires the whole import
+ * declaration of one of these, which is what makes the names it binds available
+ * to the microdiff import that takes its place.
+ */
+const COMPETING_DIFF_MODULES = new Set([
+    'deep-diff',
+    'fast-diff',
+    'diff',
+    'deep-object-diff',
+    // 'fast-deep-equal' and 'fast-deep-equal/es6' stay out of this set: they are
+    // allowed alternatives to microdiff, so their imports survive the fix.
+]);
+/**
+ * A specifier that makes a bare `diff` resolve to microdiff's diff function:
+ * its default export, or its named `diff` export, bound under the name the fix
+ * emits.
+ */
+function bindsMicrodiffDiff(specifier) {
+    if (specifier.local.name !== DIFF_NAME) {
+        return false;
+    }
+    if (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier) {
+        return true;
+    }
+    return (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+        specifier.importKind !== 'type' &&
+        specifier.imported.name === DIFF_NAME);
+}
+/**
+ * microdiff's import read off `Program.body` rather than off a flag raised by
+ * the ImportDeclaration visitor. A competing import that precedes the microdiff
+ * one is fixed before the visitor reaches microdiff, so a flag still unset at
+ * that point makes the fix emit a second `import { diff } from 'microdiff'` and
+ * duplicate the binding (TS2300). Demanding a specifier that binds `diff` also
+ * rejects the shapes a source-only test mistakes for a usable binding: a
+ * namespace import, a type-only import, and an alias of some other export.
+ */
+function findMicrodiffImport(program) {
+    return program.body.find((statement) => statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+        statement.source.value === MICRODIFF_MODULE &&
+        statement.importKind !== 'type' &&
+        statement.specifiers.some(bindsMicrodiffDiff));
+}
+/**
+ * The declarations of `diff` that a fix may write over: microdiff's own
+ * specifier, which an emitted `diff` is meant to resolve to, and the specifiers
+ * of a competing library's import, which the fix replaces or removes outright.
+ * Any other declaration of the name belongs to the file's own code.
+ */
+function collectClaimableSpecifiers(program) {
+    const claimable = new Set();
+    program.body.forEach((statement) => {
+        if (statement.type !== utils_1.AST_NODE_TYPES.ImportDeclaration) {
+            return;
+        }
+        const source = statement.source.value;
+        if (source === MICRODIFF_MODULE) {
+            statement.specifiers
+                .filter(bindsMicrodiffDiff)
+                .forEach((specifier) => claimable.add(specifier));
+            return;
+        }
+        if (COMPETING_DIFF_MODULES.has(source)) {
+            statement.specifiers.forEach((specifier) => claimable.add(specifier));
+        }
+    });
+    return claimable;
+}
+/**
+ * Whether a bare `diff` written at `scope` reaches microdiff's function.
+ * Resolving through the scope chain catches both failure modes: a module-scope
+ * binding that the inserted import redeclares (TS2440, or TS2300 against
+ * another import), and a narrower shadow that captures the emitted reference
+ * with no diagnostic at all. A binding with no declaration — a global supplied
+ * by the environment — is left alone rather than written over.
+ */
+function canEmitDiff(scope, claimable) {
+    const existing = ASTHelpers_1.ASTHelpers.findVariableInScope(scope, DIFF_NAME);
+    if (!existing) {
+        return true;
+    }
+    return (existing.defs.length > 0 &&
+        existing.defs.every((def) => claimable.has(def.node)));
+}
 exports.enforceMicrodiff = (0, createRule_1.createRule)({
     name: 'enforce-microdiff',
     meta: {
@@ -23,8 +111,31 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
         const sourceCode = context.sourceCode;
         const importedDiffLibraries = new Map();
         const importedFunctions = new Map(); // Map of imported function names to their sources
-        let hasMicrodiffImport = false;
         const reportedNodes = new Set();
+        /**
+         * Whether the fix may emit a bare `diff` at `node`. The AST is read at fix
+         * time so the answer stays correct under multi-pass `--fix`, where an
+         * earlier pass may already have added the microdiff import.
+         */
+        function canEmitDiffAt(node) {
+            return canEmitDiff(ASTHelpers_1.ASTHelpers.getScope(context, node), collectClaimableSpecifiers(sourceCode.ast));
+        }
+        /**
+         * Whether retiring `declaration` leaves every reference it binds able to
+         * take the name `diff`. The import rewrite lands at module scope while the
+         * references it serves sit in nested scopes: one standing where `diff` is
+         * shadowed keeps the old name, because its own fix declines, so rewriting
+         * the import would strand it without a binding (TS2304).
+         */
+        function canRenameReferencesOf(declaration) {
+            const claimable = collectClaimableSpecifiers(sourceCode.ast);
+            const declarationScope = ASTHelpers_1.ASTHelpers.getScope(context, declaration);
+            return declaration.specifiers.every((specifier) => {
+                const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(declarationScope, specifier.local.name);
+                return (!variable ||
+                    variable.references.every((reference) => canEmitDiff(reference.from, claimable)));
+            });
+        }
         // 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
@@ -61,19 +172,11 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
             ImportDeclaration(node) {
                 const importSource = node.source.value;
                 // Check for microdiff import
-                if (importSource === 'microdiff') {
-                    hasMicrodiffImport = true;
+                if (importSource === MICRODIFF_MODULE) {
                     return;
                 }
                 // Track other diffing libraries
-                if ([
-                    'deep-diff',
-                    'fast-diff',
-                    'diff',
-                    'deep-object-diff',
-                    // Removed 'fast-deep-equal' and 'fast-deep-equal/es6' from this list
-                    // as they are allowed alternatives to microdiff
-                ].includes(importSource)) {
+                if (COMPETING_DIFF_MODULES.has(importSource)) {
                     // Track imported function names and their sources
                     node.specifiers.forEach((specifier) => {
                         if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
@@ -94,12 +197,18 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                             importSource,
                         },
                         fix(fixer) {
+                            // Decline rather than duplicate or shadow a `diff` this file
+                            // already binds to something else. The report stands so the
+                            // author resolves the name clash deliberately.
+                            if (!canEmitDiffAt(node) || !canRenameReferencesOf(node)) {
+                                return null;
+                            }
                             // If we already have a microdiff import, just remove this import
-                            if (hasMicrodiffImport) {
+                            if (findMicrodiffImport(sourceCode.ast)) {
                                 return fixer.remove(node);
                             }
                             // Otherwise, replace with microdiff import
-                            return fixer.replaceText(node, `import { diff } from 'microdiff';`);
+                            return fixer.replaceText(node, `import { ${DIFF_NAME} } from '${MICRODIFF_MODULE}';`);
                         },
                     });
                     // Check if importing a diff function or a known equality library
@@ -154,7 +263,10 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                             node,
                             messageId: 'enforceMicrodiff',
                             fix(fixer) {
-                                return fixer.replaceText(callee, 'diff');
+                                if (!canEmitDiffAt(node)) {
+                                    return null;
+                                }
+                                return fixer.replaceText(callee, DIFF_NAME);
                             },
                         });
                         return;
@@ -179,8 +291,11 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                                 node,
                                 messageId: 'enforceMicrodiff',
                                 fix(fixer) {
+                                    if (!canEmitDiffAt(node)) {
+                                        return null;
+                                    }
                                     // When handling fast-diff and similar libraries, need to ensure the function name is replaced
-                                    return fixer.replaceText(callee, 'diff');
+                                    return fixer.replaceText(callee, DIFF_NAME);
                                 },
                             });
                         }
@@ -198,8 +313,11 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                             node,
                             messageId: 'enforceMicrodiff',
                             fix(fixer) {
+                                if (!canEmitDiffAt(node)) {
+                                    return null;
+                                }
                                 // Replace with microdiff
-                                return fixer.replaceText(node, `diff(${node.arguments
+                                return fixer.replaceText(node, `${DIFF_NAME}(${node.arguments
                                     .map((arg) => sourceCode.getText(arg))
                                     .join(', ')})`);
                             },
@@ -245,6 +363,9 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                                 node,
                                 messageId: 'enforceMicrodiff',
                                 fix(fixer) {
+                                    if (!canEmitDiffAt(node)) {
+                                        return null;
+                                    }
                                     // Find the containing function to add the import
                                     let functionNode = node;
                                     while (functionNode &&
@@ -258,15 +379,15 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                                     // we'll need to add the import manually
                                     if (functionNode &&
                                         functionNode.type === utils_1.AST_NODE_TYPES.Program &&
-                                        !hasMicrodiffImport) {
+                                        !findMicrodiffImport(sourceCode.ast)) {
                                         // Need to add an import
-                                        const importFix = fixer.insertTextBeforeRange([0, 0], "import { diff } from 'microdiff';\n\n");
+                                        const importFix = fixer.insertTextBeforeRange([0, 0], `import { ${DIFF_NAME} } from '${MICRODIFF_MODULE}';\n\n`);
                                         // Replace JSON.stringify comparison
-                                        const compareFix = fixer.replaceText(node, `diff(${sourceCode.getText(leftArg)}, ${sourceCode.getText(rightArg)})${isEqual ? '.length === 0' : '.length > 0'}`);
+                                        const compareFix = fixer.replaceText(node, `${DIFF_NAME}(${sourceCode.getText(leftArg)}, ${sourceCode.getText(rightArg)})${isEqual ? '.length === 0' : '.length > 0'}`);
                                         return [importFix, compareFix];
                                     }
                                     // Otherwise just replace the comparison
-                                    return fixer.replaceText(node, `diff(${sourceCode.getText(leftArg)}, ${sourceCode.getText(rightArg)})${isEqual ? '.length === 0' : '.length > 0'}`);
+                                    return fixer.replaceText(node, `${DIFF_NAME}(${sourceCode.getText(leftArg)}, ${sourceCode.getText(rightArg)})${isEqual ? '.length === 0' : '.length > 0'}`);
                                 },
                             });
                         }
@@ -308,13 +429,16 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                                 node,
                                 messageId: 'enforceMicrodiff',
                                 fix(fixer) {
+                                    if (!canEmitDiffAt(node)) {
+                                        return null;
+                                    }
                                     // Create a new version of the function with microdiff
                                     const newFunctionBody = `{
-  return diff(${param1}, ${param2}).length > 0;
+  return ${DIFF_NAME}(${param1}, ${param2}).length > 0;
 }`;
-                                    if (!hasMicrodiffImport) {
+                                    if (!findMicrodiffImport(sourceCode.ast)) {
                                         // Create a new import statement
-                                        return fixer.replaceText(node, `import { diff } from 'microdiff';\n\nfunction ${node.id?.name}(${param1}, ${param2}) ${newFunctionBody}`);
+                                        return fixer.replaceText(node, `import { ${DIFF_NAME} } from '${MICRODIFF_MODULE}';\n\nfunction ${node.id?.name}(${param1}, ${param2}) ${newFunctionBody}`);
                                     }
                                     else {
                                         // Just replace the function body

package/lib/rules/enforce-stable-hash-spread-props.js

@@ -146,6 +146,25 @@ function getStableHashLocalNames(sourceCode, hashImport) {
 function isStableHashImported(sourceCode, hashImport) {
     return getStableHashLocalNames(sourceCode, hashImport).length > 0;
 }
+/**
+ * Whether every declaration of a resolved binding is the configured hash import
+ * itself. A namespace import, an import of another name or module, a parameter,
+ * or a local declaration all mean the emitted call would resolve somewhere other
+ * than the intended hash function.
+ */
+function bindsHashImport(variable, hashImport) {
+    return (variable.defs.length > 0 &&
+        variable.defs.every((def) => {
+            const specifier = def.node;
+            if (specifier.type !== utils_1.AST_NODE_TYPES.ImportSpecifier ||
+                specifier.imported.name !== hashImport.importName) {
+                return false;
+            }
+            const declaration = specifier.parent;
+            return (declaration?.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+                declaration.source.value === hashImport.source);
+        }));
+}
 function getIndentBeforeNode(sourceCode, node) {
     const lineText = sourceCode.lines[node.loc.start.line - 1] ?? '';
     const match = lineText.match(/^[ \t]*/);
@@ -222,7 +241,6 @@ exports.enforceStableHashSpreadProps = (0, createRule_1.createRule)({
         // emit `stableHash(...)`, leaving calls to an unbound identifier.
         let importPlanned = false;
         const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
-        const hashIdentifier = existingHashLocalNames[0] ?? hashImport.importName;
         const functionStack = [];
         function getCurrentComponentContext() {
             for (let i = functionStack.length - 1; i >= 0; i -= 1) {
@@ -315,6 +333,27 @@ exports.enforceStableHashSpreadProps = (0, createRule_1.createRule)({
                         if (isReportSuppressed(depsArg)) {
                             return null;
                         }
+                        // Derive the emitted name from the file's imports rather than from
+                        // traversal state: `--fix` re-lints between passes, so an import a
+                        // previous pass landed must be reused, and an alias it introduced
+                        // must be honoured.
+                        const hashIdentifier = getStableHashLocalNames(sourceCode, hashImport)[0] ??
+                            hashImport.importName;
+                        // The fix writes a bare `hashIdentifier` call into the dependency
+                        // array and may add a top-level import for it. Another binding of
+                        // that name, visible from the array, makes both halves wrong: a
+                        // module-scope binding collides with the inserted import
+                        // (TS2440/TS2300), and a narrower shadow silently resolves the
+                        // emitted call to the wrong value with no TypeScript diagnostic at
+                        // all. Resolving through the scope chain of the reported node — the
+                        // exact position the call lands in — covers both, while a binding
+                        // that already is the desired import is the reuse path. Declining
+                        // leaves the report for the author to resolve deliberately.
+                        const existingBinding = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, depsArg), hashIdentifier);
+                        if (existingBinding &&
+                            !bindsHashImport(existingBinding, hashImport)) {
+                            return null;
+                        }
                         const fixes = [];
                         const seen = new Set();
                         for (const { node: targetNode } of offendingElements) {

package/lib/rules/fast-deep-equal-over-microdiff.js

@@ -3,7 +3,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.fastDeepEqualOverMicrodiff = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 const disableDirectives_1 = require("../utils/disableDirectives");
+const FAST_DEEP_EQUAL_MODULES = new Set([
+    'fast-deep-equal',
+    'fast-deep-equal/es6',
+]);
+/**
+ * Whether every declaration of a visible binding is a fast-deep-equal import,
+ * i.e. the name already means the comparison function the fix wants to call.
+ * The verdict comes off the AST (each definition's specifier and its import
+ * declaration) rather than a traversal flag, so it holds on every pass of a
+ * multi-pass `--fix`, including the passes that follow an inserted import.
+ */
+function bindsFastDeepEqual(variable) {
+    return (variable.defs.length > 0 &&
+        variable.defs.every((def) => {
+            const specifier = def.node;
+            if (specifier.type !== utils_1.AST_NODE_TYPES.ImportDefaultSpecifier &&
+                specifier.type !== utils_1.AST_NODE_TYPES.ImportSpecifier) {
+                return false;
+            }
+            const declaration = specifier.parent;
+            return (declaration?.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+                FAST_DEEP_EQUAL_MODULES.has(declaration.source.value));
+        }));
+}
 exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
     name: 'fast-deep-equal-over-microdiff',
     meta: {
@@ -306,6 +331,18 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
             if (isReportSuppressed(node)) {
                 return null;
             }
+            // A binding for the target name that is not the fast-deep-equal import
+            // makes both halves of the edit wrong: an inserted import collides with a
+            // same-scope declaration (TS2440/TS2300), and a narrower-scope shadow
+            // rebinds the emitted call to the local value with no diagnostic at all.
+            // Resolving from the fixed node's scope chain catches both. Declining
+            // before the import is scheduled leaves the carrier slot to a violation
+            // whose scope is safe, and drops the whole edit — including the removal
+            // of a redundant `const changes = diff(...)` — rather than half of it.
+            const existingBinding = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, node), fastDeepEqualImportName);
+            if (existingBinding && !bindsFastDeepEqual(existingBinding)) {
+                return null;
+            }
             const args = diffCall.arguments;
             if (args.length !== 2) {
                 return null; // Can't fix if not exactly 2 arguments

package/lib/rules/no-array-length-in-deps.js

@@ -7,6 +7,8 @@ const ASTHelpers_1 = require("../utils/ASTHelpers");
 const disableDirectives_1 = require("../utils/disableDirectives");
 // React hooks to check
 const HOOK_NAMES = new Set(['useEffect', 'useCallback', 'useMemo']);
+const REACT_MODULE = 'react';
+const MEMO_HOOK_NAME = 'useMemo';
 const DEFAULT_HASH_IMPORT = {
     source: 'functions/src/util/hash/stableHash',
     importName: 'stableHash',
@@ -232,20 +234,49 @@ function getValueImports(sourceCode, source) {
  * specifier (`useMemo as um`) or a type-only specifier does not count — the
  * value binding under the exact local name must exist.
  */
+function isNamedValueSpecifier(specifier, name) {
+    return (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+        specifier.importKind !== 'type' &&
+        specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+        specifier.imported.name === name &&
+        specifier.local.name === name);
+}
+/**
+ * Import presence is read off the AST at fix time rather than from a traversal
+ * flag: a hook call that precedes the import declaration in source order would
+ * otherwise be judged against a flag the `ImportDeclaration` visitor has not
+ * set yet, duplicating the import.
+ */
 function hasNamedValueImport(sourceCode, source, name) {
     for (const declaration of getValueImports(sourceCode, source)) {
         for (const spec of declaration.specifiers) {
-            if (spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
-                spec.importKind !== 'type' &&
-                spec.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
-                spec.imported.name === name &&
-                spec.local.name === name) {
+            if (isNamedValueSpecifier(spec, name)) {
                 return true;
             }
         }
     }
     return false;
 }
+/**
+ * Whether every declaration of a visible binding is the value import this fix
+ * intends to add. A local const/function/class, a parameter, a namespace or
+ * default import, an alias, or a named import from any other module all mean
+ * the emitted `useMemo(() => stableHash(...))` would resolve somewhere other
+ * than the helper — so the binding cannot be reused.
+ */
+function bindsIntendedImport(variable, name, source) {
+    return (variable.defs.length > 0 &&
+        variable.defs.every((def) => {
+            const specifier = def.node;
+            if (!isNamedValueSpecifier(specifier, name)) {
+                return false;
+            }
+            const declaration = specifier.parent;
+            return (declaration?.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+                declaration.importKind !== 'type' &&
+                declaration.source.value === source);
+        }));
+}
 /**
  * Extends an existing import from `source` with `name` instead of prepending
  * a duplicate declaration. Namespace-only imports cannot host a named
@@ -437,6 +468,30 @@ exports.noArrayLengthInDeps = (0, createRule_1.createRule)({
                         // All bail checks precede any shared-state mutation so a skipped
                         // fix cannot make a later fix believe imports or declarations are
                         // already handled.
+                        // The generated declaration spells both helper names bare and
+                        // imports both, so a binding of either name breaks the edit two
+                        // ways: the inserted import collides with a declaration of that
+                        // name (TS2440, or TS2300 when the binding is itself an import),
+                        // and a shadowing parameter or block-scoped binding captures the
+                        // emitted call with no compile error at all. Resolving through the
+                        // scope chain at the hook call catches both, since the insertion
+                        // point shares that scope. Because the emitted code needs BOTH
+                        // names, a clash on either withholds the whole edit — a partial
+                        // one would still be broken. The report stands so the author
+                        // resolves the clash deliberately.
+                        const scope = ASTHelpers_1.ASTHelpers.getScope(context, node);
+                        const collides = [
+                            { name: MEMO_HOOK_NAME, source: REACT_MODULE },
+                            {
+                                name: hashImportConfig.importName,
+                                source: hashImportConfig.source,
+                            },
+                        ].some(({ name, source }) => {
+                            const existing = ASTHelpers_1.ASTHelpers.findVariableInScope(scope, name);
+                            return !!existing && !bindsIntendedImport(existing, name, source);
+                        });
+                        if (collides)
+                            return null;
                         const insertion = findInsertionPoint(node);
                         if (!insertion)
                             return null;
@@ -483,12 +538,13 @@ exports.noArrayLengthInDeps = (0, createRule_1.createRule)({
                         }
                         if (!importsPlanned) {
                             const newImportLines = [];
-                            if (!hasNamedValueImport(sourceCode, 'react', 'useMemo')) {
-                                const extension = buildImportExtensionFix(fixer, sourceCode, 'react', 'useMemo');
+                            if (!hasNamedValueImport(sourceCode, REACT_MODULE, MEMO_HOOK_NAME)) {
+                                const extension = buildImportExtensionFix(fixer, sourceCode, REACT_MODULE, MEMO_HOOK_NAME);
                                 if (extension)
                                     fixes.push(extension);
-                                else
-                                    newImportLines.push(`import { useMemo } from 'react';`);
+                                else {
+                                    newImportLines.push(`import { ${MEMO_HOOK_NAME} } from '${REACT_MODULE}';`);
+                                }
                             }
                             if (!hasNamedValueImport(sourceCode, hashImportConfig.source, hashImportConfig.importName)) {
                                 const extension = buildImportExtensionFix(fixer, sourceCode, hashImportConfig.source, hashImportConfig.importName);