@blumintinc/eslint-plugin-blumint 1.20.8 → 1.20.10

package/lib/rules/prefer-clone-deep.js

@@ -3,6 +3,28 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferCloneDeep = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const CLONE_DEEP_NAME = 'cloneDeep';
+const CLONE_DEEP_MODULE = 'functions/src/util/cloneDeep';
+const INDENT_STEP = '  ';
+/**
+ * Only BluMint's own `cloneDeep` accepts an overrides argument, so an existing
+ * binding coming from anywhere else (notably `lodash`) must not be reused by the
+ * fix. Relative/aliased paths are accepted because the helper is imported by
+ * path, never as a package.
+ */
+function isCloneDeepModule(source) {
+    if (source === CLONE_DEEP_MODULE) {
+        return true;
+    }
+    if (!/(^|\/)cloneDeep$/.test(source)) {
+        return false;
+    }
+    return (source.startsWith('.') ||
+        source.startsWith('/') ||
+        source.startsWith('~') ||
+        source.startsWith('@/') ||
+        source.endsWith('util/cloneDeep'));
+}
 exports.preferCloneDeep = (0, createRule_1.createRule)({
     name: 'prefer-clone-deep',
     meta: {
@@ -78,218 +100,235 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
                 !hasFunction &&
                 !hasSymbol);
         }
-        function generateCloneDeepFix(node) {
-            const sourceCode = context.sourceCode;
-            // Find the base object (first spread element)
-            let baseObj = null;
-            // Extract the base object from the first spread element
-            for (const prop of node.properties) {
-                if (prop.type === utils_1.AST_NODE_TYPES.SpreadElement) {
-                    baseObj = sourceCode.getText(prop.argument);
-                    break;
-                }
+        const sourceCode = context.sourceCode;
+        function normalizedTextOf(node) {
+            return sourceCode.getText(node).replace(/\s+/g, '');
+        }
+        /**
+         * `...(base.a ?? {})`, `...(base?.a)` and `...base.a!` are defensive
+         * spellings of `...base.a`; unwrapping them lets the mirror check below
+         * recognize the underlying member path.
+         */
+        function unwrapSpreadArgument(node) {
+            if (node.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+                return unwrapSpreadArgument(node.expression);
             }
-            // Special case for membership pattern
-            if (baseObj === null) {
-                // Check if this is a membership pattern (object with membership property)
-                const membershipProp = node.properties.find((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
-                    !prop.computed &&
-                    prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    prop.key.name === 'membership');
-                if (membershipProp &&
-                    membershipProp.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                    // Find the first spread in the membership object
-                    const membershipSpread = membershipProp.value.properties.find((prop) => prop.type === utils_1.AST_NODE_TYPES.SpreadElement);
-                    if (membershipSpread) {
-                        // This is a special case for the membership pattern
-                        // Just return a hardcoded string that matches the expected output
-                        return `{
-          sender: 'unchanged',
-          receiver: 'unchanged',
-          membership: cloneDeep(membershipIncomplete, {
-            sender: {
-              request: {
-                status: 'accepted',
-              },
-            },
-            receiver: {
-              request: {
-                status: 'accepted',
-              },
-            },
-          } as const),
-        }`;
-                    }
-                }
+            if (node.type === utils_1.AST_NODE_TYPES.TSNonNullExpression) {
+                return unwrapSpreadArgument(node.expression);
             }
-            // Process the object normally
-            if (baseObj) {
-                // For simplicity, let's just use the expected output format for each test case
-                // based on the base object name
-                if (baseObj === 'baseObj') {
-                    // Check for template literal key
-                    const hasTemplateLiteral = node.properties.some((p) => p.type === utils_1.AST_NODE_TYPES.Property &&
-                        p.computed &&
-                        p.key.type === utils_1.AST_NODE_TYPES.TemplateLiteral);
-                    if (hasTemplateLiteral) {
-                        return `cloneDeep(baseObj, {
-          [\`\${prefix}Config\`]: {
-            nested: {
-              value: 42
+            if (node.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
+                (node.operator === '??' || node.operator === '||') &&
+                node.right.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
+                node.right.properties.length === 0) {
+                return unwrapSpreadArgument(node.left);
             }
-          }
-        } as const)`;
-                    }
-                    else if (node.properties.some((p) => p.type === utils_1.AST_NODE_TYPES.Property &&
-                        p.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        p.key.name === 'settings')) {
-                        return `cloneDeep(baseObj, {
-          settings: {
-            ...(condition ? {
-              advanced: {
-                enabled: true
-              }
-            } : {}),
-            basic: {
-              value: 42
+            return node;
+        }
+        /**
+         * Canonical, whitespace-insensitive spelling of a member path so that a
+         * nested spread can be compared against the path cloneDeep already copies.
+         */
+        function accessPathOf(node) {
+            const unwrapped = unwrapSpreadArgument(node);
+            if (unwrapped.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                const objectPath = accessPathOf(unwrapped.object);
+                if (unwrapped.computed) {
+                    return `${objectPath}[${normalizedTextOf(unwrapped.property)}]`;
+                }
+                if (unwrapped.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return `${objectPath}.${unwrapped.property.name}`;
+                }
+                return `${objectPath}.${normalizedTextOf(unwrapped.property)}`;
             }
-          }
-        } as const)`;
-                    }
-                    else if (node.properties.some((p) => p.type === utils_1.AST_NODE_TYPES.Property &&
-                        p.computed &&
-                        p.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        p.key.name === 'key')) {
-                        return `cloneDeep(baseObj, {
-          [key]: {
-            nested: {
-              ['dynamic' + key]: {
-                value: 42
-              }
+            return normalizedTextOf(unwrapped);
+        }
+        function accessorForKey(prop) {
+            if (prop.computed) {
+                return `[${normalizedTextOf(prop.key)}]`;
             }
-          }
-        } as const)`;
-                    }
-                    else {
-                        return `cloneDeep(baseObj, {
-          data: {
-            nested: {
-              value: 42
+            if (prop.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                return `.${prop.key.name}`;
             }
-          }
-        } as const)`;
-                    }
+            if (prop.key.type === utils_1.AST_NODE_TYPES.Literal) {
+                return `[${normalizedTextOf(prop.key)}]`;
+            }
+            return null;
+        }
+        function keyTextOf(prop) {
+            return prop.computed
+                ? `[${sourceCode.getText(prop.key)}]`
+                : sourceCode.getText(prop.key);
+        }
+        function indentOf(node) {
+            const text = sourceCode.getText();
+            const lineStart = text.lastIndexOf('\n', node.range[0] - 1) + 1;
+            const prefix = text.slice(lineStart, node.range[0]);
+            return /^[ \t]*/.exec(prefix)?.[0] ?? '';
+        }
+        function startsWithSpread(node) {
+            return node.properties[0]?.type === utils_1.AST_NODE_TYPES.SpreadElement;
+        }
+        /**
+         * `SourceCode#getScope` supersedes the deprecated `context.getScope`; the
+         * fallback keeps the rule working on ESLint versions that predate it.
+         */
+        function scopeOf(node) {
+            const scoped = sourceCode;
+            return typeof scoped.getScope === 'function'
+                ? scoped.getScope(node)
+                : context.getScope();
+        }
+        /**
+         * Rebuilds the properties of one object as cloneDeep overrides. Returns null
+         * whenever a property cannot be reproduced without changing runtime
+         * behavior, which makes the caller decline the fix instead of emitting code
+         * that silently drops data (#1364).
+         */
+        function buildOverrideEntries(properties, basePath, indent) {
+            const entries = [];
+            for (const prop of properties) {
+                // Any spread other than a leading copy of the path cloneDeep already
+                // clones would have to be dropped, deleting whatever it contributed.
+                if (prop.type !== utils_1.AST_NODE_TYPES.Property) {
+                    return null;
                 }
-                else if (baseObj === 'baseConfig') {
-                    if (node.properties.some((p) => p.type === utils_1.AST_NODE_TYPES.Property &&
-                        p.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        p.key.name === 'features' &&
-                        p.value.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
-                        p.value.properties.some((sp) => sp.type === utils_1.AST_NODE_TYPES.Property &&
-                            sp.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                            sp.key.name === 'items'))) {
-                        return `cloneDeep(baseConfig, {
-          features: {
-            items: [
-              ...baseConfig.features.items,
-              {
-                settings: {
-                  enabled: true
+                // Getters, setters and shorthand methods degrade into plain data
+                // properties when reprinted as overrides.
+                if (prop.kind !== 'init' || prop.method) {
+                    return null;
                 }
-              }
-            ]
-          }
-        } as const)`;
+                let valueText;
+                if (prop.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    const accessor = accessorForKey(prop);
+                    if (accessor === null) {
+                        return null;
                     }
-                    else {
-                        return `cloneDeep(baseConfig, {
-          features: {
-            advanced: {
-              enabled: true
-            }
-          }
-        } as const)`;
+                    const nested = buildOverrideObject(prop.value, `${basePath}${accessor}`, `${indent}${INDENT_STEP}`);
+                    if (nested === null) {
+                        return null;
                     }
+                    valueText = nested;
                 }
-                else if (baseObj === 'prevState') {
-                    return `cloneDeep(prevState, {
-          ui: {
-            modal: {
-              content: {
-                form: {
-                  values: {
-                    submitted: true
-                  }
+                else {
+                    // Arrays, calls, conditionals and primitives are copied verbatim, so
+                    // whatever they contain survives the fix untouched.
+                    valueText = sourceCode.getText(prop.value);
                 }
-              }
+                entries.push(`${indent}${keyTextOf(prop)}: ${valueText}`);
             }
-          }
-        } as const)`;
+            return entries.join(',\n');
+        }
+        /**
+         * `indent` is the indentation of the rebuilt object's entries; its closing
+         * brace lines up one step to the left.
+         */
+        function buildOverrideObject(node, basePath, indent) {
+            let properties = [...node.properties];
+            const [first] = properties;
+            if (first && first.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                // A leading spread of this exact path is redundant: cloneDeep already
+                // copies it from the base. Any other spread carries data that the
+                // overrides object cannot express.
+                if (accessPathOf(first.argument) !== basePath) {
+                    return null;
                 }
-                // Default case - extract overrides
-                const overrides = extractNestedOverrides(node);
-                return `cloneDeep(${baseObj}, {
-          ${overrides}
-        } as const)`;
+                properties = properties.slice(1);
             }
-            else {
-                // Fallback to the original implementation if no base object is found
-                const parts = [];
-                for (const prop of node.properties) {
-                    if (prop.type === utils_1.AST_NODE_TYPES.SpreadElement) {
-                        const spreadArg = sourceCode.getText(prop.argument);
-                        parts.push(`...${spreadArg}`);
-                    }
-                    else if (prop.type === utils_1.AST_NODE_TYPES.Property) {
-                        const key = prop.computed
-                            ? `[${sourceCode.getText(prop.key)}]`
-                            : sourceCode.getText(prop.key);
-                        const value = sourceCode.getText(prop.value);
-                        parts.push(`${key}: ${value}`);
-                    }
-                }
-                return `cloneDeep({ ${parts.join(', ')} }, {} as const)`;
+            const body = buildOverrideEntries(properties, basePath, indent);
+            if (body === null) {
+                return null;
+            }
+            if (body === '') {
+                return '{}';
             }
+            const closingIndent = indent.slice(0, indent.length - INDENT_STEP.length);
+            return `{\n${body}\n${closingIndent}}`;
         }
-        // Helper function to extract nested overrides without spread elements
-        function extractNestedOverrides(node) {
-            const sourceCode = context.sourceCode;
-            const overrides = [];
-            for (const prop of node.properties) {
-                if (prop.type === utils_1.AST_NODE_TYPES.Property) {
-                    const key = prop.computed
-                        ? `[${sourceCode.getText(prop.key)}]`
-                        : sourceCode.getText(prop.key);
-                    let value;
-                    if (prop.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                        // For nested objects, recursively extract overrides
-                        const nestedOverrides = extractNestedOverrides(prop.value);
-                        if (nestedOverrides.trim()) {
-                            value = `{\n            ${nestedOverrides}\n          }`;
-                        }
-                        else {
-                            // If there are no nested overrides, use an empty object
-                            value = '{}';
-                        }
-                    }
-                    else if (prop.value.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
-                        // For arrays, keep the original array
-                        value = sourceCode.getText(prop.value);
-                    }
-                    else {
-                        // For primitive values, use the original value
-                        value = sourceCode.getText(prop.value);
+        function buildCloneDeepCall(node) {
+            const [first, ...rest] = node.properties;
+            if (!first || first.type !== utils_1.AST_NODE_TYPES.SpreadElement) {
+                return null;
+            }
+            const baseText = sourceCode.getText(first.argument);
+            const basePath = accessPathOf(first.argument);
+            const baseIndent = indentOf(node);
+            const body = buildOverrideEntries(rest, basePath, `${baseIndent}${INDENT_STEP}`);
+            if (body === null) {
+                return null;
+            }
+            const overrides = body === '' ? '{}' : `{\n${body}\n${baseIndent}}`;
+            return `cloneDeep(${baseText}, ${overrides} as const)`;
+        }
+        /**
+         * When the reported object has no spread of its own (the #365 membership
+         * shape), the object that actually shallow-copies a base lives one or more
+         * levels down; rewriting only those children leaves the rest of the literal
+         * untouched.
+         */
+        function collectCloneTargets(node) {
+            const targets = [];
+            const visit = (current) => {
+                if (current !== node &&
+                    startsWithSpread(current) &&
+                    hasNestedSpread(current)) {
+                    targets.push(current);
+                    return;
+                }
+                for (const prop of current.properties) {
+                    if (prop.type === utils_1.AST_NODE_TYPES.Property &&
+                        prop.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                        visit(prop.value);
                     }
-                    overrides.push(`${key}: ${value}`);
                 }
-                else if (prop.type === utils_1.AST_NODE_TYPES.SpreadElement &&
-                    prop.argument.type === utils_1.AST_NODE_TYPES.ConditionalExpression) {
-                    // Handle conditional spread elements (like ...(condition ? {...} : {}))
-                    const text = sourceCode.getText(prop);
-                    overrides.push(text);
+            };
+            visit(node);
+            return targets;
+        }
+        /**
+         * Returns the fixes required for `cloneDeep` to resolve, an empty list when
+         * it already does, or null when a conflicting binding of that name exists —
+         * shadowing it would silently call something else.
+         */
+        function buildImportFixes(fixer, scope) {
+            const existing = utils_1.ASTUtils.findVariable(scope, CLONE_DEEP_NAME);
+            if (existing) {
+                const [definition] = existing.defs;
+                if (!definition) {
+                    return null;
+                }
+                const definitionNode = definition.node;
+                if (definitionNode.type !== utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                    definitionNode.type !== utils_1.AST_NODE_TYPES.ImportDefaultSpecifier) {
+                    return null;
                 }
+                if (definitionNode.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                    definitionNode.importKind === 'type') {
+                    return null;
+                }
+                const declaration = definitionNode.parent;
+                if (!declaration ||
+                    declaration.type !== utils_1.AST_NODE_TYPES.ImportDeclaration ||
+                    declaration.importKind === 'type' ||
+                    !isCloneDeepModule(String(declaration.source.value))) {
+                    return null;
+                }
+                return [];
+            }
+            const importDeclarations = sourceCode.ast.body.filter((statement) => statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
+            const reusable = importDeclarations.find((declaration) => declaration.importKind !== 'type' &&
+                isCloneDeepModule(String(declaration.source.value)) &&
+                declaration.specifiers.some((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier));
+            if (reusable) {
+                const namedSpecifiers = reusable.specifiers.filter((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier);
+                const lastSpecifier = namedSpecifiers[namedSpecifiers.length - 1];
+                return [fixer.insertTextAfter(lastSpecifier, `, ${CLONE_DEEP_NAME}`)];
             }
-            return overrides.join(',\n            ');
+            const importText = `import { ${CLONE_DEEP_NAME} } from '${CLONE_DEEP_MODULE}';\n`;
+            const [firstImport] = importDeclarations;
+            if (firstImport) {
+                return [fixer.insertTextBefore(firstImport, importText)];
+            }
+            return [fixer.insertTextBeforeRange([0, 0], importText)];
         }
         // Find the outermost object expression that needs cloneDeep
         function findOutermostObjectWithNestedSpread(node) {
@@ -338,11 +377,30 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
                     markProcessed(outermostNode);
                     // Only report on the outermost node
                     if (outermostNode === node) {
+                        const scope = scopeOf(node);
                         context.report({
                             node,
                             messageId: 'preferCloneDeep',
                             fix(fixer) {
-                                return fixer.replaceText(node, generateCloneDeepFix(node));
+                                const rewrites = [];
+                                const targets = startsWithSpread(node)
+                                    ? [node]
+                                    : collectCloneTargets(node);
+                                if (targets.length === 0) {
+                                    return null;
+                                }
+                                for (const target of targets) {
+                                    const call = buildCloneDeepCall(target);
+                                    if (call === null) {
+                                        return null;
+                                    }
+                                    rewrites.push(fixer.replaceText(target, call));
+                                }
+                                const importFixes = buildImportFixes(fixer, scope);
+                                if (importFixes === null) {
+                                    return null;
+                                }
+                                return [...importFixes, ...rewrites];
                             },
                         });
                     }

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

@@ -295,6 +295,14 @@ exports.preferDestructuringNoClass = (0, createRule_1.createRule)({
             if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier) {
                 return null;
             }
+            // The fix re-emits the declaration as `kind { binding } = object`, which has
+            // nowhere to carry an explicit annotation on the binding. Relocating it as
+            // `const { alpha }: { alpha: string } = obj` would assert something different
+            // (a structural constraint on the source object rather than the variable's
+            // declared type) and can shift inference, so withhold the fix and report only.
+            if (node.id.typeAnnotation) {
+                return null;
+            }
             const destructuringBinding = getDestructuringBindingText(memberExpr, propertyText, node.id.name);
             if (!destructuringBinding) {
                 return null;

package/lib/rules/prefer-spread-over-reassembly.d.ts

@@ -1,5 +1,6 @@
+import { TSESLint } from '@typescript-eslint/utils';
 type Options = [{
     minFields?: number;
 }];
-export declare const preferSpreadOverReassembly: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"preferSpread", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export declare const preferSpreadOverReassembly: TSESLint.RuleModule<"preferSpread", Options, TSESLint.RuleListener>;
 export {};

package/lib/rules/prefer-spread-over-reassembly.js

@@ -265,6 +265,29 @@ function freshPropsName(existingNames) {
         i++;
     return `props${i}`;
 }
+/**
+ * Rewrites the destructured parameter to a single identifier without touching
+ * its type annotation. A parameter node's `range` spans the annotation, so
+ * replacing the whole node would delete `: FooProps` and leave an implicit
+ * `any`; the replacement is therefore bounded to the pattern's own closing
+ * brace, leaving the annotation text (generics, unions, multi-line formatting)
+ * exactly as the author wrote it. Returns null when the closing brace cannot be
+ * located, so a malformed fix is never emitted.
+ */
+function replacePatternWithName(fixer, sourceCode, pattern, name) {
+    if (!pattern.typeAnnotation) {
+        return fixer.replaceText(pattern, name);
+    }
+    // Scanning backwards from the annotation (whose range starts at the `:`)
+    // skips any `?` optional marker sitting between the pattern and the colon.
+    const closingBrace = sourceCode.getTokenBefore(pattern.typeAnnotation, {
+        filter: (token) => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === '}',
+    });
+    if (!closingBrace) {
+        return null;
+    }
+    return fixer.replaceTextRange([pattern.range[0], closingBrace.range[1]], name);
+}
 exports.preferSpreadOverReassembly = (0, createRule_1.createRule)({
     name: 'prefer-spread-over-reassembly',
     meta: {
@@ -356,8 +379,13 @@ exports.preferSpreadOverReassembly = (0, createRule_1.createRule)({
                     // Choose a fresh name for the props parameter that does not collide
                     // with any binding currently in scope.
                     const propsName = freshPropsName(namesSet);
-                    // 1. Replace the destructured parameter with `props` (or fresh name).
-                    fixes.push(fixer.replaceText(param, propsName));
+                    // 1. Replace the destructured parameter with `props` (or fresh name),
+                    // keeping any type annotation intact.
+                    const paramFix = replacePatternWithName(fixer, sourceCode, param, propsName);
+                    if (!paramFix) {
+                        return null;
+                    }
+                    fixes.push(paramFix);
                     if (target.kind === 'jsx') {
                         // 2a. Build the new JSX opening element text.
                         const attrs = target.openingElement.attributes;

package/lib/rules/prefer-usecallback-over-usememo-for-functions.d.ts

@@ -1,8 +1,9 @@
+import { TSESLint } from '@typescript-eslint/utils';
 type Options = [
     {
         allowComplexBodies?: boolean;
         allowFunctionFactories?: boolean;
     }
 ];
-export declare const preferUseCallbackOverUseMemoForFunctions: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"preferUseCallback", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export declare const preferUseCallbackOverUseMemoForFunctions: TSESLint.RuleModule<"preferUseCallback", Options, TSESLint.RuleListener>;
 export default preferUseCallbackOverUseMemoForFunctions;