@blumintinc/eslint-plugin-blumint 1.20.63 → 1.20.65

package/lib/index.js

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

package/lib/rules/enforce-firestore-doc-ref-generic.js

@@ -565,6 +565,131 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
             }
             return false;
         }
+        /**
+         * `@firebase/rules-unit-testing` hands back the compat (v8) Firestore, whose
+         * `.doc()`, `.collection()` and `.collectionGroup()` declare zero type
+         * parameters. Asking for a schema generic there produces
+         * `TS2558: Expected 0 type arguments, but got 1`, so every remediation this
+         * rule suggests is uncompilable on that surface and the receiver must be
+         * exempt.
+         */
+        const RULES_UNIT_TESTING_MODULE = '@firebase/rules-unit-testing';
+        let rulesUnitTestingLocals;
+        /**
+         * Scanned lazily rather than from an `ImportDeclaration` visitor so that
+         * traversal order can never decide whether the exemption applies. Type-only
+         * specifiers count because a callback parameter annotated `RulesTestContext`
+         * is the other way a compat handle reaches a `.doc()` receiver.
+         */
+        function getRulesUnitTestingLocals() {
+            if (rulesUnitTestingLocals) {
+                return rulesUnitTestingLocals;
+            }
+            const locals = new Set();
+            for (const statement of context.sourceCode.ast.body) {
+                if (statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+                    statement.source.value === RULES_UNIT_TESTING_MODULE) {
+                    for (const specifier of statement.specifiers) {
+                        locals.add(specifier.local.name);
+                    }
+                }
+            }
+            rulesUnitTestingLocals = locals;
+            return locals;
+        }
+        /**
+         * A qualified annotation such as `rut.RulesTestContext` is rooted at the
+         * namespace binding, which is the name the import declaration provides.
+         */
+        function rootTypeNameOf(typeNode) {
+            if (typeNode.type !== utils_1.AST_NODE_TYPES.TSTypeReference) {
+                return undefined;
+            }
+            let entity = typeNode.typeName;
+            while (entity.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+                entity = entity.left;
+            }
+            return entity.type === utils_1.AST_NODE_TYPES.Identifier
+                ? entity.name
+                : undefined;
+        }
+        function isRulesUnitTestingType(typeNode) {
+            if (typeNode.type === utils_1.AST_NODE_TYPES.TSUnionType ||
+                typeNode.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+                return typeNode.types.some(isRulesUnitTestingType);
+            }
+            const rootName = rootTypeNameOf(typeNode);
+            return !!rootName && getRulesUnitTestingLocals().has(rootName);
+        }
+        /**
+         * Walks an expression toward its syntactic root and reports whether that
+         * root is a value supplied by `@firebase/rules-unit-testing`.
+         *
+         * Only `const` bindings are followed, mirroring `isTypedCollectionBinding`:
+         * a `let`/`var` receiver can be reassigned to an Admin SDK handle, where the
+         * generic is both supportable and valuable, so exempting it would silently
+         * drop enforcement.
+         */
+        function tracesToRulesUnitTesting(node, visited = new Set()) {
+            if (!node || getRulesUnitTestingLocals().size === 0) {
+                return false;
+            }
+            // Guards against a self-referential declaration such as `const a = a.b;`.
+            if (visited.has(node)) {
+                return false;
+            }
+            visited.add(node);
+            switch (node.type) {
+                case utils_1.AST_NODE_TYPES.AwaitExpression:
+                    return tracesToRulesUnitTesting(node.argument, visited);
+                case utils_1.AST_NODE_TYPES.CallExpression:
+                    return tracesToRulesUnitTesting(node.callee, visited);
+                case utils_1.AST_NODE_TYPES.MemberExpression:
+                    return tracesToRulesUnitTesting(node.object, visited);
+                case utils_1.AST_NODE_TYPES.ChainExpression:
+                    return tracesToRulesUnitTesting(node.expression, visited);
+                case utils_1.AST_NODE_TYPES.TSNonNullExpression:
+                case utils_1.AST_NODE_TYPES.TSAsExpression:
+                case utils_1.AST_NODE_TYPES.TSSatisfiesExpression:
+                case utils_1.AST_NODE_TYPES.TSTypeAssertion:
+                    return tracesToRulesUnitTesting(node.expression, visited);
+                case utils_1.AST_NODE_TYPES.Identifier:
+                    return identifierTracesToRulesUnitTesting(node, visited);
+                default:
+                    return false;
+            }
+        }
+        function identifierTracesToRulesUnitTesting(node, visited) {
+            const scope = ASTHelpers_1.ASTHelpers.getScope(context, node);
+            const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(scope, node.name);
+            if (!variable || variable.defs.length !== 1) {
+                return false;
+            }
+            const def = variable.defs[0];
+            if (def.type === 'ImportBinding') {
+                return (def.parent?.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+                    def.parent.source.value === RULES_UNIT_TESTING_MODULE);
+            }
+            // Covers the `withSecurityRulesDisabled(async (ctx: RulesTestContext) =>
+            // ...)` callback, where the compat handle never appears as an initializer.
+            if (def.type === 'Parameter') {
+                const annotation = def.name.typeAnnotation;
+                return (!!annotation && isRulesUnitTestingType(annotation.typeAnnotation));
+            }
+            if (def.type !== 'Variable' ||
+                def.node.type !== utils_1.AST_NODE_TYPES.VariableDeclarator ||
+                def.parent?.type !== utils_1.AST_NODE_TYPES.VariableDeclaration ||
+                def.parent.kind !== 'const') {
+                return false;
+            }
+            const declarator = def.node;
+            if (declarator.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                declarator.id.typeAnnotation &&
+                isRulesUnitTestingType(declarator.id.typeAnnotation.typeAnnotation)) {
+                return true;
+            }
+            return tracesToRulesUnitTesting(declarator.init, visited);
+        }
         return {
             TSTypeReference(node) {
                 if (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
@@ -601,6 +726,9 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
                 if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
                     node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
                     node.callee.property.name === 'doc') {
+                    if (tracesToRulesUnitTesting(node.callee.object)) {
+                        return;
+                    }
                     const typeAnnotation = node.typeParameters;
                     const isOnTypedCollection = isTypedCollectionReference(node.callee.object);
                     // If this is a .doc() call on a typed CollectionReference,
@@ -655,6 +783,9 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
                     node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
                     node.callee.property.name === 'collection' &&
                     !isPartOfMethodChain(node)) {
+                    if (tracesToRulesUnitTesting(node.callee.object)) {
+                        return;
+                    }
                     const typeAnnotation = node.typeParameters;
                     if (!typeAnnotation) {
                         context.report({
@@ -675,6 +806,9 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
                 else if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
                     node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
                     node.callee.property.name === 'collectionGroup') {
+                    if (tracesToRulesUnitTesting(node.callee.object)) {
+                        return;
+                    }
                     const typeAnnotation = node.typeParameters;
                     if (!typeAnnotation) {
                         context.report({

package/lib/rules/enforce-id-capitalization.js

@@ -27,6 +27,7 @@ exports.enforceIdCapitalization = (0, createRule_1.createRule)({
         // Regular expression to match standalone "id" surrounded by whitespace or punctuation
         // This ensures we only match "id" as a word, not as part of another word
         const idRegex = /(^|\s|[.,;:!?'"()\[\]{}])id(\s|$|[.,;:!?'"()\[\]{}])/g;
+        const sourceCode = context.getSourceCode();
         // DOM / Testing-Library APIs whose first argument is an attribute NAME
         // (code), not user-facing text. A literal like 'id' passed here is a DOM
         // attribute name; flagging or rewriting it to 'ID' breaks the call.
@@ -145,6 +146,54 @@ exports.enforceIdCapitalization = (0, createRule_1.createRule)({
             }
             return false;
         }
+        /**
+         * Escape a string so it can sit inside a literal delimited by `delimiter`.
+         *
+         * JSON escaping already covers backslashes, control characters and every
+         * other sequence a JavaScript string literal needs, but it is hardcoded to
+         * double quotes. For a single-quoted literal the escaping is simply
+         * inverted: the double quotes go bare and the apostrophes carry the
+         * backslash.
+         */
+        function escapeForDelimiter(text, delimiter) {
+            const jsonBody = JSON.stringify(text).slice(1, -1);
+            if (delimiter === '"') {
+                return jsonBody;
+            }
+            // Every `"` in a JSON body is escaped and every `\` belongs to an escape
+            // sequence, so unescaping the quotes first cannot corrupt a `\\` pair.
+            return jsonBody.replace(/\\"/g, '"').replace(/'/g, "\\'");
+        }
+        /**
+         * Rebuild a string literal around the corrected text, keeping the quote
+         * character the author chose. Rewriting the delimiter is a formatting
+         * regression on every fixed file, so the fix has to reuse it.
+         */
+        function fixStringLiteral(node, fixedText) {
+            const raw = sourceCode.getText(node);
+            const delimiter = raw[0];
+            if (delimiter !== "'" && delimiter !== '"') {
+                return null;
+            }
+            const rawBody = raw.slice(1, -1);
+            const isJsxAttributeValue = node.parent && node.parent.type === utils_1.AST_NODE_TYPES.JSXAttribute;
+            // Substituting inside the raw source reproduces the file byte for byte,
+            // so take that path whenever the source between the quotes already is the
+            // parsed value. It is also the only safe path for a JSX attribute value,
+            // which the parser does not escape-process: there a backslash is a
+            // literal character (rebuilding would double it) and an entity such as
+            // " decodes to a delimiter that cannot be written back escaped.
+            if (rawBody === node.value || isJsxAttributeValue) {
+                idRegex.lastIndex = 0;
+                const fixedBody = rawBody.replace(idRegex, (_match, prefix, suffix) => `${prefix}ID${suffix}`);
+                // An entity-bearing JSX value can carry the match only in its decoded
+                // form; report it without a fix rather than emit a no-op replacement.
+                return fixedBody === rawBody
+                    ? null
+                    : `${delimiter}${fixedBody}${delimiter}`;
+            }
+            return `${delimiter}${escapeForDelimiter(fixedText, delimiter)}${delimiter}`;
+        }
         /**
          * Check if a string contains "id" as a standalone word and report if found
          */
@@ -177,16 +226,21 @@ exports.enforceIdCapitalization = (0, createRule_1.createRule)({
                     node,
                     messageId: 'enforceIdCapitalization',
                     fix: (fixer) => {
-                        if (node.type === utils_1.AST_NODE_TYPES.Literal) {
-                            return fixer.replaceText(node, JSON.stringify(fixedText));
-                        }
-                        else if (node.type === utils_1.AST_NODE_TYPES.JSXText) {
+                        // JSX text carries no delimiters, so its own text is the content.
+                        if (node.type === utils_1.AST_NODE_TYPES.JSXText) {
                             return fixer.replaceText(node, fixedText);
                         }
-                        else if (node.type === utils_1.AST_NODE_TYPES.TemplateElement) {
-                            return fixer.replaceText(node, fixedText);
+                        if (node.type === utils_1.AST_NODE_TYPES.Literal) {
+                            const replacement = fixStringLiteral(node, fixedText);
+                            return replacement === null
+                                ? null
+                                : fixer.replaceText(node, replacement);
                         }
-                        return fixer.replaceText(node, JSON.stringify(fixedText));
+                        // Any other node kind (a TemplateElement, say) is a fragment of a
+                        // larger construct whose delimiters and `${}` expressions live
+                        // outside this node; rebuilding it from the parsed value would
+                        // destroy them, so report without a fix.
+                        return null;
                     },
                 });
             }

package/lib/rules/enforce-memoize-async.js

@@ -75,6 +75,57 @@ function declaresVoidResult(returnType) {
     return (typeArguments?.length === 1 &&
         typeArguments[0].type === utils_1.AST_NODE_TYPES.TSVoidKeyword);
 }
+/**
+ * The type annotation a parameter declares, reached through the wrapper shapes
+ * a parameter can take. A default value (`cb = noop`) holds the annotated
+ * binding in `left`, while a rest element carries the annotation on itself and
+ * keeps only the binding name in `argument`.
+ */
+function parameterAnnotation(param) {
+    if (param.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return param.typeAnnotation?.typeAnnotation;
+    }
+    if (param.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+        return param.left.typeAnnotation?.typeAnnotation;
+    }
+    if (param.type === utils_1.AST_NODE_TYPES.RestElement) {
+        return (param.typeAnnotation?.typeAnnotation ??
+            (param.argument.type === utils_1.AST_NODE_TYPES.Identifier
+                ? param.argument.typeAnnotation?.typeAnnotation
+                : undefined));
+    }
+    return undefined;
+}
+/**
+ * Whether the method's sole parameter is annotated as a function.
+ *
+ * `@Memoize()` keys its cache on the argument value, compared against stored
+ * entries by deep equality. A function argument satisfies that comparison in
+ * exactly two ways and both defeat the decorator: a stable reference (a
+ * module-level function, a bound method, `this.handler`) matches the first
+ * entry, so every later call replays the first result and the body never runs
+ * again; a fresh arrow per call — the common shape — matches nothing, so every
+ * lookup misses while the map accumulates one dead closure per call and each
+ * later call pays a longer scan. Neither is an optimisation, and the fixer
+ * would apply it unattended, so such a method is skipped.
+ *
+ * The `params.length > 1` gate already encodes that the decorator keys on a
+ * single argument; this asks the remaining question, whether that argument is
+ * keyable at all.
+ *
+ * Detection is syntactic, mirroring the return-type exemption: only an
+ * annotation written as a function type declares the intent to honour. A
+ * callback reached through a type alias (`onUrl: UrlPresenter`) or hidden in a
+ * union (`cb: string | (() => void)`) is not categorically a function without a
+ * type checker this rule deliberately does not require, and an unannotated
+ * parameter declares nothing at all, so all of those keep reporting.
+ */
+function declaresFunctionParameter(params) {
+    if (params.length !== 1) {
+        return false;
+    }
+    return parameterAnnotation(params[0])?.type === utils_1.AST_NODE_TYPES.TSFunctionType;
+}
 /**
  * Matches a memoize decorator in supported syntaxes:
  * - @Alias()
@@ -181,6 +232,11 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                 if (node.value.params.length > 1) {
                     return;
                 }
+                // A callback argument cannot serve as a cache key, so the decorator
+                // either replays a stale result or never hits while leaking entries.
+                if (declaresFunctionParameter(node.value.params)) {
+                    return;
+                }
                 // A method declared to produce no value has no result to cache, so the
                 // decorator's benefit is unobtainable while its cost is real: the
                 // fixer would convert a repeatable side effect into a

package/lib/rules/enforce-memoize-getters.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceMemoizeGetters = void 0;
 const utils_1 = require("@typescript-eslint/utils");
+const visitor_keys_1 = require("@typescript-eslint/visitor-keys");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const disableDirectives_1 = require("../utils/disableDirectives");
@@ -68,6 +69,238 @@ function isMemoizeDecorator(decorator, alias) {
     }
     return false;
 }
+/**
+ * Node modules whose exports observe or drive the world outside the process.
+ * A getter that reaches one of them yields a fresh observation per access, and
+ * `@Memoize()` would pin the first observation for the life of the instance —
+ * a behaviour change, not an optimization.
+ */
+const IO_MODULES = new Set([
+    'child_process',
+    'node:child_process',
+    'fs',
+    'node:fs',
+    'fs/promises',
+    'node:fs/promises',
+    'net',
+    'node:net',
+    'http',
+    'node:http',
+    'https',
+    'node:https',
+    'dns',
+    'node:dns',
+]);
+/**
+ * Builtins whose result differs between two otherwise identical accesses, so
+ * the cached first value stops tracking whatever the getter samples.
+ */
+const NON_DETERMINISTIC_CALLS = new Set([
+    'Date.now',
+    'Math.random',
+    'performance.now',
+    'crypto.randomUUID',
+    'crypto.getRandomValues',
+    'process.hrtime',
+    'process.hrtime.bigint',
+]);
+/**
+ * The dotted path of a chain of plain identifiers (`process.hrtime.bigint`), or
+ * `null` once any link is computed or is not an identifier. Keying on the
+ * spelled path keeps the analysis syntactic, which is all this rule has: it
+ * runs without `parserOptions.project`, so no type information is available.
+ */
+function staticMemberPath(node) {
+    if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return node.name;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !node.computed &&
+        node.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        const objectPath = staticMemberPath(node.object);
+        return objectPath === null ? null : `${objectPath}.${node.property.name}`;
+    }
+    return null;
+}
+/**
+ * The member name a key spells, covering the forms `this.<name>` can reach:
+ * plain identifiers, string-literal keys, and private names.
+ */
+function keyName(key) {
+    if (key.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return key.name;
+    }
+    if (key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) {
+        return `#${key.name}`;
+    }
+    if (key.type === utils_1.AST_NODE_TYPES.Literal && typeof key.value === 'string') {
+        return key.value;
+    }
+    return null;
+}
+/** The member name of a `this.<name>` access, or `null` for anything else. */
+function thisMemberName(node) {
+    if (node.type !== utils_1.AST_NODE_TYPES.MemberExpression ||
+        node.object.type !== utils_1.AST_NODE_TYPES.ThisExpression) {
+        return null;
+    }
+    return keyName(node.property);
+}
+function forEachDescendant(root, visit) {
+    const stack = [root];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current) {
+            break;
+        }
+        visit(current);
+        const keys = visitor_keys_1.visitorKeys[current.type] ?? [];
+        for (const key of keys) {
+            const value = current[key];
+            if (Array.isArray(value)) {
+                for (const element of value) {
+                    if (ASTHelpers_1.ASTHelpers.isNode(element)) {
+                        stack.push(element);
+                    }
+                }
+            }
+            else if (ASTHelpers_1.ASTHelpers.isNode(value)) {
+                stack.push(value);
+            }
+        }
+    }
+}
+/**
+ * Local names bound by an import of a Node I/O module, covering named, default
+ * and namespace specifiers alike: a call through any of them — `execFileSync()`
+ * or `fs.readFileSync()` — reaches the same I/O.
+ */
+function collectIoBindings(program) {
+    const bindings = new Set();
+    for (const statement of program.body) {
+        if (statement.type !== utils_1.AST_NODE_TYPES.ImportDeclaration ||
+            statement.importKind === 'type' ||
+            !IO_MODULES.has(String(statement.source.value))) {
+            continue;
+        }
+        for (const specifier of statement.specifiers) {
+            if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                specifier.importKind === 'type') {
+                continue;
+            }
+            bindings.add(specifier.local.name);
+        }
+    }
+    return bindings;
+}
+/**
+ * Whether a single node is one of the seed impurities: a call reaching a Node
+ * I/O binding, a non-deterministic builtin, or a read of `process.env`.
+ */
+function isImpureSeed(node, ioBindings) {
+    // `new Date()` samples the wall clock; `new Date(value)` is a pure conversion.
+    if (node.type === utils_1.AST_NODE_TYPES.NewExpression) {
+        return (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+            node.callee.name === 'Date' &&
+            node.arguments.length === 0);
+    }
+    // Every `process.env.X` / `process.env['X']` read contains this subexpression.
+    if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        return staticMemberPath(node) === 'process.env';
+    }
+    if (node.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+        return false;
+    }
+    const calleePath = staticMemberPath(node.callee);
+    if (calleePath === null) {
+        return false;
+    }
+    return (NON_DETERMINISTIC_CALLS.has(calleePath) ||
+        ioBindings.has(calleePath.split('.')[0]));
+}
+/**
+ * The function a class element carries and the name `this.<name>` reaches it
+ * by, for the element kinds a getter can delegate to: methods, accessors, and
+ * fields holding a function. Anything else (a static block, a plain field) is
+ * not a delegation target.
+ */
+function describeMember(element) {
+    if (element.type === utils_1.AST_NODE_TYPES.MethodDefinition ||
+        element.type === utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition) {
+        return { fn: element.value, name: keyName(element.key) };
+    }
+    if (element.type === utils_1.AST_NODE_TYPES.PropertyDefinition &&
+        (element.value?.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+            element.value?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression)) {
+        return { fn: element.value, name: keyName(element.key) };
+    }
+    return undefined;
+}
+/**
+ * The class elements whose value depends on live external state, as a
+ * class-local fixpoint: seed the members that reach I/O or a non-deterministic
+ * builtin directly, then keep marking any member that touches an already-impure
+ * `this.<member>` until nothing changes.
+ *
+ * The iteration — rather than a single direct-callee check — is what covers the
+ * production shape that motivates the exemption: a getter delegating to a
+ * sibling private method that itself delegates further before reaching the I/O
+ * call.
+ */
+function analyzeClassImpurity(classBody, ioBindings) {
+    const analyses = [];
+    const byName = new Map();
+    for (const element of classBody.body) {
+        const member = describeMember(element);
+        if (!member) {
+            continue;
+        }
+        const analysis = {
+            element,
+            dependencies: new Set(),
+            impure: false,
+        };
+        forEachDescendant(member.fn, (node) => {
+            if (isImpureSeed(node, ioBindings)) {
+                analysis.impure = true;
+                return;
+            }
+            // A bare read of `this.<member>` counts alongside a call: reading an
+            // impure getter is exactly the propagation path this analysis exists for.
+            const dependency = thisMemberName(node);
+            if (dependency !== null) {
+                analysis.dependencies.add(dependency);
+            }
+        });
+        analyses.push(analysis);
+        if (member.name !== null) {
+            const siblings = byName.get(member.name);
+            if (siblings) {
+                siblings.push(analysis);
+            }
+            else {
+                byName.set(member.name, [analysis]);
+            }
+        }
+    }
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const analysis of analyses) {
+            if (analysis.impure) {
+                continue;
+            }
+            const reachesImpure = [...analysis.dependencies].some((dependency) => (byName.get(dependency) ?? []).some((target) => target.impure));
+            if (reachesImpure) {
+                analysis.impure = true;
+                changed = true;
+            }
+        }
+    }
+    return new Set(analyses
+        .filter((analysis) => analysis.impure)
+        .map(({ element }) => element));
+}
 exports.enforceMemoizeGetters = (0, createRule_1.createRule)({
     name: 'enforce-memoize-getters',
     meta: {
@@ -150,6 +383,24 @@ exports.enforceMemoizeGetters = (0, createRule_1.createRule)({
             }
             return memoizeImportCache;
         };
+        let ioBindingCache = null;
+        const ioBindings = () => {
+            if (!ioBindingCache) {
+                ioBindingCache = collectIoBindings(sourceCode.ast);
+            }
+            return ioBindingCache;
+        };
+        // One fixpoint per class serves every getter it declares.
+        const impurityCache = new Map();
+        const impureMembersOf = (classBody) => {
+            const cached = impurityCache.get(classBody);
+            if (cached) {
+                return cached;
+            }
+            const analyzed = analyzeClassImpurity(classBody, ioBindings());
+            impurityCache.set(classBody, analyzed);
+            return analyzed;
+        };
         return {
             MethodDefinition(node) {
                 // Target: instance private getters
@@ -161,6 +412,14 @@ exports.enforceMemoizeGetters = (0, createRule_1.createRule)({
                 // enforce only "private" accessibility (undefined => public)
                 if (node.accessibility !== 'private')
                     return;
+                // A getter whose value is a fresh read of live external state is not a
+                // lazy factory: memoizing it pins the first observation forever, so the
+                // report is dropped along with its unattended `--fix` edit.
+                const classBody = node.parent;
+                if (classBody?.type === utils_1.AST_NODE_TYPES.ClassBody &&
+                    impureMembersOf(classBody).has(node)) {
+                    return;
+                }
                 const { hasMemoizeImport, memoizeAlias, memoizeNamespace, hasNamedImport, } = memoizeImports();
                 const decoratorAliases = memoizeAlias === MEMOIZE_NAME
                     ? [MEMOIZE_NAME]

package/lib/rules/no-empty-dependency-use-callbacks.js

@@ -390,6 +390,79 @@ function getModuleScopeValueBindings(program) {
     }
     return names;
 }
+/** The leading whitespace of the line the offset sits on. */
+function indentationAt(sourceCode, offset) {
+    const text = sourceCode.getText();
+    const lineStart = text.lastIndexOf('\n', offset - 1) + 1;
+    const match = /^[ \t]*/.exec(text.slice(lineStart, offset));
+    return match ? match[0] : '';
+}
+/**
+ * Ranges whose interior line breaks carry string data rather than formatting.
+ * A multi-line template literal (or a string spliced together with line
+ * continuations) evaluates to the whitespace written inside it, so shifting
+ * those lines would silently change the value the code produces.
+ */
+function stringDataRangesOf(sourceCode, node) {
+    return sourceCode
+        .getTokens(node)
+        .filter((token) => (token.type === utils_1.AST_TOKEN_TYPES.Template ||
+        token.type === utils_1.AST_TOKEN_TYPES.String) &&
+        token.loc.start.line !== token.loc.end.line)
+        .map((token) => token.range);
+}
+/**
+ * The callback's text re-indented for the module scope it is hoisted into.
+ *
+ * Module scope sits at least one nesting level shallower than the component
+ * body the callback is lifted out of, so splicing the text verbatim leaves
+ * every interior line — and the closing brace — indented for a level the
+ * declaration no longer occupies (issue #1560). Each line therefore moves by
+ * the difference between the callback's original indentation and the
+ * indentation of the statement the declaration is inserted before. The
+ * callback's own line is the reference rather than the declaration's, so a
+ * callback broken onto its own argument line sheds that extra level too.
+ */
+function dedentedCallbackText(sourceCode, callback, hoistTarget) {
+    const text = sourceCode.getText(callback);
+    const targetIndent = indentationAt(sourceCode, hoistTarget.range[0]);
+    const callbackIndent = indentationAt(sourceCode, callback.range[0]);
+    if (targetIndent === callbackIndent) {
+        return text;
+    }
+    const shiftLine = (() => {
+        if (callbackIndent.startsWith(targetIndent)) {
+            const removed = callbackIndent.slice(targetIndent.length);
+            return (line) => line.startsWith(removed) ? line.slice(removed.length) : line;
+        }
+        if (targetIndent.startsWith(callbackIndent)) {
+            const added = targetIndent.slice(callbackIndent.length);
+            return (line) => `${added}${line}`;
+        }
+        // Indent characters that disagree give no delta that can be applied
+        // without corrupting the layout, so the text is left as the author wrote it.
+        return null;
+    })();
+    if (!shiftLine) {
+        return text;
+    }
+    const stringData = stringDataRangesOf(sourceCode, callback);
+    const carriesStringData = (offset) => stringData.some(([start, end]) => start < offset && offset < end);
+    let offset = callback.range[0];
+    return text
+        .split('\n')
+        .map((line, index) => {
+        const lineStart = offset;
+        offset += line.length + 1;
+        // The first line is spliced in after the hoisted declaration's `=`, so it
+        // has no indentation of its own left to adjust.
+        if (index === 0 || line.trim() === '' || carriesStringData(lineStart)) {
+            return line;
+        }
+        return shiftLine(line);
+    })
+        .join('\n');
+}
 function buildHoistFixes(context, callExpression, callback, hoistedIdentifierCache) {
     if (!callExpression.parent ||
         callExpression.parent.type !== utils_1.AST_NODE_TYPES.VariableDeclarator) {
@@ -442,7 +515,7 @@ function buildHoistFixes(context, callExpression, callback, hoistedIdentifierCac
     const identifierText = sourceCode
         .getText()
         .slice(declarator.id.range[0], idRangeEnd);
-    const functionText = sourceCode.getText(callback);
+    const functionText = dedentedCallbackText(sourceCode, callback, hoistTarget);
     const hoisted = `const ${identifierText} = ${functionText};\n`;
     const fileText = sourceCode.getText();
     let removeStart = varDecl.range[0];

package/lib/rules/no-explicit-return-type.d.ts

@@ -8,6 +8,7 @@ type Options = [
         allowAbstractMethodSignatures?: boolean;
         allowDtsFiles?: boolean;
         allowFirestoreFunctionFiles?: boolean;
+        allowVoidReturnTypes?: boolean;
     }
 ];
 export declare const noExplicitReturnType: TSESLint.RuleModule<MessageIds, Options>;

package/lib/rules/no-explicit-return-type.js

@@ -10,6 +10,7 @@ const defaultOptions = {
     allowAbstractMethodSignatures: true,
     allowDtsFiles: true,
     allowFirestoreFunctionFiles: true,
+    allowVoidReturnTypes: true,
 };
 function getNameFromIdentifierOrLiteral(key) {
     if (key.type === utils_1.AST_NODE_TYPES.Identifier) {
@@ -576,6 +577,45 @@ function isReadonlyWideningReturnType(returnType) {
     }
     return false;
 }
+/**
+ * Returns true when the annotation declares that the function produces no
+ * value: a bare `void`, or `Promise<void>` with exactly one type argument.
+ *
+ * The rule's case against an explicit return type is that it restates what the
+ * implementation already returns and "can drift from what the implementation
+ * actually returns, hiding bugs behind a stale type". That case does not reach
+ * `void`/`Promise<void>`. Such an annotation is not a restatement of a result,
+ * it is a declaration that there is no result, and TypeScript enforces it:
+ * adding `return <expr>` to a function annotated `Promise<void>` is a compile
+ * error. It cannot drift into a lie, so removing it destroys information rather
+ * than removing redundancy.
+ *
+ * That information is load-bearing for other rules: `enforce-memoize-async`
+ * reads exactly this declaration of intent and skips a method declared
+ * `Promise<void>`, because caching a call that yields nothing turns a repeatable
+ * side effect into a once-per-instance one. Stripping the annotation happens
+ * unattended — `eslint --fix` re-lints until the output settles, so the strip
+ * and the memoization that follows it land in the same run.
+ *
+ * The shape match stays deliberately exact, mirroring the check
+ * `enforce-memoize-async` performs. A union (`Promise<void | string>`), a nested
+ * wrapper (`Promise<Awaited<void>>`) or any other arity can resolve to a value,
+ * so those annotations remain redundant restatements and stay reportable.
+ */
+function declaresVoidResult(returnType) {
+    const annotation = returnType.typeAnnotation;
+    if (annotation.type === utils_1.AST_NODE_TYPES.TSVoidKeyword) {
+        return true;
+    }
+    if (annotation.type !== utils_1.AST_NODE_TYPES.TSTypeReference ||
+        annotation.typeName.type !== utils_1.AST_NODE_TYPES.Identifier ||
+        annotation.typeName.name !== 'Promise') {
+        return false;
+    }
+    const typeArguments = annotation.typeParameters?.params;
+    return (typeArguments?.length === 1 &&
+        typeArguments[0].type === utils_1.AST_NODE_TYPES.TSVoidKeyword);
+}
 exports.noExplicitReturnType = (0, createRule_1.createRule)({
     name: 'no-explicit-return-type',
     meta: {
@@ -597,6 +637,7 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                     allowAbstractMethodSignatures: { type: 'boolean' },
                     allowDtsFiles: { type: 'boolean' },
                     allowFirestoreFunctionFiles: { type: 'boolean' },
+                    allowVoidReturnTypes: { type: 'boolean' },
                 },
                 additionalProperties: false,
             },
@@ -649,6 +690,18 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                 filename.endsWith('.f.ts'))) {
             return {};
         }
+        /**
+         * Applied at the implementation sites this rule's fixer can rewrite —
+         * functions, arrows and class methods. Signature-only declarations
+         * (interface methods, abstract methods, `declare function`) are outside
+         * the exemption: they have no body to infer from, so their annotation is
+         * mandatory rather than redundant, they are reported only when the
+         * matching `allow*` option is turned off, and no fixer ever strips them.
+         */
+        function isAllowedVoidReturnType(returnType) {
+            return (Boolean(mergedOptions.allowVoidReturnTypes) &&
+                declaresVoidResult(returnType));
+        }
         function fixReturnType(fixer, node) {
             // Some nodes expose returnType directly while others nest it under value.
             const returnType = 'returnType' in node
@@ -667,6 +720,7 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                     return;
                 if (isTypeGuardFunction(node) ||
                     isReadonlyWideningReturnType(returnType) ||
+                    isAllowedVoidReturnType(returnType) ||
                     (mergedOptions.allowRecursiveFunctions &&
                         isRecursiveFunction(node)) ||
                     isReturnTypeRequiredByRecursion(node)) {
@@ -693,6 +747,7 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                 }
                 if (isTypeGuardFunction(node) ||
                     isReadonlyWideningReturnType(returnType) ||
+                    isAllowedVoidReturnType(returnType) ||
                     (mergedOptions.allowRecursiveFunctions &&
                         isRecursiveFunction(node)) ||
                     isReturnTypeRequiredByRecursion(node)) {
@@ -711,6 +766,7 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                     return;
                 if (isTypeGuardFunction(node) ||
                     isReadonlyWideningReturnType(returnType) ||
+                    isAllowedVoidReturnType(returnType) ||
                     isReturnTypeRequiredByRecursion(node)) {
                     return;
                 }
@@ -744,6 +800,7 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                     return;
                 if (isTypeGuardFunction(node.value) ||
                     isReadonlyWideningReturnType(returnType) ||
+                    isAllowedVoidReturnType(returnType) ||
                     (mergedOptions.allowAbstractMethodSignatures &&
                         isInterfaceOrAbstractMethodSignature(node)) ||
                     isReturnTypeRequiredByRecursion(node)) {

package/lib/rules/use-latest-callback.js

@@ -44,6 +44,81 @@ const findLatestCallbackImport = (program) => {
     }
     return null;
 };
+/** The leading whitespace of the line the offset sits on. */
+const indentationAt = (sourceCode, offset) => {
+    const text = sourceCode.getText();
+    const lineStart = text.lastIndexOf('\n', offset - 1) + 1;
+    const match = /^[ \t]*/.exec(text.slice(lineStart, offset));
+    return match ? match[0] : '';
+};
+/**
+ * Ranges whose interior line breaks carry string data rather than formatting.
+ * A multi-line template literal (or a string spliced together with line
+ * continuations) evaluates to the whitespace written inside it, so shifting
+ * those lines would silently change the value the code produces — the same
+ * carve-out `parallelize-async-operations` makes for spliced-in arguments.
+ */
+const stringDataRangesOf = (sourceCode, node) => sourceCode
+    .getTokens(node)
+    .filter((token) => (token.type === utils_1.AST_TOKEN_TYPES.Template ||
+    token.type === utils_1.AST_TOKEN_TYPES.String) &&
+    token.loc.start.line !== token.loc.end.line)
+    .map((token) => token.range);
+/**
+ * The callback's text re-indented for the line the rewritten call puts it on.
+ *
+ * Dropping the dependency array lets the call collapse onto one line, and when
+ * the original spelled the callback on a line of its own that collapse removes
+ * exactly one nesting level. Emitting the callback verbatim would leave every
+ * interior line indented for the level it no longer occupies (issue #1559), so
+ * each line moves by the difference between the callback's original indentation
+ * and the indentation of the line the call starts on. Preserving the original
+ * multi-line layout instead is not an option: a lone function argument is
+ * hugged onto the call line by the formatter, so the broken-out form would be
+ * reformatted away on the next write.
+ */
+const reindentedCallbackText = (sourceCode, call, callback) => {
+    const text = sourceCode.getText(callback);
+    const callIndent = indentationAt(sourceCode, call.range[0]);
+    const callbackIndent = indentationAt(sourceCode, callback.range[0]);
+    // A callback already on the call's line loses no nesting level, so its body
+    // must be reproduced byte for byte.
+    if (callIndent === callbackIndent) {
+        return text;
+    }
+    const shiftLine = (() => {
+        if (callbackIndent.startsWith(callIndent)) {
+            const removed = callbackIndent.slice(callIndent.length);
+            return (line) => line.startsWith(removed) ? line.slice(removed.length) : line;
+        }
+        if (callIndent.startsWith(callbackIndent)) {
+            const added = callIndent.slice(callbackIndent.length);
+            return (line) => `${added}${line}`;
+        }
+        // Indent characters that disagree give no delta that can be applied
+        // without corrupting the layout, so the text is left as the author wrote it.
+        return null;
+    })();
+    if (!shiftLine) {
+        return text;
+    }
+    const stringData = stringDataRangesOf(sourceCode, callback);
+    const carriesStringData = (offset) => stringData.some(([start, end]) => start < offset && offset < end);
+    let offset = callback.range[0];
+    return text
+        .split('\n')
+        .map((line, index) => {
+        const lineStart = offset;
+        offset += line.length + 1;
+        // The first line is spliced in after the call's open paren, so it has no
+        // indentation of its own left to adjust.
+        if (index === 0 || line.trim() === '' || carriesStringData(lineStart)) {
+            return line;
+        }
+        return shiftLine(line);
+    })
+        .join('\n');
+};
 exports.useLatestCallback = (0, createRule_1.createRule)({
     name: 'use-latest-callback',
     meta: {
@@ -406,7 +481,7 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
                     return fixes;
                 };
                 const conversionFix = (fixer, conversion) => {
-                    const callbackText = sourceCode.getText(conversion.node.arguments[0]);
+                    const callbackText = reindentedCallbackText(sourceCode, conversion.node, conversion.node.arguments[0]);
                     const typeParams = conversion.node.typeParameters
                         ? sourceCode.getText(conversion.node.typeParameters)
                         : '';

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,72 @@
 [
+  {
+    "version": "1.20.65",
+    "date": "2026-08-01T13:35:40.762Z",
+    "rules": [
+      {
+        "name": "enforce-firestore-doc-ref-generic",
+        "changeType": "fix",
+        "issues": [
+          1564
+        ],
+        "summary": "exempt compat Firestore receivers from @firebase/rules-unit-testing (closes #1564)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.64",
+    "date": "2026-08-01T12:02:23.073Z",
+    "rules": [
+      {
+        "name": "enforce-id-capitalization",
+        "changeType": "fix",
+        "issues": [
+          1558
+        ],
+        "summary": "preserve the original quote delimiter when rewriting a literal (closes #1558)"
+      },
+      {
+        "name": "enforce-memoize-async",
+        "changeType": "fix",
+        "issues": [
+          1563
+        ],
+        "summary": "skip methods whose sole parameter is a callback (closes #1563)"
+      },
+      {
+        "name": "enforce-memoize-getters",
+        "changeType": "fix",
+        "issues": [
+          1561
+        ],
+        "summary": "exempt getters that read live external state (closes #1561)"
+      },
+      {
+        "name": "no-empty-dependency-use-callbacks",
+        "changeType": "fix",
+        "issues": [
+          1560
+        ],
+        "summary": "dedent the callback when hoisting it to module scope (closes #1560)"
+      },
+      {
+        "name": "no-explicit-return-type",
+        "changeType": "fix",
+        "issues": [
+          1562
+        ],
+        "summary": "keep void and Promise<void> annotations under allowVoidReturnTypes (closes #1562)"
+      },
+      {
+        "name": "use-latest-callback",
+        "changeType": "fix",
+        "issues": [
+          1559
+        ],
+        "summary": "re-indent the callback body when collapsing a multi-line useCallback (closes #1559)"
+      }
+    ]
+  },
   {
     "version": "1.20.63",
     "date": "2026-08-01T09:37:04.617Z",