@blumintinc/eslint-plugin-blumint 1.20.154 → 1.20.156

package/lib/index.js

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

package/lib/rules/logical-top-to-bottom-grouping.js

@@ -1806,6 +1806,49 @@ function moveSegment(segments, fromIndex, toIndex) {
     next.splice(toIndex < fromIndex ? toIndex : toIndex - 1, 0, moved.replace(/[ \t]+$/u, ''));
     return next;
 }
+const LINE_TERMINATORS = new Set(['\n', '\r', '\u2028', '\u2029']);
+/**
+ * Whether text appended to `text` would start on a fresh line.
+ *
+ * Trailing spaces and tabs are skipped: a segment ends with the indentation that
+ * belonged to whatever followed it, and that indentation still leaves an appended
+ * segment on a line of its own.
+ */
+function endsWithLineTerminator(text) {
+    let cursor = text.length - 1;
+    while (cursor >= 0 && (text[cursor] === ' ' || text[cursor] === '\t')) {
+        cursor -= 1;
+    }
+    return cursor >= 0 && LINE_TERMINATORS.has(text[cursor]);
+}
+/**
+ * The line break the source itself uses, so a separator restored below matches its
+ * neighbours instead of mixing endings into a CRLF file.
+ */
+function lineBreakOf(text) {
+    const index = text.indexOf('\n');
+    return index > 0 && text[index - 1] === '\r' ? '\r\n' : '\n';
+}
+/**
+ * Concatenates reordered segments, restoring the statement separation the source
+ * carried positionally.
+ *
+ * A segment runs up to where the next one began, so it normally already ends with the
+ * line break that separated them. Two do not: the block's last segment stops at `}` or
+ * at the end of the file, and a statement sharing a line with its predecessor never had
+ * a break in front of it. Once a reordering moves such a segment away from the end,
+ * appending the next segment directly runs two statements together — and where the
+ * first ends in a `//` comment that is not a formatting blemish, since the appended
+ * statement becomes comment text and vanishes from the program (#2023).
+ *
+ * Only the joins are separated. Nothing is appended after the final segment, whose
+ * successor is the untouched text outside the replaced range.
+ */
+function joinSegments(segments, lineBreak) {
+    return segments.reduce((text, segment, index) => index === 0 || endsWithLineTerminator(text)
+        ? text + segment
+        : text + lineBreak + segment, '');
+}
 /**
  * Emits an entire reordering as one fix by permuting the block's text segments.
  *
@@ -1827,7 +1870,7 @@ function buildReorderFix(body, moves, parent, sourceCode, fixer) {
     if (first > last) {
         return null;
     }
-    return fixer.replaceTextRange([bounds[first], bounds[last + 1]], reordered.slice(first, last + 1).join(''));
+    return fixer.replaceTextRange([bounds[first], bounds[last + 1]], joinSegments(reordered.slice(first, last + 1), lineBreakOf(sourceCode.getText())));
 }
 /**
  * A fix is emitted only for a reordering the detector scores at zero relocatable

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

@@ -569,32 +569,164 @@ function isOverloadedFunction(node) {
     }
     return false;
 }
-function isOverloadedTsDeclareFunction(node) {
+/**
+ * The statement list that directly holds `node`, looking through `export`.
+ *
+ * Overload signatures and their implementation are siblings of one statement
+ * list — an overload set cannot span containers — so this is the only list worth
+ * reading. Walking outward instead would let a same-named function in an
+ * enclosing scope answer for one it cannot overload.
+ */
+function siblingStatementsOf(node) {
+    const parent = node.parent;
+    if (!parent)
+        return undefined;
+    const container = parent.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration ||
+        parent.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration
+        ? parent.parent
+        : parent;
+    return container ? (0, lexicalScope_1.statementsOf)(container) : undefined;
+}
+const EMPTY_OVERLOAD_SET = { signatures: 0, implementations: 0 };
+/**
+ * How many declaration-only signatures and how many implementations the
+ * container holding `node` declares under `node`'s own name, `node` included.
+ *
+ * Every statement container is read, not just `Program` and `TSModuleBlock`: a
+ * function body, a bare block and a `switch` case each bind a name just as
+ * effectively, so reading only the top level makes the DEPTH of an overload set
+ * decide whether it exists (the same defect as #1771).
+ */
+function overloadSetOf(node) {
     const functionName = node.id?.name;
     if (!functionName)
+        return EMPTY_OVERLOAD_SET;
+    const statements = siblingStatementsOf(node);
+    if (!statements)
+        return EMPTY_OVERLOAD_SET;
+    let signatures = 0;
+    let implementations = 0;
+    for (const statement of statements) {
+        // `export function f(...)` is the same declaration one AST node deeper, and
+        // an overload set may export some of its members and not others.
+        const declaration = (0, lexicalScope_1.declarationOf)(statement);
+        if (declaration.type !== utils_1.AST_NODE_TYPES.TSDeclareFunction &&
+            declaration.type !== utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+            continue;
+        }
+        if (declaration.id?.name !== functionName)
+            continue;
+        if (declaration.type === utils_1.AST_NODE_TYPES.TSDeclareFunction ||
+            !declaration.body) {
+            signatures += 1;
+        }
+        else {
+            implementations += 1;
+        }
+    }
+    return { signatures, implementations };
+}
+/**
+ * True when `node` is the IMPLEMENTATION of an overload set — a function with a
+ * body whose container also declares the same name as one or more
+ * declaration-only signatures.
+ *
+ * Its annotation is not a restatement of what the body returns: TypeScript
+ * checks each overload signature against the IMPLEMENTATION SIGNATURE, so the
+ * annotation is what the overloads are measured against. Inference yields the
+ * body's own type, which need not accept them — stripping `: void | string`
+ * from `function get(param?: string): void | string {}` infers `void` and makes
+ * the `: string` overload above it TS2394 (#2019).
+ *
+ * This carve-out ignores `allowOverloadedFunctions`. That option governs the
+ * declaration-only signatures, whose annotations are mandatory but carry no
+ * fixer, so reporting them costs nothing but a message. Here the report ships a
+ * fix that does not compile, which no option may ask for.
+ */
+function isOverloadImplementation(node) {
+    if (!node.body)
         return false;
-    let container = node.parent;
-    while (container) {
-        if (container.type === utils_1.AST_NODE_TYPES.Program ||
-            container.type === utils_1.AST_NODE_TYPES.TSModuleBlock) {
-            const declarations = container.body
-                .map((statement) => {
-                if (statement.type === utils_1.AST_NODE_TYPES.TSDeclareFunction) {
-                    return statement;
-                }
-                if (statement.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration &&
-                    statement.declaration?.type === utils_1.AST_NODE_TYPES.TSDeclareFunction) {
-                    return statement.declaration;
-                }
-                return undefined;
-            })
-                .filter((value) => Boolean(value?.id?.name))
-                .filter((decl) => decl.id.name === functionName);
-            return declarations.length > 1;
+    return overloadSetOf(node).signatures > 0;
+}
+/**
+ * True when `node` is a declaration-only signature that belongs to an overload
+ * set: another signature declares the same name, or an implementation below it
+ * does. A lone `declare function f(): number;` overloads nothing, so it stays
+ * reportable.
+ */
+function isOverloadedTsDeclareFunction(node) {
+    const { signatures, implementations } = overloadSetOf(node);
+    return signatures > 1 || implementations > 0;
+}
+/**
+ * A method's identity inside its class body. Overloads agree on all three
+ * components; `static f` and `f` merely spell the same name, and a computed key
+ * names nothing resolvable, so it yields nothing. The separator keeps a private
+ * `#log` from colliding with a string key `'#log'`.
+ */
+function methodIdentityOf(node) {
+    if (node.computed)
+        return undefined;
+    if (node.key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) {
+        return `${node.static}\u0000private\u0000${node.key.name}`;
+    }
+    if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier &&
+        node.key.type !== utils_1.AST_NODE_TYPES.Literal) {
+        return undefined;
+    }
+    const name = getNameFromIdentifierOrLiteral(node.key);
+    return name === undefined
+        ? undefined
+        : `${node.static}\u0000public\u0000${name}`;
+}
+/**
+ * The overload set a class method belongs to, counted over the members of its
+ * own class body. A member without a body is an overload signature
+ * (`TSEmptyBodyFunctionExpression`); the one member with a body is the
+ * implementation.
+ */
+function classOverloadSetOf(node) {
+    const identity = methodIdentityOf(node);
+    const classBody = node.parent;
+    if (!identity || classBody?.type !== utils_1.AST_NODE_TYPES.ClassBody) {
+        return EMPTY_OVERLOAD_SET;
+    }
+    let signatures = 0;
+    let implementations = 0;
+    for (const member of classBody.body) {
+        if (member.type !== utils_1.AST_NODE_TYPES.MethodDefinition)
+            continue;
+        if (methodIdentityOf(member) !== identity)
+            continue;
+        if (member.value.body) {
+            implementations += 1;
+        }
+        else {
+            signatures += 1;
         }
-        container = container.parent;
     }
-    return false;
+    return { signatures, implementations };
+}
+/**
+ * True when the method is the implementation of an overloaded class method, for
+ * the reason {@link isOverloadImplementation} gives — a class overload set is
+ * checked exactly as a function one is (#2019).
+ */
+function isOverloadImplementationMethod(node) {
+    if (!node.value.body)
+        return false;
+    return classOverloadSetOf(node).signatures > 0;
+}
+/**
+ * True when the method is a declaration-only overload signature. A body-less
+ * method is legal only as part of an overload set, so it is exempt whenever the
+ * set holds anything else at all.
+ */
+function isOverloadedClassMethodSignature(node) {
+    if (node.value.body)
+        return false;
+    const { signatures, implementations } = classOverloadSetOf(node);
+    return signatures > 1 || implementations > 0;
 }
 function isInterfaceOrAbstractMethodSignature(node) {
     if (node.type === utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition)
@@ -1233,6 +1365,7 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                     isReadonlyWideningReturnType(returnType) ||
                     isAllowedVoidReturnType(returnType) ||
                     isDecoratorFactory(node, returnType) ||
+                    isOverloadImplementation(node) ||
                     (mergedOptions.allowRecursiveFunctions &&
                         isRecursiveFunction(node)) ||
                     isReturnTypeRequiredByRecursion(node)) {
@@ -1292,6 +1425,9 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                     isReadonlyWideningReturnType(returnType) ||
                     isAllowedVoidReturnType(returnType) ||
                     isDecoratorFactory(node, returnType) ||
+                    isOverloadImplementationMethod(node) ||
+                    (mergedOptions.allowOverloadedFunctions &&
+                        isOverloadedClassMethodSignature(node)) ||
                     (mergedOptions.allowAbstractMethodSignatures &&
                         isInterfaceOrAbstractMethodSignature(node)) ||
                     isReturnTypeRequiredByRecursion(node)) {

package/lib/rules/prefer-nullish-coalescing-boolean-props.js

@@ -27,6 +27,7 @@ exports.preferNullishCoalescingBooleanProps = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const ts = __importStar(require("typescript"));
 const createRule_1 = require("../utils/createRule");
+const replacementSegments_1 = require("../utils/replacementSegments");
 const BOOLEAN_PROP_REGEX = /^(is|has|should|can|will|do|does|did|was|were|enable|disable)/;
 function isBooleanType(type, checker) {
     if (type.isUnion()) {
@@ -531,6 +532,68 @@ function needsSelfParens(node, sourceCode) {
     }
     return !isParenthesized(node, sourceCode);
 }
+/**
+ * Comments the rewrite would delete.
+ *
+ * The fix rebuilds the whole expression from `getText` of each operand, so every
+ * comment written inside the node but outside both operand ranges has no anchor
+ * in the replacement: the trivia around the `||` operator, and anything sitting
+ * inside source-level parentheses that the rebuild discards. Comments nested
+ * within an operand travel with that operand's own text and are never stranded.
+ */
+function strandedComments(node, sourceCode) {
+    const enclosedBy = (operand) => (comment) => comment.range[0] >= operand.range[0] &&
+        comment.range[1] <= operand.range[1];
+    const inLeft = enclosedBy(node.left);
+    const inRight = enclosedBy(node.right);
+    return sourceCode
+        .getCommentsInside(node)
+        .filter((comment) => !inLeft(comment) && !inRight(comment));
+}
+function groupStrandedComments(node, sourceCode) {
+    const operator = sourceCode.getTokenAfter(node.left, {
+        filter: (token) => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === '||',
+    });
+    const groups = {
+        leading: [],
+        beforeOperator: [],
+        afterOperator: [],
+        trailing: [],
+    };
+    for (const comment of strandedComments(node, sourceCode)) {
+        if (comment.range[1] <= node.left.range[0]) {
+            groups.leading.push(comment);
+        }
+        else if (comment.range[0] >= node.right.range[1]) {
+            groups.trailing.push(comment);
+        }
+        else if (operator && comment.range[1] <= operator.range[0]) {
+            groups.beforeOperator.push(comment);
+        }
+        else {
+            groups.afterOperator.push(comment);
+        }
+    }
+    return groups;
+}
+/**
+ * `return`, `throw` and `yield` forbid a LineTerminator between themselves and
+ * their operand, so a carried comment that demands its own line cannot sit
+ * between one of them and the rewritten expression: a line comment there ends
+ * the statement through ASI, and so does a block comment carrying a line
+ * terminator, which the grammar reads AS a LineTerminator (#1963). Such a
+ * comment rides ahead of the keyword instead.
+ *
+ * The keyword token is the anchor rather than the start of its line because an
+ * insertion point immediately before a token is always a token boundary, while a
+ * line start can fall inside a multi-line template literal and would be written
+ * into the template's text.
+ */
+const RESTRICTED_KEYWORDS = new Set(['return', 'throw', 'yield']);
+function restrictedKeywordBefore(node, sourceCode) {
+    const before = sourceCode.getTokenBefore(node);
+    return before && RESTRICTED_KEYWORDS.has(before.value) ? before : null;
+}
 exports.preferNullishCoalescingBooleanProps = (0, createRule_1.createRule)({
     name: 'prefer-nullish-coalescing-boolean-props',
     meta: {
@@ -582,10 +645,67 @@ exports.preferNullishCoalescingBooleanProps = (0, createRule_1.createRule)({
                                 right: rightText,
                             },
                             fix(fixer) {
-                                const replacement = `${parenthesizeLogical(leftText, node.left)} ?? ${parenthesizeLogical(rightText, node.right)}`;
-                                return fixer.replaceText(node, needsSelfParens(node, sourceCode)
-                                    ? `(${replacement})`
-                                    : replacement);
+                                const groups = groupStrandedComments(node, sourceCode);
+                                // Whether the replacement is parenthesized is decided by the
+                                // expression's context exactly as it is without comments:
+                                // parentheses are tokens, so letting a carried comment add them
+                                // would make the comment change the emitted program.
+                                const selfParens = needsSelfParens(node, sourceCode);
+                                const text = sourceCode.getText();
+                                const toSegment = (comment) => ({
+                                    text: text.slice(comment.range[0], comment.range[1]),
+                                    breakAfter: (0, replacementSegments_1.requiresLineBreakAfter)(comment),
+                                });
+                                // A carried comment's only anchor is the line the expression
+                                // opens on, which can start mid-line.
+                                const startLine = sourceCode.lines[node.loc.start.line - 1] ?? '';
+                                const indent = /^[\t ]*/.exec(startLine)?.[0] ?? '';
+                                // Inside parentheses a newline can never trigger ASI, so every
+                                // comment can ride within the replacement on a line of its own.
+                                // Without them, a leading comment that demands its own line
+                                // moves ahead of a restricted keyword when one governs the
+                                // expression; everywhere else a line break before the
+                                // expression is inert.
+                                const keyword = selfParens
+                                    ? null
+                                    : restrictedKeywordBefore(node, sourceCode);
+                                const hoisted = keyword
+                                    ? groups.leading.filter(replacementSegments_1.requiresOwnLine)
+                                    : [];
+                                const segments = [
+                                    ...groups.leading
+                                        .filter((comment) => !hoisted.includes(comment))
+                                        .map(toSegment),
+                                    {
+                                        text: parenthesizeLogical(leftText, node.left),
+                                        breakAfter: false,
+                                    },
+                                    ...groups.beforeOperator.map(toSegment),
+                                    { text: '??', breakAfter: false },
+                                    ...groups.afterOperator.map(toSegment),
+                                    {
+                                        text: parenthesizeLogical(rightText, node.right),
+                                        breakAfter: false,
+                                    },
+                                    ...groups.trailing.map(toSegment),
+                                ];
+                                if (selfParens) {
+                                    return fixer.replaceText(node, (0, replacementSegments_1.joinSegments)(segments, indent));
+                                }
+                                const body = (0, replacementSegments_1.joinSegmentBody)(segments, indent);
+                                const trailing = segments[segments.length - 1].breakAfter
+                                    ? `\n${indent}`
+                                    : '';
+                                const replacement = fixer.replaceText(node, `${body}${trailing}`);
+                                if (!keyword || hoisted.length === 0) {
+                                    return replacement;
+                                }
+                                return [
+                                    fixer.insertTextBefore(keyword, hoisted
+                                        .map((comment) => `${text.slice(comment.range[0], comment.range[1])}\n${indent}`)
+                                        .join('')),
+                                    replacement,
+                                ];
                             },
                         });
                     }

package/lib/rules/prefer-union-from-const-array.js

@@ -34,6 +34,46 @@ function isStringLiteralType(member) {
     const { literal } = member;
     return (literal.type === utils_1.AST_NODE_TYPES.Literal && typeof literal.value === 'string');
 }
+/**
+ * A declaration file is ambient in its entirety, so a declaration in one is
+ * subject to the ambient restriction even without an explicit `declare`.
+ */
+const DECLARATION_FILE = /\.d\.[cm]?ts$/i;
+/**
+ * An ambient context accepts only a string, numeric or literal-enum `const`
+ * initializer (TS1254), so the derived `as const` array cannot be emitted there
+ * at all — `as const` or not, an array literal is rejected. Declining is the
+ * remedy rather than a different rewrite, because no legal rewrite exists in
+ * that position: the rule asks for importable runtime values and an ambient
+ * declaration is precisely the promise that no runtime value is emitted.
+ *
+ * `declare` on the OUTERMOST module declaration makes every level nested below
+ * it ambient too, so the whole ancestor chain is walked rather than just the
+ * enclosing block. A module named by a string literal (`module 'x' {}`) and a
+ * `global {}` augmentation are ambient by construction, with or without the
+ * modifier.
+ */
+function isInAmbientContext(node, filename) {
+    if (DECLARATION_FILE.test(filename)) {
+        return true;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration &&
+        node.declare === true) {
+        return true;
+    }
+    let current = node.parent;
+    while (current) {
+        if (current.type === utils_1.AST_NODE_TYPES.TSModuleDeclaration) {
+            if (current.declare === true ||
+                current.global === true ||
+                current.id.type === utils_1.AST_NODE_TYPES.Literal) {
+                return true;
+            }
+        }
+        current = current.parent;
+    }
+    return false;
+}
 /**
  * Walk the scope chain upward collecting declared variable names. Used to skip
  * the autofix (report-only) when the derived `{TYPE}_VALUES` name is already
@@ -154,6 +194,9 @@ exports.preferUnionFromConstArray = (0, createRule_1.createRule)({
                 if (!members.every(isStringLiteralType)) {
                     return;
                 }
+                if (isInAmbientContext(node, context.getFilename())) {
+                    return;
+                }
                 const typeName = node.id.name;
                 const constName = `${toUpperSnake(typeName)}_VALUES`;
                 // The type alias is exported when wrapped in `export type X = ...`

package/lib/rules/require-image-optimized.js

@@ -62,6 +62,49 @@ const isInsideComponentMock = (node, componentModule) => {
     }
     return false;
 };
+/**
+ * Name a declaration binds, for the forms a component is declared under:
+ * `const ImageOptimized = ...` (including `memo(...)`/`forwardRef(...)` around
+ * the body), `function ImageOptimized()` and `class ImageOptimized`. Anything
+ * else — an object property, a parameter — binds no declaration name the
+ * wrapper can be identified by, and treating it as one would exempt a mock
+ * factory keyed by the component name whatever module it stands in for.
+ */
+const declaredNameOf = (node) => {
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.VariableDeclarator:
+            return node.id.type === utils_1.AST_NODE_TYPES.Identifier ? node.id.name : null;
+        case utils_1.AST_NODE_TYPES.FunctionDeclaration:
+        case utils_1.AST_NODE_TYPES.FunctionExpression:
+        case utils_1.AST_NODE_TYPES.ClassDeclaration:
+        case utils_1.AST_NODE_TYPES.ClassExpression:
+            return node.id ? node.id.name : null;
+        default:
+            return null;
+    }
+};
+/**
+ * Names each local binding is exported under, so a wrapper declared as
+ * `Picture` and shipped as `export { Picture as ImageOptimized }` is still
+ * recognized as the component's own definition. A specifier carrying a `from`
+ * clause re-exports another module's binding and declares nothing here.
+ */
+const exportedNamesByLocal = (program) => {
+    const exported = new Map();
+    for (const statement of program.body) {
+        if (statement.type !== utils_1.AST_NODE_TYPES.ExportNamedDeclaration ||
+            statement.source ||
+            statement.exportKind === 'type') {
+            continue;
+        }
+        for (const specifier of statement.specifiers) {
+            const names = exported.get(specifier.local.name) ?? new Set();
+            names.add(specifier.exported.name);
+            exported.set(specifier.local.name, names);
+        }
+    }
+    return exported;
+};
 /**
  * A type-only specifier binds no value: it renders nothing, so it neither
  * bypasses the optimization pipeline nor can back a fix. The modifier lives
@@ -219,6 +262,40 @@ module.exports = (0, createRule_1.createRule)({
          * rule exists to centralize, not a violation of it.
          */
         const isComponentImplementationFile = moduleNameOf(context.getFilename()) === componentModule;
+        /**
+         * The wrapper is identified by the name the fixer would emit and by its
+         * module's name, which a component module's export shares by convention.
+         * Matching is exact so a distinct component whose name merely starts with
+         * it (`ImageOptimizedGallery`) stays reportable.
+         */
+        const isComponentName = (name) => name === COMPONENT_NAME || name === componentModule;
+        const exportedNames = exportedNamesByLocal(sourceCode.ast);
+        const definesComponent = (name) => {
+            if (isComponentName(name)) {
+                return true;
+            }
+            const aliases = exportedNames.get(name);
+            return !!aliases && [...aliases].some(isComponentName);
+        };
+        /**
+         * Whether the element sits inside the declaration of the component the fix
+         * points at. That declaration renders the image primitive by definition, so
+         * swapping it for the component makes the wrapper render itself: unbounded
+         * recursion, and a type error too, since the wrapper forwards only the
+         * props it destructured. The whole ancestry is walked because a helper
+         * nested inside the declaration is part of that implementation as well.
+         */
+        const isInsideComponentDefinition = (node) => {
+            let current = node.parent;
+            while (current) {
+                const declared = declaredNameOf(current);
+                if (declared && definesComponent(declared)) {
+                    return true;
+                }
+                current = current.parent;
+            }
+            return false;
+        };
         return {
             // Handle JSX img elements
             JSXElement(node) {
@@ -228,7 +305,8 @@ module.exports = (0, createRule_1.createRule)({
                     return;
                 }
                 if (isComponentImplementationFile ||
-                    isInsideComponentMock(node, componentModule)) {
+                    isInsideComponentMock(node, componentModule) ||
+                    isInsideComponentDefinition(node)) {
                     return;
                 }
                 const scope = ASTHelpers_1.ASTHelpers.getScope(context, node);

package/lib/utils/ASTHelpers.d.ts

@@ -85,6 +85,12 @@ export declare class ASTHelpers {
      * expression reads some other object.
      */
     private static classMemberNameReferencedBy;
+    /**
+     * The ECMA private names a class body declares, spelled as the graph spells
+     * them. A private name is scoped to the body that declares it, so this set
+     * is what an enclosing class must not mistake for its own members.
+     */
+    private static privateNamesDeclaredBy;
     private static walkChildNodes;
     static isNode(value: unknown): value is TSESTree.Node;
     static hasReturnStatement(node: TSESTree.Node): boolean;

package/lib/utils/ASTHelpers.js

@@ -423,7 +423,16 @@ class ASTHelpers {
             case 'ClassExpression': {
                 // Traversal continues so `<ClassName>.<member>` statics stay visible,
                 // but `this` no longer denotes the graphed instance.
-                this.walkChildNodes(node, className, false, dependencies);
+                const nested = [];
+                this.walkChildNodes(node, className, false, nested);
+                // A nested class body SHADOWS the private names it declares: its `#q`
+                // is a member of that class, distinct from an enclosing class's `#q`,
+                // so reads of it constrain the nested layout rather than this one.
+                // Private names the nested class does not declare still resolve
+                // outward, so only the declared ones are dropped. Filtering as the
+                // recursion unwinds composes across any depth of nesting.
+                const shadowed = this.privateNamesDeclaredBy(node);
+                dependencies.push(...nested.filter((name) => !shadowed.has(name)));
                 return;
             }
             case 'MemberExpression': {
@@ -447,6 +456,18 @@ class ASTHelpers {
      */
     static classMemberNameReferencedBy(node, className, isThisTheInstance) {
         const { object, property, computed } = node;
+        // A `#name` resolves LEXICALLY: it is a syntax error unless a class body
+        // enclosing the reference declares it, so the receiver it is read through
+        // cannot change which member it names. `other.#helper` and `this.#helper`
+        // reach the same member, which is why this branch precedes the receiver
+        // test that the dotted spellings need. Requiring `this`/<ClassName> here
+        // dropped the read a static initializer makes through another value of
+        // the same class, and with it the constraint that keeps the field's
+        // declaration above its reader (#2022). The `#` is part of the name so
+        // `#helper` and `helper` stay distinct members.
+        if (!computed && property?.type === 'PrivateIdentifier') {
+            return `#${property.name}`;
+        }
         const readsInstance = object?.type === 'ThisExpression' && isThisTheInstance;
         // An anonymous class expression has an empty name, which no identifier
         // can match.
@@ -457,12 +478,6 @@ class ASTHelpers {
         if (!computed && property?.type === 'Identifier') {
             return property.name;
         }
-        // `this.#helper` names a member as precisely as `this.helper` does, and it
-        // is the only spelling available for an ECMA private member. The `#` is
-        // part of the name so `#helper` and `helper` stay distinct members.
-        if (!computed && property?.type === 'PrivateIdentifier') {
-            return `#${property.name}`;
-        }
         // `this['helper']` names the member as precisely as `this.helper` does,
         // whereas `this[key]` names one only at runtime.
         if (computed &&
@@ -472,6 +487,25 @@ class ASTHelpers {
         }
         return null;
     }
+    /**
+     * The ECMA private names a class body declares, spelled as the graph spells
+     * them. A private name is scoped to the body that declares it, so this set
+     * is what an enclosing class must not mistake for its own members.
+     */
+    static privateNamesDeclaredBy(node) {
+        const names = new Set();
+        const members = node.body?.body;
+        if (!Array.isArray(members)) {
+            return names;
+        }
+        for (const member of members) {
+            const key = member?.key;
+            if (key?.type === 'PrivateIdentifier') {
+                names.add(`#${key.name}`);
+            }
+        }
+        return names;
+    }
     static walkChildNodes(node, className, isThisTheInstance, dependencies) {
         for (const [key, value] of Object.entries(node)) {
             if (ASTHelpers.NON_TRAVERSABLE_NODE_KEYS.has(key)) {

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,64 @@
 [
+  {
+    "version": "1.20.156",
+    "date": "2026-08-15T18:39:54.919Z",
+    "rules": [
+      {
+        "name": "logical-top-to-bottom-grouping",
+        "changeType": "fix",
+        "issues": [
+          2023
+        ],
+        "summary": "separate reordered statements so a relocated one cannot land inside a trailing // comment (closes #2023)"
+      },
+      {
+        "name": "prefer-nullish-coalescing-boolean-props",
+        "changeType": "fix",
+        "issues": [
+          2024
+        ],
+        "summary": "carry the comments stranded between the operands instead of deleting them (closes #2024)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.155",
+    "date": "2026-08-15T14:21:55.491Z",
+    "rules": [
+      {
+        "name": "class-methods-read-top-to-bottom",
+        "changeType": "fix",
+        "issues": [
+          2022
+        ],
+        "summary": "pin a # field by every read of it, not just this.#x (closes #2022)"
+      },
+      {
+        "name": "no-explicit-return-type",
+        "changeType": "fix",
+        "issues": [
+          2019
+        ],
+        "summary": "spare the implementation signature of an overload set (closes #2019)"
+      },
+      {
+        "name": "prefer-union-from-const-array",
+        "changeType": "fix",
+        "issues": [
+          2020
+        ],
+        "summary": "decline in an ambient context, where no const array is legal (closes #2020)"
+      },
+      {
+        "name": "require-image-optimized",
+        "changeType": "fix",
+        "issues": [
+          2021
+        ],
+        "summary": "exempt the img inside ImageOptimized's own definition (closes #2021)"
+      }
+    ]
+  },
   {
     "version": "1.20.154",
     "date": "2026-08-15T03:47:51.570Z",