@blumintinc/eslint-plugin-blumint 1.20.123 → 1.20.125

package/lib/index.js

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

package/lib/rules/enforce-console-error.js

@@ -41,6 +41,45 @@ exports.enforceConsoleError = (0, createRule_1.createRule)({
                 node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
                 node.callee.property.name === method);
         }
+        /**
+         * A type assertion carries no runtime behaviour, so `'error' as const`,
+         * `'error' satisfies Severity`, `<const>'error'` and `'error'!` all evaluate
+         * to exactly the string their inner expression evaluates to. Reading through
+         * the wrapper keeps a severity that is pinned at compile time out of the
+         * `dynamic` bucket, whose report demands both console methods and asserts
+         * the severity may render either dialog. The wrappers nest, so unwrap until
+         * a non-assertion node is reached.
+         */
+        function unwrapTypeAssertions(node) {
+            let current = node;
+            while (current.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+                current.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression ||
+                current.type === utils_1.AST_NODE_TYPES.TSNonNullExpression ||
+                current.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) {
+                current = current.expression;
+            }
+            return current;
+        }
+        /**
+         * Reads a severity that is fixed at compile time, or null when the value can
+         * only be known at runtime. A template with no substitutions denotes a
+         * single constant string exactly as a quoted literal does; only an
+         * INTERPOLATED template is genuinely dynamic.
+         */
+        function getStaticSeverityValue(node) {
+            const value = unwrapTypeAssertions(node);
+            if (value.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof value.value === 'string') {
+                return value.value;
+            }
+            if (value.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+                value.expressions.length === 0 &&
+                value.quasis.length === 1 &&
+                typeof value.quasis[0].value.cooked === 'string') {
+                return value.quasis[0].value.cooked;
+            }
+            return null;
+        }
         function getSeverityFromObjectExpression(node) {
             for (const prop of node.properties) {
                 if (prop.type === utils_1.AST_NODE_TYPES.Property) {
@@ -57,11 +96,11 @@ exports.enforceConsoleError = (0, createRule_1.createRule)({
                         isSeverityProperty = true;
                     }
                     if (isSeverityProperty) {
-                        if (prop.value.type === utils_1.AST_NODE_TYPES.Literal &&
-                            typeof prop.value.value === 'string') {
-                            return prop.value.value;
+                        const staticSeverity = getStaticSeverityValue(prop.value);
+                        if (staticSeverity !== null) {
+                            return staticSeverity;
                         }
-                        // If severity is not a literal, treat as dynamic
+                        // A severity only known at runtime forces the stricter dynamic path
                         return 'dynamic';
                     }
                 }

package/lib/rules/enforce-mock-firestore.js

@@ -8,6 +8,38 @@ const FIRESTORE_PATHS = [
     'firebase-admin',
     'firebase-admin/firestore',
 ];
+/**
+ * `x as T`, `<T>x`, `x satisfies T` and `x!` assert a type without contributing
+ * a value of their own, so a check that classifies the *shape* of an expression
+ * must look through all four alike.
+ *
+ * This matters beyond hand-written code: sibling rules' autofixes append
+ * ` as const` to the very objects this rule inspects
+ * (`enforce-object-literal-as-const` rewrites
+ * `jest.mock(path, () => { return ({ db }); })` into
+ * `jest.mock(path, () => { return ({ db } as const); })`). A bare
+ * `node.type === ObjectExpression` test taken on the wrapper therefore goes
+ * silent on code `eslint --fix` had just reported (Issue #1806).
+ */
+const ASSERTION_EXPRESSION_TYPES = new Set([
+    utils_1.AST_NODE_TYPES.TSAsExpression,
+    utils_1.AST_NODE_TYPES.TSSatisfiesExpression,
+    utils_1.AST_NODE_TYPES.TSNonNullExpression,
+    utils_1.AST_NODE_TYPES.TSTypeAssertion,
+]);
+const isAssertionExpression = (node) => ASSERTION_EXPRESSION_TYPES.has(node.type);
+/**
+ * Peels every assertion wrapper off an expression, so `{ db } as const`,
+ * `<const>{ db }` and chains such as `{ db } as const satisfies Module` all
+ * classify as the object literal they wrap.
+ */
+const unwrapAssertions = (node) => {
+    let target = node;
+    while (isAssertionExpression(target)) {
+        target = target.expression;
+    }
+    return target;
+};
 /**
  * A `jest.mock` factory produces the same module shape whether it is written as
  * a concise arrow, a block-bodied arrow, or a `function` expression. Matching
@@ -15,28 +47,37 @@ const FIRESTORE_PATHS = [
  * identical mock evade the rule on a body-form choice alone. Resolving to the
  * produced object keeps every spelling on one matching path.
  *
+ * Assertions are peeled at both ends — off the factory and off the expression
+ * it produces — so every body form is covered by one unwrap rather than only
+ * the spelling a bug report happened to quote.
+ *
  * A body with more than a lone `return` is deliberately unresolved: the object
  * reaching the caller can no longer be read off a single expression.
  */
 const resolveFactoryReturn = (factory) => {
-    if (!factory ||
-        (factory.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
-            factory.type !== utils_1.AST_NODE_TYPES.FunctionExpression)) {
+    if (!factory) {
+        return undefined;
+    }
+    const callable = unwrapAssertions(factory);
+    if (callable.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+        callable.type !== utils_1.AST_NODE_TYPES.FunctionExpression) {
         return undefined;
     }
     // A concise arrow body is the produced expression itself. Parentheses around
     // an object body are not part of the AST, so the node is matched directly.
-    if (factory.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
-        return factory.body;
+    if (callable.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+        return unwrapAssertions(callable.body);
     }
-    const statements = factory.body.body;
+    const statements = callable.body.body;
     if (statements.length !== 1) {
         return undefined;
     }
     const [statement] = statements;
-    return statement.type === utils_1.AST_NODE_TYPES.ReturnStatement
-        ? statement.argument ?? undefined
-        : undefined;
+    if (statement.type !== utils_1.AST_NODE_TYPES.ReturnStatement ||
+        !statement.argument) {
+        return undefined;
+    }
+    return unwrapAssertions(statement.argument);
 };
 exports.enforceFirestoreMock = (0, createRule_1.createRule)({
     name: 'enforce-mock-firestore',
@@ -57,34 +98,51 @@ exports.enforceFirestoreMock = (0, createRule_1.createRule)({
         return {
             // Detect jest.mock() calls for firebaseAdmin
             CallExpression(node) {
-                if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                    node.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    node.callee.object.name === 'jest' &&
-                    node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    node.callee.property.name === 'mock' &&
-                    node.arguments.length > 0 &&
-                    node.arguments[0].type === utils_1.AST_NODE_TYPES.Literal &&
-                    typeof node.arguments[0].value === 'string' &&
-                    FIRESTORE_PATHS.some((path) => node.arguments[0].type === utils_1.AST_NODE_TYPES.Literal &&
-                        typeof node.arguments[0].value === 'string' &&
-                        node.arguments[0].value?.includes(path))) {
-                    // Check if the mock includes Firestore-related properties
-                    const mockedModule = resolveFactoryReturn(node.arguments[1]);
-                    if (mockedModule &&
-                        mockedModule.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
-                        mockedModule.properties.some((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
-                            prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                            (prop.key.name === 'db' ||
-                                prop.key.name === 'firestore' ||
-                                prop.key.name === 'getFirestore'))) {
-                        context.report({
-                            node,
-                            messageId: 'noManualFirestoreMock',
-                        });
-                    }
+                // `(jest.mock as any)(...)` and `jest!.mock(...)` call the same
+                // function, so the callee and its object are read through assertions
+                // too. The property name cannot carry one: an assertion there requires
+                // computed access, a spelling this rule does not resolve at all.
+                const callee = unwrapAssertions(node.callee);
+                if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+                    return;
+                }
+                const calleeObject = unwrapAssertions(callee.object);
+                if (calleeObject.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                    calleeObject.name !== 'jest' ||
+                    callee.property.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                    callee.property.name !== 'mock' ||
+                    node.arguments.length === 0) {
+                    return;
+                }
+                const modulePath = unwrapAssertions(node.arguments[0]);
+                if (modulePath.type !== utils_1.AST_NODE_TYPES.Literal) {
+                    return;
+                }
+                const mockedPath = modulePath.value;
+                if (typeof mockedPath !== 'string' ||
+                    !FIRESTORE_PATHS.some((path) => mockedPath.includes(path))) {
+                    return;
+                }
+                // Check if the mock includes Firestore-related properties
+                const mockedModule = resolveFactoryReturn(node.arguments[1]);
+                if (mockedModule &&
+                    mockedModule.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
+                    mockedModule.properties.some((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
+                        prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        (prop.key.name === 'db' ||
+                            prop.key.name === 'firestore' ||
+                            prop.key.name === 'getFirestore'))) {
+                    context.report({
+                        node,
+                        messageId: 'noManualFirestoreMock',
+                    });
                 }
             },
-            // Detect imports of mockFirebase
+            // Detect imports of mockFirebase.
+            //
+            // No unwrapping applies here: the grammar admits only a bare string
+            // literal as an import source and only a bare identifier as an imported
+            // name, so neither position can carry an assertion for a fixer to add.
             ImportDeclaration(node) {
                 if (node.source.type === utils_1.AST_NODE_TYPES.Literal &&
                     node.source.value === 'firestore-jest-mock' &&

package/lib/rules/enforce-querykey-ts.js

@@ -478,15 +478,60 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
             return false;
         }
         /**
-         * Generate auto-fix suggestion for string literals
+         * The key's value when it is knowable without running the program, paired
+         * with the node that spells it.
+         *
+         * The substituted `QUERY_KEY_*` name is derived from that value, so what a
+         * fix needs is the value — not the notation carrying it. Gating on the node
+         * type instead left a static template reported exactly like the quoted
+         * string it renders to but with no fix behind the report (#1803). Every
+         * genuinely underivable shape — concatenation, a ternary, a template WITH
+         * expressions — holds no single value and falls out here on its own, so the
+         * conservative carve-out survives without being keyed to notation.
+         *
+         * Read through `cooked` rather than `raw` so an escape names the character
+         * it renders to, and the two spellings of one key derive one constant.
+         */
+        function staticKeyOf(node) {
+            if (node.type === utils_1.AST_NODE_TYPES.Literal) {
+                return typeof node.value === 'string'
+                    ? { node, text: node.value }
+                    : null;
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+                node.expressions.length === 0) {
+                const cooked = node.quasis[0]?.value.cooked;
+                // A cooked value is absent only for an invalid escape sequence, which
+                // names no character and so cannot name a constant either.
+                return typeof cooked === 'string' ? { node, text: cooked } : null;
+            }
+            return null;
+        }
+        /**
+         * The `QUERY_KEY_*` constant a key value names, or null when it names none.
+         *
+         * A key that is empty, or built only from the characters normalization
+         * folds into separators and then strips, leaves nothing after the prefix:
+         * the bare `QUERY_KEY_` that emitted is a name `queryKeys.ts` neither
+         * exports nor plausibly would, so applying it traded a report for a file
+         * that no longer compiles. Declining here leaves the report standing with
+         * no fix, which is the honest outcome — the author has to choose a real
+         * key, and no rewrite can choose one for them.
+         *
+         * The test is on the derived text alone, so it answers the same way for
+         * every notation the same value can be written in; putting it in
+         * `staticKeyOf` instead would gate the fix on content at the point that
+         * exists to keep notation out of the gate (#1803, #1813).
          */
         function generateAutoFix(keyValue) {
-            // Simple heuristic to suggest query key constant names
             const normalizedKey = keyValue
                 .toUpperCase()
                 .replace(/[^A-Z0-9]/g, '_')
                 .replace(/_+/g, '_')
                 .replace(/^_|_$/g, '');
+            if (normalizedKey === '') {
+                return null;
+            }
             return `QUERY_KEY_${normalizedKey}`;
         }
         return {
@@ -549,18 +594,17 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
                                 if (!isValidQueryKeyUsage(keyValue)) {
                                     // Check if it contains invalid string literals
                                     if (containsInvalidStringLiteral(keyValue)) {
-                                        // Only simple string literals can be auto-fixed
-                                        const suggestedConstant = keyValue.type === utils_1.AST_NODE_TYPES.Literal &&
-                                            typeof keyValue.value === 'string'
-                                            ? generateAutoFix(keyValue.value)
+                                        // Only a statically known key value can be auto-fixed.
+                                        const staticKey = staticKeyOf(keyValue);
+                                        const suggestedConstant = staticKey
+                                            ? generateAutoFix(staticKey.text)
                                             : null;
                                         pendingReports.push({
                                             node: keyValue,
                                             messageId: 'enforceQueryKeyImport',
-                                            substitution: suggestedConstant &&
-                                                keyValue.type === utils_1.AST_NODE_TYPES.Literal
+                                            substitution: staticKey && suggestedConstant
                                                 ? {
-                                                    keyNode: keyValue,
+                                                    keyNode: staticKey.node,
                                                     constant: suggestedConstant,
                                                     scope: scopeOf(keyValue),
                                                 }

package/lib/rules/ensure-pointer-events-none.js

@@ -9,6 +9,34 @@ const createRule_1 = require("../utils/createRule");
 function hasPseudoElementSelector(selector) {
     return /::?(before|after)\b/i.test(selector);
 }
+/**
+ * Reads the static string a node denotes, so a property name or value carries
+ * the same meaning however it is spelled. A no-substitution template literal is
+ * a notation-only rewrite of a quoted string, and CSS-in-JS code writes both.
+ *
+ * Reading every name and value through one accessor keeps detection and the
+ * `pointerEvents` exemption on the same footing. Widening only the detection
+ * side would make the rule report objects that already set `pointerEvents` in a
+ * spelling it cannot read, and its fixer would append a second key — an object
+ * literal with duplicate keys does not compile.
+ *
+ * An interpolated template stays opaque: its text is not known statically, so
+ * the rule keeps its conservative silence there.
+ */
+function staticStringOf(node) {
+    if (node.type === utils_1.AST_NODE_TYPES.Literal) {
+        return String(node.value);
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return node.name;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+        node.expressions.length === 0 &&
+        node.quasis.length === 1) {
+        return node.quasis[0].value.cooked ?? node.quasis[0].value.raw;
+    }
+    return undefined;
+}
 /**
  * Checks if a property name is position with absolute or fixed value
  */
@@ -151,6 +179,13 @@ exports.ensurePointerEventsNone = (0, createRule_1.createRule)({
         const absolutePositionedStyles = new Map();
         // Track style objects that already have pointer-events defined
         const stylesWithPointerEvents = new Map();
+        // Track style objects that declare a `pointerEvents` key whose value cannot
+        // be read statically (a member expression, a call, a ternary, an
+        // interpolated template). Such a value earns no exemption — it might be
+        // 'auto', so the report stands — but it does veto the fix: the rule's only
+        // remedy is to append a `pointerEvents` key, and an object literal with two
+        // identical keys does not compile (TS1117).
+        const stylesWithUnreadablePointerEvents = new Map();
         // Track style objects that are hit-slop touch-target extensions: an
         // absolute/fixed overlay whose inset offsets only extend beyond the origin
         // box (>=1 negative, none positive). A browser attributes pointer events on
@@ -164,40 +199,29 @@ exports.ensurePointerEventsNone = (0, createRule_1.createRule)({
         function processStyleObject(node) {
             let hasAbsolutePosition = false;
             let pointerEventsValue;
+            let hasUnreadablePointerEvents = false;
             let hasNegativeOffset = false;
             let hasPositiveOffset = false;
             // Check each property in the style object
             for (const property of node.properties) {
                 if (property.type !== utils_1.AST_NODE_TYPES.Property)
                     continue;
-                let propertyName = '';
-                let propertyValue;
-                // Get property name
-                if (property.key.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    propertyName = property.key.name;
-                }
-                else if (property.key.type === utils_1.AST_NODE_TYPES.Literal &&
-                    typeof property.key.value === 'string') {
-                    propertyName = property.key.value;
-                }
-                // Get property value if it's a string literal
-                if (property.value.type === utils_1.AST_NODE_TYPES.Literal) {
-                    propertyValue = String(property.value.value);
-                }
-                else if (property.value.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    propertyValue = property.value.name;
-                }
+                const propertyName = staticStringOf(property.key) ?? '';
+                const propertyValue = staticStringOf(property.value);
                 // Check if this is position: absolute/fixed
                 if (isAbsoluteOrFixedPosition(propertyName, propertyValue)) {
                     hasAbsolutePosition = true;
                 }
-                // Check if this is pointer-events property
+                // Check if this is pointer-events property. A value that can be read
+                // decides the exemption; one that cannot is recorded separately, because
+                // the key's presence vetoes the fix even where it cannot prove the
+                // overlay is inert. An unreadable value never clears one already read.
                 if (isPointerEventsProperty(propertyName)) {
-                    if (property.value.type === utils_1.AST_NODE_TYPES.Literal) {
-                        pointerEventsValue = String(property.value.value);
+                    if (propertyValue !== undefined) {
+                        pointerEventsValue = propertyValue;
                     }
-                    else if (property.value.type === utils_1.AST_NODE_TYPES.Identifier) {
-                        pointerEventsValue = property.value.name;
+                    else {
+                        hasUnreadablePointerEvents = true;
                     }
                 }
                 // Track inset offsets to detect hit-slop touch-target extensions
@@ -216,6 +240,7 @@ exports.ensurePointerEventsNone = (0, createRule_1.createRule)({
             if (pointerEventsValue !== undefined) {
                 stylesWithPointerEvents.set(node, pointerEventsValue);
             }
+            stylesWithUnreadablePointerEvents.set(node, hasUnreadablePointerEvents);
             // A hit-slop extension only enlarges the tappable area: it is
             // absolute/fixed and its inset offsets extend outward (>=1 negative, none
             // positive). Such overlays cannot occlude the control they belong to.
@@ -246,6 +271,13 @@ exports.ensurePointerEventsNone = (0, createRule_1.createRule)({
                         selector: formatSelector(selector),
                     },
                     fix(fixer) {
+                        // The object already declares `pointerEvents`, but in a spelling
+                        // whose value cannot be read. Appending the key is the rule's only
+                        // remedy, and here it would emit a duplicate key that does not
+                        // compile. A report with no fix is the correct outcome: the reader
+                        // decides what the opaque value resolves to.
+                        if (stylesWithUnreadablePointerEvents.get(node))
+                            return null;
                         // Find the last property in the object
                         const sourceCode = context.sourceCode;
                         const properties = node.properties;
@@ -350,12 +382,12 @@ exports.ensurePointerEventsNone = (0, createRule_1.createRule)({
             // Process CSS-in-JS libraries that use objects with selectors
             Property(node) {
                 // Check for patterns like { '&::before': { ... } }
-                if (node.key.type === utils_1.AST_NODE_TYPES.Literal &&
-                    typeof node.key.value === 'string' &&
-                    hasPseudoElementSelector(node.key.value) &&
+                const selector = staticStringOf(node.key);
+                if (selector !== undefined &&
+                    hasPseudoElementSelector(selector) &&
                     node.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
                     processStyleObject(node.value);
-                    checkStyleObject(node.value, node.key.value);
+                    checkStyleObject(node.value, selector);
                 }
             },
         };