@blumintinc/eslint-plugin-blumint 1.19.11 → 1.19.13

package/lib/index.js

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

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

@@ -23,6 +23,52 @@ function isAbsoluteOrFixedPosition(propertyName, propertyValue) {
 function isPointerEventsProperty(propertyName) {
     return propertyName === 'pointerEvents' || propertyName === 'pointer-events';
 }
+/**
+ * The inset offsets that position a pseudo-element relative to its origin box.
+ */
+const INSET_PROPERTIES = new Set(['top', 'right', 'bottom', 'left']);
+/**
+ * Classifies the sign of a leading numeric length in a string offset value
+ * (e.g. '-6px' -> negative, '0'/'0px' -> zero, '6px' -> positive). Anything
+ * that does not start with an optional-minus number is unknown.
+ */
+function classifyOffsetString(raw) {
+    const match = raw.trim().match(/^(-?)(\d+(?:\.\d+)?|\.\d+)/);
+    if (!match)
+        return 'unknown';
+    const numericPart = parseFloat(match[2]);
+    if (numericPart === 0)
+        return 'zero';
+    return match[1] === '-' ? 'negative' : 'positive';
+}
+/**
+ * Classifies an inset offset property value (top/right/bottom/left) as a
+ * positive, negative, zero, or unknown length. Only the shapes that can be
+ * resolved statically are classified; variables, member expressions, template
+ * literals, and calls are treated as unknown and never counted toward the
+ * hit-slop exemption.
+ */
+function classifyOffsetValue(value) {
+    if (value.type === utils_1.AST_NODE_TYPES.Literal) {
+        if (typeof value.value === 'number') {
+            if (value.value === 0)
+                return 'zero';
+            return value.value < 0 ? 'negative' : 'positive';
+        }
+        if (typeof value.value === 'string') {
+            return classifyOffsetString(value.value);
+        }
+        return 'unknown';
+    }
+    // Negative numeric literals parse as `-` UnaryExpression over a number.
+    if (value.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+        value.operator === '-' &&
+        value.argument.type === utils_1.AST_NODE_TYPES.Literal &&
+        typeof value.argument.value === 'number') {
+        return value.argument.value === 0 ? 'zero' : 'negative';
+    }
+    return 'unknown';
+}
 function formatSelector(selector) {
     if (!selector)
         return 'pseudo-element';
@@ -63,12 +109,21 @@ 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 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
+        // a pseudo-element to its origin element, so such an overlay cannot occlude
+        // the control and must not be flagged (its autofix would shrink the tap
+        // target, the very accessibility regression this rule exists to prevent).
+        const hitSlopStyles = new Map();
         /**
          * Process a CSS-in-JS style object to check for position: absolute/fixed and pointer-events
          */
         function processStyleObject(node) {
             let hasAbsolutePosition = false;
             let pointerEventsValue;
+            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)
@@ -103,12 +158,26 @@ exports.ensurePointerEventsNone = (0, createRule_1.createRule)({
                         pointerEventsValue = property.value.name;
                     }
                 }
+                // Track inset offsets to detect hit-slop touch-target extensions
+                if (INSET_PROPERTIES.has(propertyName)) {
+                    const sign = classifyOffsetValue(property.value);
+                    if (sign === 'negative') {
+                        hasNegativeOffset = true;
+                    }
+                    else if (sign === 'positive') {
+                        hasPositiveOffset = true;
+                    }
+                }
             }
             // Store the results for this style object
             absolutePositionedStyles.set(node, hasAbsolutePosition);
             if (pointerEventsValue !== undefined) {
                 stylesWithPointerEvents.set(node, pointerEventsValue);
             }
+            // 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.
+            hitSlopStyles.set(node, hasAbsolutePosition && hasNegativeOffset && !hasPositiveOffset);
         }
         /**
          * Check if a style object needs pointer-events: none
@@ -117,6 +186,13 @@ exports.ensurePointerEventsNone = (0, createRule_1.createRule)({
             const isPseudoElement = selector && hasPseudoElementSelector(selector);
             const isAbsolutePositioned = absolutePositionedStyles.get(node) || false;
             const pointerEventsValue = stylesWithPointerEvents.get(node);
+            // A hit-slop touch-target extension extends the origin element's tappable
+            // area outward; because pointer events on it are attributed to the origin
+            // control, it cannot block anything. Skip reporting (and its destructive
+            // shrink-the-tap-target autofix).
+            if (hitSlopStyles.get(node)) {
+                return;
+            }
             // If this is a pseudo-element with absolute positioning but no pointer-events
             if (isPseudoElement &&
                 isAbsolutePositioned &&

package/lib/rules/test-file-location-enforcement.d.ts

@@ -1 +1,7 @@
-export declare const testFileLocationEnforcement: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"misplacedTestFile", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+type Options = [
+    {
+        additionalSubjectExtensions?: string[];
+    }?
+];
+export declare const testFileLocationEnforcement: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"misplacedTestFile", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};

package/lib/rules/test-file-location-enforcement.js

@@ -9,6 +9,10 @@ const path_1 = __importDefault(require("path"));
 const createRule_1 = require("../utils/createRule");
 const TEST_FILE_PATTERN = /\.test\.tsx?$/i;
 const SUPPORTED_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx'];
+const DEFAULT_OPTIONS = {
+    additionalSubjectExtensions: [],
+};
+const normalizeExtension = (extension) => extension.startsWith('.') ? extension : `.${extension}`;
 exports.testFileLocationEnforcement = (0, createRule_1.createRule)({
     name: 'test-file-location-enforcement',
     meta: {
@@ -17,13 +21,31 @@ exports.testFileLocationEnforcement = (0, createRule_1.createRule)({
             description: 'Enforce colocating *.test.ts or *.test.tsx files with the code they cover.',
             recommended: 'error',
         },
-        schema: [],
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    additionalSubjectExtensions: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        default: [],
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
         messages: {
             misplacedTestFile: 'Test file "{{testFile}}" is not colocated with its subject. Keep tests in the same directory as {{expectedNames}} so refactors move code and coverage together and engineers can find the implementation without searching separate test folders.',
         },
     },
-    defaultOptions: [],
-    create(context) {
+    defaultOptions: [DEFAULT_OPTIONS],
+    create(context, [options]) {
+        const resolvedOptions = { ...DEFAULT_OPTIONS, ...(options ?? {}) };
+        const additionalExtensions = (resolvedOptions.additionalSubjectExtensions ?? []).map(normalizeExtension);
+        const subjectExtensions = [
+            ...SUPPORTED_EXTENSIONS,
+            ...additionalExtensions.filter((extension) => !SUPPORTED_EXTENSIONS.includes(extension)),
+        ];
         return {
             Program(node) {
                 const filename = context.getFilename();
@@ -36,7 +58,7 @@ exports.testFileLocationEnforcement = (0, createRule_1.createRule)({
                 const directory = path_1.default.dirname(filename);
                 const testFileName = path_1.default.basename(filename);
                 const baseName = testFileName.replace(TEST_FILE_PATTERN, '');
-                const candidates = SUPPORTED_EXTENSIONS.map((extension) => path_1.default.join(directory, `${baseName}${extension}`));
+                const candidates = subjectExtensions.map((extension) => path_1.default.join(directory, `${baseName}${extension}`));
                 const hasSibling = candidates.some((candidate) => fs_1.default.existsSync(candidate));
                 if (hasSibling) {
                     return;
@@ -44,7 +66,9 @@ exports.testFileLocationEnforcement = (0, createRule_1.createRule)({
                 const relativePath = path_1.default.isAbsolute(filename)
                     ? path_1.default.relative(process.cwd(), filename) || filename
                     : filename;
-                const expectedNames = SUPPORTED_EXTENSIONS.map((extension) => `"${baseName}${extension}"`).join(' or ');
+                const expectedNames = subjectExtensions
+                    .map((extension) => `"${baseName}${extension}"`)
+                    .join(' or ');
                 context.report({
                     node,
                     messageId: 'misplacedTestFile',

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.19.13",
+    "date": "2026-07-17T21:25:11.513Z",
+    "rules": [
+      {
+        "name": "ensure-pointer-events-none",
+        "changeType": "fix",
+        "issues": [
+          1315
+        ],
+        "summary": "exempt hit-slop touch-target pseudo-elements (closes #1315)"
+      }
+    ]
+  },
+  {
+    "version": "1.19.12",
+    "date": "2026-07-17T19:23:55.157Z",
+    "rules": [
+      {
+        "name": "test-file-location-enforcement",
+        "changeType": "fix",
+        "issues": [
+          1314
+        ],
+        "summary": "add opt-in additionalSubjectExtensions for non-JS/TS subjects (closes #1314)"
+      }
+    ]
+  },
   {
     "version": "1.19.11",
     "date": "2026-07-17T10:46:20.593Z",