@blumintinc/eslint-plugin-blumint 1.20.113 → 1.20.115

package/lib/index.js

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

package/lib/rules/enforce-serializable-params.d.ts

@@ -4,6 +4,7 @@ declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").R
     functionTypes: string[];
 }[], {
     TSTypeAliasDeclaration(node: TSESTree.TSTypeAliasDeclaration): void;
+    TSInterfaceDeclaration(node: TSESTree.TSInterfaceDeclaration): void;
     TSTypeReference(node: TSESTree.TSTypeReference): void;
     'Program:exit'(): void;
 }>;

package/lib/rules/enforce-serializable-params.js

@@ -53,17 +53,63 @@ exports.default = (0, createRule_1.createRule)({
             ...NON_SERIALIZABLE_TYPES,
             ...(options.additionalNonSerializableTypes || []),
         ]);
-        const typeAliasMap = new Map();
+        /**
+         * Interfaces sit here alongside aliases because a request contract is as
+         * often an `interface` as a `type`, and resolving only one of the two makes
+         * the rule's coverage depend on which keyword the author reached for.
+         */
+        const declarations = new Map();
+        /**
+         * A node reports at most once. Resolution follows references, so a type
+         * reachable by two paths (`{ x: Inner; y: Inner }`) would otherwise produce
+         * duplicate reports at one location.
+         */
+        const reported = new Set();
         function isNonSerializableType(typeName) {
             return allNonSerializableTypes.has(typeName);
         }
