@blumintinc/eslint-plugin-blumint 1.20.12 → 1.20.13

package/lib/index.js

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

package/lib/rules/require-props-composition.js

@@ -237,6 +237,88 @@ function collectJsxElementNames(node) {
     visit(node);
     return names;
 }
+/**
+ * Collect the capitalized binding names introduced by a destructuring pattern,
+ * following renames (`{ Slot: Renderer }`), defaults (`{ Slot = Fallback }`)
+ * and nesting (`{ slots: { Item } }`).
+ */
+function collectPatternBindings(pattern, into) {
+    switch (pattern.type) {
+        case utils_1.AST_NODE_TYPES.Identifier:
+            if (/^[A-Z]/.test(pattern.name)) {
+                into.add(pattern.name);
+            }
+            break;
+        case utils_1.AST_NODE_TYPES.ObjectPattern:
+            for (const property of pattern.properties) {
+                if (property.type === utils_1.AST_NODE_TYPES.Property) {
+                    collectPatternBindings(property.value, into);
+                }
+                // A `...rest` element rebinds the remaining props under a single
+                // lowercase-by-convention name; it introduces no component slot.
+            }
+            break;
+        case utils_1.AST_NODE_TYPES.AssignmentPattern:
+            collectPatternBindings(pattern.left, into);
+            break;
+        default:
+            break;
+    }
+}
+/**
+ * Names of JSX elements that resolve to one of the component's own props — a
+ * rendering strategy injected by the caller (`ViewComponent: ComponentType<T>`)
+ * rather than a fixed child.
+ *
+ * A props-parameter binding shadows every import, so such an element is not a
+ * dependency the parent can compose with: the concrete component is chosen per
+ * call site and the slot's accepted props are already constrained by the prop's
+ * own type annotation. Demanding `<Slot>Props` composition names a type that
+ * exists nowhere.
+ */
+function collectPropSlotNames(funcNode) {
+    const slots = new Set();
+    const propsParam = funcNode.params[0];
+    if (!propsParam)
+        return slots;
+    if (propsParam.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+        collectPatternBindings(propsParam, slots);
+        return slots;
+    }
+    // `(props: Props) => ...` — the slot may be destructured out of `props` in
+    // the body instead of in the signature.
+    if (propsParam.type !== utils_1.AST_NODE_TYPES.Identifier)
+        return slots;
+    const propsName = propsParam.name;
+    function visit(node) {
+        if (!node || typeof node !== 'object')
+            return;
+        if (node.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+            node.id.type === utils_1.AST_NODE_TYPES.ObjectPattern &&
+            node.init?.type === utils_1.AST_NODE_TYPES.Identifier &&
+            node.init.name === propsName) {
+            collectPatternBindings(node.id, slots);
+        }
+        for (const key of Object.keys(node)) {
+            if (key === 'parent')
+                continue;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const child = node[key];
+            if (Array.isArray(child)) {
+                for (const item of child) {
+                    if (item && typeof item === 'object' && 'type' in item) {
+                        visit(item);
+                    }
+                }
+            }
+            else if (child && typeof child === 'object' && 'type' in child) {
+                visit(child);
+            }
+        }
+    }
+    visit(funcNode.body);
+    return slots;
+}
 /**
  * Find the Props type alias node that corresponds to a component by name.
  * Looks for `type <ComponentName>Props = ...` in the program body.
@@ -929,10 +1011,12 @@ exports.requirePropsComposition = (0, createRule_1.createRule)({
             // Collect all JSX element names used in the component body
             const body = funcNode.body ?? funcNode;
             const allJsxNames = collectJsxElementNames(body);
+            const propSlots = collectPropSlotNames(funcNode);
             // Filter to non-excluded custom components
             const depComponents = Array.from(allJsxNames).filter((name) => !excludeComponents.has(name) &&
                 !isDecorativeIcon(name) &&
                 name !== componentName &&
+                !propSlots.has(name) &&
                 !isZeroPropComponent(prog, name));
             if (depComponents.length < minDependencyCount) {
                 return;

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,18 @@
 [
+  {
+    "version": "1.20.13",
+    "date": "2026-07-29T06:26:25.973Z",
+    "rules": [
+      {
+        "name": "require-props-composition",
+        "changeType": "fix",
+        "issues": [
+          1374
+        ],
+        "summary": "exempt caller-injected component prop slots (closes #1374)"
+      }
+    ]
+  },
   {
     "version": "1.20.12",
     "date": "2026-07-28T22:32:01.811Z",