@blumintinc/eslint-plugin-blumint 1.20.197 → 1.20.198

package/lib/index.js

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

package/lib/rules/no-entire-object-hook-deps.js

@@ -109,6 +109,51 @@ function readExhaustiveDepsDisable(comment) {
     }
     return comment.type === utils_1.AST_TOKEN_TYPES.Block ? 'file' : null;
 }
+/**
+ * Whether a dependency's type is a primitive, so that narrowing it into member
+ * paths is meaningless and an unread entry is a deliberate recompute trigger
+ * rather than a stale object.
+ *
+ * why the `*Like` flags, never the bare ones: each `*Like` is the union of a
+ * primitive and its LITERAL form, and a literal type is what this repo's own
+ * fixers produce. `global-const-style` appends `as const`, which turns `0` into
+ * the numeric literal type `0`. The list used to name `StringLiteral`
+ * explicitly but `Number` and `Boolean` bare, so a string literal was primitive
+ * while `0 as const` and `true as const` were not — the same value lost its
+ * exemption the moment a sibling fixer froze it, which made this an exemption
+ * destroyed by COMPOSITION rather than a latent gap (#2238).
+ *
+ * why unions are walked: a union carries `TypeFlags.Union` and none of the
+ * flags above, so a bitmask test on the union ITSELF answers no for
+ * `'compact' | 'full'` — a string at runtime, and the shape
+ * `prefer-union-from-const-array` leaves behind. A union is primitive exactly
+ * when every constituent is, which also keeps `string | { a: number }` an
+ * object.
+ */
+function isPrimitiveType(type) {
+    // why the mask is built HERE and not hoisted to module scope: this module is
+    // imported by `src/index.ts`, so a module-scope `TypeFlags.X` is read the
+    // moment the plugin loads. Against a compiler that does not root-export the
+    // API, `TypeFlags` is `undefined` and the read throws — taking down every
+    // rule in the plugin, not just this one. `plugin-load-without-compiler-api`
+    // is the guard that says so.
+    const primitiveFlags = typescript_1.TypeFlags.StringLike |
+        typescript_1.TypeFlags.NumberLike |
+        typescript_1.TypeFlags.BooleanLike |
+        typescript_1.TypeFlags.BigIntLike |
+        typescript_1.TypeFlags.ESSymbolLike |
+        typescript_1.TypeFlags.Null |
+        typescript_1.TypeFlags.Undefined |
+        typescript_1.TypeFlags.Void |
+        typescript_1.TypeFlags.Never;
+    if (type.flags & primitiveFlags)
+        return true;
+    if (type.flags & typescript_1.TypeFlags.Union) {
+        const constituents = type.types;
+        return constituents.length > 0 && constituents.every(isPrimitiveType);
+    }
+    return false;
+}
 /** `channelGroupActive` -> `setChannelGroupActive`, `a` -> `setA`. */
 function toSetterName(dependencyName) {
     return `set${dependencyName.charAt(0).toUpperCase()}${dependencyName.slice(1)}`;
@@ -119,19 +164,16 @@ function isArrayOrPrimitive(checker, esTreeNode, nodeMap) {
         if (!tsNode)
             return false;
         const type = checker.getTypeAtLocation(tsNode);
-        // Check if it's a primitive type
-        if (type.flags &
-            (typescript_1.TypeFlags.String |
-                typescript_1.TypeFlags.StringLike |
-                typescript_1.TypeFlags.StringLiteral |
-                typescript_1.TypeFlags.Number |
-                typescript_1.TypeFlags.Boolean |
-                typescript_1.TypeFlags.Null |
-                typescript_1.TypeFlags.Undefined |
-                typescript_1.TypeFlags.Void |
-                typescript_1.TypeFlags.Never |
-                typescript_1.TypeFlags.BigInt |
-                typescript_1.TypeFlags.ESSymbol)) {
+        // why: the `*Like` flags, never the bare ones. Each `*Like` is the union of
+        // a primitive and its LITERAL form, and a literal type is what this repo's
+        // own `global-const-style` produces — it appends `as const`, which turns
+        // `0` into the numeric literal type `0`. The list used to name
+        // `StringLiteral` explicitly but `Number` and `Boolean` bare, so a string
+        // literal was primitive while `0 as const` and `true as const` were not:
+        // the same value lost the exemption the moment a sibling fixer froze it
+        // (#2238). Enum members come in through `NumberLike`/`StringLike` for the
+        // same reason — an enum member is a primitive at runtime.
+        if (isPrimitiveType(type)) {
             return true;
         }
         // Check if it's an array type

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,18 @@
 [
+  {
+    "version": "1.20.198",
+    "date": "2026-08-31T11:06:34.784Z",
+    "rules": [
+      {
+        "name": "no-entire-object-hook-deps",
+        "changeType": "fix",
+        "issues": [
+          2238
+        ],
+        "summary": "treat a literal type as the primitive it is (closes #2238)"
+      }
+    ]
+  },
   {
     "version": "1.20.197",
     "date": "2026-08-31T08:50:13.198Z",