@blumintinc/eslint-plugin-blumint 1.20.49 → 1.20.50

package/lib/index.js

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

package/lib/rules/consistent-callback-naming.js

@@ -52,7 +52,7 @@ module.exports = (0, createRule_1.createRule)({
         messages: {
             callbackPropPrefix: 'Callback prop "{{propName}}" is a function but lacks the "on" prefix. ' +
                 'Consistent "on" prefixes signal event handlers to consumers and distinguish callbacks from data props. ' +
-                'Rename to "on{{eventName}}".',
+                'Rename to "on{{eventName}}" here, in the props type that declares it, and in every reader of that prop.',
             callbackFunctionPrefix: 'Function "{{functionName}}" uses the "handle" prefix. ' +
                 'The "handle" prefix is redundant and less descriptive than action-oriented verb phrases. ' +
                 'Rename using a descriptive verb (e.g., click instead of handleClick).',
@@ -252,6 +252,18 @@ module.exports = (0, createRule_1.createRule)({
                         !isRenderFunction(node.value.expression) &&
                         !isReactComponentType(node.value.expression)) {
                         const eventName = propName.charAt(0).toUpperCase() + propName.slice(1);
+                        // Reported without an autofix (Bug #1522). A JSX attribute name is
+                        // one end of a props contract: the other end is the declaration
+                        // that binds the name — a props `type`/`interface`, a
+                        // `JSX.IntrinsicElements` augmentation for host elements — plus
+                        // every reader of that member (`props.validate`, destructuring) and
+                        // every other call site of the component. Rewriting only the
+                        // attribute yields TS2322, and renaming the local declaration
+                        // as well merely relocates the break: readers in the same file fail
+                        // with TS2551 and call sites in other files (which a single-file
+                        // fixer cannot see, let alone edit atomically) fail with TS2322.
+                        // No subset of the rename is safe to apply in isolation, so the
+                        // report carries the full instruction instead of a broken fix.
                         context.report({
                             node,
                             messageId: 'callbackPropPrefix',
@@ -259,10 +271,6 @@ module.exports = (0, createRule_1.createRule)({
                                 propName,
                                 eventName,
                             },
-                            fix(fixer) {
-                                // Convert camelCase to PascalCase for the event name
-                                return fixer.replaceText(node.name, `on${eventName}`);
-                            },
                         });
                     }
                 }

package/lib/rules/enforce-early-destructuring.js

@@ -407,8 +407,9 @@ function renderArrayPatternWithDefaults(pattern, sourceCode) {
             return `${leftText} = ${sourceCode.getText(element.right)}`;
         }
         if (element.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
-            const nested = renderObjectPatternWithDefaults(element, sourceCode);
-            return `${nested} = {}`;
+            // No synthesized `= {}` here either, for the reason spelled out in
+            // formatPropertyText: the default is checked against the bindings under it.
+            return renderObjectPatternWithDefaults(element, sourceCode);
         }
         if (element.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
             const nested = renderArrayPatternWithDefaults(element, sourceCode);
@@ -441,10 +442,19 @@ function formatPropertyText(property, sourceCode) {
         return renderPropertyWithAssignment(property, value, keyText, sourceCode);
     }
     if (value.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+        // A nested object pattern is re-emitted as authored, without a synthesized
+        // `= {}`. TypeScript checks such a default against every binding element
+        // beneath it, so `{ profile: { name, age } = {} }` reports TS2525 once per
+        // name: `{}` supplies no value and the names carry no defaults of their own.
+        // The default also only ever guarded a nullish parent (an explicitly `null`
+        // one still throws), so dropping it costs a partial runtime guard and buys
+        // back the invariant that compiling input yields compiling output.
         const nested = renderObjectPatternWithDefaults(value, sourceCode);
-        return `${keyText}: ${nested} = {}`;
+        return `${keyText}: ${nested}`;
     }
     if (value.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+        // An array pattern's `= []` default is safe to synthesize: TypeScript does
+        // not push it down onto the element bindings the way it does for objects.
         const nested = renderArrayPatternWithDefaults(value, sourceCode);
         return `${keyText}: ${nested} = []`;
     }

package/lib/rules/enforce-object-literal-as-const.js

@@ -3,6 +3,143 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceObjectLiteralAsConst = void 0;
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
+const FUNCTION_TYPES = new Set([
+    'FunctionDeclaration',
+    'FunctionExpression',
+    'ArrowFunctionExpression',
+]);
+/**
+ * A `return` inside a generator yields the generator type's *second* type
+ * argument; the first types the `yield`s. `IterableIterator` and friends leave
+ * `TReturn` unparameterised, so they carry no constraint on the returned value.
+ */
+const GENERATOR_TYPE_NAMES = new Set(['Generator', 'AsyncGenerator']);
+const PROMISE_TYPE_NAMES = new Set(['Promise', 'PromiseLike']);
+/**
+ * A readonly tuple is assignable to none of these, so a union member spelled
+ * this way cannot rescue an `as const` the rest of the union rejects.
+ */
+const NON_ARRAY_KEYWORDS = new Set([
+    'TSBigIntKeyword',
+    'TSBooleanKeyword',
+    'TSLiteralType',
+    'TSNeverKeyword',
+    'TSNullKeyword',
+    'TSNumberKeyword',
+    'TSStringKeyword',
+    'TSSymbolKeyword',
+    'TSUndefinedKeyword',
+    'TSVoidKeyword',
+]);
+/**
+ * Type arguments are `typeParameters` on this parser version and
+ * `typeArguments` on newer ones; both spell the same `<T>` after the name.
+ */
+function typeArgumentsOf(node) {
+    const withTypeArgs = node;
+    return ((withTypeArgs.typeArguments ?? withTypeArgs.typeParameters)?.params ?? []);
+}
+function typeReferenceNameOf(node) {
+    if (node.type !== 'TSTypeReference' || node.typeName.type !== 'Identifier') {
+        return undefined;
+    }
+    return node.typeName.name;
+}
+/**
+ * Whether a readonly tuple — what `as const` makes of an array literal — can be
+ * assigned to this annotation, judged from syntax alone.
+ *
+ * Only shapes the annotation states outright are treated as hostile. Anything
+ * the rule cannot resolve (a type reference, a type parameter, an object type)
+ * counts as accepting, because declining on no evidence would silence the rule
+ * across most annotated code.
+ */
+function acceptsReadonlyArray(typeNode) {
+    switch (typeNode.type) {
+        // `string[]` and `[string, number]` are mutable: TS4104 rejects a readonly
+        // tuple assigned to either.
+        case 'TSArrayType':
+        case 'TSTupleType':
+            return false;
+        // `readonly string[]` / `readonly [string, number]`.
+        case 'TSTypeOperator':
+            return typeNode.operator === 'readonly';
+        case 'TSTypeReference':
+            return typeReferenceNameOf(typeNode) !== 'Array';
+        // Assignable to the union as a whole iff assignable to some member.
+        case 'TSUnionType':
+            return typeNode.types.some(acceptsReadonlyArray);
+        case 'TSIntersectionType':
+            return typeNode.types.every(acceptsReadonlyArray);
+        default:
+            return !NON_ARRAY_KEYWORDS.has(typeNode.type);
+    }
+}
+/**
+ * The type a function type annotation declares for its return value, or
+ * `undefined` when the annotation is not a function type (a type reference to
+ * an aliased signature, say) and so states nothing resolvable here.
+ */
+function returnTypeOfFunctionType(typeNode) {
+    if (typeNode?.type !== 'TSFunctionType') {
+        return undefined;
+    }
+    return typeNode.returnType?.typeAnnotation;
+}
+/**
+ * The declared return type visible for `fn`, whether written on the function
+ * itself (`function f(): string[]`) or on the site that declares it — a typed
+ * variable, a typed class property, or an assertion on the function expression.
+ *
+ * A callback passed as a call argument is deliberately not resolved: its
+ * contextual type lives on the callee's declaration, which is usually in
+ * another file, and the in-file shapes that do reach here (`useMemo`, `.map`)
+ * annotate their callbacks generically rather than with a mutable array.
+ */
+function declaredReturnTypeOf(fn) {
+    if (fn.returnType) {
+        return fn.returnType.typeAnnotation;
+    }
+    const { parent } = fn;
+    if (!parent) {
+        return undefined;
+    }
+    if (parent.type === 'VariableDeclarator') {
+        return parent.id.type === 'Identifier'
+            ? returnTypeOfFunctionType(parent.id.typeAnnotation?.typeAnnotation)
+            : undefined;
+    }
+    if (parent.type === 'PropertyDefinition') {
+        return returnTypeOfFunctionType(parent.typeAnnotation?.typeAnnotation);
+    }
+    if (parent.type === 'TSAsExpression') {
+        return returnTypeOfFunctionType(parent.typeAnnotation);
+    }
+    return undefined;
+}
+/**
+ * The type the *returned expression* must satisfy. For an async function or a
+ * generator the declared return type wraps that expression's type, so the
+ * wrapper is peeled off before the annotation is judged.
+ */
+function returnedValueTypeOf(fn) {
+    const declared = declaredReturnTypeOf(fn);
+    if (!declared) {
+        return undefined;
+    }
+    const referenceName = typeReferenceNameOf(declared);
+    if (fn.generator) {
+        return referenceName && GENERATOR_TYPE_NAMES.has(referenceName)
+            ? typeArgumentsOf(declared)[1]
+            : undefined;
+    }
+    if (fn.async) {
+        return referenceName && PROMISE_TYPE_NAMES.has(referenceName)
+            ? typeArgumentsOf(declared)[0]
+            : undefined;
+    }
+    return declared;
+}
 exports.enforceObjectLiteralAsConst = (0, createRule_1.createRule)({
     name: 'enforce-object-literal-as-const',
     meta: {
@@ -55,6 +192,44 @@ exports.enforceObjectLiteralAsConst = (0, createRule_1.createRule)({
         function isArrayLiteral(node) {
             return node.type === 'ArrayExpression';
         }
+        /**
+         * The function the `return` belongs to — the nearest one, so a `return`
+         * inside a nested callback is judged against that callback's annotation
+         * rather than the outer function's.
+         */
+        function enclosingFunctionOf(ancestors) {
+            for (let i = ancestors.length - 1; i >= 0; i--) {
+                const ancestor = ancestors[i];
+                if (FUNCTION_TYPES.has(ancestor.type)) {
+                    return ancestor;
+                }
+            }
+            return undefined;
+        }
+        /**
+         * `as const` turns an array literal into a readonly *tuple*, which TS4104
+         * refuses to assign to a mutable array or tuple. Where the annotation says
+         * the value must be mutable, appending `as const` breaks the build, and no
+         * edit at the literal can satisfy the rule — honouring it would mean
+         * rewriting the signature, a call the author has to make. So the rule stays
+         * silent rather than reporting something the developer cannot act on
+         * (#1526).
+         *
+         * Object literals are unaffected: `readonly` property modifiers do not
+         * enter assignability, so `{ a: 1 } as const` still satisfies a mutable
+         * `{ a: number }`.
+         */
+        function conflictsWithDeclaredType(literal, ancestors) {
+            if (!isArrayLiteral(literal)) {
+                return false;
+            }
+            const enclosingFunction = enclosingFunctionOf(ancestors);
+            if (!enclosingFunction) {
+                return false;
+            }
+            const returnedValueType = returnedValueTypeOf(enclosingFunction);
+            return !!returnedValueType && !acceptsReadonlyArray(returnedValueType);
+        }
         return {
             ReturnStatement(node) {
                 // Skip if there's no argument in the return statement
@@ -102,12 +277,18 @@ exports.enforceObjectLiteralAsConst = (0, createRule_1.createRule)({
                         argument.elements.some((elem) => elem !== null && elem.type === 'SpreadElement'))) {
                     return;
                 }
+                const literal = argument.type === 'TSAsExpression'
+                    ? argument.expression
+                    : argument;
                 // Skip arrays returned from React hooks (memoized data/prop lists that
                 // must not be frozen into readonly tuples — see #511 and #1324)
-                if (isInsideReactHook(ancestors) &&
-                    isArrayLiteral(argument.type === 'TSAsExpression'
-                        ? argument.expression
-                        : argument)) {
+                if (isInsideReactHook(ancestors) && isArrayLiteral(literal)) {
+                    return;
+                }
+                // Skip arrays the enclosing signature declares mutable: `as const`
+                // cannot compile there and the developer cannot act on the report
+                // (#1526)
+                if (conflictsWithDeclaredType(literal, ancestors)) {
                     return;
                 }
                 // Report the issue and provide a fix

package/lib/rules/enforce-timestamp-now.d.ts

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

package/lib/rules/enforce-timestamp-now.js

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceTimestampNow = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const FIRESTORE_MODULES = new Set([
+    'firebase-admin/firestore',
+    'firebase/firestore',
+]);
 exports.enforceTimestampNow = (0, createRule_1.createRule)({
     name: 'enforce-timestamp-now',
     meta: {
@@ -35,8 +39,102 @@ exports.enforceTimestampNow = (0, createRule_1.createRule)({
         if (filename.includes('.test.') || filename.includes('.spec.')) {
             return {};
         }
-        // Track Timestamp imports and aliases
+        // Names that may denote the Firestore `Timestamp` class when matching
+        // `X.fromDate(new Date())` / `X.fromMillis(Date.now())`. Seeded with the
+        // default name so detection still works when the class reaches the file
+        // through a re-export or a `require()` the rule cannot see. Those reports
+        // rewrite an expression whose object identifier is already written in the
+        // source, so a seeded name can never produce an unbound reference.
         const timestampAliases = new Set(['Timestamp']);
+        // Names actually bound by an observed `Timestamp` import. Tracked apart
+        // from `timestampAliases` because the `new Date()` fix synthesizes an
+        // identifier the original code never mentions: with no real import the
+        // rewrite emits an unbound `Timestamp` and turns compiling code into
+        // TS2304 (issue #1521).
+        const importedTimestampAliases = [];
+        function recordTimestampAlias(localName) {
+            timestampAliases.add(localName);
+            if (!importedTimestampAliases.includes(localName)) {
+                importedTimestampAliases.push(localName);
+            }
+        }
+        /** Local names a static Firestore import binds to `Timestamp`. */
+        function staticTimestampAliases(node) {
+            if (typeof node.source.value !== 'string' ||
+                !FIRESTORE_MODULES.has(node.source.value)) {
+                return [];
+            }
+            return node.specifiers
+                .filter((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                specifier.imported.name === 'Timestamp')
+                .map((specifier) => specifier.local.name);
+        }
+        /**
+         * Local names a `const { Timestamp } = await import(...)` declarator binds
+         * to `Timestamp`.
+         */
+        function dynamicTimestampAliases(node) {
+            if (node.init?.type !== utils_1.AST_NODE_TYPES.AwaitExpression ||
+                node.init.argument.type !== utils_1.AST_NODE_TYPES.ImportExpression ||
+                node.id.type !== utils_1.AST_NODE_TYPES.ObjectPattern) {
+                return [];
+            }
+            const source = node.init.argument.source;
+            if (source.type !== utils_1.AST_NODE_TYPES.Literal ||
+                typeof source.value !== 'string' ||
+                !FIRESTORE_MODULES.has(source.value)) {
+                return [];
+            }
+            const aliases = [];
+            node.id.properties.forEach((prop) => {
+                if (prop.type === utils_1.AST_NODE_TYPES.Property &&
+                    prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    prop.key.name === 'Timestamp' &&
+                    prop.value.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    aliases.push(prop.value.name);
+                }
+            });
+            return aliases;
+        }
+        /** Whether a resolved binding is the Firestore `Timestamp` class itself. */
+        function isTimestampImportBinding(variable) {
+            return variable.defs.some((def) => {
+                if (def.node.type === utils_1.AST_NODE_TYPES.ImportSpecifier) {
+                    const declaration = def.node.parent;
+                    return (declaration?.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+                        staticTimestampAliases(declaration).includes(variable.name));
+                }
+                if (def.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                    return dynamicTimestampAliases(def.node).includes(variable.name);
+                }
+                return false;
+            });
+        }
+        /** The binding a name resolves to at the node currently being visited. */
+        function resolveBinding(name) {
+            let scope = context.getScope();
+            while (scope) {
+                const binding = scope.variables.find((variable) => variable.name === name);
+                if (binding) {
+                    return binding;
+                }
+                scope = scope.upper;
+            }
+            return undefined;
+        }
+        // A synthesized `Timestamp.now()` is only safe when the alias resolves to
+        // the import at the rewrite site. Resolution has to run per name from the
+        // innermost scope outward: an alias bound by a dynamic import inside another
+        // function is unreachable here, and an inner binding of the same name would
+        // capture the emitted reference and silently swap in a different value
+        // (issues #1455/#1456).
+        function findTimestampAliasInScope() {
+            return importedTimestampAliases.find((alias) => {
+                const binding = resolveBinding(alias);
+                return !!binding && isTimestampImportBinding(binding);
+            });
+        }
         function isTimestampFromDateWithNewDate(node) {
             // Check if it's a Timestamp.fromDate(new Date()) call
             if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
@@ -118,41 +216,20 @@ exports.enforceTimestampNow = (0, createRule_1.createRule)({
             });
         }
         return {
-            ImportDeclaration(node) {
-                // Track Timestamp imports from Firebase
-                if (node.source.value === 'firebase-admin/firestore' ||
-                    node.source.value === 'firebase/firestore') {
-                    node.specifiers.forEach((specifier) => {
-                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
-                            specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
-                            specifier.imported.name === 'Timestamp') {
-                            timestampAliases.add(specifier.local.name);
-                        }
-                    });
-                }
+            Program(node) {
+                // Collect static imports before any usage is visited. An import is
+                // hoisted and module-scoped, so it binds `Timestamp` for the whole file
+                // regardless of where it sits; visiting imports in traversal order
+                // would make the guard depend on the import preceding the usage.
+                node.body.forEach((statement) => {
+                    if (statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration) {
+                        staticTimestampAliases(statement).forEach(recordTimestampAlias);
+                    }
+                });
             },
             VariableDeclarator(node) {
                 // Track dynamic imports of Timestamp
-                if (node.init?.type === utils_1.AST_NODE_TYPES.AwaitExpression &&
-                    node.init.argument.type === utils_1.AST_NODE_TYPES.ImportExpression) {
-                    const importSource = node.init.argument.source;
-                    if (importSource.type === utils_1.AST_NODE_TYPES.Literal &&
-                        (importSource.value === 'firebase-admin/firestore' ||
-                            importSource.value === 'firebase/firestore')) {
-                        // Handle destructured imports
-                        if (node.id.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
-                            node.id.properties.forEach((prop) => {
-                                if (prop.type === utils_1.AST_NODE_TYPES.Property &&
-                                    prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                    prop.key.name === 'Timestamp') {
-                                    if (prop.value.type === utils_1.AST_NODE_TYPES.Identifier) {
-                                        timestampAliases.add(prop.value.name);
-                                    }
-                                }
-                            });
-                        }
-                    }
-                }
+                dynamicTimestampAliases(node).forEach(recordTimestampAlias);
             },
             CallExpression(node) {
                 if (isTimestampFromDateWithNewDate(node)) {
@@ -216,22 +293,26 @@ exports.enforceTimestampNow = (0, createRule_1.createRule)({
                                 // If the Date is being modified, don't flag it
                                 return;
                             }
-                            // Check if we have a Timestamp import before suggesting
-                            if (timestampAliases.size > 0) {
-                                const timestampName = Array.from(timestampAliases)[0];
-                                const expressionText = sourceCode.getText(node);
-                                context.report({
-                                    node,
-                                    messageId: 'preferTimestampNow',
-                                    data: {
-                                        expression: expressionText,
-                                        timestampAlias: timestampName,
-                                    },
-                                    fix(fixer) {
-                                        return fixer.replaceText(node, `${timestampName}.now()`);
-                                    },
-                                });
+                            // Stay silent unless a real `Timestamp` binding is in scope. The
+                            // rewrite names an identifier the source never mentions, and a
+                            // file with no Firestore import is almost certainly using the
+                            // `Date` for something other than a Firestore document anyway.
+                            const timestampName = findTimestampAliasInScope();
+                            if (!timestampName) {
+                                return;
                             }
+                            const expressionText = sourceCode.getText(node);
+                            context.report({
+                                node,
+                                messageId: 'preferTimestampNow',
+                                data: {
+                                    expression: expressionText,
+                                    timestampAlias: timestampName,
+                                },
+                                fix(fixer) {
+                                    return fixer.replaceText(node, `${timestampName}.now()`);
+                                },
+                            });
                         }
                     }
                 }

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/package.json

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

package/release-manifest.json

@@ -1,4 +1,50 @@
 [
+  {
+    "version": "1.20.50",
+    "date": "2026-07-31T12:53:09.792Z",
+    "rules": [
+      {
+        "name": "consistent-callback-naming",
+        "changeType": "fix",
+        "issues": [
+          1522
+        ],
+        "summary": "stop autofixing prop renames, which broke compilation (closes #1522)"
+      },
+      {
+        "name": "enforce-early-destructuring",
+        "changeType": "fix",
+        "issues": [
+          1523
+        ],
+        "summary": "drop the synthesized `= {}` on nested object patterns (closes #1523)"
+      },
+      {
+        "name": "enforce-object-literal-as-const",
+        "changeType": "fix",
+        "issues": [
+          1526
+        ],
+        "summary": "skip array literals a signature declares mutable (closes #1526)"
+      },
+      {
+        "name": "enforce-timestamp-now",
+        "changeType": "fix",
+        "issues": [
+          1521
+        ],
+        "summary": "gate the new Date() autofix on an in-scope Timestamp import (closes #1521)"
+      },
+      {
+        "name": "no-class-instance-destructuring",
+        "changeType": "fix",
+        "issues": [
+          1524
+        ],
+        "summary": "bind the instance once instead of reconstructing per property (closes #1524)"
+      }
+    ]
+  },
   {
     "version": "1.20.49",
     "date": "2026-07-31T10:04:24.469Z",