pour-engine 1.27.0 → 1.28.0

package/config/project.config.js

@@ -6,6 +6,6 @@
 export default {
   engine: {
     name: 'pour engine',
-    version: '1.27.0',
+    version: '1.28.0',
   },
 };

package/engine/lib/contrast.js

@@ -130,6 +130,7 @@ let opacityAnimatorsCache = null;
 let mediaRectsCache = null;
 let panelRectsCache = null;
 let pseudoCache = new WeakMap();
+let zeroClipCache = new WeakMap();
 const HAS_IMAGE = Symbol('background-image in chain');
 
 export function resetAuditCaches() {
@@ -139,6 +140,49 @@ export function resetAuditCaches() {
   mediaRectsCache = null;
   panelRectsCache = null;
   pseudoCache = new WeakMap();
+  zeroClipCache = new WeakMap();
+}
+
+/**
+ * True when the element sits inside a subtree erased by a ZERO-AREA clip —
+ * the sr-only recipe (clip: rect(0,0,0,0) / clip-path: inset(50%) on an
+ * absolutely positioned wrapper) applied to an ANCESTOR, which is where it
+ * usually lives: a chart's accessible data table hides the table, and the
+ * judged element is a cell inside it. Only provably zero-area patterns
+ * count: a clip rect with no width or height (any `auto` component keeps
+ * the element judged), or a percentage inset consuming a full axis.
+ * Partial clips never hide. Verdicts cache per ancestor, so a page pays
+ * per container, not per descendant.
+ */
+export function inZeroClipSubtree(element) {
+  for (let a = element; a; a = a.parentElement) {
+    let hidden = zeroClipCache.get(a);
+    if (hidden === undefined) {
+      const s = getComputedStyle(a);
+      hidden = false;
+      if (s.clip !== 'auto' && s.position !== 'static') {
+        const m = /rect\(([^)]+)\)/.exec(s.clip);
+        if (m) {
+          const parts = m[1].split(',').map((v) => v.trim());
+          if (!parts.includes('auto') && parts.length === 4) {
+            const [t, r, b, l] = parts.map(parseFloat);
+            if (r - l <= 0 || b - t <= 0) hidden = true;
+          }
+        }
+      }
+      if (!hidden && s.clipPath && s.clipPath !== 'none') {
+        const m = /inset\(([^)]+)\)/.exec(s.clipPath);
+        if (m && !m[1].includes('px')) {
+          const parts = m[1].trim().split(/\s+/).map(parseFloat);
+          const [t, r = t, b = t, l = r] = parts;
+          if (t + b >= 100 || l + r >= 100) hidden = true;
+        }
+      }
+      zeroClipCache.set(a, hidden);
+    }
+    if (hidden) return true;
+  }
+  return false;
 }
 
 /**

package/engine/rules/wcag/1.4.3-color-contrast.js

@@ -3,7 +3,7 @@ import {
   parseColor, contrastRatio, composite, effectiveBackground, backgroundObscured,
   backgroundImageSource, backgroundImagePaintRect, imagePaintRectInBox, imageLuminanceRange,
   gradientLuminanceRange, rangeVerdict, rangeWithBackdrop, isLargeText, cumulativeOpacity,
-  opacityAnimating, restingOpacity, mediaRects,
+  opacityAnimating, restingOpacity, mediaRects, inZeroClipSubtree,
   paintedBackdrop, opaquePanelRects, viewportVeil, textShadowHalo, textShadowNegligible,
   pseudoBackdropForText, filmedContrastBounds, backgroundColorSource, scrimPaint, applyOverlays,
   showRatio,
@@ -138,13 +138,15 @@ function textVisuallyHidden(element, style, foreground) {
   const indent = parseFloat(style.textIndent) || 0;
   const clipped = /hidden|clip/.test(`${style.overflow} ${style.overflowX} ${style.overflowY}`)
     || style.clipPath !== 'none' || (style.clip !== 'auto' && style.position === 'absolute');
-  // Nothing hints at hiding: skip the getBoundingClientRect layout read —
-  // this runs for every text element on the page, and most are plainly shown.
-  if (!clipped && Math.abs(indent) <= 1000) return false;
+  // Nothing on the element itself hints at hiding: the recipe may still sit
+  // on a WRAPPER (a chart's sr-only data table hides the table; the judged
+  // cell inside computes clip: auto) — the ancestor walk is cached per
+  // container, so this stays affordable on every text element.
+  if (!clipped && Math.abs(indent) <= 1000) return inZeroClipSubtree(element);
   const rect = element.getBoundingClientRect();
   if ((rect.width <= 1 || rect.height <= 1) && clipped) return true;
   if (Math.abs(indent) > rect.width && (clipped || Math.abs(indent) > 1000)) return true;
-  return false;
+  return inZeroClipSubtree(element);
 }
 
 // Turn a luminance-range bracket into a rule outcome (or null = can't tell).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pour-engine",
-  "version": "1.27.0",
+  "version": "1.28.0",
   "description": "Accessibility (WCAG 2.2) audit engine written from the W3C specifications — runs entirely in the browser, no dependencies.",
   "type": "module",
   "main": "engine/index.js",