a11ylens 0.1.0

package/dist/rules/contrastRatio.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contrastRatioRule = void 0;
+const css_1 = require("../parser/css");
+const utils_1 = require("./utils");
+const parseHexChannel = (value) => {
+    const parsed = Number.parseInt(value, 16);
+    if (Number.isNaN(parsed))
+        return undefined;
+    return parsed;
+};
+const parseColor = (value) => {
+    const normalized = value.trim().toLowerCase();
+    if (normalized.startsWith("#")) {
+        const hex = normalized.slice(1);
+        if (hex.length === 3) {
+            const r = parseHexChannel(hex[0] + hex[0]);
+            const g = parseHexChannel(hex[1] + hex[1]);
+            const b = parseHexChannel(hex[2] + hex[2]);
+            if (r === undefined || g === undefined || b === undefined)
+                return undefined;
+            return [r, g, b];
+        }
+        if (hex.length === 6) {
+            const r = parseHexChannel(hex.slice(0, 2));
+            const g = parseHexChannel(hex.slice(2, 4));
+            const b = parseHexChannel(hex.slice(4, 6));
+            if (r === undefined || g === undefined || b === undefined)
+                return undefined;
+            return [r, g, b];
+        }
+        return undefined;
+    }
+    const rgbMatch = normalized.match(/^rgba?\(([^)]+)\)$/);
+    if (rgbMatch) {
+        const parts = rgbMatch[1].split(",").map((item) => item.trim());
+        if (parts.length < 3)
+            return undefined;
+        const r = Number(parts[0]);
+        const g = Number(parts[1]);
+        const b = Number(parts[2]);
+        if ([r, g, b].some((channel) => Number.isNaN(channel)))
+            return undefined;
+        return [clampChannel(r), clampChannel(g), clampChannel(b)];
+    }
+    return undefined;
+};
+const clampChannel = (value) => {
+    if (value < 0)
+        return 0;
+    if (value > 255)
+        return 255;
+    return Math.round(value);
+};
+const channelToLinear = (value) => {
+    const s = value / 255;
+    return s <= 0.03928 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
+};
+const luminance = (rgb) => {
+    const [r, g, b] = rgb.map(channelToLinear);
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+};
+const contrastRatio = (fg, bg) => {
+    const l1 = luminance(fg);
+    const l2 = luminance(bg);
+    const lighter = Math.max(l1, l2);
+    const darker = Math.min(l1, l2);
+    return (lighter + 0.05) / (darker + 0.05);
+};
+const isLargeText = (styles) => {
+    const fontSize = styles.fontSize;
+    const fontWeight = styles.fontWeight;
+    let sizePx;
+    if (fontSize && fontSize.endsWith("px")) {
+        const parsed = Number(fontSize.slice(0, -2));
+        if (!Number.isNaN(parsed))
+            sizePx = parsed;
+    }
+    const weight = fontWeight ? Number(fontWeight) : undefined;
+    const isBold = weight !== undefined && weight >= 700;
+    if (sizePx === undefined)
+        return false;
+    if (sizePx >= 18)
+        return true;
+    if (isBold && sizePx >= 14)
+        return true;
+    return false;
+};
+const getInlineContrast = (node, styles) => {
+    const colorValue = styles.color;
+    const backgroundValue = styles.backgroundColor;
+    if (!colorValue || !backgroundValue)
+        return undefined;
+    const fg = parseColor(colorValue);
+    const bg = parseColor(backgroundValue);
+    if (!fg || !bg)
+        return undefined;
+    const ratio = contrastRatio(fg, bg);
+    const threshold = isLargeText(styles) ? 3 : 4.5;
+    return { ratio, threshold };
+};
+const getResolvedStyles = (node, styleLookup) => {
+    var _a, _b, _c, _d;
+    const base = styleLookup ? styleLookup.getStyleFor(node) : {};
+    const styleAttr = (0, utils_1.getAttr)(node, "style");
+    if (typeof styleAttr !== "string")
+        return base;
+    const inline = (0, css_1.parseInlineStyle)(styleAttr);
+    return {
+        color: (_a = inline.color) !== null && _a !== void 0 ? _a : base.color,
+        backgroundColor: (_b = inline.backgroundColor) !== null && _b !== void 0 ? _b : base.backgroundColor,
+        fontSize: (_c = inline.fontSize) !== null && _c !== void 0 ? _c : base.fontSize,
+        fontWeight: (_d = inline.fontWeight) !== null && _d !== void 0 ? _d : base.fontWeight
+    };
+};
+const getContrast = (node, styleLookup) => {
+    const resolved = getResolvedStyles(node, styleLookup);
+    return getInlineContrast(node, resolved);
+};
+exports.contrastRatioRule = {
+    id: "color-contrast",
+    description: "Text color should meet WCAG AA contrast ratios.",
+    severity: "warn",
+    check: (ast, context) => {
+        const issues = [];
+        (0, utils_1.walkWithAncestors)(ast, (node) => {
+            var _a, _b;
+            if (node.type !== "element")
+                return;
+            const text = (0, utils_1.getAccessibleText)(node).replace(/\s+/g, " ").trim();
+            if (!text)
+                return;
+            const contrast = getContrast(node, context.styleLookup);
+            if (!contrast)
+                return;
+            if (contrast.ratio < contrast.threshold) {
+                issues.push({
+                    ruleId: "color-contrast",
+                    message: `Color contrast ${contrast.ratio.toFixed(2)}:1 is below ${contrast.threshold}:1.`,
+                    filePath: context.filePath,
+                    line: (_a = node.loc) === null || _a === void 0 ? void 0 : _a.line,
+                    column: (_b = node.loc) === null || _b === void 0 ? void 0 : _b.column,
+                    severity: "warn"
+                });
+            }
+        });
+        return issues;
+    }
+};

