@blumintinc/eslint-plugin-blumint 1.20.130 → 1.20.131

package/lib/index.js

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

package/lib/rules/enforce-dynamic-imports.d.ts

@@ -22,5 +22,23 @@ type Options = [
  */
 export declare const DEFAULT_IGNORED_LIBRARIES: string[];
 export declare const DEFAULT_INTERNAL_PREFIXES: string[];
+/**
+ * Builds an O(1) + glob matcher from a list of library patterns.
+ *
+ * With `coverSubpaths`, a non-glob entry stands for the package *and*
+ * everything published under it. A package's subpath entry point is the same
+ * dependency as its root — `fast-deep-equal/es6` is upstream's documented ESM
+ * build, and the spelling `fast-deep-equal-over-microdiff` steers code toward —
+ * so exempting the root while enforcing the subpath left the pair of rules
+ * jointly unsatisfiable (#1845).
+ *
+ * The boundary is `entry + '/'`, never a bare substring: `fast-deep-equal-extra`
+ * is a different package on the registry and stays enforced. Glob entries keep
+ * their minimatch semantics untouched, since a pattern already says how far it
+ * reaches.
+ */
+export declare const buildLibraryMatcher: (list: string[], { coverSubpaths }: {
+    coverSubpaths: boolean;
+}) => (source: string) => boolean;
 declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"dynamicImportRequired", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
 export default _default;

package/lib/rules/enforce-dynamic-imports.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_INTERNAL_PREFIXES = exports.DEFAULT_IGNORED_LIBRARIES = exports.RULE_NAME = void 0;
+exports.buildLibraryMatcher = exports.DEFAULT_INTERNAL_PREFIXES = exports.DEFAULT_IGNORED_LIBRARIES = exports.RULE_NAME = void 0;
 const createRule_1 = require("../utils/createRule");
 const minimatch_1 = require("minimatch");
 const module_1 = require("module");
@@ -43,6 +43,42 @@ exports.DEFAULT_IGNORED_LIBRARIES = [
     'fast-deep-equal', // fast-deep-equal-over-microdiff, for files already on upstream
 ];
 exports.DEFAULT_INTERNAL_PREFIXES = ['src/', 'functions/'];
+/**
+ * Builds an O(1) + glob matcher from a list of library patterns.
+ *
+ * With `coverSubpaths`, a non-glob entry stands for the package *and*
+ * everything published under it. A package's subpath entry point is the same
+ * dependency as its root — `fast-deep-equal/es6` is upstream's documented ESM
+ * build, and the spelling `fast-deep-equal-over-microdiff` steers code toward —
+ * so exempting the root while enforcing the subpath left the pair of rules
+ * jointly unsatisfiable (#1845).
+ *
+ * The boundary is `entry + '/'`, never a bare substring: `fast-deep-equal-extra`
+ * is a different package on the registry and stays enforced. Glob entries keep
+ * their minimatch semantics untouched, since a pattern already says how far it
+ * reaches.
+ */
+const buildLibraryMatcher = (list, { coverSubpaths }) => {
+    const exactSet = new Set();
+    const subpathPrefixes = [];
+    const globs = [];
+    for (const lib of list) {
+        const mm = new minimatch_1.Minimatch(lib);
+        if (mm.hasMagic()) {
+            globs.push(mm);
+        }
+        else {
+            exactSet.add(lib);
+            if (coverSubpaths) {
+                subpathPrefixes.push(lib.endsWith('/') ? lib : `${lib}/`);
+            }
+        }
+    }
+    return (source) => exactSet.has(source) ||
+        subpathPrefixes.some((prefix) => source.startsWith(prefix)) ||
+        globs.some((mm) => mm.match(source));
+};
+exports.buildLibraryMatcher = buildLibraryMatcher;
 // Pre-built set of Node.js core module names for O(1) lookup.
 const NODE_BUILTINS = new Set(module_1.builtinModules);
 // Returns true for any source that resolves to a Node builtin: bare name
@@ -106,25 +142,22 @@ exports.default = (0, createRule_1.createRule)({
         // When `libraries` is absent, enforce-by-default mode applies:
         // all external imports are flagged unless in `ignoredLibraries`.
         const isWhitelistMode = libraries !== undefined;
-        // Build an O(1) + glob matcher from a list of library patterns.
-        const buildMatcher = (list) => {
-            const exactSet = new Set();
-            const globs = [];
-            for (const lib of list) {
-                const mm = new minimatch_1.Minimatch(lib);
-                if (mm.hasMagic()) {
-                    globs.push(mm);
-                }
-                else {
-                    exactSet.add(lib);
-                }
-            }
-            return (source) => exactSet.has(source) || globs.some((mm) => mm.match(source));
-        };
         // In whitelist mode, `libraries` is defined (checked above). In
         // enforce-by-default mode, `ignoredLibraries` is used instead.
-        const isListedInWhitelist = buildMatcher(libraries ?? []);
-        const isIgnoredLibrary = buildMatcher(ignoredLibraries);
+        //
+        // Subpath covering is asymmetric between the two lists because the lists
+        // point in opposite directions. Widening `ignoredLibraries` only ever
+        // REMOVES reports, so it can safely absorb a package's subpath entry
+        // points. Widening `libraries` would ADD reports — a consumer who listed
+        // `pkg` to restore pre-1.16.0 behaviour would start failing on `pkg/sub` —
+        // so the whitelist keeps exact + glob semantics, and consumers who do want
+        // the subpaths enforced spell that as a glob (`pkg/**`), which still works.
+        const isListedInWhitelist = (0, exports.buildLibraryMatcher)(libraries ?? [], {
+            coverSubpaths: false,
+        });
+        const isIgnoredLibrary = (0, exports.buildLibraryMatcher)(ignoredLibraries, {
+            coverSubpaths: true,
+        });
         // A source is external only if it looks like an npm package specifier AND
         // is not a known-internal path. Node builtins and configured internal
         // prefixes (e.g. src/, functions/) are excluded to avoid false positives

package/lib/rules/enforce-react-type-naming.js

@@ -8,6 +8,189 @@ const renameFixes_1 = require("../utils/renameFixes");
 const LOWERCASE_TYPES = ['ReactNode', 'JSX.Element'];
 // Types that should have uppercase variable names
 const UPPERCASE_TYPES = ['ComponentType', 'FC', 'FunctionComponent'];
+/**
+ * `global-const-style` owns the NAME of a module-scope `const`, and the two
+ * rules cannot both be satisfied there: it demands UPPER_SNAKE_CASE, this rule
+ * demands a lowercase initial for `ReactNode`/`JSX.Element`. Every spelling
+ * reports under one or the other, so a consumer running both — they are both
+ * `'error'` in `recommended` — cannot write the line at all.
+ *
+ * Unexported, both renamers also autofix, so `--fix` oscillates (`element` ->
+ * `ELEMENT` -> `eLEMENT` -> `E_LEMENT` -> `e_LEMENT` -> …) until ESLint's
+ * ten-pass cap and writes the mangled identifier to disk (Issue #1846).
+ * EXPORTED, both withhold the rename — an exported name is a cross-file
+ * contract a single-file fixer cannot complete — so `--fix` is a no-op and the
+ * damage is only the unsatisfiable report pair (Issue #1847).
+ *
+ * The pair is resolved by this rule yielding: module-scope constant naming is
+ * `global-const-style`'s universal contract, while this rule's purpose —
+ * telling an element VALUE apart from a COMPONENT — is about local and
+ * parameter naming, where nothing competes with it. Do not re-open the
+ * carve-out without changing `global-const-style` in the same breath.
+ *
+ * GOVERNANCE FOLLOWS WHICH RULE REPORTS ON THE NAME, NOT WHICH ONE FIXES IT.
+ * #1846 drew the boundary at the fixer war and so excluded exports; that left
+ * the exported form unsatisfiable, because `global-const-style` withholds only
+ * its FIX there (#1700) and still emits `upperSnakeCase`. The predicate below
+ * therefore mirrors that rule's ACTUAL reporting gates, which is also why it
+ * cannot be simplified to "module-scope const" — it declines on several shapes,
+ * and yielding on one of those would leave the declaration governed by nothing:
+ *
+ *   - `let`/`var`, and any non-module scope, are outside it entirely;
+ *   - a declaration whose parent is neither `Program` nor an
+ *     `ExportNamedDeclaration` (a block, a `for` head, a namespace body) never
+ *     reaches its check;
+ *   - an exported Next.js reserved name (`config`, `getStaticProps`, …) has its
+ *     rename declined outright (#1257), so this rule keeps its report there —
+ *     report-only, since its own fixer stands down for exports too;
+ *   - a function value or a `memo`/`forwardRef` call makes it skip the whole
+ *     declaration list — `const button: FC = () => …` is this rule's alone;
+ *   - an absent initializer, a dynamic value, a binding alias and a
+ *     `jest.Mock*` cast each silence its rename check.
+ *
+ * When any of that cannot be established the answer is `false`: keeping a
+ * report is recoverable, silently governing nothing is not.
+ */
+const VALUE_WRAPPER_TYPES = new Set([
+    utils_1.AST_NODE_TYPES.TSAsExpression,
+    utils_1.AST_NODE_TYPES.TSTypeAssertion,
+    utils_1.AST_NODE_TYPES.TSSatisfiesExpression,
+    utils_1.AST_NODE_TYPES.TSNonNullExpression,
+]);
+const isValueWrapper = (node) => VALUE_WRAPPER_TYPES.has(node.type);
+const unwrapValueWrappers = (node) => {
+    let target = node;
+    while (isValueWrapper(target)) {
+        target = target.expression;
+    }
+    return target;
+};
+// `global-const-style` unwraps only `as`/`<T>` casts before classifying an
+// initializer as dynamic or as a binding alias, so the mirror does the same.
+const unwrapCasts = (node) => {
+    let target = node;
+    while (target.type === utils_1.AST_NODE_TYPES.TSTypeAssertion ||
+        target.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
+        target = target.expression;
+    }
+    return target;
+};
+const COMPONENT_FACTORY_NAMES = new Set(['forwardRef', 'memo']);
+const isComponentFactoryCall = (node) => {
+    if (node.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+        return false;
+    }
+    const { callee } = node;
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return COMPONENT_FACTORY_NAMES.has(callee.name);
+    }
+    return (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+        COMPONENT_FACTORY_NAMES.has(callee.property.name));
+};
+const isFunctionValue = (node) => node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+    node.type === utils_1.AST_NODE_TYPES.FunctionExpression;
+const isDynamicValue = (node) => {
+    const target = unwrapCasts(node);
+    if (target.type === utils_1.AST_NODE_TYPES.CallExpression ||
+        target.type === utils_1.AST_NODE_TYPES.NewExpression ||
+        target.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
+        return true;
+    }
+    if (target.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+        return isDynamicValue(target.expression);
+    }
+    if (target.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        return isDynamicValue(target.object);
+    }
+    return false;
+};
+const PRIMITIVE_VALUE_GLOBALS = new Set(['undefined', 'NaN', 'Infinity']);
+const isBindingAlias = (node) => {
+    const target = unwrapCasts(node);
+    return (target.type === utils_1.AST_NODE_TYPES.Identifier &&
+        !PRIMITIVE_VALUE_GLOBALS.has(target.name));
+};
+const JEST_MOCK_TYPE_NAMES = new Set([
+    'Mock',
+    'MockedFunction',
+    'Mocked',
+    'MockedClass',
+]);
+const isJestMockTypeReference = (typeAnnotation) => {
+    if (typeAnnotation.type !== utils_1.AST_NODE_TYPES.TSTypeReference) {
+        return false;
+    }
+    const { typeName } = typeAnnotation;
+    return (typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName &&
+        typeName.left.type === utils_1.AST_NODE_TYPES.Identifier &&
+        typeName.left.name === 'jest' &&
+        typeName.right.type === utils_1.AST_NODE_TYPES.Identifier &&
+        JEST_MOCK_TYPE_NAMES.has(typeName.right.name));
+};
+const isJestMockCast = (node) => {
+    let current = node;
+    while (isValueWrapper(current)) {
+        if (current.type === utils_1.AST_NODE_TYPES.TSAsExpression &&
+            isJestMockTypeReference(current.typeAnnotation)) {
+            return true;
+        }
+        current = current.expression;
+    }
+    return false;
+};
+// Mirrors `global-const-style`'s own list. Next.js recognizes these export
+// names by their literal identifier, so that rule declines the rename outright
+// rather than breaking the framework contract (#1257) — nothing there governs
+// the name, so this rule keeps its report. Only the EXPORT name matters to
+// Next.js, exactly as the sibling gates it.
+const NEXTJS_RESERVED_EXPORTS = new Set([
+    'config',
+    'getServerSideProps',
+    'getStaticProps',
+    'getStaticPaths',
+    'getInitialProps',
+    'middleware',
+]);
+const isGlobalConstStyleGoverned = (declarator) => {
+    const declaration = declarator.parent;
+    if (!declaration ||
+        declaration.type !== utils_1.AST_NODE_TYPES.VariableDeclaration ||
+        declaration.kind !== 'const') {
+        return false;
+    }
+    // The sibling's own scope gate: module scope, whether written bare or behind
+    // an inline `export`. Exports are INCLUDED because it reports `upperSnakeCase`
+    // on them — it withholds only the FIX (#1700) — so leaving them out kept the
+    // pair unsatisfiable for `export const element: JSX.Element = …` (#1847).
+    const isExported = declaration.parent?.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration;
+    if (declaration.parent?.type !== utils_1.AST_NODE_TYPES.Program && !isExported) {
+        return false;
+    }
+    if (isExported &&
+        declarator.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+        NEXTJS_RESERVED_EXPORTS.has(declarator.id.name)) {
+        return false;
+    }
+    // The function-value / component-factory skip is evaluated over the whole
+    // declaration LIST there, so `const a = () => {}, b = <div />;` exempts both.
+    const listSkipped = declaration.declarations.some((one) => {
+        if (one.id.type !== utils_1.AST_NODE_TYPES.Identifier || !one.init) {
+            return false;
+        }
+        const target = unwrapValueWrappers(one.init);
+        return isFunctionValue(target) || isComponentFactoryCall(target);
+    });
+    if (listSkipped) {
+        return false;
+    }
+    const { init } = declarator;
+    if (!init) {
+        return false;
+    }
+    return (!isDynamicValue(init) && !isBindingAlias(init) && !isJestMockCast(init));
+};
 exports.enforceReactTypeNaming = (0, createRule_1.createRule)({
     name: 'enforce-react-type-naming',
     meta: {
@@ -123,6 +306,12 @@ exports.enforceReactTypeNaming = (0, createRule_1.createRule)({
             // Skip destructured variables
             if (isDestructured(id))
                 return;
+            // Yield the name to `global-const-style` where it governs (Issue #1846).
+            // Both branches yield: its UPPER_SNAKE_CASE target already satisfies the
+            // component branch's "starts uppercase", so nothing is lost there, and
+            // the element branch is the one that cannot coexist with it at all.
+            if (isGlobalConstStyleGoverned(node))
+                return;
             const variableName = id.name;
             // Get the type annotation
             const typeAnnotation = id.typeAnnotation?.typeAnnotation;

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,27 @@
 [
+  {
+    "version": "1.20.131",
+    "date": "2026-08-07T10:28:22.079Z",
+    "rules": [
+      {
+        "name": "enforce-dynamic-imports",
+        "changeType": "fix",
+        "issues": [
+          1845
+        ],
+        "summary": "cover a package's subpaths from one ignoredLibraries entry (closes #1845)"
+      },
+      {
+        "name": "enforce-react-type-naming",
+        "changeType": "fix",
+        "issues": [
+          1846,
+          1847
+        ],
+        "summary": "yield exported module-scope constants to global-const-style (closes #1847); yield module-scope constants to global-const-style (closes #1846)"
+      }
+    ]
+  },
   {
     "version": "1.20.130",
     "date": "2026-08-07T08:38:15.008Z",