@blumintinc/eslint-plugin-blumint 1.20.124 → 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.124',
+        version: '1.20.125',
     },
     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

@@ -179,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
@@ -192,6 +199,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 +212,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 +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.
@@ -257,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;

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.125",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

@@ -1,4 +1,34 @@
 [
+  {
+    "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",