@blumintinc/eslint-plugin-blumint 1.20.125 → 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.125',
+        version: '1.20.126',
     },
     parseOptions: {
         ecmaVersion: 2020,

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)

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/package.json

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

package/release-manifest.json

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