@blumintinc/eslint-plugin-blumint 1.20.200 → 1.20.202

package/lib/index.js

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

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

@@ -64,6 +64,52 @@ const DEFAULT_TARGET_PATHS = ['src/components/**/*.tsx'];
 function isDecorativeIcon(name) {
     return /Icon$/.test(name);
 }
+const MUI_ICONS_PACKAGE = '@mui/icons-material';
+/**
+ * Whether a specifier names the MUI icon package: the barrel
+ * (`@mui/icons-material`) or a per-icon deep path
+ * (`@mui/icons-material/CheckRounded`). Sibling packages such as
+ * `@mui/material` are deliberately not matched — the carve-out covers icons,
+ * not MUI at large, so a `@mui/lab` or `@mui/material` child stays a
+ * composition dependency.
+ */
+function isMuiIconSource(source) {
+    return (source === MUI_ICONS_PACKAGE || source.startsWith(`${MUI_ICONS_PACKAGE}/`));
+}
+/**
+ * Whether `localName` is bound by a value import from the MUI icon package.
+ * The `*Icon` suffix alone cannot decide this: MUI's own export names carry no
+ * such suffix (`NotificationsNoneRounded`, `CheckRounded`), and the plugin's
+ * own `enforce-mui-rounded-icons` fixer emits exactly that spelling, so the
+ * binding cannot be renamed to opt in (issue #2282). An icon is a decorative
+ * leaf wherever it comes from, so the import source answers the same question
+ * the suffix does.
+ *
+ * A sibling of `findRelativeImport`, which accepts only relative specifiers by
+ * design (issue #1316 reads a child module off disk and must not chase a
+ * package). Type-only imports bind no renderable value and are skipped.
+ */
+function isMuiIconImport(program, localName) {
+    for (const stmt of program.body) {
+        if (stmt.type !== utils_1.AST_NODE_TYPES.ImportDeclaration ||
+            stmt.importKind === 'type' ||
+            typeof stmt.source.value !== 'string' ||
+            !isMuiIconSource(stmt.source.value)) {
+            continue;
+        }
+        for (const specifier of stmt.specifiers) {
+            if (specifier.local.name !== localName) {
+                continue;
+            }
+            // A module-scope name has one binding, so the first specifier that
+            // introduces it settles the question.
+            return (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+                (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                    specifier.importKind !== 'type'));
+        }
+    }
+    return false;
+}
 /**
  * Derives the expected Props type name for a JSX element name.
  * e.g. "LoadingButton" → "LoadingButtonProps"
@@ -1704,6 +1750,7 @@ exports.requirePropsComposition = (0, createRule_1.createRule)({
                 !isDecorativeIcon(name) &&
                 name !== componentName &&
                 !propSlots.has(name) &&
+                !isMuiIconImport(prog, name) &&
                 !isZeroPropComponent(bodyScope, name));
             if (depComponents.length < minDependencyCount) {
                 return;

package/lib/rules/use-custom-link.js

@@ -71,23 +71,27 @@ exports.useCustomLink = (0, createRule_1.createRule)({
                     const defaultAsSpecifier = importSpecifiers.find((specifier) => specifier.type === 'ImportSpecifier' &&
                         specifier.imported.name === 'default');
                     if (defaultSpecifier || defaultAsSpecifier) {
+                        // The fix rebuilds the whole declaration from the default binding
+                        // alone, so any other specifier would be deleted outright and
+                        // whatever still references it left dangling — including an
+                        // `export { LinkProps }` that keeps the exported NAME while losing
+                        // what it resolves to. Relocating them instead is not available:
+                        // whether the wrapper re-exports a given specifier is unknowable
+                        // from here, so carrying them over would trade a silent dangling
+                        // binding for a possibly unresolvable import. Decline the fix and
+                        // keep the report, so the migration stays a deliberate edit.
+                        const droppedSpecifiers = importSpecifiers.filter((specifier) => specifier !== defaultSpecifier &&
+                            specifier !== defaultAsSpecifier);
+                        const localName = defaultSpecifier?.local?.name ||
+                            defaultAsSpecifier?.local?.name ||
+                            'Link';
                         context.report({
                             node,
                             messageId: 'useCustomLink',
-                            data: {
-                                localName: defaultSpecifier?.local?.name ||
-                                    defaultAsSpecifier?.local?.name ||
-                                    'Link',
-                            },
-                            fix(fixer) {
-                                // Get the local name of the imported Link component
-                                const localName = defaultSpecifier?.local?.name ||
-                                    defaultAsSpecifier?.local?.name ||
-                                    'Link';
-                                // Create the new import statement
-                                const newImport = `import ${localName} from '${LINK_MODULE_PATH}';`;
-                                return fixer.replaceText(node, newImport);
-                            },
+                            data: { localName },
+                            fix: droppedSpecifiers.length > 0
+                                ? undefined
+                                : (fixer) => fixer.replaceText(node, `import ${localName} from '${LINK_MODULE_PATH}';`),
                         });
                     }
                 }

package/lib/utils/composedFixConfig.d.ts

@@ -32,10 +32,28 @@ export declare const PLUGIN_PREFIX = "@blumintinc/blumint/";
  */
 export declare const recommendedRulesExcluding: (excluded: ReadonlySet<string>) => Record<string, unknown>;
 /**
- * The composed set for one fixture: the shipped severities, plus the owner's own
- * entry carrying the options its author wrote.
+ * The severities an OVERRIDE contributes for one filename.
+ *
+ * `configs.recommended` is not the flat `rules` map alone — it also carries an
+ * `overrides` array, and a rule reachable only through one is still enabled in
+ * recommended. Reading `rules` by itself leaves such a rule outside every guard
+ * that composes the config, both on its own fixtures and, more importantly, as
+ * a SIBLING while some other rule's fixtures are linted. `enforce-date-ttime`
+ * is enabled exactly that way, for `src/**` (#1734 fixed the same blind read in
+ * `recommended-severity-consistency`; the model stayed flat everywhere else).
+ *
+ * Resolved per FILENAME rather than merged unconditionally, because the glob is
+ * what decides whether a consumer gets the rule on a given file. Merging it
+ * everywhere would enable it on paths no consumer runs it on, which is a
+ * different configuration and not the one being modelled.
+ */
+export declare const overrideRulesFor: (filename: string, excluded: ReadonlySet<string>) => Record<string, unknown>;
+/**
+ * The composed set for one fixture: the shipped severities, the severities any
+ * matching override adds for this fixture's path, plus the owner's own entry
+ * carrying the options its author wrote.
  */
