@blumintinc/eslint-plugin-blumint 1.20.192 → 1.20.193

package/lib/index.js

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

package/lib/rules/enforce-memoize-getters.js

@@ -423,6 +423,19 @@ exports.enforceMemoizeGetters = (0, createRule_1.createRule)({
                 // breakage.
                 if (node.key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier)
                     return;
+                // The same unwritable-remedy shape, one key form over: `Memoize`
+                // declares its `propertyKey` parameter as `string`, so decorating a
+                // symbol-keyed getter — `get [Symbol.iterator]()` — is TS1241, and the
+                // `--fix` edit turns compiling code into code that does not compile.
+                // A computed key that IS a string literal (`get ['name']()`) is an
+                // ordinary string key and stays in scope; anything else cannot be shown
+                // to be a string without the checker, and a false negative is the
+                // cheaper error here.
+                if (node.computed &&
+                    !(node.key.type === utils_1.AST_NODE_TYPES.Literal &&
+                        typeof node.key.value === 'string')) {
+                    return;
+                }
                 const classBody = node.parent;
                 // The same reasoning, one level out: under `experimentalDecorators` a
                 // decorator is rejected on EVERY member of a class EXPRESSION — TS1206

package/lib/rules/no-direct-function-state.d.ts

@@ -4,6 +4,6 @@ type Options = [
         functionPatterns?: string[];
     }
 ];
-type MessageIds = 'noDirectFunctionState' | 'noDirectFunctionStateAssertion';
+type MessageIds = 'noDirectFunctionState' | 'noDirectFunctionStateAssertion' | 'invalidFunctionPattern';
 export declare const noDirectFunctionState: TSESLint.RuleModule<MessageIds, Options, TSESLint.RuleListener>;
 export {};

package/lib/rules/no-direct-function-state.js

@@ -198,22 +198,33 @@ function isDefinitelySafeArg(argNode) {
     }
 }
 /**
- * Checks whether an identifier name matches any of the function-naming patterns
- * (e.g. onClose, handler, fn, callback).
+ * Compiles the configured function-naming patterns once, separating the ones
+ * that do not compile from the ones that do.
+ *
+ * Swallowing an uncompilable pattern makes the consumer's allowlist silently
+ * inert: the rule then reports the very code they wrote the pattern to exclude,
+ * with nothing anywhere saying why. Returning the rejects lets `create` report
+ * them, which is what the sibling pattern-compiling rules already do.
  */
-function matchesFunctionPattern(name, patterns) {
+function compileFunctionPatterns(patterns) {
+    const matchers = [];
+    const invalid = [];
     for (const pattern of patterns) {
         try {
-            const regex = new RegExp(`^${pattern}$`);
-            if (regex.test(name)) {
-                return true;
-            }
+            matchers.push(new RegExp(`^${pattern}$`));
         }
         catch {
-            // Ignore invalid regex patterns
+            invalid.push(pattern);
         }
     }
-    return false;
+    return { matchers, invalid };
+}
+/**
+ * Checks whether an identifier name matches any of the function-naming patterns
+ * (e.g. onClose, handler, fn, callback).
+ */
+function matchesFunctionPattern(name, matchers) {
+    return matchers.some((matcher) => matcher.test(name));
 }
 /**
  * Extracts the identifier name from an argument node for pattern matching.
@@ -296,12 +307,16 @@ exports.noDirectFunctionState = (0, createRule_1.createRule)({
                 'Why it matters: The function will be called with the previous state value and its return value stored — a silent bug with no error. ' +
                 'How to fix: Give the asserted value a name, then store that name through a thunk: const value = {{argText}}; {{setterName}}(() => value). ' +
                 'The assertion is hoisted out because a thunk that returned it would be an arrow returning a cast, which no-type-assertion-returns reports.',
+            invalidFunctionPattern: 'What\u2019s wrong: "{{pattern}}" in functionPatterns is not a valid regular expression, so it was dropped. ' +
+                'Why it matters: the rule silently stops honouring that entry, and reports the very code the pattern was written to exclude. ' +
+                'How to fix: correct the pattern in your ESLint configuration.',
         },
     },
     defaultOptions: [{ functionPatterns: DEFAULT_FUNCTION_PATTERNS }],
     create(context) {
         const options = context.options[0] ?? {};
         const functionPatterns = options.functionPatterns ?? DEFAULT_FUNCTION_PATTERNS;
+        const { matchers: functionPatternMatchers, invalid: invalidPatterns } = compileFunctionPatterns(functionPatterns);
         /**
          * Maps setter-variable names to whether the corresponding useState has
          * an explicit function type parameter. This is populated as we encounter
@@ -309,6 +324,15 @@ exports.noDirectFunctionState = (0, createRule_1.createRule)({
          */
         const setterFunctionTyped = new Map();
         return {
+            Program(node) {
+                for (const pattern of invalidPatterns) {
+                    context.report({
+                        node,
+                        messageId: 'invalidFunctionPattern',
+                        data: { pattern },
+                    });
+                }
+            },
             VariableDeclarator(node) {
                 // Look for `const [state, setter] = useState<T>(...)` or
                 // `const [state, setter] = React.useState<T>(...)`.
@@ -383,7 +407,8 @@ exports.noDirectFunctionState = (0, createRule_1.createRule)({
                 // No explicit function type. Fall back to heuristic: name pattern match
                 // or scope-level binding to a function.
                 const argName = getArgName(arg);
-                if (argName && matchesFunctionPattern(argName, functionPatterns)) {
+                if (argName &&
+                    matchesFunctionPattern(argName, functionPatternMatchers)) {
                     reportAndFix(node, arg, setterName, context);
                     return;
                 }

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,26 @@
 [
+  {
+    "version": "1.20.193",
+    "date": "2026-08-30T05:32:04.963Z",
+    "rules": [
+      {
+        "name": "enforce-memoize-getters",
+        "changeType": "fix",
+        "issues": [
+          2215
+        ],
+        "summary": "decline a getter whose computed key is not a string literal"
+      },
+      {
+        "name": "no-direct-function-state",
+        "changeType": "fix",
+        "issues": [
+          2218
+        ],
+        "summary": "report an uncompilable functionPatterns entry instead of dropping it (closes #2218)"
+      }
+    ]
+  },
   {
     "version": "1.20.192",
     "date": "2026-08-30T01:20:08.891Z",