@blumintinc/eslint-plugin-blumint 1.21.2 → 1.21.4

package/lib/rules/prefer-map-over-conditional-dispatch.js

@@ -140,6 +140,32 @@ function attributePrintedName(intended, printed, type) {
     }
     recordAttribution(intended, printed, symbol);
 }
+/**
+ * The bare identifier a declaration's own type annotation is written as, or
+ * null when the annotation is anything else.
+ *
+ * Only an un-parameterised reference to a plain identifier qualifies. A
+ * qualified name (`Theme.Mode`) needs its namespace to resolve at the fix site,
+ * which this answer cannot establish; a parameterised one (`Alias<'x'>`) is not
+ * denoted by its head at all, and emitting the head alone would name a
+ * different type. Both keep the printed union rather than guess.
+ */
+function annotatedTypeReferenceName(declaration) {
+    const annotation = ts.isParameter(declaration) ||
+        ts.isVariableDeclaration(declaration) ||
+        ts.isPropertySignature(declaration) ||
+        ts.isPropertyDeclaration(declaration)
+        ? declaration.type
+        : undefined;
+    if (!annotation ||
+        !ts.isTypeReferenceNode(annotation) ||
+        !ts.isIdentifier(annotation.typeName) ||
+        (annotation.typeArguments?.length ?? 0) > 0) {
+        return null;
+    }
+    const name = annotation.typeName.text;
+    return BARE_TYPE_NAME.test(name) ? name : null;
+}
 /**
  * Function/constructor/conditional type notation must be parenthesized to
  * appear as a `|` union member, or the emitted annotation does not parse
@@ -833,11 +859,75 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                 return null;
             }
         }
+        /**
+         * The bare type-alias name written on the discriminant's own annotation,
+         * when that name is provably the union the checker printed the members of.
+         *
+         * `checker.typeToString()` keeps an alias only while the type still carries
+         * an `aliasSymbol`, and TypeScript drops that resolving an indexed access
+         * over a `typeof` query — `const M = ['a', 'b'] as const; type Mode =
+         * (typeof M)[number]`, which is exactly the shape the key-space companion
+         * rule named on this rule's docs page emits. The printed text there is the
+         * widened literal union, the one spelling this rule's exhaustiveness
+         * promise exists to avoid: a stale `Record<'a' | 'b', V>` keeps
+         * typechecking after the union grows and only the LOOKUP complains, as
+         * TS7053 — an implicit-any diagnostic that disappears entirely under
+         * `noImplicitAny: false` and leaves the new member yielding `undefined` at
+         * runtime (#2009).
+         *
+         * The name is read off SYNTAX because the type no longer carries it, so it
+         * ships only against evidence that it denotes this very union: a bare,
+         * un-parameterised type reference written on the declaration the
+         * discriminant resolves to, whose symbol — resolved where the `Record`
+         * lands, not where the annotation was written — declares exactly this type.
+         * Mere presence of the name is not enough. Naming the WRONG union in the
+         * emitted `Record` breaks the build where the widened union merely weakens
+         * it, so anything short of type identity declines and keeps the printed
+         * text. Flow narrowing declines through the same check: a discriminant
+         * narrowed above the dispatch has a type the alias does not declare, and
+         * the alias would demand keys the construct has no branches for.
+         */
+        function annotationAliasTypeText(discriminant, discriminantType) {
+            const tsNode = esTreeNodeToTSNodeMap.get(unwrapLink(discriminant));
+            const tsFixSite = esTreeNodeToTSNodeMap.get(discriminant);
+            if (!tsNode || !tsFixSite) {
+                return null;
+            }
+            try {
+                const symbol = checker.getSymbolAtLocation(tsNode);
+                const names = new Set((symbol?.declarations ?? [])
+                    .map(annotatedTypeReferenceName)
+                    .filter((name) => name !== null));
+                // Two declarations annotated with different names (a merged symbol, an
+                // overload set) leave no single spelling that is right for both.
+                if (names.size !== 1) {
+                    return null;
+                }
+                const [name] = names;
+                const inScope = checker
+                    .getSymbolsInScope(tsFixSite, ts.SymbolFlags.Type | ts.SymbolFlags.Alias)
+                    .find((candidate) => candidate.name === name);
+                if (!inScope) {
+                    return null;
+                }
+                const declaredSymbol = inScope.flags & ts.SymbolFlags.Alias
+                    ? checker.getAliasedSymbol(inScope)
+                    : inScope;
+                if (checker.getDeclaredTypeOfSymbol(declaredSymbol) !== discriminantType) {
+                    return null;
+                }
+                return { text: name, symbol: declaredSymbol };
+            }
+            catch {
+                return null;
+            }
+        }
         /**
          * Key type for the emitted `Record`. A discriminant whose own type prints
          * as a bare name already carries the union's identity, so that name is
-         * kept; otherwise the fix reaches for the tag's declaring type before
-         * settling for the resolved literal union (#1926).
+         * kept; otherwise the fix reaches for the tag's declaring type (#1926),
+         * then for the alias its annotation names where the checker resolved past
+         * one (#2009), before settling for the resolved literal union.
          */
         function discriminantTypeText(type, discriminant) {
             let printed;
@@ -865,10 +955,27 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
             // already ships only when the name resolves, at the fix site, to exactly
             // the object's declared type, and identity of the TYPE accepts a nearer
             // alias that denotes the same type — which compiles, and reads the same.
-            const text = indexedAccessTypeText(discriminant, type) ?? printed;
-            return text === null
+            const indexed = indexedAccessTypeText(discriminant, type);
+            if (indexed !== null) {
+                return { text: normalizeTypeQuotes(indexed, singleQuote), intended };
+            }
+            // Recovery runs only where the printer already produced usable text, so
+            // it can only change the SPELLING of a key type the rule was going to
+            // emit anyway — never whether the rule fires. A discriminant the printer
+            // could not print at all stays silent exactly as before.
+            if (printed !== null) {
+                const alias = annotationAliasTypeText(discriminant, type);
+                if (alias) {
+                    // Unlike the printed bare name, this one was never checked against
+                    // the fix site's scope by the printer, so it carries its symbol into
+                    // the gate for the same shadow check (#2229).
+                    recordAttribution(intended, alias.text, alias.symbol);
+                    return { text: alias.text, intended };
+                }
+            }
+            return printed === null
                 ? null
-                : { text: normalizeTypeQuotes(text, singleQuote), intended };
+                : { text: normalizeTypeQuotes(printed, singleQuote), intended };
         }
         /**
          * Whether the binding a type name reaches at the fix site is the symbol the

package/lib/rules/require-memoize-jsx-returners.js

@@ -6,6 +6,7 @@ const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const disableDirectives_1 = require("../utils/disableDirectives");
 const importInsertion_1 = require("../utils/importInsertion");
+const memoModule_1 = require("../utils/memoModule");
 const MEMOIZE_PREFERRED_MODULE = '@blumintinc/typescript-memoize';
 const MEMOIZE_MODULES = new Set([
     MEMOIZE_PREFERRED_MODULE,
@@ -292,7 +293,7 @@ function callExpressionReturnsJSX(expression, knownFunctions, cache, factoryCont
         if (isIdentifierReturningJsx(callee, knownFunctions, cache, factoryContext)) {
             return true;
         }
-        if (factoryContext.reactMemoIdentifiers.has(callee.name) &&
+        if (factoryContext.memoIdentifiers.has(callee.name) &&
             firstNonSpreadArgument &&
             expressionReturnsJSX(firstNonSpreadArgument, knownFunctions, cache, factoryContext)) {
             return true;
@@ -567,11 +568,11 @@ exports.requireMemoizeJsxReturners = (0, createRule_1.createRule)({
          */
         const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
         const jsxReturnCache = new WeakMap();
