@blumintinc/eslint-plugin-blumint 1.20.72 → 1.20.74

package/lib/index.js

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

package/lib/rules/enforce-boolean-naming-prefixes.js

@@ -7,6 +7,7 @@ exports.enforceBooleanNamingPrefixes = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const pluralize_1 = __importDefault(require("pluralize"));
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 // Default approved boolean prefixes. Some less common prefixes (e.g., 'are',
 // 'includes') stay allowed for flexibility even though the user-facing message
 // highlights only the most common ones. Underscore-prefixed names are also
@@ -226,6 +227,27 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
             }
             return false;
         }
+        /**
+         * Recognize `Boolean(x)` — the explicit spelling of `!!x` — as producing a
+         * primitive boolean.
+         *
+         * The callee name alone cannot decide this. A local binding, a parameter or
+         * an import named `Boolean` shadows the global and may return anything, so
+         * the identifier is resolved through the scope chain at the call site: only
+         * an unresolved reference, or one reaching a definition-less global, is the
+         * built-in. `new Boolean(x)` is deliberately not covered here — a
+         * `NewExpression` builds a Boolean wrapper *object*, which is always truthy
+         * and never a primitive boolean.
+         */
+        function isGlobalBooleanCall(callExpression) {
+            const { callee } = callExpression;
+            if (callee.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                callee.name !== 'Boolean') {
+                return false;
+            }
+            const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, callee), 'Boolean');
+            return !variable || variable.defs.length === 0;
+        }
         /**
          * Check if a node is initialized with a boolean value
          */
