@blumintinc/eslint-plugin-blumint 1.20.70 → 1.20.71

package/lib/index.js

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

package/lib/rules/no-firestore-object-arrays.js

@@ -43,6 +43,42 @@ const isParenthesizedType = (node) => {
     return (candidate.type === 'TSParenthesizedType' &&
         candidate.typeAnnotation !== undefined);
 };
+const unwrapParenthesizedTypeNode = (node) => {
+    let current = node;
+    // Cap iterations for the same reason as unwrapArrayElementType: wrappers are
+    // finite, but a future wrapper case must not be able to loop forever.
+    for (let i = 0; i < 10; i++) {
+        if (isParenthesizedType(current)) {
+            current = current.typeAnnotation;
+            continue;
+        }
+        break;
+    }
+    return current;
+};
+// Assertion wrappers never change the runtime value, so `[...] as const` and
+// `[...] as const satisfies readonly string[]` both still describe an array.
+const EXPRESSION_ASSERTION_TYPES = new Set([
+    utils_1.AST_NODE_TYPES.TSAsExpression,
+    utils_1.AST_NODE_TYPES.TSNonNullExpression,
+    utils_1.AST_NODE_TYPES.TSTypeAssertion,
+    'TSSatisfiesExpression',
+]);
+const unwrapExpressionAssertions = (node) => {
+    let current = node;
+    for (let i = 0; i < 10; i++) {
+        if (EXPRESSION_ASSERTION_TYPES.has(current.type)) {
+            const inner = current
+                .expression;
+            if (!inner)
+                break;
+            current = inner;
+            continue;
+        }
+        break;
+    }
+    return current;
+};
 const unwrapArrayElementType = (node) => {
     let current = node;
     // Fixpoint loop: peel wrappers in any order until none remain
@@ -181,6 +217,7 @@ exports.noFirestoreObjectArrays = (0, createRule_1.createRule)({
         const aliasNameToType = new Map();
         const interfaceNames = new Set();
         const enumNames = new Set();
+        const constArrayNameToLiteral = new Map();
         const visitNode = (n) => {
             switch (n.type) {
                 case utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration: {
@@ -195,6 +232,22 @@ exports.noFirestoreObjectArrays = (0, createRule_1.createRule)({
                     enumNames.add(n.id.name);
                     break;
                 }
+                case utils_1.AST_NODE_TYPES.VariableDeclaration: {
+                    // Only `const` bindings can back a `(typeof X)[number]` element union
+                    if (n.kind !== 'const')
+                        break;
+                    for (const declarator of n.declarations) {
+                        if (declarator.id.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                            !declarator.init) {
+                            continue;
+                        }
+                        const init = unwrapExpressionAssertions(declarator.init);
+                        if (init.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
+                            constArrayNameToLiteral.set(declarator.id.name, init);
+                        }
+                    }
+                    break;
+                }
                 case utils_1.AST_NODE_TYPES.ExportNamedDeclaration: {
                     if (n.declaration)
                         visitNode(n.declaration);
@@ -235,6 +288,85 @@ exports.noFirestoreObjectArrays = (0, createRule_1.createRule)({
         }
         const seenAlias = new Set();
         const visitingAliases = new Set();
+        const isPrimitiveLiteralElement = (element, visitedConstArrays) => {
+            // Array holes resolve to `undefined`, but the shape is unusual enough
+            // that refusing to classify it keeps the narrowing conservative.
+            if (!element)
+                return false;
+            if (element.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                const argument = unwrapExpressionAssertions(element.argument);
+                if (argument.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
+                    return argument.elements.every((nested) => isPrimitiveLiteralElement(nested, visitedConstArrays));
+                }
+                if (argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return isPrimitiveConstArray(argument.name, visitedConstArrays);
+                }
+                return false;
+            }
+            const expression = unwrapExpressionAssertions(element);
+            switch (expression.type) {
+                case utils_1.AST_NODE_TYPES.Literal: {
+                    // A regex literal is an object; its `value` is engine-dependent, so
+                    // reject it explicitly rather than relying on the typeof check.
+                    if (expression.regex)
+                        return false;
+                    const value = expression.value;
+                    return (value === null ||
+                        typeof value === 'string' ||
+                        typeof value === 'number' ||
+                        typeof value === 'boolean' ||
+                        typeof value === 'bigint');
+                }
+                case utils_1.AST_NODE_TYPES.TemplateLiteral:
+                    return true; // a template literal always produces a string
+                case utils_1.AST_NODE_TYPES.ArrayExpression:
+                    // Nested primitive arrays mirror the allowance for `string[][]` and
+                    // tuples of primitives elsewhere in this rule.
+                    return expression.elements.every((nested) => isPrimitiveLiteralElement(nested, visitedConstArrays));
+                case utils_1.AST_NODE_TYPES.UnaryExpression: {
+                    const unary = expression;
+                    if (unary.operator !== '-' && unary.operator !== '+')
+                        return false;
+                    return isPrimitiveLiteralElement(unary.argument, visitedConstArrays);
+                }
+                case utils_1.AST_NODE_TYPES.Identifier:
+                    return expression.name === 'undefined';
+                default:
+                    return false;
+            }
+        };
+        const isPrimitiveConstArray = (name, visitedConstArrays) => {
+            // A cyclic spread cannot be resolved syntactically; refuse to classify it
+            if (visitedConstArrays.has(name))
+                return false;
+            const arrayLiteral = constArrayNameToLiteral.get(name);
+            if (!arrayLiteral)
+                return false;
+            visitedConstArrays.add(name);
+            const result = arrayLiteral.elements.every((element) => isPrimitiveLiteralElement(element, visitedConstArrays));
+            visitedConstArrays.delete(name);
+            return result;
+        };
+        /**
+         * Recognizes `(typeof VALUES)[number]` where VALUES is a same-file const
+         * array of primitive literals. That form denotes the union of those
+         * literals, not an object lookup, and it is exactly what the sibling
+         * rule prefer-union-from-const-array autofixes toward.
+         */
+        const isConstArrayElementUnion = (node) => {
+            const indexType = unwrapParenthesizedTypeNode(node.indexType);
+            // Only a `number` index yields the element union; `['length']` or any key
+            // lookup resolves to something this syntactic check cannot vouch for.
+            if (indexType.type !== utils_1.AST_NODE_TYPES.TSNumberKeyword)
+                return false;
+            const objectType = unwrapParenthesizedTypeNode(node.objectType);
+            if (objectType.type !== utils_1.AST_NODE_TYPES.TSTypeQuery)
+                return false;
+            const exprName = objectType.exprName;
+            if (exprName.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return false;
+            return isPrimitiveConstArray(exprName.name, new Set());
+        };
         const isPrimitiveLikeAlias = (name, recursionDepth) => {
             if (seenAlias.has(name))
                 return true;
@@ -286,6 +418,8 @@ exports.noFirestoreObjectArrays = (0, createRule_1.createRule)({
                     return false;
                 case utils_1.AST_NODE_TYPES.TSLiteralType:
                     return true; // string/number/boolean literals
+                case utils_1.AST_NODE_TYPES.TSIndexedAccessType:
+                    return isConstArrayElementUnion(node);
                 case utils_1.AST_NODE_TYPES.TSTypeReference: {
                     // Allow known primitive-like references and enums or primitive-like aliases
                     const ref = node;
@@ -361,8 +495,10 @@ exports.noFirestoreObjectArrays = (0, createRule_1.createRule)({
                 case utils_1.AST_NODE_TYPES.TSMappedType:
                     return true;
                 case utils_1.AST_NODE_TYPES.TSIndexedAccessType:
-                    // Treat indexed access as object-like to align with existing tests
-                    return true;
+                    // An indexed access such as `DataShape['user']` is an object lookup,
+                    // but `(typeof VALUES)[number]` over a const array of primitive
+                    // literals is a primitive union and must not be flagged.
+                    return !isConstArrayElementUnion(node);
                 case utils_1.AST_NODE_TYPES.TSTypeOperator:
                     if (node.operator === 'readonly') {
                         return isObjectType(node

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,18 @@
 [
+  {
+    "version": "1.20.71",
+    "date": "2026-08-02T01:25:22.489Z",
+    "rules": [
+      {
+        "name": "no-firestore-object-arrays",
+        "changeType": "fix",
+        "issues": [
+          1594
+        ],
+        "summary": "treat (typeof X)[number] over a primitive const array as a primitive union (closes #1594)"
+      }
+    ]
+  },
   {
     "version": "1.20.70",
     "date": "2026-08-01T23:31:02.214Z",