-        const reactMemoIdentifiers = new Set();
+        const memoIdentifiers = new Set();
         const reactNamespaceIdentifiers = new Set();
         const reactCreateElementIdentifiers = new Set();
         const factoryContext = {
-            reactMemoIdentifiers,
+            memoIdentifiers,
             reactNamespaceIdentifiers,
             reactCreateElementIdentifiers,
         };
@@ -583,7 +584,7 @@ exports.requireMemoizeJsxReturners = (0, createRule_1.createRule)({
                         if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
                             specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
                             specifier.imported.name === 'memo') {
-                            reactMemoIdentifiers.add(specifier.local?.name ?? specifier.imported.name);
+                            memoIdentifiers.add(specifier.local?.name ?? specifier.imported.name);
                         }
                         else if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
                             specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
@@ -598,6 +599,19 @@ exports.requireMemoizeJsxReturners = (0, createRule_1.createRule)({
                         }
                     });
                 }
+                else if ((0, memoModule_1.isCustomMemoModuleImport)(sourceValue, filename)) {
+                    // The wrapper re-exports React's `memo` and nothing else this rule
+                    // reads, so only the `memo` binding is collected: `createElement` and
+                    // a namespace object stay bound to a react import, keeping an
+                    // unrelated `X.createElement` out.
+                    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 === 'memo') {
+                            memoIdentifiers.add(specifier.local?.name ?? specifier.imported.name);
+                        }
+                    });
+                }
                 if (!MEMOIZE_MODULES.has(sourceValue)) {
                     return;
                 }

