@blumintinc/eslint-plugin-blumint 1.20.80 → 1.20.81

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.81',
     },
     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/package.json

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

package/release-manifest.json

@@ -1,4 +1,26 @@
 [
+  {
+    "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",