@@ -308,6 +330,12 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 // Check for function calls that might return boolean
                 if (node.init.type === utils_1.AST_NODE_TYPES.CallExpression &&
                     node.init.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    // A coercion through the global `Boolean` is as definitive as `!!x`,
+                    // and its callee carries no approved prefix for the name heuristic
+                    // below to recognize.
+                    if (isGlobalBooleanCall(node.init)) {
+                        return true;
+                    }
                     const calleeName = node.init.callee.name;
                     const lowerCallee = calleeName.toLowerCase();
                     // For assert*-style utilities, only treat as boolean if we can confirm boolean return type

package/lib/rules/global-const-style.js

@@ -3,6 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const isUpperSnakeCase = (str) => /^[A-Z][A-Z0-9_]*$/.test(str);
+/**
+ * Converts an identifier to UPPER_SNAKE_CASE by splitting on case *boundaries*.
+ *
+ * Idempotence is a correctness requirement, not a nicety: `--fix` re-lints its
+ * own output up to ten times per file, and a sibling rule can rewrite the same
+ * identifier in between (`enforce-react-type-naming` lowercases it), so a
+ * converter that re-separates what it already separated compounds every pass
+ * and writes an ever-growing, corrupted identifier into source (Issue #1605).
+ * Splitting on boundaries also keeps acronym runs intact, so `HTTPServer` reads
+ * as `HTTP_SERVER` rather than `H_T_T_P_SERVER`.
+ *
+ * The leading underscore is dropped because `_PRIVATE_THING` fails
+ * `isUpperSnakeCase`, which would leave the rule demanding a rename it can
+ * never satisfy.
+ */
+const toUpperSnakeCase = (name) => name
+    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+    .toUpperCase()
+    .replace(/^_/, '');
 // Jest mock handles produced by an `as` cast to a `jest.Mock*` type are
 // stateful test doubles that are reassigned/mutated through
 // `.mockImplementation()`, `.mockReturnValue()`, etc. They are not immutable
@@ -328,10 +348,7 @@ exports.default = (0, createRule_1.createRule)({
                     // the `mockedX` idiom is intentional. The exemption gates only this
                     // rename check — the `as const` logic above is untouched.
                     if (!isUpperSnakeCase(name) && !isJestMockCast(init)) {
-                        const newName = name
-                            .replace(/([A-Z])/g, '_$1')
-                            .toUpperCase()
-                            .replace(/^_/, '');
+                        const newName = toUpperSnakeCase(name);
                         const idNode = declaration.id;
                         context.report({
                             node: declaration,

package/lib/rules/react-memoize-literals.js

@@ -701,6 +701,85 @@ function buildHookImportFix(fixer, program, hookName) {
         ? fixer.insertTextBefore(anchor, statement)
         : fixer.insertTextAfterRange([0, 0], statement);
 }
+/**
+ * Scope kinds whose bindings are established once per module evaluation:
+ * globals, imports and module-level declarations. Such a value is identical on
+ * every render, so it can never belong in a dependency array.
+ */
+const MODULE_LEVEL_SCOPE_TYPES = new Set(['global', 'module']);
+/**
+ * True when `inner` lies entirely inside `outer`'s source range.
+ */
+function isRangeWithin(inner, outer) {
+    return inner[0] >= outer[0] && inner[1] <= outer[1];
+}
+/**
+ * True when a reference appears purely in type position (an annotation or a
+ * `satisfies`/`as` target inside the literal). Types erase at compile time, so
+ * such a name never becomes a dependency however it resolves. The flags are read
+ * defensively: an analyzer that omits them leaves the reference classified as a
+ * value, which keeps the suggestion — the conservative direction.
+ */
+function isTypeOnlyReference(reference) {
+    const flags = reference;
+    return flags.isTypeReference === true && flags.isValueReference === false;
+}
+/**
+ * True when a reference names a value that can differ between renders, i.e. one
+ * bound in a scope INSIDE the module and OUTSIDE the literal: a prop, a local, a
+ * destructured value, another hook's result.
+ *
+ * Everything else is unusable as a dependency. An unresolved name is a global.
+ * A module- or global-scoped binding is fixed for the module's lifetime. A
+ * binding whose own scope sits inside the literal — an inline function's
+ * parameters, its locals, its `arguments` — is not closed over at all.
+ */
+function isRenderScopeReference(reference, literalRange) {
+    const variable = reference.resolved;
+    if (!variable) {
+        return false;
+    }
+    if (MODULE_LEVEL_SCOPE_TYPES.has(variable.scope.type)) {
+        return false;
+    }
+    return !isRangeWithin(variable.scope.block.range, literalRange);
+}
+/**
+ * True when the literal reads at least one value a dependency array could hold.
+ *
+ * Answered from RESOLVED scope references rather than identifier names, so
+ * shadowing, destructuring and imports are all accounted for exactly as the
+ * scope analyzer sees them.
+ *
+ * The walk starts at the literal's own scope and descends into every scope
+ * nested inside it — a callback buried in an object property closes over the
+ * component's scope just as a property value would — while the range filter
+ * keeps the literal's siblings out of the answer.
+ */
+function closesOverRenderScopeValue(node, scope) {
+    const literalRange = node.range;
+    const pending = [scope];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        for (const reference of current.references) {
+            if (!isRangeWithin(reference.identifier.range, literalRange)) {
+                continue;
+            }
+            if (isTypeOnlyReference(reference)) {
+                continue;
+            }
+            if (isRenderScopeReference(reference, literalRange)) {
+                return true;
+            }
+        }
+        for (const child of current.childScopes) {
+            if (isRangeWithin(child.block.range, literalRange)) {
+                pending.push(child);
+            }
+        }
+    }
+    return false;
+}
 /**
  * Builds memoization suggestions with dependency placeholders for developers.
  * @param node Literal node to wrap.
@@ -725,6 +804,19 @@ function buildMemoSuggestions(node, descriptor, sourceCode, context) {
                 memoHook: descriptor.memoHook,
             },
             fix(fixer) {
+                // The wrap writes an EMPTY dependency array for the author to fill in.
+                // A literal that closes over nothing has nothing to fill it with, and
+                // `enforce-global-constants` forbids precisely that shape — a useMemo
+                // over an object literal with empty deps — while offering no fixer of
+                // its own. Accepting the suggestion would therefore trade this report
+                // for a permanent, non-autofixable one. Hoisting is the correct branch
+                // when nothing is closed over, and the report's own message already
+                // prescribes it, so decline rather than emit a state the author cannot
+                // complete (the #1417 principle, applied here as in the shadowed-hook
+                // guard below).
+                if (!closesOverRenderScopeValue(node, ASTHelpers_1.ASTHelpers.getScope(context, node))) {
+                    return null;
+                }
                 // The wrapper is only correct if the hook name resolves to React's
                 // hook. A shadowing local/parameter would silently call that value
                 // instead, and an import of the same name from another module would

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,40 @@
 [
+  {
+    "version": "1.20.74",
+    "date": "2026-08-02T06:07:00.009Z",
+    "rules": [
+      {
+        "name": "global-const-style",
+        "changeType": "fix",
+        "issues": [
+          1605
+        ],
+        "summary": "split the rename on case boundaries so it is idempotent (closes #1605)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.73",
+    "date": "2026-08-02T05:14:39.301Z",
+    "rules": [
+      {
+        "name": "enforce-boolean-naming-prefixes",
+        "changeType": "fix",
+        "issues": [
+          1602
+        ],
+        "summary": "recognise a direct Boolean(...) initializer (closes #1602)"
+      },
+      {
+        "name": "react-memoize-literals",
+        "changeType": "fix",
+        "issues": [
+          1600
+        ],
+        "summary": "decline the memo suggestion when the literal closes over nothing (closes #1600)"
+      }
+    ]
+  },
   {
     "version": "1.20.72",
     "date": "2026-08-02T03:33:22.821Z",