@qualweb/act-rules 0.7.7 → 0.8.1

package/dist/rules/QW-ACT-R30.js

@@ -17,7 +17,7 @@ class QW_ACT_R30 extends AtomicRule_object_1.AtomicRule {
     execute(element) {
         const test = new evaluation_1.Test();
         const accessibleName = window.AccessibilityUtils.getAccessibleName(element);
-        const elementText = window.DomUtils.getTrimmedText(element);
+        const elementText = window.DomUtils.getVisibleText(element);
         const isIconValue = this.isIcon(elementText, accessibleName, element);
         if (accessibleName === undefined) {
             test.verdict = evaluation_1.Verdict.FAILED;

package/dist/rules/QW-ACT-R37.d.ts

@@ -1,14 +1,20 @@
 import type { QWElement } from '@qualweb/qw-element';
 import { AtomicRule } from '../lib/AtomicRule.object';
 declare class QW_ACT_R37 extends AtomicRule {
+    private disabledSelectorCache?;
     execute(element: QWElement): void;
-    private isHumanLanguage;
+    private getDisabledSelectors;
+    private isDisabledGroup;
+    private hasDisqualifyingShadow;
+    private splitShadowLayers;
+    private shadowLengthToPx;
+    private resolveSolidBackground;
+    private getBackground;
+    private isImage;
     private evaluateGradient;
+    private gradientStopsToCheck;
     private parseGradientString;
     private getColorInGradient;
-    private getTextSize;
-    private getBackground;
-    private isImage;
     private parseRGBString;
     private flattenColors;
     private getContrast;
@@ -16,6 +22,10 @@ declare class QW_ACT_R37 extends AtomicRule {
     private hasValidContrastRatio;
     private isBold;
     private equals;
+    private isFullyTransparent;
+    private isHumanLanguage;
+    private getTextSize;
+    private emit;
 }
 export { QW_ACT_R37 };
 //# sourceMappingURL=QW-ACT-R37.d.ts.map

package/dist/rules/QW-ACT-R37.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"QW-ACT-R37.d.ts","sourceRoot":"","sources":["../../src/rules/QW-ACT-R37.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAQrD,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAUtD,cAAM,UAAW,SAAQ,UAAU;IAKjC,OAAO,CAAC,OAAO,EAAE,SAAS,GAAG,IAAI;IAqIjC,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,gBAAgB;IA+BxB,OAAO,CAAC,mBAAmB;IAW3B,OAAO,CAAC,kBAAkB;IAS1B,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,OAAO;IAKf,OAAO,CAAC,cAAc;IAkBtB,OAAO,CAAC,aAAa;IAUrB,OAAO,CAAC,WAAW;IAOnB,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,qBAAqB;IAM7B,OAAO,CAAC,MAAM;IAId,OAAO,CAAC,MAAM;CAGf;AAED,OAAO,EAAE,UAAU,EAAE,CAAC"}
+{"version":3,"file":"QW-ACT-R37.d.ts","sourceRoot":"","sources":["../../src/rules/QW-ACT-R37.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAQrD,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AA2BtD,cAAM,UAAW,SAAQ,UAAU;IAEjC,OAAO,CAAC,qBAAqB,CAAC,CAA8C;IAM5E,OAAO,CAAC,OAAO,EAAE,SAAS,GAAG,IAAI;IA+FjC,OAAO,CAAC,oBAAoB;IA6B5B,OAAO,CAAC,eAAe;IAgBvB,OAAO,CAAC,sBAAsB;IAoB9B,OAAO,CAAC,iBAAiB;IAqBzB,OAAO,CAAC,gBAAgB;IAoBxB,OAAO,CAAC,sBAAsB;IA8B9B,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,OAAO;IASf,OAAO,CAAC,gBAAgB;IAgDxB,OAAO,CAAC,oBAAoB;IA2B5B,OAAO,CAAC,mBAAmB;IAW3B,OAAO,CAAC,kBAAkB;IAe1B,OAAO,CAAC,cAAc;IAiCtB,OAAO,CAAC,aAAa;IAUrB,OAAO,CAAC,WAAW;IAOnB,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,qBAAqB;IAM7B,OAAO,CAAC,MAAM;IAId,OAAO,CAAC,MAAM;IAId,OAAO,CAAC,kBAAkB;IAQ1B,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,IAAI;CAMb;AAED,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/rules/QW-ACT-R37.js

@@ -17,172 +17,233 @@ const applicability_1 = require("@qualweb/util/applicability");
 const evaluation_1 = require("@qualweb/core/evaluation");
 const AtomicRule_object_1 = require("../lib/AtomicRule.object");
 const colorjs_io_1 = __importDefault(require("colorjs.io"));
+const WHITE = { red: 255, green: 255, blue: 255, alpha: 1 };
+const INPUT_TAGS = ['input', 'select', 'textarea'];
+const GRADIENT_REGEX = /((\w-?)*gradient.*)/gm;
 class QW_ACT_R37 extends AtomicRule_object_1.AtomicRule {
     execute(element) {
         var _a;
-        const visible = window.DomUtils.isElementVisible(element);
-        if (!visible)
+        if (!window.DomUtils.isElementVisible(element))
             return;
         const nodeName = element.getElementTagName();
-        const isInputField = ['input', 'select', 'textarea'].includes(nodeName);
+        const isInputField = INPUT_TAGS.includes(nodeName);
         const elementText = element.getElementOwnText().trim();
         const placeholder = (_a = element.getElementAttribute('placeholder')) === null || _a === void 0 ? void 0 : _a.trim();
-        if (elementText === '' && !isInputField && !placeholder) {
+        if (elementText === '' && !isInputField && !placeholder)
             return;
-        }
         if (!element.isElementHTMLElement())
             return;
-        const disabledWidgets = window.disabledWidgets;
-        const elementSelectors = element.getElementSelector();
-        for (const disableWidget of disabledWidgets || []) {
-            const selectorsResult = window.AccessibilityUtils.getAccessibleNameSelector(disableWidget);
-            const selectors = typeof selectorsResult === 'string' ? [selectorsResult] : selectorsResult;
-            if (disableWidget && selectors && selectors.includes(elementSelectors))
-                return;
-            if (disableWidget.getElementSelector() === elementSelectors)
-                return;
-            const children = disableWidget.getElementChildren();
-            if (children) {
-                for (const child of children) {
-                    if (child.getElementSelector() === elementSelectors)
-                        return;
-                }
-            }
-        }
-        const role = window.AccessibilityUtils.getElementRole(element);
-        if (role === 'group') {
-            const disable = element.getElementAttribute('disabled') !== null;
-            const ariaDisable = element.getElementAttribute('aria-disabled') !== null;
-            if (disable || ariaDisable)
-                return;
-        }
-        const test = new evaluation_1.Test();
+        const elementSelector = element.getElementSelector();
+        if (this.getDisabledSelectors(window.disabledWidgets).has(elementSelector))
+            return;
+        if (this.isDisabledGroup(element))
+            return;
         const fgColor = element.getElementStyleProperty('color', null);
-        let bgColor = this.getBackground(element);
+        const bgColor = this.getBackground(element);
         const opacity = parseFloat(element.getElementStyleProperty('opacity', null) || '1');
         const fontSize = element.getElementStyleProperty('font-size', null);
         const fontWeight = element.getElementStyleProperty('font-weight', null);
         const fontFamily = element.getElementStyleProperty('font-family', null);
         const fontStyle = element.getElementStyleProperty('font-style', null);
         const textShadow = element.getElementStyleProperty('text-shadow', null);
-        if (textShadow && textShadow.trim() !== 'none' && textShadow.trim() !== '') {
-            const pixelValues = textShadow.match(/(-?\d+px)/g);
-            if (pixelValues && pixelValues.length >= 3) {
-                const hs = Math.abs(parseInt(pixelValues[0].replace('px', ''), 10));
-                const vs = Math.abs(parseInt(pixelValues[1].replace('px', ''), 10));
-                const blur = parseInt(pixelValues[2].replace('px', ''), 10);
-                if (blur > 0 || hs > 1 || vs > 1) {
-                    test.verdict = evaluation_1.Verdict.WARNING;
-                    test.resultCode = 'W1';
-                    test.addElement(element);
-                    this.addTestResult(test);
-                    return;
-                }
-            }
+        const test = new evaluation_1.Test();
+        if (this.hasDisqualifyingShadow(textShadow, parseFloat(fontSize))) {
+            this.emit(test, element, evaluation_1.Verdict.WARNING, 'W1');
+            return;
         }
         if (this.isImage(bgColor)) {
-            test.verdict = evaluation_1.Verdict.WARNING;
-            test.resultCode = 'W2';
-            test.addElement(element);
-            this.addTestResult(test);
+            this.emit(test, element, evaluation_1.Verdict.WARNING, 'W2');
             return;
         }
-        const regexGradient = /((\w-?)*gradient.*)/gm;
-        let regexGradientMatches = bgColor.match(regexGradient);
-        if (regexGradientMatches) {
-            if (this.isHumanLanguage(elementText || placeholder || "")) {
-                this.evaluateGradient(test, element, regexGradientMatches[0], fgColor, opacity, fontSize, fontWeight, fontStyle, fontFamily, elementText || placeholder || "");
+        const gradientMatch = bgColor.match(GRADIENT_REGEX);
+        if (gradientMatch) {
+            const text = elementText || placeholder || '';
+            if (this.isHumanLanguage(text)) {
+                this.evaluateGradient(test, element, gradientMatch[0], fgColor, opacity, fontSize, fontWeight, fontStyle, fontFamily, text);
             }
             else {
-                test.verdict = evaluation_1.Verdict.PASSED;
-                test.resultCode = 'P2';
-                test.addElement(element);
-                this.addTestResult(test);
+                this.emit(test, element, evaluation_1.Verdict.PASSED, 'P2');
             }
             return;
         }
-        let parsedBG = this.parseRGBString(bgColor);
-        if (parsedBG)
-            parsedBG.alpha *= opacity;
-        let elementAux = element;
-        while (!parsedBG || (parsedBG.red === 0 && parsedBG.green === 0 && parsedBG.blue === 0 && parsedBG.alpha === 0)) {
-            const parent = elementAux.getElementParent();
-            if (!parent)
-                break;
-            const parentOpacity = parseFloat(parent.getElementStyleProperty('opacity', null) || '1');
-            parsedBG = this.parseRGBString(this.getBackground(parent));
-            if (parsedBG)
-                parsedBG.alpha *= parentOpacity;
-            elementAux = parent;
+        const background = this.resolveSolidBackground(element, opacity);
+        if (background.kind === 'cantTell') {
+            this.emit(test, element, evaluation_1.Verdict.WARNING, background.resultCode);
+            return;
         }
-        if (!parsedBG || parsedBG.alpha === 0) {
-            parsedBG = { red: 255, green: 255, blue: 255, alpha: 1 };
+        const parsedBG = background.color;
+        const parsedFG = this.parseRGBString(fgColor);
+        if (!parsedFG)
+            return;
+        parsedFG.alpha *= opacity;
+        if (this.equals(parsedBG, parsedFG))
+            return;
+        const textToVerify = elementText || placeholder || '';
+        if (!this.isHumanLanguage(textToVerify)) {
+            this.emit(test, element, evaluation_1.Verdict.PASSED, 'P2');
+            return;
         }
-        if (parsedBG.alpha < 1) {
-            parsedBG = this.flattenColors(parsedBG, { red: 255, green: 255, blue: 255, alpha: 1 });
+        const contrastRatio = this.getContrast(parsedBG, parsedFG);
+        const isValid = this.hasValidContrastRatio(contrastRatio, fontSize, this.isBold(fontWeight));
+        this.emit(test, element, isValid ? evaluation_1.Verdict.PASSED : evaluation_1.Verdict.FAILED, isValid ? 'P1' : 'F1');
+    }
+    getDisabledSelectors(widgets) {
+        var _a;
+        const cache = this.disabledSelectorCache;
+        if (cache && cache.source === widgets) {
+            return cache.selectors;
         }
-        const parsedFG = this.parseRGBString(fgColor);
-        if (parsedFG) {
-            parsedFG.alpha *= opacity;
-            if (!this.equals(parsedBG, parsedFG)) {
-                const textToVerify = elementText || placeholder || "";
-                if (this.isHumanLanguage(textToVerify)) {
-                    const contrastRatio = this.getContrast(parsedBG, parsedFG);
-                    const isValid = this.hasValidContrastRatio(contrastRatio, fontSize, this.isBold(fontWeight));
-                    test.verdict = isValid ? evaluation_1.Verdict.PASSED : evaluation_1.Verdict.FAILED;
-                    test.resultCode = isValid ? 'P1' : 'F1';
-                    test.addElement(element);
-                    this.addTestResult(test);
-                }
-                else {
-                    test.verdict = evaluation_1.Verdict.PASSED;
-                    test.resultCode = 'P2';
-                    test.addElement(element);
-                    this.addTestResult(test);
-                }
+        const selectors = new Set();
+        for (const widget of widgets !== null && widgets !== void 0 ? widgets : []) {
+            const accNameSelectors = window.AccessibilityUtils.getAccessibleNameSelector(widget);
+            if (typeof accNameSelectors === 'string') {
+                selectors.add(accNameSelectors);
+            }
+            else if (Array.isArray(accNameSelectors)) {
+                for (const selector of accNameSelectors)
+                    selectors.add(selector);
+            }
+            selectors.add(widget.getElementSelector());
+            for (const child of (_a = widget.getElementChildren()) !== null && _a !== void 0 ? _a : []) {
+                selectors.add(child.getElementSelector());
             }
         }
+        this.disabledSelectorCache = { source: widgets, selectors };
+        return selectors;
     }
-    isHumanLanguage(text) {
-        return window.DomUtils.isHumanLanguage(text);
+    isDisabledGroup(element) {
+        if (window.AccessibilityUtils.getElementRole(element) !== 'group')
+            return false;
+        const disabled = element.getElementAttribute('disabled') !== null;
+        const ariaDisabled = element.getElementAttribute('aria-disabled') === 'true';
+        return disabled || ariaDisabled;
     }
-    evaluateGradient(test, element, parsedGradientString, fgColor, opacity, fontSize, fontWeight, fontStyle, fontFamily, elementText) {
-        if (parsedGradientString.startsWith('linear-gradient')) {
-            const colors = this.parseGradientString(parsedGradientString);
-            let isValid = true;
-            const parsedFG = this.parseRGBString(fgColor);
-            if (!parsedFG)
-                return false;
-            parsedFG.alpha *= opacity;
-            const textSize = this.getTextSize(fontFamily.toLowerCase().replace(/['"]+/g, ''), parseInt(fontSize.replace('px', '')), this.isBold(fontWeight), fontStyle.toLowerCase().includes('italic'), elementText);
-            if (textSize !== -1) {
-                const elementWidth = element.getElementStyleProperty('width', null);
-                const lastCharRatio = textSize / parseInt(elementWidth.replace('px', ''));
-                const lastCharBgColor = this.getColorInGradient(colors[0], colors[colors.length - 1], lastCharRatio);
-                isValid = isValid && this.hasValidContrastRatio(this.getContrast(colors[0], parsedFG), fontSize, this.isBold(fontWeight));
-                isValid = isValid && this.hasValidContrastRatio(this.getContrast(lastCharBgColor, parsedFG), fontSize, this.isBold(fontWeight));
+    hasDisqualifyingShadow(textShadow, fontSizePx) {
+        if (!textShadow)
+            return false;
+        const trimmed = textShadow.trim();
+        if (trimmed === '' || trimmed === 'none')
+            return false;
+        for (const layer of this.splitShadowLayers(trimmed)) {
+            const lengths = layer.match(/-?\d*\.?\d+(px|rem|em)/g);
+            if (!lengths || lengths.length < 2)
+                continue;
+            const horizontal = Math.abs(this.shadowLengthToPx(lengths[0], fontSizePx));
+            const vertical = Math.abs(this.shadowLengthToPx(lengths[1], fontSizePx));
+            const blur = lengths[2] ? this.shadowLengthToPx(lengths[2], fontSizePx) : 0;
+            if (blur > 0 || horizontal > 1 || vertical > 1)
+                return true;
+        }
+        return false;
+    }
+    splitShadowLayers(value) {
+        const layers = [];
+        let depth = 0;
+        let current = '';
+        for (const char of value) {
+            if (char === '(')
+                depth++;
+            else if (char === ')')
+                depth = Math.max(0, depth - 1);
+            if (char === ',' && depth === 0) {
+                layers.push(current.trim());
+                current = '';
             }
             else {
-                for (const color of colors) {
-                    isValid = isValid && this.hasValidContrastRatio(this.getContrast(color, parsedFG), fontSize, this.isBold(fontWeight));
-                }
+                current += char;
             }
-            test.verdict = isValid ? evaluation_1.Verdict.PASSED : evaluation_1.Verdict.FAILED;
-            test.resultCode = isValid ? 'P3' : 'F2';
         }
-        else {
-            test.verdict = evaluation_1.Verdict.WARNING;
-            test.resultCode = 'W3';
+        if (current.trim())
+            layers.push(current.trim());
+        return layers;
+    }
+    shadowLengthToPx(length, fontSizePx) {
+        const numeric = parseFloat(length);
+        if (length.endsWith('rem'))
+            return numeric * 16;
+        if (length.endsWith('em'))
+            return numeric * (Number.isFinite(fontSizePx) ? fontSizePx : 16);
+        return numeric;
+    }
+    resolveSolidBackground(element, opacity) {
+        let parsed = this.parseRGBString(this.getBackground(element));
+        if (parsed)
+            parsed.alpha *= opacity;
+        let current = element;
+        while (!parsed || this.isFullyTransparent(parsed)) {
+            const parent = current.getElementParent();
+            if (!parent)
+                break;
+            const parentBg = this.getBackground(parent);
+            if (this.isImage(parentBg))
+                return { kind: 'cantTell', resultCode: 'W2' };
+            if (parentBg.match(GRADIENT_REGEX))
+                return { kind: 'cantTell', resultCode: 'W3' };
+            const parentOpacity = parseFloat(parent.getElementStyleProperty('opacity', null) || '1');
+            parsed = this.parseRGBString(parentBg);
+            if (parsed)
+                parsed.alpha *= parentOpacity;
+            current = parent;
         }
-        test.addElement(element);
-        this.addTestResult(test);
-        return true;
+        if (!parsed || parsed.alpha === 0) {
+            parsed = Object.assign({}, WHITE);
+        }
+        if (parsed.alpha < 1) {
+            parsed = this.flattenColors(parsed, WHITE);
+        }
+        return { kind: 'color', color: parsed };
+    }
+    getBackground(element) {
+        const bgImg = element.getElementStyleProperty('background-image', null);
+        if (bgImg && bgImg !== 'none' && bgImg !== '')
+            return bgImg;
+        const bgColor = element.getElementStyleProperty('background-color', null);
+        return bgColor && bgColor !== '' && bgColor !== 'transparent'
+            ? bgColor
+            : element.getElementStyleProperty('background', null);
+    }
+    isImage(background) {
+        const lower = background.toLowerCase();
+        return lower.includes('.jpg') || lower.includes('.png') || lower.includes('.svg') || lower.includes('url(');
+    }
+    evaluateGradient(test, element, parsedGradientString, fgColor, opacity, fontSize, fontWeight, fontStyle, fontFamily, elementText) {
+        if (!parsedGradientString.startsWith('linear-gradient')) {
+            this.emit(test, element, evaluation_1.Verdict.WARNING, 'W3');
+            return;
+        }
+        const colors = this.parseGradientString(parsedGradientString);
+        if (colors.length === 0) {
+            this.emit(test, element, evaluation_1.Verdict.WARNING, 'W3');
+            return;
+        }
+        const parsedFG = this.parseRGBString(fgColor);
+        if (!parsedFG) {
+            this.emit(test, element, evaluation_1.Verdict.WARNING, 'W3');
+            return;
+        }
+        parsedFG.alpha *= opacity;
+        const bold = this.isBold(fontWeight);
+        const stopsToCheck = this.gradientStopsToCheck(element, colors, fontSize, fontWeight, fontStyle, fontFamily, elementText);
+        const isValid = stopsToCheck.every((stop) => this.hasValidContrastRatio(this.getContrast(stop, parsedFG), fontSize, bold));
+        this.emit(test, element, isValid ? evaluation_1.Verdict.PASSED : evaluation_1.Verdict.FAILED, isValid ? 'P3' : 'F2');
+    }
+    gradientStopsToCheck(element, colors, fontSize, fontWeight, fontStyle, fontFamily, elementText) {
+        var _a;
+        const textSize = this.getTextSize(fontFamily.toLowerCase().replace(/['"]+/g, ''), parseInt(fontSize.replace('px', ''), 10), this.isBold(fontWeight), fontStyle.toLowerCase().includes('italic'), elementText);
+        const elementWidth = parseInt(((_a = element.getElementStyleProperty('width', null)) !== null && _a !== void 0 ? _a : '').replace('px', ''), 10);
+        if (textSize !== -1 && Number.isFinite(elementWidth) && elementWidth > 0) {
+            const lastCharRatio = textSize / elementWidth;
+            const lastCharColor = this.getColorInGradient(colors[0], colors[colors.length - 1], lastCharRatio);
+            return [colors[0], lastCharColor];
+        }
+        return colors;
     }
     parseGradientString(gradient) {
+        var _a;
         const regex = /rgb(a?)\((\d+), (\d+), (\d+)+(, +(\d)+)?\)/gm;
-        const colorsMatch = gradient.match(regex);
+        const matches = (_a = gradient.match(regex)) !== null && _a !== void 0 ? _a : [];
         const colors = [];
-        for (const stringColor of colorsMatch || []) {
+        for (const stringColor of matches) {
             const parsed = this.parseRGBString(stringColor);
             if (parsed)
                 colors.push(parsed);
@@ -190,48 +251,42 @@ class QW_ACT_R37 extends AtomicRule_object_1.AtomicRule {
         return colors;
     }
     getColorInGradient(fromColor, toColor, ratio) {
+        const r = Math.max(0, Math.min(1, ratio));
         return {
-            red: fromColor.red + (toColor.red - fromColor.red) * ratio,
-            green: fromColor.green + (toColor.green - fromColor.green) * ratio,
-            blue: fromColor.blue + (toColor.blue - fromColor.blue) * ratio,
+            red: fromColor.red + (toColor.red - fromColor.red) * r,
+            green: fromColor.green + (toColor.green - fromColor.green) * r,
+            blue: fromColor.blue + (toColor.blue - fromColor.blue) * r,
             alpha: 1
         };
     }
-    getTextSize(font, fontSize, bold, italic, text) {
-        return window.DomUtils.getTextSize(font, fontSize, bold, italic, text);
-    }
-    getBackground(element) {
-        const bgImg = element.getElementStyleProperty('background-image', null);
-        if (bgImg && bgImg !== 'none' && bgImg !== '')
-            return bgImg;
-        const bgColor = element.getElementStyleProperty('background-color', null);
-        return (bgColor && bgColor !== '' && bgColor !== 'transparent') ? bgColor : element.getElementStyleProperty('background', null);
-    }
-    isImage(s) {
-        const lower = s.toLowerCase();
-        return lower.includes('.jpg') || lower.includes('.png') || lower.includes('.svg') || lower.includes('url(');
-    }
     parseRGBString(colorString) {
         var _a;
-        if (!colorString || colorString === 'transparent' || colorString === 'none')
+        if (!colorString || colorString === 'transparent' || colorString === 'none') {
             return { red: 0, green: 0, blue: 0, alpha: 0 };
+        }
         const rgb = colorString.match(/^rgb\((\d+), (\d+), (\d+)\)/);
-        if (rgb)
-            return { red: parseInt(rgb[1]), green: parseInt(rgb[2]), blue: parseInt(rgb[3]), alpha: 1.0 };
+        if (rgb) {
+            return { red: parseInt(rgb[1], 10), green: parseInt(rgb[2], 10), blue: parseInt(rgb[3], 10), alpha: 1.0 };
+        }
         const rgba = colorString.match(/^rgba\((\d+), (\d+), (\d+), (\d*(\.\d+)?)\)/);
-        if (rgba)
-            return { red: parseInt(rgba[1]), green: parseInt(rgba[2]), blue: parseInt(rgba[3]), alpha: Math.round(parseFloat(rgba[4]) * 100) / 100 };
+        if (rgba) {
+            return {
+                red: parseInt(rgba[1], 10),
+                green: parseInt(rgba[2], 10),
+                blue: parseInt(rgba[3], 10),
+                alpha: Math.round(parseFloat(rgba[4]) * 100) / 100
+            };
+        }
         try {
-            const color = new colorjs_io_1.default(colorString);
-            const srgb = color.to('srgb');
+            const srgb = new colorjs_io_1.default(colorString).to('srgb');
             return {
                 red: Math.round(srgb.coords[0] * 255),
                 green: Math.round(srgb.coords[1] * 255),
                 blue: Math.round(srgb.coords[2] * 255),
-                alpha: (_a = color.alpha) !== null && _a !== void 0 ? _a : 1
+                alpha: (_a = srgb.alpha) !== null && _a !== void 0 ? _a : 1
             };
         }
-        catch (e) {
+        catch (_b) {
             return undefined;
         }
     }
@@ -251,16 +306,16 @@ class QW_ACT_R37 extends AtomicRule_object_1.AtomicRule {
         return (Math.max(L1, L2) + 0.05) / (Math.min(L1, L2) + 0.05);
     }
     getLuminance(c) {
-        const a = [c.red, c.green, c.blue].map(v => {
-            v /= 255;
+        const [r, g, b] = [c.red, c.green, c.blue].map((value) => {
+            const v = value / 255;
             return v <= 0.03928 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
         });
-        return a[0] * 0.2126 + a[1] * 0.7152 + a[2] * 0.0722;
+        return r * 0.2126 + g * 0.7152 + b * 0.0722;
     }
     hasValidContrastRatio(contrast, fontSize, isBold) {
         const size = parseFloat(fontSize);
         const threshold = (isBold && size >= 18.66) || size >= 24 ? 3 : 4.5;
-        return (contrast + 0.02) >= threshold;
+        return contrast + 0.02 >= threshold;
     }
     isBold(fontWeight) {
         return !!fontWeight && ['bold', 'bolder', '700', '800', '900'].includes(fontWeight);
@@ -268,6 +323,21 @@ class QW_ACT_R37 extends AtomicRule_object_1.AtomicRule {
     equals(c1, c2) {
         return c1.red === c2.red && c1.green === c2.green && c1.blue === c2.blue && c1.alpha === c2.alpha;
     }
+    isFullyTransparent(c) {
+        return c.red === 0 && c.green === 0 && c.blue === 0 && c.alpha === 0;
+    }
+    isHumanLanguage(text) {
+        return window.DomUtils.isHumanLanguage(text);
+    }
+    getTextSize(font, fontSize, bold, italic, text) {
+        return window.DomUtils.getTextSize(font, fontSize, bold, italic, text);
+    }
+    emit(test, element, verdict, resultCode) {
+        test.verdict = verdict;
+        test.resultCode = resultCode;
+        test.addElement(element);
+        this.addTestResult(test);
+    }
 }
 exports.QW_ACT_R37 = QW_ACT_R37;
 __decorate([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qualweb/act-rules",
-  "version": "0.7.7",
+  "version": "0.8.1",
   "description": "ACT rules module for qualweb web accessibility evaluator",
   "files": [
     "dist/*"
@@ -45,10 +45,10 @@
   "author": "João Vicente",
   "license": "ISC",
   "devDependencies": {
-    "@qualweb/core": "^0.8.10",
+    "@qualweb/core": "^0.8.12",
     "@qualweb/locale": "0.2.2",
-    "@qualweb/qw-page": "0.3.6",
-    "@qualweb/util": "0.6.6",
+    "@qualweb/qw-page": "0.3.7",
+    "@qualweb/util": "0.7.1",
     "@tsconfig/recommended": "^1.0.3",
     "@types/mocha": "^10.0.6",
     "@types/node": "^16.11.11",