-        function checkTypeNode(node, propName) {
+        /**
+         * The rightmost identifier of a possibly-namespaced name, so
+         * `admin.firestore.Timestamp` is matched as `Timestamp`. The whole rule
+         * keys off simple names, and a namespaced spelling of a type is the same
+         * type — reading only `Identifier.name` leaves it `undefined` and silently
+         * exempts every firebase-admin-style reference.
+         */
+        function simpleTypeNameOf(entity) {
+            if (!entity)
+                return undefined;
+            if (entity.type === utils_1.AST_NODE_TYPES.Identifier)
+                return entity.name;
+            if (entity.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+                return simpleTypeNameOf(entity.right);
+            }
+            return undefined;
+        }
+        const propertyNameOf = (member) => {
+            const { key } = member;
+            if (key.type === utils_1.AST_NODE_TYPES.Identifier)
+                return key.name;
+            if (key.type === utils_1.AST_NODE_TYPES.Literal)
+                return String(key.value);
+            return undefined;
+        };
+        function checkMembers(members, seen, propName) {
+            for (const member of members) {
+                if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature)
+                    continue;
+                checkTypeNode(member.typeAnnotation, propertyNameOf(member) ?? propName, seen);
+            }
+        }
+        function checkTypeNode(node, propName, seen = new Set()) {
             if (!node)
                 return;
             switch (node.type) {
                 case utils_1.AST_NODE_TYPES.TSTypeReference: {
-                    const typeName = node.typeName.name;
-                    if (isNonSerializableType(typeName)) {
+                    const typeName = simpleTypeNameOf(node.typeName);
+                    if (typeName &&
+                        isNonSerializableType(typeName) &&
+                        !reported.has(node)) {
+                        reported.add(node);
                         context.report({
                             node,
                             messageId: propName
@@ -75,28 +121,51 @@ exports.default = (0, createRule_1.createRule)({
                             },
                         });
                     }
+                    /**
+                     * A reference to a locally declared type is followed so a payload
+                     * assembled from named parts is inspected as a whole. `seen` is
+                     * path-scoped rather than global: a self-referential type must not
+                     * loop, but a type legitimately used by two siblings must still be
+                     * checked under each of them.
+                     */
+                    if (typeName && !seen.has(typeName)) {
+                        const declaration = declarations.get(typeName);
+                        if (declaration) {
+                            seen.add(typeName);
+                            if (declaration.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                                checkTypeNode(declaration.typeAnnotation, propName, seen);
+                            }
+                            else {
+                                checkMembers(declaration.body.body, seen, propName);
+                            }
+                            seen.delete(typeName);
+                        }
+                    }
                     // Check type parameters of generic types (like Array<T>)
                     if (node.typeParameters) {
-                        node.typeParameters.params.forEach((param) => checkTypeNode(param, propName));
+                        node.typeParameters.params.forEach((param) => checkTypeNode(param, propName, seen));
                     }
                     break;
                 }
                 case utils_1.AST_NODE_TYPES.TSArrayType:
-                    checkTypeNode(node.elementType, propName);
+                    checkTypeNode(node.elementType, propName, seen);
                     break;
                 case utils_1.AST_NODE_TYPES.TSTypeAnnotation:
-                    checkTypeNode(node.typeAnnotation, propName);
+                    checkTypeNode(node.typeAnnotation, propName, seen);
                     break;
                 case utils_1.AST_NODE_TYPES.TSTypeLiteral:
-                    node.members.forEach((member) => {
-                        if (member.type === utils_1.AST_NODE_TYPES.TSPropertySignature) {
-                            const propertyName = member.key.name;
-                            checkTypeNode(member.typeAnnotation, propertyName);
-                        }
-                    });
+                    checkMembers(node.members, seen, propName);
                     break;
                 case utils_1.AST_NODE_TYPES.TSUnionType:
-                    node.types.forEach((type) => checkTypeNode(type, propName));
+                case utils_1.AST_NODE_TYPES.TSIntersectionType:
+                    node.types.forEach((type) => checkTypeNode(type, propName, seen));
+                    break;
+                case utils_1.AST_NODE_TYPES.TSTupleType:
+                    node.elementTypes.forEach((type) => checkTypeNode(type, propName, seen));
+                    break;
+                // `readonly T[]` wraps its operand rather than replacing it.
+                case utils_1.AST_NODE_TYPES.TSTypeOperator:
+                    checkTypeNode(node.typeAnnotation, propName, seen);
                     break;
             }
         }
@@ -109,35 +178,30 @@ exports.default = (0, createRule_1.createRule)({
         const wrapperReferences = [];
         return {
             TSTypeAliasDeclaration(node) {
-                typeAliasMap.set(node.id.name, node);
+                declarations.set(node.id.name, node);
+            },
+            TSInterfaceDeclaration(node) {
+                declarations.set(node.id.name, node);
             },
             TSTypeReference(node) {
-                const typeName = node.typeName.name;
-                if (options.functionTypes.includes(typeName) &&
+                const typeName = simpleTypeNameOf(node.typeName);
+                if (typeName &&
+                    options.functionTypes.includes(typeName) &&
                     node.typeParameters?.params[0]) {
                     wrapperReferences.push(node);
                 }
             },
             'Program:exit'() {
                 for (const node of wrapperReferences) {
-                    const typeParam = node.typeParameters?.params[0];
-                    if (!typeParam)
-                        continue;
-                    if (typeParam.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
-                        const referencedTypeName = typeParam.typeName.name;
-                        const typeAlias = typeAliasMap.get(referencedTypeName);
-                        /**
-                         * A reference that names no local alias is still a type in its own
-                         * right — `CallableRequest<Timestamp>` is the plainest form of the
-                         * violation. Checking the node itself lets the non-serializable
-                         * lookup and the generic descent apply; an unrecognized name simply
-                         * yields no report, so an imported request type stays silent.
-                         */
-                        checkTypeNode(typeAlias ? typeAlias.typeAnnotation : typeParam);
-                    }
-                    else {
-                        checkTypeNode(typeParam);
-                    }
+                    /**
+                     * The payload is handed to `checkTypeNode` whatever its shape: it
+                     * resolves a reference to a local declaration itself, and a reference
+                     * that names none is still a type in its own right —
+                     * `CallableRequest<Timestamp>` is the plainest form of the violation.
+                     * An unrecognized name yields no report, so an imported request type
+                     * stays silent.
+                     */
+                    checkTypeNode(node.typeParameters?.params[0]);
                 }
             },
         };

package/lib/rules/fast-deep-equal-over-microdiff.d.ts

@@ -1,4 +1,2 @@
 import { TSESLint } from '@typescript-eslint/utils';
-type MessageIds = 'useFastDeepEqual' | 'addFastDeepEqualImport';
-export declare const fastDeepEqualOverMicrodiff: TSESLint.RuleModule<MessageIds, [], TSESLint.RuleListener>;
-export {};
+export declare const fastDeepEqualOverMicrodiff: TSESLint.RuleModule<"useFastDeepEqual", [], TSESLint.RuleListener>;

package/lib/rules/fast-deep-equal-over-microdiff.js

@@ -89,9 +89,6 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
             useFastDeepEqual: "What's wrong: This code uses `{{diffName}}(...).length` as a deep equality check.\n" +
                 'Why it matters: `{{diffName}}` allocates a full change list (paths, types, values) before you compare it to zero, which hides the boolean intent and wastes memory/time.\n' +
                 'How to fix: Call `{{fastEqualName}}(left, right)` for equality (or prefix with `!` for inequality) using the same two arguments instead of counting diff length.',
-            addFastDeepEqualImport: "What's wrong: This file checks equality via `{{diffName}}(...).length` but does not import a deep-equality function.\n" +
-                'Why it matters: Without `@blumintinc/fast-deep-equal`, equality checks keep building diff entries just to count them, adding overhead and obscuring intent.\n' +
-                'How to fix: Add a default import from `@blumintinc/fast-deep-equal` as `{{fastEqualName}}` and use `{{fastEqualName}}(a, b)` for equality checks.',
         },
     },
     defaultOptions: [],

package/lib/rules/no-jsx-in-hooks.js

@@ -13,20 +13,47 @@ const isJsxElement = (node) => {
         node.type === utils_1.AST_NODE_TYPES.JSXFragment ||
         node.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer);
 };
+/**
+ * A type reference's name as dotted segments.
+ *
+ * A qualified name nests to the LEFT, so `React.JSX.Element` is a
+ * TSQualifiedName whose own `left` is another TSQualifiedName. Matching one
+ * nesting level at a time therefore recognizes `JSX.Element` but not the
+ * React-namespaced spelling of the same type; comparing whole paths recognizes
+ * both.
+ */
+const qualifiedSegments = (typeName) => {
+    if (typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return [typeName.name];
+    }
+    if (typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+        const left = qualifiedSegments(typeName.left);
+        return left && [...left, typeName.right.name];
+    }
+    return null;
+};
+/** JSX-producing type paths, written without the optional `React` qualifier. */
+const JSX_TYPE_PATHS = new Set([
+    'JSX',
+    'JSX.Element',
+    'ReactNode',
+    'ReactElement',
+]);
 const isJsxReturnType = (node) => {
-    if (node.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
-        const typeName = node.typeAnnotation.typeName;
-        if (typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
-            return ['JSX', 'ReactNode', 'ReactElement'].includes(typeName.name);
-        }
-        if (typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
-            return (typeName.left.type === utils_1.AST_NODE_TYPES.Identifier &&
-                typeName.left.name === 'JSX' &&
-                typeName.right.type === utils_1.AST_NODE_TYPES.Identifier &&
-                typeName.right.name === 'Element');
-        }
+    if (node.typeAnnotation.type !== utils_1.AST_NODE_TYPES.TSTypeReference) {
+        return false;
     }
-    return false;
+    const segments = qualifiedSegments(node.typeAnnotation.typeName);
+    if (!segments) {
+        return false;
+    }
+    /**
+     * `React.` re-exports the same declarations, so it carries no meaning for
+     * this question. Every other qualifier names a type from a different module
+     * and must not match — `Foo.ReactNode` is not React's.
+     */
+    const path = segments[0] === 'React' ? segments.slice(1) : segments;
+    return path.length > 0 && JSX_TYPE_PATHS.has(path.join('.'));
 };
 const containsJsxInBlockStatement = (node) => {
     const variablesWithJsx = new Set();

package/lib/rules/prefer-fragment-component.d.ts

@@ -1,4 +1,2 @@
 import { TSESLint } from '@typescript-eslint/utils';
-type MessageIds = 'preferFragment' | 'addFragmentImport';
-export declare const preferFragmentComponent: TSESLint.RuleModule<MessageIds, [], TSESLint.RuleListener>;
-export {};
+export declare const preferFragmentComponent: TSESLint.RuleModule<"preferFragment", [], TSESLint.RuleListener>;

package/lib/rules/prefer-fragment-component.js

@@ -121,7 +121,6 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
         schema: [],
         messages: {
             preferFragment: 'Prefer Fragment imported from react over {{type}}. Shorthand fragments block props like "key" and mixing fragment styles makes JSX harder to refactor. Import { Fragment } from "react" and wrap the children with <Fragment>...</Fragment> so fragment usage stays explicit.',
-            addFragmentImport: "Fragment is used but not imported from react. Without an explicit import the fixer leaves <Fragment> undefined and the React dependency implicit. Add `import { Fragment } from 'react'` alongside your other React imports so the file compiles.",
         },
     },
     defaultOptions: [],

package/lib/rules/prefer-next-dynamic.d.ts

@@ -1,9 +1,8 @@
 import { TSESLint } from '@typescript-eslint/utils';
-type MessageIds = 'preferNextDynamic' | 'addNextDynamicImport' | 'removeUseDynamicImport';
 type Options = [
     {
         useDynamicSources?: string[];
     }?
 ];
-export declare const preferNextDynamic: TSESLint.RuleModule<MessageIds, Options, TSESLint.RuleListener>;
+export declare const preferNextDynamic: TSESLint.RuleModule<"preferNextDynamic", Options, TSESLint.RuleListener>;
 export {};

package/lib/rules/prefer-next-dynamic.js

@@ -206,8 +206,6 @@ exports.preferNextDynamic = (0, createRule_1.createRule)({
         ],
         messages: {
             preferNextDynamic: 'Component "{{componentName}}" is created with useDynamic(import(...)), which bypasses Next.js dynamic() handling for client-only components and leaves SSR control to a custom wrapper. Wrap the import in dynamic(() => import(...), { ssr: false }) so Next.js manages code-splitting and disables server rendering safely.',
-            addNextDynamicImport: "The auto-fix will replace useDynamic(import(...)) with dynamic(() => import(...), { ssr: false }), which references Next.js's dynamic function. Without importing dynamic from 'next/dynamic', the fixed code will throw a ReferenceError at runtime when the module loads. Add `import dynamic from 'next/dynamic'` at the top of the file to make the dynamic identifier available.",
-            removeUseDynamicImport: 'Remove the unused useDynamic import after migrating to dynamic(); leaving the custom hook imported invites accidental reuse and keeps dead code in the bundle.',
         },
     },
     defaultOptions: [{}],

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.20.115",
+    "date": "2026-08-05T18:41:41.153Z",
+    "rules": [
+      {
+        "name": "no-jsx-in-hooks",
+        "changeType": "fix",
+        "issues": [
+          1753
+        ],
+        "summary": "detect React-qualified JSX return types (closes #1753)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.114",
+    "date": "2026-08-05T18:16:40.596Z",
+    "rules": [
+      {
+        "name": "enforce-serializable-params",
+        "changeType": "fix",
+        "issues": [
+          1751
+        ],
+        "summary": "resolve namespaced names, interfaces and reference chains (closes #1751)"
+      }
+    ]
+  },
   {
     "version": "1.20.113",
     "date": "2026-08-05T17:37:08.020Z",