package/dist/rules/engine.d.ts

@@ -0,0 +1,4 @@
+import type { Issue } from "../types/results";
+import type { Rule } from "../types/rules";
+import type { RootNode } from "../parser/ast";
+export declare const runRules: (rules: Rule[], ast: RootNode, filePath: string, source: string, styleLookup?: import("../types/style").StyleLookup) => Issue[];

package/dist/rules/engine.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRules = void 0;
+const runRules = (rules, ast, filePath, source, styleLookup) => {
+    const issues = [];
+    for (const rule of rules) {
+        try {
+            const results = rule.check(ast, { filePath, source, styleLookup });
+            issues.push(...results.map((issue) => { var _a; return ({ ...issue, severity: (_a = issue.severity) !== null && _a !== void 0 ? _a : rule.severity }); }));
+        }
+        catch {
+            issues.push({
+                ruleId: rule.id,
+                message: `Rule ${rule.id} failed to execute.`,
+                filePath,
+                severity: "warn"
+            });
+        }
+    }
+    return issues;
+};
+exports.runRules = runRules;

package/dist/rules/iconOnlyControl.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../types/rules";
+export declare const iconOnlyControlRule: Rule;

package/dist/rules/iconOnlyControl.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iconOnlyControlRule = void 0;
+const utils_1 = require("./utils");
+const iconTags = new Set(["i", "svg", "mat-icon", "fa-icon"]);
+const hasText = (node) => {
+    const text = (0, utils_1.getAccessibleText)(node).replace(/\s+/g, " ").trim();
+    return text.length > 0;
+};
+const isOnlyIconChildren = (node) => {
+    const elementChildren = node.children.filter((child) => child.type === "element");
+    if (elementChildren.length === 0)
+        return false;
+    for (const child of elementChildren) {
+        if (!iconTags.has(child.tagName))
+            return false;
+    }
+    return true;
+};
+exports.iconOnlyControlRule = {
+    id: "icon-only-control",
+    description: "Controls with only icons need accessible labels.",
+    severity: "warn",
+    check: (ast, context) => {
+        const issues = [];
+        (0, utils_1.walkWithAncestors)(ast, (node) => {
+            var _a, _b;
+            if (node.type !== "element")
+                return;
+            if (node.tagName !== "button" && node.tagName !== "a")
+                return;
+            const ariaLabel = (0, utils_1.getAttr)(node, "aria-label");
+            if (typeof ariaLabel === "string" && ariaLabel.trim().length > 0)
+                return;
+            if (hasText(node))
+                return;
+            if (!isOnlyIconChildren(node))
+                return;
+            issues.push({
+                ruleId: "icon-only-control",
+                message: "Icon-only controls need aria-label text.",
+                filePath: context.filePath,
+                line: (_a = node.loc) === null || _a === void 0 ? void 0 : _a.line,
+                column: (_b = node.loc) === null || _b === void 0 ? void 0 : _b.column,
+                severity: "warn"
+            });
+        });
+        return issues;
+    }
+};

package/dist/rules/imgAlt.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../types/rules";
+export declare const imgAltRule: Rule;