package/lib/rules/use-custom-memo.js

@@ -3,9 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useCustomMemo = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
-const MEMO_MODULE = `'src/util/memo'`;
-/** `MEMO_MODULE` carries the quotes the fixer emits; a path never does. */
-const MEMO_MODULE_PATH = MEMO_MODULE.slice(1, -1);
+const memoModule_1 = require("../utils/memoModule");
 const SOURCE_EXTENSION = /\.(?:ts|tsx|js|jsx)$/;
 /**
  * The module the fixer points every `memo` import at is the one module that must
@@ -20,10 +18,10 @@ const SOURCE_EXTENSION = /\.(?:ts|tsx|js|jsx)$/;
  */
 const isMemoModule = (filename) => {
     const normalized = filename.replace(/\\/g, '/').replace(SOURCE_EXTENSION, '');
-    if (!normalized.endsWith(MEMO_MODULE_PATH)) {
+    if (!normalized.endsWith(memoModule_1.CUSTOM_MEMO_MODULE_PATH)) {
         return false;
     }
-    const suffixStart = normalized.length - MEMO_MODULE_PATH.length;
+    const suffixStart = normalized.length - memoModule_1.CUSTOM_MEMO_MODULE_PATH.length;
     return suffixStart === 0 || normalized[suffixStart - 1] === '/';
 };
 const isComment = (token) => token.type === utils_1.AST_TOKEN_TYPES.Line || token.type === utils_1.AST_TOKEN_TYPES.Block;
@@ -206,7 +204,7 @@ exports.useCustomMemo = (0, createRule_1.createRule)({
                     messageId: 'useCustomMemo',
                     fix(fixer) {
                         const sourceCode = context.getSourceCode();
-                        const memoImport = buildImport(memoSpecifiers, MEMO_MODULE, node.importKind, sourceCode);
+                        const memoImport = buildImport(memoSpecifiers, memoModule_1.CUSTOM_MEMO_MODULE_SOURCE, node.importKind, sourceCode);
                         const survivingSpecifiers = node.specifiers.filter((specifier) => !isMemoSpecifier(specifier));
                         const comments = sourceCode
                             .getCommentsInside(node)

package/lib/utils/memoModule.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The project's memo wrapper: the module `use-custom-memo`'s fixer points every
+ * `import { memo } from 'react'` at. It re-exports React's `memo`, so a rule
+ * that recognises a `memo(...)` call has to accept this module's binding as
+ * React's — keying recognition on the `'react'` spelling alone lets that fixer
+ * switch the recogniser off on the very convention this plugin enforces.
+ *
+ * The quotes live inside the value because the fixer splices the specifier into
+ * emitted import text verbatim, beside `sourceCode.getText(node.source)`, which
+ * carries its own quotes.
+ */
+export declare const CUSTOM_MEMO_MODULE_SOURCE = "'src/util/memo'";
+/** `CUSTOM_MEMO_MODULE_SOURCE` carries the quotes the fixer emits; a path never does. */
+export declare const CUSTOM_MEMO_MODULE_PATH: string;
+/** Whether an import specifier, read alone, names the memo wrapper module. */
+export declare const isCustomMemoModuleSource: (source: string) => boolean;
+/**
+ * Whether `source`, imported from `filename`, names the memo wrapper module.
+ *
+ * A relative specifier is resolved against the importing file before matching,
+ * because a file that sits inside the wrapper's own directory spells the same
+ * module `../memo` — a specifier naming no `util` segment of its own. Only
+ * relative specifiers resolve: a bare specifier is a package or an alias whose
+ * target the linter cannot know without a resolver.
+ */
+export declare const isCustomMemoModuleImport: (source: string, filename?: string) => boolean;

package/lib/utils/memoModule.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCustomMemoModuleImport = exports.isCustomMemoModuleSource = exports.CUSTOM_MEMO_MODULE_PATH = exports.CUSTOM_MEMO_MODULE_SOURCE = void 0;
+const path_1 = __importDefault(require("path"));
+/**
+ * The project's memo wrapper: the module `use-custom-memo`'s fixer points every
+ * `import { memo } from 'react'` at. It re-exports React's `memo`, so a rule
+ * that recognises a `memo(...)` call has to accept this module's binding as
+ * React's — keying recognition on the `'react'` spelling alone lets that fixer
+ * switch the recogniser off on the very convention this plugin enforces.
+ *
+ * The quotes live inside the value because the fixer splices the specifier into
+ * emitted import text verbatim, beside `sourceCode.getText(node.source)`, which
+ * carries its own quotes.
+ */
+exports.CUSTOM_MEMO_MODULE_SOURCE = `'src/util/memo'`;
+/** `CUSTOM_MEMO_MODULE_SOURCE` carries the quotes the fixer emits; a path never does. */
+exports.CUSTOM_MEMO_MODULE_PATH = exports.CUSTOM_MEMO_MODULE_SOURCE.slice(1, -1);
+/**
+ * The trailing segments that identify the wrapper module however it is spelled.
+ * Only the leading segments vary between spellings of the same module — the
+ * `src/` alias the fixer emits, a `@/` alias, or any depth of `../` — so the
+ * tail is what a specifier has to carry. It has to land on a segment boundary,
+ * so `./memo`, `lodash-memo` and `react-memo` name other modules and stay out.
+ */
+const MODULE_TAIL = exports.CUSTOM_MEMO_MODULE_PATH.split('/').slice(-2).join('/');
+const MODULE_TAIL_PATTERN = new RegExp(`(?:^|/)${MODULE_TAIL}$`);
+/** Whether an import specifier, read alone, names the memo wrapper module. */
+const isCustomMemoModuleSource = (source) => MODULE_TAIL_PATTERN.test(source);
+exports.isCustomMemoModuleSource = isCustomMemoModuleSource;
+/**
+ * Whether `source`, imported from `filename`, names the memo wrapper module.
+ *
+ * A relative specifier is resolved against the importing file before matching,
+ * because a file that sits inside the wrapper's own directory spells the same
+ * module `../memo` — a specifier naming no `util` segment of its own. Only
+ * relative specifiers resolve: a bare specifier is a package or an alias whose
+ * target the linter cannot know without a resolver.
+ */
+const isCustomMemoModuleImport = (source, filename) => {
+    if ((0, exports.isCustomMemoModuleSource)(source)) {
+        return true;
+    }
+    if (!filename || !source.startsWith('.')) {
+        return false;
+    }
+    const importerDirectory = path_1.default.posix.dirname(filename.replace(/\\/g, '/'));
+    return (0, exports.isCustomMemoModuleSource)(path_1.default.posix.normalize(path_1.default.posix.join(importerDirectory, source)));
+};
+exports.isCustomMemoModuleImport = isCustomMemoModuleImport;
+//# sourceMappingURL=memoModule.js.map

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,152 @@
 [
+  {
+    "version": "1.21.4",
+    "date": "2026-09-04T11:47:38.427Z",
+    "rules": [
+      {
+        "name": "prefer-map-over-conditional-dispatch",
+        "changeType": "fix",
+        "issues": [
+          2009
+        ],
+        "summary": "keep the alias when the checker resolves past it (closes #2009)"
+      }
+    ]
+  },
+  {
+    "version": "1.21.3",
+    "date": "2026-09-03T23:34:34.310Z",
+    "rules": [
+      {
+        "name": "enforce-boolean-naming-prefixes",
+        "changeType": "fix",
+        "issues": [
+          2308
+        ],
+        "summary": "accept `??` as a boolean fallback operator (closes #2308)"
+      },
+      {
+        "name": "enforce-centralized-mock-firestore",
+        "changeType": "fix",
+        "issues": [
+          2307
+        ],
+        "summary": "match the local mock by normalized name so a MOCK_FIRESTORE constant is flagged (closes #2307)"
+      },
+      {
+        "name": "enforce-fieldpath-syntax-in-docsetter",
+        "changeType": "fix",
+        "issues": [
+          2303
+        ],
+        "summary": "decline the fix when a flattened key collides (closes #2303)"
+      },
+      {
+        "name": "enforce-firestore-set-merge",
+        "changeType": "fix",
+        "issues": [
+          2311
+        ],
+        "summary": "decline the merge rewrite on update's varargs and precondition forms (closes #2311)"
+      },
+      {
+        "name": "enforce-object-literal-as-const",
+        "changeType": "fix",
+        "issues": [
+          2319
+        ],
+        "summary": "fall back to the sole return's own assertion for the declared type (closes #2319)"
+      },
+      {
+        "name": "enforce-positive-naming",
+        "changeType": "fix",
+        "issues": [
+          2306
+        ],
+        "summary": "make the boolean-like gate spelling-independent (closes #2306)"
+      },
+      {
+        "name": "enforce-snapshot-state-narrowing",
+        "changeType": "fix",
+        "issues": [
+          2315
+        ],
+        "summary": "accept ?? alongside || in the logical guard (closes #2315)"
+      },
+      {
+        "name": "memo-nested-react-components",
+        "changeType": "fix",
+        "issues": [
+          2313
+        ],
+        "summary": "admit useLatestCallback as a callback hook (closes #2313)"
+      },
+      {
+        "name": "no-entire-object-hook-deps",
+        "changeType": "fix",
+        "issues": [
+          2309
+        ],
+        "summary": "govern the deep-compare hooks, which the useMemo rename walked out of view (closes #2309)"
+      },
+      {
+        "name": "no-hungarian",
+        "changeType": "fix",
+        "issues": [
+          2317
+        ],
+        "summary": "read a leading single-letter segment as a prefix in SCREAMING_SNAKE_CASE (closes #2317)"
+      },
+      {
+        "name": "no-inline-component-prop",
+        "changeType": "fix",
+        "issues": [
+          2314
+        ],
+        "summary": "resolve a memo(namedReference) argument to its declaration (closes #2314)"
+      },
+      {
+        "name": "no-restricted-properties-fix",
+        "changeType": "fix",
+        "issues": [
+          2318
+        ],
+        "summary": "match a configured object through global-const-style's rename (closes #2318)"
+      },
+      {
+        "name": "no-useless-usememo-primitives",
+        "changeType": "fix",
+        "issues": [
+          2312
+        ],
+        "summary": "recognise the deep-compare memo spelling so a renamed callee still reports (closes #2312)"
+      },
+      {
+        "name": "prefer-destructuring-no-class",
+        "changeType": "fix",
+        "issues": [
+          2316
+        ],
+        "summary": "match a binding to its property ignoring case and underscores (closes #2316)"
+      },
+      {
+        "name": "prefer-document-flattening",
+        "changeType": "fix",
+        "issues": [
+          2304
+        ],
+        "summary": "rewrite an existing shouldFlatten in place rather than appending a duplicate key (closes #2304)"
+      },
+      {
+        "name": "require-memoize-jsx-returners",
+        "changeType": "fix",
+        "issues": [
+          2305
+        ],
+        "summary": "re-cut the degenerate-identifier duplicate ceiling for the wrapper-memo fixtures (closes #2305); recognise memo imported from the project memo wrapper (closes #2305)"
+      }
+    ]
+  },
   {
     "version": "1.21.2",
     "date": "2026-09-03T01:55:23.074Z",