@blumintinc/eslint-plugin-blumint 1.20.49 → 1.20.51

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

@@ -5,10 +5,46 @@ 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',
-]);
+const microdiffModules_1 = require("../utils/microdiffModules");
+const fastDeepEqualModules_1 = require("../utils/fastDeepEqualModules");
+const DIFF_EXPORT_NAME = 'diff';
+/**
+ * Whether a declaration imports values — a `import type ...` declaration binds
+ * nothing at runtime, so it neither supplies a callable `diff` nor satisfies
+ * the fast-deep-equal import the fix emits.
+ */
+function isValueImport(declaration) {
+    return declaration.importKind !== 'type';
+}
+/**
+ * Whether a specifier binds microdiff's diff function: the module default, or
+ * its named `diff` export under whatever local name. Type-only specifiers are
+ * excluded for the same reason a type-only declaration is.
+ *
+ * The check matters because microdiff's other exports are types — a file
+ * importing only `Difference` binds no `diff` at all, and treating that import
+ * as proof of one turns any local `diff(...)` in the file into a violation.
+ */
+function bindsMicrodiffDiff(specifier) {
+    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_EXPORT_NAME);
+}
+/**
+ * Whether a specifier binds a callable equality function rather than the module
+ * object: the default export the package is, or a named specifier of it. A
+ * namespace import binds the module, and a bare `import '...'` binds nothing at
+ * all — reading either as the file's equality function leaves the emitted
+ * `isEqual(...)` call with no declaration behind it.
+ */
+function bindsFastDeepEqualFunction(specifier) {
+    return (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+        (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+            specifier.importKind !== 'type'));
+}
 /**
  * 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.
@@ -26,7 +62,8 @@ function bindsFastDeepEqual(variable) {
             }
             const declaration = specifier.parent;
             return (declaration?.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
-                FAST_DEEP_EQUAL_MODULES.has(declaration.source.value));
+                isValueImport(declaration) &&
+                fastDeepEqualModules_1.FAST_DEEP_EQUAL_MODULES.has(String(declaration.source.value)));
         }));
 }
 /**
@@ -52,9 +89,9 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
             useFastDeepEqual: "What's wrong: This code uses `{{diffName}}(...).length` as a deep equality check.\n" +
                 'Why it matters: `{{diffName}}` allocates a full change list (paths, types, values) before you compare it to zero, which hides the boolean intent and wastes memory/time.\n' +
                 'How to fix: Call `{{fastEqualName}}(left, right)` for equality (or prefix with `!` for inequality) using the same two arguments instead of counting diff length.',
-            addFastDeepEqualImport: "What's wrong: This file checks equality via `{{diffName}}(...).length` but does not import `fast-deep-equal`.\n" +
-                'Why it matters: Without `fast-deep-equal`, equality checks keep building diff entries just to count them, adding overhead and obscuring intent.\n' +
-                'How to fix: Add a default import for `fast-deep-equal` as `{{fastEqualName}}` and use `{{fastEqualName}}(a, b)` for equality checks.',
+            addFastDeepEqualImport: "What's wrong: This file checks equality via `{{diffName}}(...).length` but does not import a deep-equality function.\n" +
+                'Why it matters: Without `@blumintinc/fast-deep-equal`, equality checks keep building diff entries just to count them, adding overhead and obscuring intent.\n' +
+                'How to fix: Add a default import from `@blumintinc/fast-deep-equal` as `{{fastEqualName}}` and use `{{fastEqualName}}(a, b)` for equality checks.',
         },
     },
     defaultOptions: [],
@@ -67,8 +104,8 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
         const reportedNodes = new Set();
         let plannedFastDeepEqualImport = false;
         /**
-         * The `import ... from 'fast-deep-equal'` statement rides on a single
-         * violation's fix, so that violation is the file's import carrier. A
+         * The `import ... from '@blumintinc/fast-deep-equal'` statement rides on a
+         * single violation's fix, so that violation is the file's import carrier. A
          * suppressed carrier would take the import down with it while the surviving
          * violations still emit `isEqual(...)` calls, leaving them unbound.
          */