package/dist/rules/imgAlt.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.imgAltRule = void 0;
+const utils_1 = require("./utils");
+const hasAccessibleName = (node) => {
+    const ariaLabel = (0, utils_1.getAttr)(node, "aria-label");
+    const text = (0, utils_1.getAccessibleText)(node).replace(/\s+/g, " ").trim();
+    return (typeof ariaLabel === "string" && ariaLabel.trim().length > 0) || text.length > 0;
+};
+exports.imgAltRule = {
+    id: "img-alt",
+    description: "Images must have alternative text.",
+    severity: "error",
+    check: (ast, context) => {
+        const issues = [];
+        (0, utils_1.walkWithAncestors)(ast, (node, ancestors) => {
+            var _a, _b, _c, _d;
+            if (node.type !== "element" || node.tagName !== "img")
+                return;
+            const alt = (0, utils_1.getAttr)(node, "alt");
+            if (alt === undefined) {
+                issues.push({
+                    ruleId: "img-alt",
+                    message: "Image elements must have an alt attribute.",
+                    filePath: context.filePath,
+                    line: (_a = node.loc) === null || _a === void 0 ? void 0 : _a.line,
+                    column: (_b = node.loc) === null || _b === void 0 ? void 0 : _b.column,
+                    severity: "error"
+                });
+                return;
+            }
+            if (alt === "") {
+                const linkAncestor = ancestors.find((ancestor) => ancestor.tagName === "a");
+                if (linkAncestor && !hasAccessibleName(linkAncestor)) {
+                    issues.push({
+                        ruleId: "img-alt",
+                        message: "Linked images with empty alt text need another accessible name.",
+                        filePath: context.filePath,
+                        line: (_c = node.loc) === null || _c === void 0 ? void 0 : _c.line,
+                        column: (_d = node.loc) === null || _d === void 0 ? void 0 : _d.column,
+                        severity: "warn"
+                    });
+                }
+            }
+        });
+        return issues;
+    }
+};

package/dist/rules/registry.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from "../types/rules";
+export declare const builtInRules: Rule[];
+export declare const getRuleById: (id: string) => Rule | undefined;

package/dist/rules/registry.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRuleById = exports.builtInRules = void 0;
+const imgAlt_1 = require("./imgAlt");
+const clickableNonsemantic_1 = require("./clickableNonsemantic");
+const routerLinkText_1 = require("./routerLinkText");
+const iconOnlyControl_1 = require("./iconOnlyControl");
+const contrastRatio_1 = require("./contrastRatio");
+exports.builtInRules = [
+    imgAlt_1.imgAltRule,
+    clickableNonsemantic_1.clickableNonSemanticRule,
+    routerLinkText_1.routerLinkTextRule,
+    iconOnlyControl_1.iconOnlyControlRule,
+    contrastRatio_1.contrastRatioRule
+];
+const getRuleById = (id) => {
+    return exports.builtInRules.find((rule) => rule.id === id);
+};
+exports.getRuleById = getRuleById;

package/dist/rules/routerLinkText.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../types/rules";
+export declare const routerLinkTextRule: Rule;

package/dist/rules/routerLinkText.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routerLinkTextRule = void 0;
+const utils_1 = require("./utils");
+exports.routerLinkTextRule = {
+    id: "routerlink-text",
+    description: "Router links need an accessible name.",
+    severity: "error",
+    check: (ast, context) => {
+        const issues = [];
+        (0, utils_1.walkWithAncestors)(ast, (node) => {
+            var _a, _b;
+            if (node.type !== "element" || node.tagName !== "a")
+                return;
+            if (!(0, utils_1.hasAttr)(node, "routerLink") && !(0, utils_1.hasAttr)(node, "[routerLink]"))
+                return;
+            const ariaLabel = (0, utils_1.getAttr)(node, "aria-label");
+            const text = (0, utils_1.getAccessibleText)(node).replace(/\s+/g, " ").trim();
+            if (!(typeof ariaLabel === "string" && ariaLabel.trim().length > 0) && text.length === 0) {
+                issues.push({
+                    ruleId: "routerlink-text",
+                    message: "Router links need text or aria-label for an accessible name.",
+                    filePath: context.filePath,
+                    line: (_a = node.loc) === null || _a === void 0 ? void 0 : _a.line,
+                    column: (_b = node.loc) === null || _b === void 0 ? void 0 : _b.column,
+                    severity: "error"
+                });
+            }
+        });
+        return issues;
+    }
+};

package/dist/rules/utils.d.ts

@@ -0,0 +1,6 @@
+import type { ElementNode, Node, RootNode } from "../parser/ast";
+export declare const getAttr: (node: ElementNode, name: string) => string | true | undefined;
+export declare const hasAttr: (node: ElementNode, name: string) => boolean;
+export declare const getTextContent: (node: RootNode | Node) => string;
+export declare const getAccessibleText: (node: RootNode | Node) => string;
+export declare const walkWithAncestors: (node: RootNode | Node, visit: (node: Node, ancestors: ElementNode[]) => void, ancestors?: ElementNode[]) => void;

