@blumintinc/eslint-plugin-blumint 1.20.51 → 1.20.52

package/lib/index.js

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

package/lib/rules/enforce-m3-sentence-case.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceM3SentenceCase = void 0;
 const utils_1 = require("@typescript-eslint/utils");
+const compilePatternOption_1 = require("../utils/compilePatternOption");
 const createRule_1 = require("../utils/createRule");
 /**
  * Default props that carry user-facing label text, per the issue spec.
@@ -452,7 +453,11 @@ exports.enforceM3SentenceCase = (0, createRule_1.createRule)({
             ...DEFAULT_IGNORED_WORDS,
             ...(options.ignoredWords ?? []),
         ]);
-        const ignorePatternRegexes = (options.ignorePatterns ?? []).map((p) => new RegExp(p));
+        // Rejecting a malformed `ignorePatterns` entry rather than dropping it keeps
+        // the consumer's exception list honest: a silently discarded pattern would
+        // make text they deliberately excluded start getting reported with no
+        // indication why.
+        const ignorePatternRegexes = (0, compilePatternOption_1.compilePatternOption)('enforce-m3-sentence-case', 'ignorePatterns', options.ignorePatterns ?? []);
         const allowListSet = new Set(options.allowList ?? []);
         const checkJsxText = options.checkJsxText !== false;
         /**

package/lib/rules/no-handler-suffix.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noHandlerSuffix = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const minimatch_1 = require("minimatch");
+const compilePatternOption_1 = require("../utils/compilePatternOption");
 const createRule_1 = require("../utils/createRule");
 const DEFAULT_OPTIONS = {
     ignoreClassMethods: false,
@@ -26,6 +27,12 @@ function isUnsafeAllowPattern(pattern) {
     const nestedQuantifierPattern = /\((?:[^()\\]|\\.)*[+*{][^)]*\)\s*[+*{]/;
     return nestedQuantifierPattern.test(pattern);
 }
+// A pattern that compiles can still hang the linter, so allowlist sources are
+// refused for catastrophic-backtracking risk as well as for syntax.
+const UNSAFE_ALLOW_PATTERN_REJECTION = {
+    isRejected: isUnsafeAllowPattern,
+    describe: (optionName) => `unsafe ${optionName} (avoid nested quantifiers that risk catastrophic backtracking)`,
+};
 function getStaticKeyName(key) {
     if (key.type === utils_1.AST_NODE_TYPES.Identifier) {
         return key.name;
@@ -131,34 +138,7 @@ exports.noHandlerSuffix = (0, createRule_1.createRule)({
         const resolvedOptions = { ...DEFAULT_OPTIONS, ...(options ?? {}) };
         const allowNames = new Set(resolvedOptions.allowNames);
         const interfaceAllowlist = new Set(resolvedOptions.interfaceAllowlist);
-        const invalidAllowPatterns = [];
-        const unsafeAllowPatterns = [];
-        const allowPatterns = (resolvedOptions.allowPatterns ?? []).flatMap((pattern) => {
-            try {
-                if (isUnsafeAllowPattern(pattern)) {
-                    unsafeAllowPatterns.push(pattern);
-                    return [];
-                }
-                return [new RegExp(pattern)];
-            }
-            catch (error) {
-                const reason = error && typeof error === 'object' && 'message' in error
-                    ? ` (${String(error.message)})`
-                    : '';
-                invalidAllowPatterns.push(`${pattern}${reason}`);
-                return [];
-            }
-        });
-        if (invalidAllowPatterns.length > 0 || unsafeAllowPatterns.length > 0) {
-            const errorParts = [];
-            if (invalidAllowPatterns.length > 0) {
-                errorParts.push(`invalid allowPatterns: ${invalidAllowPatterns.join(', ')}`);
-            }
-            if (unsafeAllowPatterns.length > 0) {
-                errorParts.push(`unsafe allowPatterns (avoid nested quantifiers that risk catastrophic backtracking): ${unsafeAllowPatterns.join(', ')}`);
-            }
-            throw new Error(`no-handler-suffix: ${errorParts.join('; ')}`);
-        }
+        const allowPatterns = (0, compilePatternOption_1.compilePatternOption)('no-handler-suffix', 'allowPatterns', resolvedOptions.allowPatterns ?? [], undefined, UNSAFE_ALLOW_PATTERN_REJECTION);
         if (isInAllowedFile(filename, resolvedOptions.allowFilePatterns ?? [])) {
             return {};
         }

package/lib/rules/no-render-function-components.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noRenderFunctionComponents = void 0;
 const utils_1 = require("@typescript-eslint/utils");
+const compilePatternOption_1 = require("../utils/compilePatternOption");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 /**
@@ -95,7 +96,10 @@ exports.noRenderFunctionComponents = (0, createRule_1.createRule)({
             ...DEFAULT_RENDER_PROP_NAMES,
             ...userRenderPropNames,
         ]);
-        const allowNamePatterns = (options?.allowNames ?? []).map((pattern) => new RegExp(pattern));
+        // Rejecting a malformed `allowNames` entry rather than dropping it keeps the
+        // consumer's allowlist honest: a silently discarded pattern would report the
+        // functions they deliberately exempted with no indication why.
+        const allowNamePatterns = (0, compilePatternOption_1.compilePatternOption)('no-render-function-components', 'allowNames', options?.allowNames ?? []);
         const candidates = [];
         function isAllowed(name) {
             return allowNamePatterns.some((pattern) => pattern.test(name));

package/lib/rules/no-separate-loading-state.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noSeparateLoadingState = void 0;
 const utils_1 = require("@typescript-eslint/utils");
+const compilePatternOption_1 = require("../utils/compilePatternOption");
 const createRule_1 = require("../utils/createRule");
 const LOADING_PATTERNS = [
     /^is.*Loading$/i,
@@ -34,7 +35,18 @@ exports.noSeparateLoadingState = (0, createRule_1.createRule)({
     },
     defaultOptions: [{}],
     create(context, [options]) {
-        const effectivePatterns = options?.patterns?.map((p) => new RegExp(p, 'i')) ?? LOADING_PATTERNS;
+        // Rejecting a malformed `patterns` entry rather than falling back to
+        // `LOADING_PATTERNS` keeps the consumer's detection list honest: a silent
+        // fallback would look configured while leaving the names they meant to flag
+        // unreported.
+        //
+        // The `undefined` check is load-bearing: an absent `patterns` falls back to
+        // the built-ins, while an explicit empty list stays empty, so the option can
+        // disable name matching entirely.
+        const configuredPatterns = options?.patterns === undefined
+            ? undefined
+            : (0, compilePatternOption_1.compilePatternOption)('no-separate-loading-state', 'patterns', options.patterns, 'i');
+        const effectivePatterns = configuredPatterns ?? LOADING_PATTERNS;
         const setterTrackers = [];
         function isLoadingPattern(name) {
             return effectivePatterns.some((pattern) => pattern.test(name));

package/lib/utils/compilePatternOption.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Pattern options are declared as bare `string[]` because JSON Schema cannot
+ * express "is a compilable regex". Schema validation therefore hands any string
+ * straight to `new RegExp`, and an exception raised while building a rule aborts
+ * the entire lint run — every file, every other rule — with an opaque
+ * `Error while loading rule …` naming neither the option nor the offending
+ * value.
+ *
+ * Rejecting the configuration is the right response: silently dropping a
+ * pattern would leave the consumer's allowlist inert, so the code they
+ * deliberately excluded would be reported anyway with no indication why. This
+ * helper makes the rejection actionable and uniform — every failure is
+ * collected and rethrown as a single error naming the rule, the option and each
+ * bad pattern alongside the underlying regex error.
+ */
+export type PatternRejection = {
+    /**
+     * Refuses a pattern that compiles but is still unacceptable — a source with
+     * nested quantifiers, say, which risks catastrophic backtracking. Checked
+     * before compilation, so a refused pattern is never also reported as invalid.
+     */
+    isRejected: (pattern: string) => boolean;
+    /**
+     * Builds the clause head for refused patterns, e.g.
+     * `unsafe allowPatterns (avoid nested quantifiers…)`. Receives the option name
+     * so callers need not repeat it.
+     */
+    describe: (optionName: string) => string;
+};
+/**
+ * Compiles a user-supplied list of regex sources, throwing one actionable
+ * configuration error listing every pattern that failed.
+ *
+ * @param ruleName Rule id used to prefix the thrown message.
+ * @param optionName Option the patterns came from, named in the thrown message.
+ * @param patterns Regex source strings supplied by the consumer.
+ * @param flags Flags applied to every compiled pattern (`'i'`, say).
+ * @param rejection Optional extra admissibility check applied before compiling.
+ */
+export declare function compilePatternOption(ruleName: string, optionName: string, patterns: readonly string[], flags?: string, rejection?: PatternRejection): RegExp[];

