@blumintinc/eslint-plugin-blumint 1.19.12 → 1.19.14

package/lib/index.js

@@ -222,7 +222,7 @@ function noFrontendImportsFromFunctionsPatterns(pattern) {
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.19.12',
+        version: '1.19.14',
     },
     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/require-props-composition.js

@@ -118,6 +118,13 @@ function getTypeReferenceName(node) {
 function typeNodeComposesWithProps(typeNode, propsTypeName) {
     switch (typeNode.type) {
         case utils_1.AST_NODE_TYPES.TSTypeReference: {
+            // A direct reference to the child's whole props type (bare `ChildProps`
+            // or generic-instantiated `ChildProps<T>`) is the maximal form of
+            // composition: the entire surface is inherited verbatim, strictly
+            // stronger than Pick/Omit, so no duplication/drift is possible.
+            if (getTypeReferenceName(typeNode) === propsTypeName) {
+                return true;
+            }
             if (typeReferenceContainsPickOrOmit(typeNode, propsTypeName)) {
                 return true;
             }
@@ -313,6 +320,16 @@ function findComponentFunction(program, name, seen = new Set()) {
     }
     return null;
 }
+/**
+ * A rendered child that resolves in-file to a component function taking no
+ * parameters has no props surface to compose with, so it is not a composition
+ * dependency (same category as a decorative icon). Only in-file resolution is
+ * used; imported children are left to the normal composition check.
+ */
+function isZeroPropComponent(program, name) {
+    const fn = findComponentFunction(program, name);
+    return fn !== null && fn.params.length === 0;
+}
 /**
  * Resolve the type node that defines a rendered dependency's props: its
  * `{Dep}Props` alias if one exists, otherwise the dependency component's
@@ -446,7 +463,8 @@ exports.requirePropsComposition = (0, createRule_1.createRule)({
             // Filter to non-excluded custom components
             const depComponents = Array.from(allJsxNames).filter((name) => !excludeComponents.has(name) &&
                 !isDecorativeIcon(name) &&
-                name !== componentName);
+                name !== componentName &&
+                !isZeroPropComponent(prog, name));
             if (depComponents.length < minDependencyCount) {
                 return;
             }

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.19.14",
+    "date": "2026-07-17T21:35:22.880Z",
+    "rules": [
+      {
+        "name": "require-props-composition",
+        "changeType": "fix",
+        "issues": [
+          1316
+        ],
+        "summary": "recognize direct whole-props refs and skip zero-prop children (closes #1316)"
+      }
+    ]
+  },
+  {
+    "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",