-export declare const composedRulesFor: (recommended: Record<string, unknown>, excluded: ReadonlySet<string>, owner: string, testCase: FixtureCase) => Record<string, unknown>;
+export declare const composedRulesFor: (recommended: Record<string, unknown>, excluded: ReadonlySet<string>, owner: string, testCase: FixtureCase, filename?: string) => Record<string, unknown>;
 export type OptionCarriage = {
     /** Screens whose composed config carried author-declared options. */
     carried: number;

package/lib/utils/composedFixConfig.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.subsetInConfigOrder = exports.noteOptionCarriage = exports.composedRulesFor = exports.recommendedRulesExcluding = exports.PLUGIN_PREFIX = void 0;
+exports.subsetInConfigOrder = exports.noteOptionCarriage = exports.composedRulesFor = exports.overrideRulesFor = exports.recommendedRulesExcluding = exports.PLUGIN_PREFIX = void 0;
+const minimatch_1 = require("minimatch");
 const fixtureCorpus_1 = require("./fixtureCorpus");
 /* eslint-disable @typescript-eslint/no-var-requires */
 const plugin = require('../index');
@@ -54,11 +55,54 @@ const recommendedRulesExcluding = (excluded) => {
 };
 exports.recommendedRulesExcluding = recommendedRulesExcluding;
 /**
- * The composed set for one fixture: the shipped severities, plus the owner's own
- * entry carrying the options its author wrote.
+ * The severities an OVERRIDE contributes for one filename.
+ *
+ * `configs.recommended` is not the flat `rules` map alone — it also carries an
+ * `overrides` array, and a rule reachable only through one is still enabled in
+ * recommended. Reading `rules` by itself leaves such a rule outside every guard
+ * that composes the config, both on its own fixtures and, more importantly, as
+ * a SIBLING while some other rule's fixtures are linted. `enforce-date-ttime`
+ * is enabled exactly that way, for `src/**` (#1734 fixed the same blind read in
+ * `recommended-severity-consistency`; the model stayed flat everywhere else).
+ *
+ * Resolved per FILENAME rather than merged unconditionally, because the glob is
+ * what decides whether a consumer gets the rule on a given file. Merging it
+ * everywhere would enable it on paths no consumer runs it on, which is a
+ * different configuration and not the one being modelled.
+ */
+const overrideRulesFor = (filename, excluded) => {
+    const rules = {};
+    for (const override of plugin.configs.recommended.overrides || []) {
+        const globs = override.files || [];
+        if (!globs.some((glob) => (0, minimatch_1.minimatch)(filename, glob, { dot: true }))) {
+            continue;
+        }
+        for (const [id, severity] of Object.entries(override.rules || {})) {
+            if (!id.startsWith(exports.PLUGIN_PREFIX))
+                continue;
+            if (severity === 'off' || severity === 0)
+                continue;
+            const name = id.slice(exports.PLUGIN_PREFIX.length);
+            if (!plugin.rules[name])
+                continue;
+            if (excluded.has(name))
+                continue;
+            rules[id] = severity;
+        }
+    }
+    return rules;
+};
+exports.overrideRulesFor = overrideRulesFor;
+/**
+ * The composed set for one fixture: the shipped severities, the severities any
+ * matching override adds for this fixture's path, plus the owner's own entry
+ * carrying the options its author wrote.
  */
-const composedRulesFor = (recommended, excluded, owner, testCase) => {
-    const rules = { ...recommended };
+const composedRulesFor = (recommended, excluded, owner, testCase, filename = (0, fixtureCorpus_1.defaultFilenameFor)(testCase)) => {
+    const rules = {
+        ...recommended,
+        ...(0, exports.overrideRulesFor)(filename, excluded),
+    };
     if (!excluded.has(owner)) {
         rules[`${exports.PLUGIN_PREFIX}${owner}`] = (0, fixtureCorpus_1.severityWithOptions)(testCase);
     }

package/lib/utils/harvestRuleTesterCases.d.ts

@@ -49,7 +49,7 @@ export type HarvestResult = {
  * Only suites that import the shared tester module can declare a case, since
  * `src/tests/no-local-rule-tester.test.ts` forbids a locally-built tester. That
  * makes the import a sound admission test rather than a heuristic, and it is
- * what keeps this affordable: the ~28 files it excludes are the meta-suites
+ * what keeps this affordable: the files it excludes are the meta-suites
  * (`fixer-type-safety`, `docs-examples-conformance`, `rule-crash-robustness`,
  * this guard's own siblings) which run full corpus sweeps at module scope and
  * cost more to load than every rule suite combined.

package/lib/utils/harvestRuleTesterCases.js

@@ -33,7 +33,7 @@ const TESTS_DIR = path.join(__dirname, '..', 'tests');
  * Only suites that import the shared tester module can declare a case, since
  * `src/tests/no-local-rule-tester.test.ts` forbids a locally-built tester. That
  * makes the import a sound admission test rather than a heuristic, and it is
- * what keeps this affordable: the ~28 files it excludes are the meta-suites
+ * what keeps this affordable: the files it excludes are the meta-suites
  * (`fixer-type-safety`, `docs-examples-conformance`, `rule-crash-robustness`,
  * this guard's own siblings) which run full corpus sweeps at module scope and
  * cost more to load than every rule suite combined.

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.20.202",
+    "date": "2026-09-02T04:11:09.443Z",
+    "rules": [
+      {
+        "name": "require-props-composition",
+        "changeType": "fix",
+        "issues": [
+          2282
+        ],
+        "summary": "treat an @mui/icons-material import as decorative whatever its binding is called (closes #2282)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.201",
+    "date": "2026-09-01T19:58:16.746Z",
+    "rules": [
+      {
+        "name": "use-custom-link",
+        "changeType": "fix",
+        "issues": [
+          2272
+        ],
+        "summary": "decline the autofix when it would drop a specifier (closes #2272)"
+      }
+    ]
+  },
   {
     "version": "1.20.200",
     "date": "2026-09-01T14:50:44.328Z",