package/lib/utils/compilePatternOption.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * Pattern options are declared as bare `string[]` because JSON Schema cannot
+ * express "is a compilable regex". Schema validation therefore hands any string
+ * straight to `new RegExp`, and an exception raised while building a rule aborts
+ * the entire lint run — every file, every other rule — with an opaque
+ * `Error while loading rule …` naming neither the option nor the offending
+ * value.
+ *
+ * Rejecting the configuration is the right response: silently dropping a
+ * pattern would leave the consumer's allowlist inert, so the code they
+ * deliberately excluded would be reported anyway with no indication why. This
+ * helper makes the rejection actionable and uniform — every failure is
+ * collected and rethrown as a single error naming the rule, the option and each
+ * bad pattern alongside the underlying regex error.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compilePatternOption = void 0;
+function describeError(error) {
+    return error && typeof error === 'object' && 'message' in error
+        ? ` (${String(error.message)})`
+        : '';
+}
+/**
+ * Compiles a user-supplied list of regex sources, throwing one actionable
+ * configuration error listing every pattern that failed.
+ *
+ * @param ruleName Rule id used to prefix the thrown message.
+ * @param optionName Option the patterns came from, named in the thrown message.
+ * @param patterns Regex source strings supplied by the consumer.
+ * @param flags Flags applied to every compiled pattern (`'i'`, say).
+ * @param rejection Optional extra admissibility check applied before compiling.
+ */
+function compilePatternOption(ruleName, optionName, patterns, flags, rejection) {
+    const invalid = [];
+    const rejected = [];
+    const compiled = patterns.flatMap((pattern) => {
+        try {
+            if (rejection?.isRejected(pattern)) {
+                rejected.push(pattern);
+                return [];
+            }
+            return [new RegExp(pattern, flags)];
+        }
+        catch (error) {
+            invalid.push(`${pattern}${describeError(error)}`);
+            return [];
+        }
+    });
+    if (invalid.length === 0 && rejected.length === 0) {
+        return compiled;
+    }
+    const clauses = [];
+    if (invalid.length > 0) {
+        clauses.push(`invalid ${optionName}: ${invalid.join(', ')}`);
+    }
+    if (rejected.length > 0 && rejection) {
+        clauses.push(`${rejection.describe(optionName)}: ${rejected.join(', ')}`);
+    }
+    throw new Error(`${ruleName}: ${clauses.join('; ')}`);
+}
+exports.compilePatternOption = compilePatternOption;
+//# sourceMappingURL=compilePatternOption.js.map

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,34 @@
 [
+  {
+    "version": "1.20.52",
+    "date": "2026-07-31T19:23:46.059Z",
+    "rules": [
+      {
+        "name": "enforce-m3-sentence-case",
+        "changeType": "fix",
+        "issues": [
+          1534
+        ],
+        "summary": "validate ignorePatterns regexes with an actionable error (closes #1534)"
+      },
+      {
+        "name": "no-render-function-components",
+        "changeType": "fix",
+        "issues": [
+          1536
+        ],
+        "summary": "validate allowNames regexes with an actionable error (closes #1536)"
+      },
+      {
+        "name": "no-separate-loading-state",
+        "changeType": "fix",
+        "issues": [
+          1535
+        ],
+        "summary": "validate patterns regexes with an actionable error (closes #1535)"
+      }
+    ]
+  },
   {
     "version": "1.20.51",
     "date": "2026-07-31T15:20:05.562Z",