@@ -415,28 +452,29 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
             return fixes;
         }
         /**
-         * The `import ... from 'fast-deep-equal'` edit, scheduled at most once per
-         * file. Claiming the carrier slot is a side effect, so this runs last —
-         * after every reason to decline the fix has been ruled out — otherwise a
-         * declining violation takes the import down with it and leaves the
-         * surviving violations' `isEqual(...)` calls unbound.
+         * The `import ... from '@blumintinc/fast-deep-equal'` edit, scheduled at
+         * most once per file. Claiming the carrier slot is a side effect, so this
+         * runs last — after every reason to decline the fix has been ruled out —
+         * otherwise a declining violation takes the import down with it and leaves
+         * the surviving violations' `isEqual(...)` calls unbound.
+         *
+         * The specifier is the scoped fork: it is the dependency this codebase
+         * declares, so any other name would be written as an import that resolves
+         * nowhere.
          */
         function planFastDeepEqualImport(fixer) {
             if (hasFastDeepEqualImport || plannedFastDeepEqualImport) {
                 return [];
             }
             plannedFastDeepEqualImport = true;
+            const importStatement = (0, fastDeepEqualModules_1.fastDeepEqualImport)(fastDeepEqualImportName);
             const importDeclarations = sourceCode.ast.body.filter((statement) => statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
-            const microdiffImport = importDeclarations.find((declaration) => declaration.source.value === 'microdiff');
+            const microdiffImport = importDeclarations.find((declaration) => microdiffModules_1.MICRODIFF_MODULES.has(String(declaration.source.value)));
             const anchor = microdiffImport ?? importDeclarations[importDeclarations.length - 1];
             if (anchor) {
-                return [
-                    fixer.insertTextAfter(anchor, `\nimport ${fastDeepEqualImportName} from 'fast-deep-equal';`),
-                ];
+                return [fixer.insertTextAfter(anchor, `\n${importStatement}`)];
             }
-            return [
-                fixer.insertTextBeforeRange([0, 0], `import ${fastDeepEqualImportName} from 'fast-deep-equal';\n`),
-            ];
+            return [fixer.insertTextBeforeRange([0, 0], `${importStatement}\n`)];
         }
         /**
          * Create a fix for replacing microdiff equality check with fast-deep-equal
@@ -508,24 +546,31 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
         return {
             // Track imports of microdiff and fast-deep-equal
             ImportDeclaration(node) {
-                const importSource = node.source.value;
-                // Check for microdiff import
-                if (importSource === 'microdiff') {
-                    hasMicrodiffImport = true;
-                    // Get the local name of the imported diff function
-                    node.specifiers.forEach((specifier) => {
-                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
-                            specifier.imported.name === 'diff') {
-                            microdiffImportName = specifier.local.name;
-                        }
-                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier) {
-                            microdiffImportName = specifier.local.name;
-                        }
+                const importSource = String(node.source.value);
+                if (!isValueImport(node)) {
+                    return;
+                }
+                // A microdiff import counts only once it binds the diff function
+                // itself. Every other export of the package is a type, so
+                // `import { Difference } from '@blumintinc/microdiff'` brings in
+                // nothing callable — reading it as microdiff's presence turns an
+                // unrelated local `diff(...)` in that file into a violation whose fix
+                // rewrites it to an equality check.
+                if (microdiffModules_1.MICRODIFF_MODULES.has(importSource)) {
+                    node.specifiers.filter(bindsMicrodiffDiff).forEach((specifier) => {
+                        hasMicrodiffImport = true;
+                        microdiffImportName = specifier.local.name;
                     });
                 }
-                // Check for fast-deep-equal import
-                if (importSource === 'fast-deep-equal' ||
-                    importSource === 'fast-deep-equal/es6') {
+                // An equality function the file already has, under any of the
+                // specifiers that resolve to one — the scoped fork this codebase
+                // depends on, its React entry point, and upstream. Missing one of them
+                // costs the fix twice over: a second import of a function already in
+                // scope, and, when that import's local name is the one the fix emits, a
+                // collision with it that makes the fix decline outright and leaves the
+                // report with no remedy.
+                if (fastDeepEqualModules_1.FAST_DEEP_EQUAL_MODULES.has(importSource) &&
+                    node.specifiers.some(bindsFastDeepEqualFunction)) {
                     hasFastDeepEqualImport = true;
                     // Get the local name of the imported isEqual function
                     node.specifiers.forEach((specifier) => {

package/lib/rules/no-class-instance-destructuring.d.ts

@@ -1 +1,2 @@
-export declare const noClassInstanceDestructuring: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noClassInstanceDestructuring", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const noClassInstanceDestructuring: TSESLint.RuleModule<"noClassInstanceDestructuring", [], TSESLint.RuleListener>;

package/lib/rules/no-class-instance-destructuring.js

@@ -3,6 +3,94 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noClassInstanceDestructuring = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+/**
+ * A synthesized binding may not be a keyword, and may not be one of the
+ * bare-word globals whose rebinding would be legal but ruinous.
+ */
+const UNUSABLE_NAMES = new Set([
+    'break',
+    'case',
+    'catch',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'else',
+    'enum',
+    'export',
+    'extends',
+    'false',
+    'finally',
+    'for',
+    'function',
+    'if',
+    'implements',
+    'import',
+    'in',
+    'instanceof',
+    'interface',
+    'let',
+    'new',
+    'null',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'return',
+    'static',
+    'super',
+    'switch',
+    'this',
+    'throw',
+    'true',
+    'try',
+    'typeof',
+    'var',
+    'void',
+    'while',
+    'with',
+    'yield',
+    'await',
+    'arguments',
+    'eval',
+    'undefined',
+    'NaN',
+    'Infinity',
+]);
+/**
+ * Node types whose children are statements, so a single statement may be
+ * replaced by several. Anything else (a `for` initializer, an unbraced `if`
+ * body, a label) can hold exactly one.
+ */
+const STATEMENT_CONTAINERS = new Set([
+    utils_1.AST_NODE_TYPES.Program,
+    utils_1.AST_NODE_TYPES.BlockStatement,
+    utils_1.AST_NODE_TYPES.StaticBlock,
+    utils_1.AST_NODE_TYPES.SwitchCase,
+    utils_1.AST_NODE_TYPES.TSModuleBlock,
+]);
+const IDENTIFIER_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function isUsableName(name) {
+    return IDENTIFIER_PATTERN.test(name) && !UNUSABLE_NAMES.has(name);
+}
+/**
+ * `Person` -> `person`, `URL` -> `url`, `URLParser` -> `urlParser`. The leading
+ * run of capitals is treated as one word so an acronym does not become `uRL`.
+ */
+function lowerFirstWord(name) {
+    const leadingCapitals = /^[A-Z]+/.exec(name);
+    if (!leadingCapitals)
+        return name;
+    const run = leadingCapitals[0];
+    if (run.length === name.length)
+        return name.toLowerCase();
+    if (run.length === 1)
+        return name[0].toLowerCase() + name.slice(1);
+    return run.slice(0, -1).toLowerCase() + name.slice(run.length - 1);
+}
 exports.noClassInstanceDestructuring = (0, createRule_1.createRule)({
     name: 'no-class-instance-destructuring',
     meta: {
@@ -41,12 +129,12 @@ exports.noClassInstanceDestructuring = (0, createRule_1.createRule)({
             }
             return 'member';
         }
-        function buildAccessPath(initText, prop) {
+        function buildAccessPath(receiverText, prop) {
             const keyText = sourceCode.getText(prop.key);
             if (prop.key.type === utils_1.AST_NODE_TYPES.Identifier && !prop.computed) {
-                return `${initText}.${keyText}`;
+                return `${receiverText}.${keyText}`;
             }
-            return `${initText}[${keyText}]`;
+            return `${receiverText}[${keyText}]`;
         }
         function formatMembers(properties) {
             const memberNames = properties.map(describeMember).filter(Boolean);
@@ -54,12 +142,12 @@ exports.noClassInstanceDestructuring = (0, createRule_1.createRule)({
                 return '`<members>`';
             return memberNames.map((name) => `\`${name}\``).join(', ');
         }
-        function formatAccessExamples(properties, initText) {
+        function formatAccessExamples(properties, receiverText) {
             const accessPaths = properties
                 .filter((prop) => prop.type === utils_1.AST_NODE_TYPES.Property)
-                .map((prop) => buildAccessPath(initText, prop));
+                .map((prop) => buildAccessPath(receiverText, prop));
             if (accessPaths.length === 0) {
-                return `\`${initText}.<member>\``;
+                return `\`${receiverText}.<member>\``;
             }
             return accessPaths.map((path) => `\`${path}\``).join(', ');
         }
@@ -81,20 +169,134 @@ exports.noClassInstanceDestructuring = (0, createRule_1.createRule)({
             }
             return false;
         }
+        /**
+         * `new Person` and `new Person()` construct alike, but only the latter can
+         * carry a member access: `new Person.name` reads `name` off the class and
+         * constructs that instead.
+         */
+        function callableInitText(init) {
+            const text = sourceCode.getText(init);
+            if (init.type === utils_1.AST_NODE_TYPES.NewExpression && init.arguments) {
+                const lastToken = sourceCode.getLastToken(init);
+                if (lastToken?.value !== ')')
+                    return `${text}()`;
+            }
+            return text;
+        }
+        /**
+         * Every name that is visible where the temp binding would be inserted,
+         * including names only referenced (globals, imports resolved elsewhere) and
+         * names bound by nested closures that read through this scope. Reusing any
+         * of them would either redeclare or shadow a live binding — see the
+         * shadow-capture guard in `src/tests/fixer-shadow-capture.test.ts`.
+         */
+        function collectVisibleNames(scope) {
+            const names = new Set();
+            for (let current = scope; current; current = current.upper) {
+                for (const variable of current.variables) {
+                    names.add(variable.name);
+                }
+                for (const reference of current.through) {
+                    names.add(reference.identifier.name);
+                }
+            }
+            return names;
+        }
+        function calleeName(init) {
+            const { callee } = init;
+            if (callee.type === utils_1.AST_NODE_TYPES.Identifier)
+                return callee.name;
+            if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                !callee.computed &&
+                callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                return callee.property.name;
+            }
+            return null;
+        }
+        function baseNameFor(init) {
+            if (init.type !== utils_1.AST_NODE_TYPES.NewExpression)
+                return 'instance';
+            const raw = calleeName(init);
+            if (!raw)
+                return 'instance';
+            const lowered = lowerFirstWord(raw);
+            // An already-lowercase callee would have the temp shadow the class itself.
+            if (lowered !== raw && isUsableName(lowered))
+                return lowered;
+            const suffixed = `${lowered}Instance`;
+            return isUsableName(suffixed) ? suffixed : 'instance';
+        }
+        function uniqueName(base, taken) {
+            if (!taken.has(base))
+                return base;
+            for (let suffix = 2; suffix <= taken.size + 2; suffix++) {
+                const candidate = `${base}${suffix}`;
+                if (!taken.has(candidate))
+                    return candidate;
+            }
+            return base;
+        }
+        function indentOf(node) {
+            const line = sourceCode.lines[node.loc.start.line - 1] ?? '';
+            const leading = /^[\t ]*/.exec(line);
+            return leading ? leading[0] : '';
+        }
+        /**
+         * The statement that may be swapped for several declarations, or `null`
+         * when the declarator does not own a whole statement of its own.
+         */
+        function resolveStatement(node) {
+            const declaration = node.parent;
+            if (declaration?.type !== utils_1.AST_NODE_TYPES.VariableDeclaration)
+                return null;
+            // Splitting one declarator out of `const {a, b} = inst, c = 1;` would have
+            // to hoist emitted lines past declarators this fix does not own.
+            if (declaration.declarations.length !== 1)
+                return null;
+            const exportDeclaration = declaration.parent?.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration
+                ? declaration.parent
+                : null;
+            const statement = exportDeclaration ?? declaration;
+            if (!STATEMENT_CONTAINERS.has(statement.parent?.type ?? ''))
+                return null;
+            const text = sourceCode.getText(statement);
+            return {
+                statement,
+                kind: declaration.kind,
+                // Re-exporting each extracted member keeps the module's public surface,
+                // while the temp binding stays private.
+                exportPrefix: exportDeclaration ? 'export ' : '',
+                indent: indentOf(statement),
+                // Matching the source's own terminator keeps semicolon-free files intact.
+                terminator: text.endsWith(';') ? ';' : '',
+            };
+        }
         return {
             VariableDeclarator(node) {
                 if (node.id.type === utils_1.AST_NODE_TYPES.ObjectPattern &&
                     node.init &&
                     isClassInstance(node.init)) {
                     const objectPattern = node.id;
-                    const initText = sourceCode.getText(node.init);
+                    const init = node.init;
+                    const initText = sourceCode.getText(init);
+                    const propertyCount = objectPattern.properties.filter((prop) => prop.type === utils_1.AST_NODE_TYPES.Property).length;
+                    // Reading two members off `new Person()` twice would construct twice,
+                    // so the instance is bound once and read from. A plain identifier is
+                    // already such a binding, and a lone member read constructs once.
+                    const needsTempBinding = init.type !== utils_1.AST_NODE_TYPES.Identifier && propertyCount > 1;
+                    const tempName = needsTempBinding
+                        ? uniqueName(baseNameFor(init), collectVisibleNames(context.getScope()))
+                        : null;
+                    const receiverText = tempName ?? callableInitText(init);
                     context.report({
                         node,
                         messageId: 'noClassInstanceDestructuring',
                         data: {
                             members: formatMembers(objectPattern.properties),
                             instance: `\`${initText}\``,
-                            suggestion: formatAccessExamples(objectPattern.properties, initText),
+                            suggestion: tempName
+                                ? `\`const ${tempName} = ${initText};\` then ${formatAccessExamples(objectPattern.properties, tempName)}`
+                                : formatAccessExamples(objectPattern.properties, receiverText),
                         },
                         fix(fixer) {
                             const properties = objectPattern.properties;
@@ -108,33 +310,39 @@ exports.noClassInstanceDestructuring = (0, createRule_1.createRule)({
                             // the code to something more weakly typed than the author wrote.
                             if (objectPattern.typeAnnotation)
                                 return null;
-                            // For single property, use simple replacement
-                            if (properties.length === 1) {
-                                const prop = properties[0];
-                                if (prop.type === utils_1.AST_NODE_TYPES.Property) {
-                                    const value = prop.value.type === utils_1.AST_NODE_TYPES.Identifier
-                                        ? prop.value.name
-                                        : sourceCode.getText(prop.value);
-                                    const accessPath = buildAccessPath(initText, prop);
-                                    return fixer.replaceText(node, `${value} = ${accessPath}`);
-                                }
+                            if (properties.length === 0)
+                                return null;
+                            // A rest element collects the members no other property names, a
+                            // set only the type checker knows, so it cannot become a member
+                            // read. Rewriting the siblings alone would delete the binding.
+                            if (properties.some((prop) => prop.type !== utils_1.AST_NODE_TYPES.Property)) {
                                 return null;
                             }
-                            // For multiple properties, create multiple declarations
-                            const declarations = properties
-                                .filter((prop) => prop.type === utils_1.AST_NODE_TYPES.Property)
-                                .map((prop) => {
-                                const value = prop.value.type === utils_1.AST_NODE_TYPES.Identifier
-                                    ? prop.value.name
-                                    : sourceCode.getText(prop.value);
-                                const accessPath = buildAccessPath(initText, prop);
-                                return `${value} = ${accessPath}`;
-                            })
-                                .join(';\nconst ');
-                            // Only apply the fix if we have valid declarations
-                            if (!declarations)
+                            const props = properties;
+                            // `const {a = 1} = inst` applies the default only when the member
+                            // is `undefined`; a plain member read cannot express that.
+                            if (props.some((prop) => prop.value.type === utils_1.AST_NODE_TYPES.AssignmentPattern)) {
                                 return null;
-                            return fixer.replaceText(node, declarations);
+                            }
+                            const targetOf = (prop) => prop.value.type === utils_1.AST_NODE_TYPES.Identifier
+                                ? prop.value.name
+                                : sourceCode.getText(prop.value);
+                            // A single binding stays a single declarator, so it can be
+                            // rewritten in place wherever the declaration sits.
+                            if (props.length === 1) {
+                                return fixer.replaceText(node, `${targetOf(props[0])} = ${buildAccessPath(receiverText, props[0])}`);
+                            }
+                            const target = resolveStatement(node);
+                            if (!target)
+                                return null;
+                            const lines = tempName ? [`const ${tempName} = ${initText}`] : [];
+                            for (const prop of props) {
+                                lines.push(`${target.exportPrefix}${target.kind} ${targetOf(prop)} = ${buildAccessPath(receiverText, prop)}`);
+                            }
+                            // One replacement, so the whole rewrite lands or none of it does.
+                            return fixer.replaceText(target.statement, lines
+                                .map((line) => `${line}${target.terminator}`)
+                                .join(`\n${target.indent}`));
                         },
                     });
                 }

package/lib/utils/fastDeepEqualModules.d.ts

@@ -0,0 +1,30 @@
+/**
+ * BluMint's fast-deep-equal fork: the dependency this codebase declares, and
+ * therefore the only specifier a fixer may emit. An unscoped `fast-deep-equal`
+ * import resolves nowhere here (TS2307).
+ */
+export declare const FAST_DEEP_EQUAL_MODULE = "@blumintinc/fast-deep-equal";
+/**
+ * Every specifier that resolves to a deep-equality function of the same shape:
+ * the fork, its React entry point, upstream, and upstream's ESM build. A file on
+ * any of them already has the comparison this rule asks for, so all four have to
+ * be read identically when deciding whether an import is still needed.
+ *
+ * The literals live here rather than in each rule because the microdiff pair
+ * drifted twice: a rule carrying only the unscoped name is inert on every call
+ * site in a codebase that depends on the fork, and a fixer emitting the unscoped
+ * name writes an import that does not resolve.
+ */
+export declare const FAST_DEEP_EQUAL_MODULES: ReadonlySet<string>;
+/**
+ * The import statement a fixer writes to bind the equality function to
+ * `localName`.
+ *
+ * It is assembled here, beside the literal, rather than in the rule that emits
+ * it: `src/tests/enforce-dynamic-imports.test.ts` derives the modules this
+ * plugin's fixers inject by resolving module-scope string constants *within each
+ * source file*, so a specifier interpolated from an imported constant reads as
+ * unresolved and drops out of the check that every injected module is one the
+ * recommended config accepts.
+ */
+export declare const fastDeepEqualImport: (localName: string) => string;

package/lib/utils/fastDeepEqualModules.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fastDeepEqualImport = exports.FAST_DEEP_EQUAL_MODULES = exports.FAST_DEEP_EQUAL_MODULE = void 0;
+/**
+ * BluMint's fast-deep-equal fork: the dependency this codebase declares, and
+ * therefore the only specifier a fixer may emit. An unscoped `fast-deep-equal`
+ * import resolves nowhere here (TS2307).
+ */
+exports.FAST_DEEP_EQUAL_MODULE = '@blumintinc/fast-deep-equal';
+/**
+ * Every specifier that resolves to a deep-equality function of the same shape:
+ * the fork, its React entry point, upstream, and upstream's ESM build. A file on
+ * any of them already has the comparison this rule asks for, so all four have to
+ * be read identically when deciding whether an import is still needed.
+ *
+ * The literals live here rather than in each rule because the microdiff pair
+ * drifted twice: a rule carrying only the unscoped name is inert on every call
+ * site in a codebase that depends on the fork, and a fixer emitting the unscoped
+ * name writes an import that does not resolve.
+ */
+exports.FAST_DEEP_EQUAL_MODULES = new Set([
+    exports.FAST_DEEP_EQUAL_MODULE,
+    '@blumintinc/fast-deep-equal/react',
+    'fast-deep-equal',
+    'fast-deep-equal/es6',
+]);
+/**
+ * The import statement a fixer writes to bind the equality function to
+ * `localName`.
+ *
+ * It is assembled here, beside the literal, rather than in the rule that emits
+ * it: `src/tests/enforce-dynamic-imports.test.ts` derives the modules this
+ * plugin's fixers inject by resolving module-scope string constants *within each
+ * source file*, so a specifier interpolated from an imported constant reads as
+ * unresolved and drops out of the check that every injected module is one the
+ * recommended config accepts.
+ */
+const fastDeepEqualImport = (localName) => `import ${localName} from '${exports.FAST_DEEP_EQUAL_MODULE}';`;
+exports.fastDeepEqualImport = fastDeepEqualImport;
+//# sourceMappingURL=fastDeepEqualModules.js.map

package/lib/utils/microdiffModules.d.ts

@@ -0,0 +1,15 @@
+/**
+ * BluMint's microdiff fork: the dependency this codebase declares, and the
+ * specifier every real call site resolves against.
+ */
+export declare const MICRODIFF_MODULE = "@blumintinc/microdiff";
+/**
+ * Every specifier that resolves to microdiff. The fork and upstream are the
+ * same library under two names, so a file on either one is diffing
+ * structurally and has to be matched identically.
+ *
+ * The literal lives here rather than in each rule because the pair drifted
+ * twice: a rule carrying only the unscoped name is inert on every call site in
+ * a codebase that depends on the fork.
+ */
+export declare const MICRODIFF_MODULES: ReadonlySet<string>;

package/lib/utils/microdiffModules.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MICRODIFF_MODULES = exports.MICRODIFF_MODULE = void 0;
+/**
+ * BluMint's microdiff fork: the dependency this codebase declares, and the
+ * specifier every real call site resolves against.
+ */
+exports.MICRODIFF_MODULE = '@blumintinc/microdiff';
+/**
+ * Every specifier that resolves to microdiff. The fork and upstream are the
+ * same library under two names, so a file on either one is diffing
+ * structurally and has to be matched identically.
+ *
+ * The literal lives here rather than in each rule because the pair drifted
+ * twice: a rule carrying only the unscoped name is inert on every call site in
+ * a codebase that depends on the fork.
+ */
+exports.MICRODIFF_MODULES = new Set([
+    exports.MICRODIFF_MODULE,
+    'microdiff',
+]);
+//# sourceMappingURL=microdiffModules.js.map

package/package.json

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