@blumintinc/eslint-plugin-blumint 1.20.124 → 1.20.126

package/lib/index.js

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

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

@@ -508,15 +508,30 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
             return null;
         }
         /**
-         * Generate auto-fix suggestion for string literals
+         * 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 {

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

@@ -9,6 +9,33 @@ const createRule_1 = require("../utils/createRule");
 function hasPseudoElementSelector(selector) {
     return /::?(before|after)\b/i.test(selector);
 }
+/**
+ * The four expression assertions state a type about the expression they wrap and
+ * contribute no value of their own, so `'none' as const`, `'none' satisfies
+ * string`, `('none')!` and `<const>'none'` all denote the same string as
+ * `'none'`. A read that classifies the value a property holds must look through
+ * every one of them alike, or the verdict turns on which type syntax an author
+ * reached for.
+ */
+const ASSERTION_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 isAssertion = (node) => ASSERTION_TYPES.has(node.type);
+/**
+ * Peels every assertion off a node. Assertions nest — `'none' as const
+ * satisfies string` is a satisfies over an as — so a single unwrap would still
+ * hand back a wrapper.
+ */
+function unwrapAssertions(node) {
+    let target = node;
+    while (isAssertion(target)) {
+        target = target.expression;
+    }
+    return target;
+}
 /**
  * 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
@@ -21,19 +48,22 @@ function hasPseudoElementSelector(selector) {
  * 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.
+ * the rule keeps its conservative silence there. An assertion around an opaque
+ * value is equally opaque: unwrapping reaches the expression underneath, and
+ * that expression still decides whether anything can be read.
  */
 function staticStringOf(node) {
-    if (node.type === utils_1.AST_NODE_TYPES.Literal) {
-        return String(node.value);
+    const target = unwrapAssertions(node);
+    if (target.type === utils_1.AST_NODE_TYPES.Literal) {
+        return String(target.value);
     }
-    if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
-        return node.name;
+    if (target.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return target.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;
+    if (target.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+        target.expressions.length === 0 &&
+        target.quasis.length === 1) {
+        return target.quasis[0].value.cooked ?? target.quasis[0].value.raw;
     }
     return undefined;
 }
@@ -110,7 +140,11 @@ function classifyOffsetComponents(raw) {
  * classified; variables, member expressions, and calls are treated as unknown
  * and never counted toward the hit-slop exemption.
  */
-function classifyOffsetValue(value) {
+function classifyOffsetValue(node) {
+    // An assertion states a type, not a length. Reading the position through one
+    // while leaving the offsets opaque would strip an assertion-written hit-slop
+    // overlay of its carve-out and hand it the tap-target-shrinking autofix.
+    const value = unwrapAssertions(node);
     if (value.type === utils_1.AST_NODE_TYPES.Literal) {
         if (typeof value.value === 'number') {
             if (value.value === 0)
@@ -179,6 +213,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
@@ -192,6 +233,7 @@ 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
@@ -204,12 +246,17 @@ exports.ensurePointerEventsNone = (0, createRule_1.createRule)({
                 if (isAbsoluteOrFixedPosition(propertyName, propertyValue)) {
                     hasAbsolutePosition = true;
                 }
-                // Check if this is pointer-events property. A value that cannot be read
-                // statically never clears one already read: the rule's only remedy is to
-                // append a `pointerEvents` key, which would duplicate the existing one.
-                if (isPointerEventsProperty(propertyName) &&
-                    propertyValue !== undefined) {
-                    pointerEventsValue = propertyValue;
+                // 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 (propertyValue !== undefined) {
+                        pointerEventsValue = propertyValue;
+                    }
+                    else {
+                        hasUnreadablePointerEvents = true;
+                    }
                 }
                 // Track inset offsets to detect hit-slop touch-target extensions
                 if (INSET_PROPERTIES.has(propertyName)) {
@@ -227,6 +274,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.
@@ -257,6 +305,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;

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

@@ -421,6 +421,21 @@ exports.default = (0, createRule_1.createRule)({
                                 if (!declaredVariable) {
                                     return null;
                                 }
+                                // The conversion degenerates on some names: one built only from
+                                // underscores derives the empty string, and a leading
+                                // underscore in front of a digit derives a name that starts
+                                // with that digit. Applying either trades a naming report for a
+                                // file that no longer parses — `const  = {…}` — and the rename
+                                // rewrites every reference, so the damage spreads to each use
+                                // site. Declining leaves the report standing with no fix, which
+                                // is the honest outcome: the author has to choose a real name,
+                                // and no mechanical rewrite can choose one for them. The test is
+                                // the rule's own acceptance predicate, so a derivation that
+                                // would only relocate the same report (`_$` to `$`) is declined
+                                // on the same terms.
+                                if (!isUpperSnakeCase(newName)) {
+                                    return null;
+                                }
                                 // An exported binding's name is a cross-file contract: every
                                 // importer spells it out in a file this single-file fixer
                                 // cannot reach, so renaming the declaration breaks them all

package/lib/rules/prefer-global-router-state-key.js

@@ -336,7 +336,20 @@ exports.preferGlobalRouterStateKey = (0, createRule_1.createRule)({
             return null;
         }
         /**
-         * Generate auto-fix suggestion for string literals
+         * 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 (#1804, #1811).
          */
         function generateAutoFix(keyValue) {
             const normalizedKey = keyValue
@@ -344,6 +357,9 @@ exports.preferGlobalRouterStateKey = (0, createRule_1.createRule)({
                 .replace(/[^A-Z0-9]/g, '_')
                 .replace(/_+/g, '_')
                 .replace(/^_|_$/g, '');
+            if (normalizedKey === '') {
+                return null;
+            }
             return `QUERY_KEY_${normalizedKey}`;
         }
         /**

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,56 @@
 [
+  {
+    "version": "1.20.126",
+    "date": "2026-08-06T22:42:22.372Z",
+    "rules": [
+      {
+        "name": "ensure-pointer-events-none",
+        "changeType": "fix",
+        "issues": [
+          1814
+        ],
+        "summary": "read every selector, name, value and offset through expression assertions (closes #1814)"
+      },
+      {
+        "name": "global-const-style",
+        "changeType": "fix",
+        "issues": [
+          1816
+        ],
+        "summary": "decline the rename when the derived name is not an identifier (closes #1816)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.125",
+    "date": "2026-08-06T17:33:56.677Z",
+    "rules": [
+      {
+        "name": "enforce-querykey-ts",
+        "changeType": "fix",
+        "issues": [
+          1813
+        ],
+        "summary": "decline the fix when a key normalizes to nothing (closes #1813)"
+      },
+      {
+        "name": "ensure-pointer-events-none",
+        "changeType": "fix",
+        "issues": [
+          1810
+        ],
+        "summary": "decline the fix when an existing pointerEvents value is unreadable (closes #1810)"
+      },
+      {
+        "name": "prefer-global-router-state-key",
+        "changeType": "fix",
+        "issues": [
+          1811
+        ],
+        "summary": "decline the fix when a key normalizes to nothing (closes #1811)"
+      }
+    ]
+  },
   {
     "version": "1.20.124",
     "date": "2026-08-06T15:15:14.462Z",