@blumintinc/eslint-plugin-blumint 1.20.80 → 1.20.82

package/lib/index.js

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

package/lib/rules/no-unused-props.js

@@ -156,6 +156,44 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
             }
             return null;
         };
+        /**
+         * The props type carried by a component annotation on the DECLARATOR —
+         * `const C: React.FC<X> = ({ ... }) => ...` — used only when the parameter
+         * itself is unannotated (#1620). Gated to FC-shaped annotations so an
+         * arbitrary declarator type is never mistaken for a props source; the
+         * returned argument runs through the same resolver as a direct annotation,
+         * so wrappers like `React.FC<Readonly<XProps>>` resolve for free.
+         */
+        const FC_TYPE_NAMES = new Set([
+            'FC',
+            'FunctionComponent',
+            'VFC',
+            'VoidFunctionComponent',
+        ]);
+        const propsArgumentOfFcAnnotation = (declarationId) => {
+            if (declarationId.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return undefined;
+            }
+            const annotation = declarationId.typeAnnotation?.typeAnnotation;
+            if (annotation?.type !== utils_1.AST_NODE_TYPES.TSTypeReference) {
+                return undefined;
+            }
+            const { typeName } = annotation;
+            const localName = typeName.type === utils_1.AST_NODE_TYPES.Identifier
+                ? typeName.name
+                : typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName &&
+                    typeName.left.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    typeName.left.name === 'React' &&
+                    typeName.right.type === utils_1.AST_NODE_TYPES.Identifier
+                    ? typeName.right.name
+                    : null;
+            if (localName === null || !FC_TYPE_NAMES.has(localName)) {
+                return undefined;
+            }
+            const typeArgs = annotation.typeParameters ??
+                annotation.typeArguments;
+            return typeArgs?.params[0];
+        };
         const isAnyPropFromSpreadTypeUsed = (spreadTypeName, used, knownProps) => {
             const spreadTypeProps = spreadTypeToPropNames.get(spreadTypeName);
             if (!spreadTypeProps || spreadTypeProps.size === 0) {
@@ -769,8 +807,10 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                 const param = fn.params[0];
                 if (param?.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
                     // Resolve through generic wrappers (e.g. `Readonly<FooProps>`) as well
-                    // as the plain `FooProps` annotation.
-                    const typeName = resolvePropsTypeName(param.typeAnnotation?.typeAnnotation);
+                    // as the plain `FooProps` annotation; an unannotated pattern under an
+                    // FC-annotated declarator resolves from the annotation's argument.
+                    const typeName = resolvePropsTypeName(param.typeAnnotation?.typeAnnotation ??
+                        propsArgumentOfFcAnnotation(declaration.id));
                     if (typeName) {
                         const used = new Set();
                         const restUsed = collectUsedFromObjectPattern(param, typeName, used);
@@ -782,7 +822,8 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                     // Identifier param (`props: FooProps`): the destructuring happens in
                     // the body. Resolve the Props type (unwrapping generic wrappers) and
                     // scan the body for `const { ... } = props`.
-                    const typeName = resolvePropsTypeName(param.typeAnnotation?.typeAnnotation);
+                    const typeName = resolvePropsTypeName(param.typeAnnotation?.typeAnnotation ??
+                        propsArgumentOfFcAnnotation(declaration.id));
                     if (!typeName) {
                         return;
                     }

package/lib/rules/prefer-destructuring-no-class.js

@@ -9,6 +9,59 @@ const defaultOptions = [
         enforceForRenamedProperties: false,
     },
 ];
+/**
+ * Names of every class declared anywhere in the file. A purely syntactic rule
+ * cannot see an imported class, so same-file declarations are the entire
+ * population a type annotation can be resolved against (#1619).
+ */
+function collectClassNames(sourceCode) {
+    const names = new Set();
+    const stack = [sourceCode.ast];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if ((current.type === utils_1.AST_NODE_TYPES.ClassDeclaration ||
+            current.type === utils_1.AST_NODE_TYPES.ClassExpression) &&
+            current.id) {
+            names.add(current.id.name);
+        }
+        for (const key of sourceCode.visitorKeys[current.type] ?? []) {
+            const value = current[key];
+            const children = Array.isArray(value) ? value : [value];
+            for (const child of children) {
+                if (child && typeof child === 'object' && 'type' in child) {
+                    stack.push(child);
+                }
+            }
+        }
+    }
+    return names;
+}
+/**
+ * Reports whether an identifier's declared type names a class declared in this
+ * file — the annotation-carried form of a class instance (`user: User` as a
+ * parameter or an annotated variable), which the docs promise the same
+ * exemption as a `new User()` initializer (#1619).
+ */
+function annotationNamesFileClass(identifier, classNames) {
+    if (!identifier || identifier.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    const annotation = identifier.typeAnnotation?.typeAnnotation;
+    return (annotation?.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+        annotation.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+        classNames.has(annotation.typeName.name));
+}
+const fileClassNames = new WeakMap();
+function classNamesFor(context) {
+    const sourceCode = context.getSourceCode();
+    const cached = fileClassNames.get(sourceCode.ast);
+    if (cached) {
+        return cached;
+    }
+    const names = collectClassNames(sourceCode);
+    fileClassNames.set(sourceCode.ast, names);
+    return names;
+}
 function isClassInstance(node, context) {
     // Check if node is a MemberExpression
     if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
@@ -22,12 +75,22 @@ function isClassInstance(node, context) {
             const variable = object.name;
             const scope = context.getScope();
             const ref = scope.references.find((ref) => ref.identifier.name === variable);
-            if (ref?.resolved?.defs[0]?.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
-                const init = ref.resolved.defs[0].node.init;
-                return init?.type === utils_1.AST_NODE_TYPES.NewExpression;
+            const def = ref?.resolved?.defs[0];
+            if (def?.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                const init = def.node.init;
+                return (init?.type === utils_1.AST_NODE_TYPES.NewExpression ||
+                    // `const user: User = getUser();` — the annotation, not the
+                    // initializer, is what marks the value as a class instance.
+                    annotationNamesFileClass(def.node.id, classNamesFor(context)));
+            }
+            // `function greet(user: User)` — a parameter typed with a same-file
+            // class is a class instance the initializer-based check cannot see.
+            if (def?.type === 'Parameter' &&
+                annotationNamesFileClass(def.name, classNamesFor(context))) {
+                return true;
             }
             // Check if the identifier refers to a class (not an instance)
-            if (ref?.resolved?.defs[0]?.node.type === utils_1.AST_NODE_TYPES.ClassDeclaration) {
+            if (def?.node.type === utils_1.AST_NODE_TYPES.ClassDeclaration) {
                 return false;
             }
         }

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

@@ -62,21 +62,75 @@ const isInsideComponentMock = (node, componentModule) => {
     }
     return false;
 };
+/**
+ * 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
+ * either on the specifier (`{ type Image }`) or on the whole declaration
+ * (`import type ...`).
+ */
+const isTypeOnlySpecifier = (specifier) => {
+    if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+        specifier.importKind === 'type') {
+        return true;
+    }
+    return (specifier.parent?.importKind ===
+        'type');
+};
 /** A type-only binding cannot be rendered, so it is no basis for a fix. */
 const isTypeOnlyImport = (definition) => {
     const { node } = definition;
-    if (node.type === utils_1.AST_NODE_TYPES.ImportSpecifier) {
-        return (node.importKind === 'type' ||
-            node.parent?.importKind ===
-                'type');
-    }
-    if (node.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+    if (node.type === utils_1.AST_NODE_TYPES.ImportSpecifier ||
+        node.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
         node.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
-        return (node.parent?.importKind ===
-            'type');
+        return isTypeOnlySpecifier(node);
     }
     return false;
 };
+/**
+ * Whether a specifier binds `next/image`'s Image component. The default export
+ * *is* that component whatever local name it is bound to, so the binding's
+ * identity decides rather than the local name — otherwise `import Img from
+ * 'next/image'` becomes a rename-shaped bypass of the rule. `{ default as X }`
+ * is the same binding written differently. The named `Image` form is matched
+ * too, while every other named export (`getImageProps`, the prop types) is
+ * left alone: those are not the optimization bypass.
+ */
+const bindsImageComponent = (specifier) => {
+    if (isTypeOnlySpecifier(specifier)) {
+        return false;
+    }
+    if (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier) {
+        return true;
+    }
+    // A namespace binds the module rather than the component, and is consumed
+    // through a member expression the fix has no shape for.
+    if (specifier.type !== utils_1.AST_NODE_TYPES.ImportSpecifier) {
+        return false;
+    }
+    return (specifier.imported.name === 'default' || specifier.imported.name === 'Image');
+};
+/**
+ * The declaration text that keeps the specifiers the fix does not move pointed
+ * at their original source. Rewriting the whole declaration would drop them
+ * while they are still referenced, and their bindings (`ImageProps`,
+ * `getImageProps`) come from `next/image` alone — the wrapper does not
+ * re-export them.
+ */
+const retainedImportText = (specifiers, sourceCode, source) => {
+    const named = specifiers.filter((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier);
+    const standalone = specifiers.filter((specifier) => specifier.type !== utils_1.AST_NODE_TYPES.ImportSpecifier);
+    const clauses = [
+        ...standalone.map((specifier) => sourceCode.getText(specifier)),
+        ...(named.length > 0
+            ? [
+                `{ ${named
+                    .map((specifier) => sourceCode.getText(specifier))
+                    .join(', ')} }`,
+            ]
+            : []),
+    ];
+    return `import ${clauses.join(', ')} from ${sourceCode.getText(source)};`;
+};
 const isBoundAsValue = (scope, name) => {
     const variable = utils_1.ASTUtils.findVariable(scope, name);
     return (!!variable &&
@@ -213,28 +267,32 @@ module.exports = (0, createRule_1.createRule)({
                 if (isComponentImplementationFile) {
                     return;
                 }
-                if (node.source.value === 'next/image' && node.specifiers.length > 0) {
-                    const imageSpecifier = node.specifiers.find((spec) => (spec.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
-                        spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier) &&
-                        (spec.local.name === 'Image' ||
-                            (spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
-                                spec.imported.name === 'Image')));
-                    if (imageSpecifier) {
-                        const localName = imageSpecifier.local.name;
-                        // Report the import
-                        context.report({
-                            node,
-                            messageId: 'useImageOptimized',
-                            data: {
-                                componentPath,
-                                component: 'next/image',
-                            },
-                            fix(fixer) {
-                                return fixer.replaceText(node, `import ${localName} from '${componentPath}';`);
-                            },
-                        });
-                    }
+                if (node.source.value !== 'next/image') {
+                    return;
+                }
+                // A default binding comes first in the specifier list, so this prefers
+                // it over a redundant named `Image` alongside it.
+                const imageSpecifier = node.specifiers.find(bindsImageComponent);
+                if (!imageSpecifier) {
+                    return;
                 }
+                const localName = imageSpecifier.local.name;
+                const retained = node.specifiers.filter((specifier) => specifier !== imageSpecifier);
+                context.report({
+                    node,
+                    messageId: 'useImageOptimized',
+                    data: {
+                        componentPath,
+                        component: 'next/image',
+                    },
+                    fix(fixer) {
+                        const swapped = `import ${localName} from '${componentPath}';`;
+                        if (retained.length === 0) {
+                            return fixer.replaceText(node, swapped);
+                        }
+                        return fixer.replaceText(node, `${retainedImportText(retained, sourceCode, node.source)}\n${swapped}`);
+                    },
+                });
             },
         };
     },

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,40 @@
 [
+  {
+    "version": "1.20.82",
+    "date": "2026-08-02T21:42:12.697Z",
+    "rules": [
+      {
+        "name": "require-image-optimized",
+        "changeType": "fix",
+        "issues": [
+          1623
+        ],
+        "summary": "key next/image detection on the imported binding (closes #1623)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.81",
+    "date": "2026-08-02T12:22:56.245Z",
+    "rules": [
+      {
+        "name": "no-unused-props",
+        "changeType": "fix",
+        "issues": [
+          1620
+        ],
+        "summary": "resolve the props type from an FC-annotated declarator (closes #1620)"
+      },
+      {
+        "name": "prefer-destructuring-no-class",
+        "changeType": "fix",
+        "issues": [
+          1619
+        ],
+        "summary": "recognize annotation-carried class instances (closes #1619)"
+      }
+    ]
+  },
   {
     "version": "1.20.80",
     "date": "2026-08-02T11:35:36.730Z",