@blumintinc/eslint-plugin-blumint 1.21.9 → 1.21.11

package/lib/index.js

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

package/lib/rules/global-const-style.js

@@ -350,9 +350,14 @@ const storageContainerOf = (node) => {
  * the file compiling is not.
  *
  * A reference STORED INTO a composite literal is followed through that
- * container, since storing does not copy — see `storageContainerOf`. A
- * destructuring id extracts a member rather than the whole, so it is not an
- * alias here.
+ * container, since storing does not copy — see `storageContainerOf`.
+ *
+ * A destructuring id is accepted in BOTH spellings. It does not name the whole
+ * value, but every binding it introduces is typed from that value, and a rest
+ * element is itself a fresh container the assertion narrows: `const [, ...rest]
+ * = ITEMS` gives `rest` the frozen element type, so `rest.push(4)` is TS2345
+ * for an input that compiled. Admitting only the object spelling gave the same
+ * construct opposite verdicts (#2336).
  */
 const aliasDeclaratorOf = (identifier) => {
     // Ascends strictly, so reaching a node with no parent terminates the walk.
@@ -361,7 +366,9 @@ const aliasDeclaratorOf = (identifier) => {
         const declarator = value.parent;
         if (declarator?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
             declarator.init === value &&
-            declarator.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+            (declarator.id.type === utils_1.AST_NODE_TYPES.Identifier ||
+                declarator.id.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                declarator.id.type === utils_1.AST_NODE_TYPES.ArrayPattern)) {
             return declarator;
         }
         const container = storageContainerOf(value);
@@ -376,12 +383,42 @@ const aliasDeclaratorOf = (identifier) => {
  * bracketed form — read through `accessedPropertyName` so the two spellings
  * cannot diverge from how the mutation walk already reads a method name.
  */
-const isObjectAssignCallee = (callee) => {
+const isNamespacedCallee = (callee, namespace, method) => {
     const value = outermostValueOf(callee);
     return (value.type === utils_1.AST_NODE_TYPES.MemberExpression &&
         value.object.type === utils_1.AST_NODE_TYPES.Identifier &&
-        value.object.name === 'Object' &&
-        accessedPropertyName(value) === 'assign');
+        value.object.name === namespace &&
+        accessedPropertyName(value) === method);
+};
+const isObjectAssignCallee = (callee) => isNamespacedCallee(callee, 'Object', 'assign');
+/** Whether a callee is the bare global `structuredClone`. */
+const isStructuredCloneCallee = (callee) => {
+    const value = outermostValueOf(callee);
+    return (value.type === utils_1.AST_NODE_TYPES.Identifier && value.name === 'structuredClone');
+};
+/**
+ * Whether a call COPIES the argument at `index` while keeping its type.
+ *
+ * `Array.from(X)` and `structuredClone(X)` both hand back a fresh, mutable
+ * value whose element or property types are the argument's — so freezing the
+ * argument narrows the copy exactly as a spread does. `Array.from(X, fn)` is
+ * excluded for the same reason `map` is: a mapper retypes the result, so
+ * nothing of the constant's type survives into it.
+ */
+const isCopyingCall = (call, index) => {
+    if (isObjectAssignCallee(call.callee)) {
+        return true;
+    }
+    if (index !== 0) {
+        return false;
+    }
+    if (isStructuredCloneCallee(call.callee)) {
+        return true;
+    }
+    if (isNamespacedCallee(call.callee, 'Array', 'from')) {
+        return call.arguments.length === 1;
+    }
+    return false;
 };
 /**
  * Array methods whose result keeps the receiver's ELEMENT type. `map` is
@@ -390,7 +427,19 @@ const isObjectAssignCallee = (callee) => {
  * `map`. Admitting it would withhold the assertion from every derived array
  * anything is computed from, to cover a spelling nobody writes.
  */
-const TYPE_PRESERVING_COPY_METHODS = new Set(['concat', 'slice', 'filter']);
+const TYPE_PRESERVING_COPY_METHODS = new Set([
+    'concat',
+    'slice',
+    'filter',
+    'flat',
+    // The ES2023 copying methods. Listed even though this repo's TypeScript
+    // predates them, because they are the same category and admitting them costs
+    // nothing: a name that does not resolve produces no reports to lose.
+    'toSorted',
+    'toReversed',
+    'toSpliced',
+    'with',
+]);
 /**
  * The expression that builds a COPY carrying this value's type — the literal
  * around a spread of it, the call of a copying array method on it, or an
@@ -415,10 +464,11 @@ const copyExpressionOf = (node) => {
             parent.parent?.type === utils_1.AST_NODE_TYPES.ArrayExpression)) {
         return parent.parent;
     }
-    if (parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
-        parent.arguments.includes(node) &&
-        isObjectAssignCallee(parent.callee)) {
-        return parent;
+    if (parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
+        const index = parent.arguments.indexOf(node);
+        if (index !== -1 && isCopyingCall(parent, index)) {
+            return parent;
+        }
     }
     if (parent.type === utils_1.AST_NODE_TYPES.MemberExpression &&
         parent.object === node) {
@@ -442,6 +492,10 @@ const PATTERN_CONTAINERS = new Set([
     utils_1.AST_NODE_TYPES.ObjectPattern,
     utils_1.AST_NODE_TYPES.ArrayPattern,
     utils_1.AST_NODE_TYPES.RestElement,
+    // A parameter property is a parameter AND declares a class property, so it
+    // infers twice over. Without it the walk stops before reaching the
+    // constructor's params and `constructor(public stage = DEFAULT)` narrows.
+    utils_1.AST_NODE_TYPES.TSParameterProperty,
 ]);
 const FUNCTION_TYPES = new Set([
     utils_1.AST_NODE_TYPES.FunctionDeclaration,

package/lib/rules/memo-nested-react-components.js

@@ -347,6 +347,101 @@ const isInsideFunction = (node) => {
     return findEnclosingFunction(node) !== null;
 };
 const isPascalCaseName = (name) => /^[A-Z]/.test(name);
+/**
+ * Prop names whose value a parent MOUNTS rather than calls. Kept identical to
+ * the `JSXAttribute` visitor's own test so the two paths cannot disagree about
+ * what a component-type prop is — the disagreement between them is #2334.
+ */
+const COMPONENT_PROP_SUFFIX = /(Wrapper|Component|Template|Header|Footer)$/;
+const isComponentPropName = (name) => isPascalCaseName(name) && COMPONENT_PROP_SUFFIX.test(name);
+const consumptionOfReference = (identifier, reactImports) => {
+    // `<Binding />`. The scope manager reports the tag name as a reference whose
+    // identifier is a `JSXIdentifier`, which no other position produces.
+    if (identifier.type === utils_1.AST_NODE_TYPES.JSXIdentifier) {
+        return 'component';
+    }
+    let current = identifier;
+    for (;;) {
+        const parent = parentBeyondChain(current);
+        if (!parent) {
+            return 'unknown';
+        }
+        // `Binding as Something` / `Binding!` keep the value on its way to a use.
+        if ((parent.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+            parent.type === utils_1.AST_NODE_TYPES.TSNonNullExpression ||
+            parent.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression) &&
+            parent.expression === current) {
+            current = parent;
+            continue;
+        }
+        if (parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
+            // `createElement(Binding, ...)` mounts it exactly as a tag name does.
+            if (parent.arguments[0] === current &&
+                isReactCreateElementCall(parent, reactImports)) {
+                return 'component';
+            }
+            // `Binding(onClose)` — the parent INVOKES it, which is what a render
+            // callback is for. A component is never called directly.
+            if (parent.callee === current) {
+                return 'callback';
+            }
+            return 'unknown';
+        }
+        // `<Host ContentComponent={Binding} />` mounts it; `<Host render={Binding} />`
+        // calls it. The prop name is the parent's contract, and it is read on the
+        // same terms the `JSXAttribute` visitor uses so the two cannot disagree.
+        if (parent.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer &&
+            parent.parent?.type === utils_1.AST_NODE_TYPES.JSXAttribute &&
+            parent.parent.name.type === utils_1.AST_NODE_TYPES.JSXIdentifier) {
+            return isComponentPropName(parent.parent.name.name)
+                ? 'component'
+                : 'callback';
+        }
+        return 'unknown';
+    }
+};
+/**
+ * Whether the binding a memo-hook call initializes is MOUNTED, CALLED, or
+ * neither, read from the scope manager's reference list rather than a textual
+ * search so a same-named binding in a sibling scope cannot answer for this one.
+ *
+ * `unknown` is the honest answer for a binding with no informative reference —
+ * an exported component has none in its own file, and so does a fixture
+ * fragment. Falling back to the name there keeps the rule's reach while letting
+ * evidence override the guess wherever evidence exists.
+ */
+const consumptionOfDeclaration = (declaration, id, context, reactImports) => {
+    // `getDeclaredVariables` on a FunctionDeclaration yields its PARAMETERS
+    // alongside the function name, and a parameter handed to a non-component prop
+    // votes `callback` for a binding it says nothing about. Keep only the
+    // variable this declaration's own id introduces.
+    const declared = context
+        .getDeclaredVariables(declaration)
+        .filter((variable) => variable.defs.some((def) => def.name === id));
+    let sawCallback = false;
+    for (const variable of declared) {
+        for (const reference of variable.references) {
+            const consumption = consumptionOfReference(reference.identifier, reactImports);
+            // A single mounting use settles it: the identity churn happens there
+            // regardless of how many other places merely call it.
+            if (consumption === 'component') {
+                return 'component';
+            }
+            if (consumption === 'callback') {
+                sawCallback = true;
+            }
+        }
+    }
+    return sawCallback ? 'callback' : 'unknown';
+};
+const consumptionOfBinding = (node, context, reactImports) => {
+    const declarator = parentBeyondChain(node);
+    if (declarator?.type !== utils_1.AST_NODE_TYPES.VariableDeclarator ||
+        declarator.id.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return 'unknown';
+    }
+    return consumptionOfDeclaration(declarator, declarator.id, context, reactImports);
+};
 /**
  * The values a container hands to its caller: object property values and array
  * elements. Mirrors `containedValues` in the paired `require-memo` rule (#1919),
@@ -725,10 +820,20 @@ See: https://react.dev/learn/your-first-component#nesting-and-organizing-compone
                     }
                 }
                 const variableName = getVariableName(node);
-                // A non-PascalCase binding (e.g. renderHit) is a render callback used
-                // with a render={...} prop, not a component—skip it.
-                if (variableName && !isPascalCaseName(variableName)) {
-                    return;
+                // The NAME was the whole discriminator here, which reported every
+                // PascalCase render callback the message explicitly exempts and missed
+                // every lowercase binding handed to a component-type prop. Evidence
+                // from the use site overrides it in both directions; the name still
+                // decides where there is no evidence, which is where an exported
+                // component lives (#2334).
+                if (variableName) {
+                    const consumption = consumptionOfBinding(node, context, reactImports);
+                    if (consumption === 'callback') {
+                        return;
+                    }
+                    if (consumption === 'unknown' && !isPascalCaseName(variableName)) {
+                        return;
+                    }
                 }
                 // Inside an HOC factory the binding has a stable identity, so it does
                 // not remount on re-render and must not be flagged.
@@ -747,8 +852,10 @@ See: https://react.dev/learn/your-first-component#nesting-and-organizing-compone
                     return;
                 if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier)
                     return;
-                // Only check if name starts with uppercase (convention for components)
-                if (!isPascalCaseName(node.id.name))
+                const vdConsumption = consumptionOfDeclaration(node, node.id, context, reactImports);
+                if (vdConsumption === 'callback')
+                    return;
+                if (vdConsumption === 'unknown' && !isPascalCaseName(node.id.name))
                     return;
                 if (!isInsideFunction(node))
                     return;
@@ -772,7 +879,12 @@ See: https://react.dev/learn/your-first-component#nesting-and-organizing-compone
                 reportNestedComponentViolation(node, node.id.name, 'a render body');
             },
             FunctionDeclaration(node) {
-                if (!node.id || !isPascalCaseName(node.id.name))
+                if (!node.id)
+                    return;
+                const fdConsumption = consumptionOfDeclaration(node, node.id, context, reactImports);
+                if (fdConsumption === 'callback')
+                    return;
+                if (fdConsumption === 'unknown' && !isPascalCaseName(node.id.name))
                     return;
                 if (!isInsideFunction(node))
                     return;

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,48 @@
 [
+  {
+    "version": "1.21.11",
+    "date": "2026-09-05T11:06:01.167Z",
+    "rules": [
+      {
+        "name": "global-const-style",
+        "changeType": "fix",
+        "issues": [
+          2336
+        ],
+        "summary": "follow the array spelling of a destructured copy, and the rest element that needs no copy (closes #2336)"
+      },
+      {
+        "name": "memo-nested-react-components",
+        "changeType": "fix",
+        "issues": [
+          2335
+        ],
+        "summary": "decide by the use site in the two non-hook visitors too (closes #2335)"
+      }
+    ]
+  },
+  {
+    "version": "1.21.10",
+    "date": "2026-09-05T09:28:38.523Z",
+    "rules": [
+      {
+        "name": "global-const-style",
+        "changeType": "fix",
+        "issues": [
+          2333
+        ],
+        "summary": "follow every copy that carries the frozen type, and the parameter property that infers from it (closes #2333)"
+      },
+      {
+        "name": "memo-nested-react-components",
+        "changeType": "fix",
+        "issues": [
+          2334
+        ],
+        "summary": "decide by the use site, not the binding's first letter (closes #2334)"
+      }
+    ]
+  },
   {
     "version": "1.21.9",
     "date": "2026-09-05T05:55:33.427Z",