@blumintinc/eslint-plugin-blumint 1.20.11 → 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.11',
+        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/lib/rules/test-file-location-enforcement.js

@@ -13,6 +13,26 @@ const DEFAULT_OPTIONS = {
     additionalSubjectExtensions: [],
 };
 const normalizeExtension = (extension) => extension.startsWith('.') ? extension : `.${extension}`;
+/**
+ * A suite may be split by concern into `Subject.<qualifier>.test.tsx` files that
+ * sit beside `Subject.tsx`. Progressively dropping trailing dot-segments lets
+ * such a test resolve to its subject at any qualifier depth, while never
+ * crossing a directory boundary — a genuinely misplaced test still reports.
+ * Empty prefixes are dropped so a dotfile stem cannot match a bare `.ts`.
+ */
+const subjectBaseNamesFor = (stem) => {
+    const segments = stem.split('.');
+    const baseNames = [];
+    for (let depth = segments.length; depth > 0; depth--) {
+        const baseName = segments.slice(0, depth).join('.');
+        if (baseName) {
+            baseNames.push(baseName);
+        }
+    }
+    // An extensionless stem (a file named exactly ".test.ts") leaves nothing to
+    // probe; keep it so the report still names what was looked for.
+    return baseNames.length > 0 ? baseNames : [stem];
+};
 exports.testFileLocationEnforcement = (0, createRule_1.createRule)({
     name: 'test-file-location-enforcement',
     meta: {
@@ -57,17 +77,22 @@ exports.testFileLocationEnforcement = (0, createRule_1.createRule)({
                 }
                 const directory = path_1.default.dirname(filename);
                 const testFileName = path_1.default.basename(filename);
-                const baseName = testFileName.replace(TEST_FILE_PATTERN, '');
-                const candidates = subjectExtensions.map((extension) => path_1.default.join(directory, `${baseName}${extension}`));
-                const hasSibling = candidates.some((candidate) => fs_1.default.existsSync(candidate));
+                const stem = testFileName.replace(TEST_FILE_PATTERN, '');
+                const baseNames = subjectBaseNamesFor(stem);
+                const hasSibling = baseNames.some((baseName) => subjectExtensions.some((extension) => fs_1.default.existsSync(path_1.default.join(directory, `${baseName}${extension}`))));
                 if (hasSibling) {
                     return;
                 }
                 const relativePath = path_1.default.isAbsolute(filename)
                     ? path_1.default.relative(process.cwd(), filename) || filename
                     : filename;
-                const expectedNames = subjectExtensions
-                    .map((extension) => `"${baseName}${extension}"`)
+                // Naming the shortest prefix alongside the full stem keeps the guidance
+                // honest: either subject name satisfies the rule.
+                const reportedBaseNames = baseNames.length > 1
+                    ? [baseNames[0], baseNames[baseNames.length - 1]]
+                    : baseNames;
+                const expectedNames = reportedBaseNames
+                    .flatMap((baseName) => subjectExtensions.map((extension) => `"${baseName}${extension}"`))
                     .join(' or ');
                 context.report({
                     node,

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "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",
+    "rules": [
+      {
+        "name": "test-file-location-enforcement",
+        "changeType": "fix",
+        "issues": [
+          1372
+        ],
+        "summary": "accept suite-qualifier test files (closes #1372)"
+      }
+    ]
+  },
   {
     "version": "1.20.11",
     "date": "2026-07-28T20:40:15.882Z",