package/dist/rules/utils.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkWithAncestors = exports.getAccessibleText = exports.getTextContent = exports.hasAttr = exports.getAttr = void 0;
+const getAttr = (node, name) => {
+    return node.attrs[name];
+};
+exports.getAttr = getAttr;
+const hasAttr = (node, name) => {
+    return Object.prototype.hasOwnProperty.call(node.attrs, name);
+};
+exports.hasAttr = hasAttr;
+const getTextContent = (node) => {
+    if (node.type === "root") {
+        return node.children.map(exports.getTextContent).join("");
+    }
+    if (node.type === "text") {
+        return node.value;
+    }
+    return node.children.map(exports.getTextContent).join("");
+};
+exports.getTextContent = getTextContent;
+const iconTags = new Set(["i", "svg", "mat-icon", "fa-icon"]);
+const getAccessibleText = (node) => {
+    if (node.type === "root") {
+        return node.children.map(exports.getAccessibleText).join("");
+    }
+    if (node.type === "text") {
+        return node.value;
+    }
+    if (iconTags.has(node.tagName)) {
+        return "";
+    }
+    return node.children.map(exports.getAccessibleText).join("");
+};
+exports.getAccessibleText = getAccessibleText;
+const walkWithAncestors = (node, visit, ancestors = []) => {
+    if (node.type === "root") {
+        for (const child of node.children) {
+            (0, exports.walkWithAncestors)(child, visit, ancestors);
+        }
+        return;
+    }
+    visit(node, ancestors);
+    if (node.type === "element") {
+        const nextAncestors = [...ancestors, node];
+        for (const child of node.children) {
+            (0, exports.walkWithAncestors)(child, visit, nextAncestors);
+        }
+    }
+};
+exports.walkWithAncestors = walkWithAncestors;

package/dist/scanner/fileAnalyzer.d.ts

@@ -0,0 +1 @@
+export declare const readFileContent: (filePath: string) => string;

package/dist/scanner/fileAnalyzer.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFileContent = void 0;
+const fs = __importStar(require("fs"));
+const readFileContent = (filePath) => {
+    try {
+        return fs.readFileSync(filePath, "utf8");
+    }
+    catch {
+        return "";
+    }
+};
+exports.readFileContent = readFileContent;

package/dist/scanner/fileSystemWalker.js

@@ -0,0 +1,122 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileSystemWalker = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+/**
+ * Walk one or more root directories and return all matching file paths.
+ */
+const fileSystemWalker = (rootDirs, options) => {
+    const results = [];
+    for (const root of rootDirs) {
+        if (!fs.existsSync(root))
+            continue;
+        let stat;
+        try {
+            stat = fs.statSync(root);
+        }
+        catch {
+            continue;
+        }
+        if (!stat.isDirectory())
+            continue;
+        const resolvedPath = path.resolve(root);
+        walkDirectory(resolvedPath, options, results);
+    }
+    return results;
+};
+exports.fileSystemWalker = fileSystemWalker;
+/**
+ * Recursively walk a directory and collect matching files.
+ */
+const walkDirectory = (currentDir, options, results) => {
+    if (shouldIgnorePath(currentDir, options.ignoreDirs))
+        return;
+    let entries;
+    try {
+        entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name);
+        if (entry.isDirectory()) {
+            walkDirectory(fullPath, options, results);
+        }
+        else if (entry.isFile()) {
+            if (matchesPattern(entry.name, options.includePatterns) &&
+                !shouldIgnorePath(fullPath, options.ignoreDirs)) {
+                results.push(fullPath);
+            }
+        }
+    }
+};
+/**
+ * Returns true if the given path should be ignored based on ignoreDirs.
+ * ignoreDirs are treated as directory *names* (e.g. "node_modules", "dist").
+ */
+const shouldIgnorePath = (p, ignoreDirs) => {
+    const normalized = path.resolve(p);
+    const parts = normalized.split(path.sep);
+    for (const dirName of ignoreDirs) {
+        if (parts.includes(dirName))
+            return true;
+    }
+    return false;
+};
+/**
+ * Checks whether a file name matches any of the include patterns.
+ *
+ * Supported pattern forms:
+ *   "*.component.html"  → filename endsWith(".component.html")
+ *   "*.component.ts"    → filename endsWith(".component.ts")
+ *   "exactName.ext"     → filename === pattern
+ */
+const matchesPattern = (fileName, patterns) => {
+    for (const pattern of patterns) {
+        if (pattern.startsWith("*.")) {
+            const suffix = pattern.slice(1);
+            if (fileName.endsWith(suffix))
+                return true;
+        }
+        else {
+            if (fileName === pattern)
+                return true;
+        }
+    }
+    return false;
+};

package/dist/scanner/fileWalker.d.ts

@@ -0,0 +1,8 @@
+import type { A11yLensConfig } from "../types/config";
+export interface WalkOptions {
+    includePatterns: string[];
+    ignoreDirs: string[];
+    ignorePatterns: string[];
+}
+export declare const fileSystemWalker: (rootDirs: string[], options: WalkOptions) => string[];
+export declare const defaultWalkOptions: (config: A11yLensConfig) => WalkOptions;