a11ylens 0.1.0

package/dist/engine/styleResolver.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStyleLookup = void 0;
+const css_1 = require("../parser/css");
+const invalidSelectorChars = /[\\s>#:[\\]+~*]/;
+const parseSelector = (selector) => {
+    if (invalidSelectorChars.test(selector))
+        return undefined;
+    const parts = selector.split(".");
+    const tag = parts[0] ? parts[0].toLowerCase() : undefined;
+    const classes = parts.slice(1).filter((item) => item.length > 0);
+    if (!tag && classes.length === 0)
+        return undefined;
+    return { tag, classes };
+};
+const matchSelector = (node, selector, classList) => {
+    if (selector.tag && selector.tag !== node.tagName)
+        return false;
+    if (selector.classes.length === 0)
+        return true;
+    for (const cls of selector.classes) {
+        if (!classList.includes(cls))
+            return false;
+    }
+    return true;
+};
+const mergeStyles = (base, next) => {
+    var _a, _b, _c, _d;
+    return {
+        color: (_a = next.color) !== null && _a !== void 0 ? _a : base.color,
+        backgroundColor: (_b = next.backgroundColor) !== null && _b !== void 0 ? _b : base.backgroundColor,
+        fontSize: (_c = next.fontSize) !== null && _c !== void 0 ? _c : base.fontSize,
+        fontWeight: (_d = next.fontWeight) !== null && _d !== void 0 ? _d : base.fontWeight
+    };
+};
+const buildStyleLookup = (styleSheets) => {
+    const rules = styleSheets.flatMap((sheet) => (0, css_1.parseCss)(sheet));
+    const ruleSelectors = rules.map((rule) => ({
+        selectors: rule.selectors.map(parseSelector),
+        declarations: rule.declarations
+    }));
+    return {
+        getStyleFor: (node) => {
+            const classAttr = node.attrs["class"];
+            const classList = typeof classAttr === "string"
+                ? classAttr.split(/\s+/).map((item) => item.trim()).filter(Boolean)
+                : [];
+            let resolved = {};
+            for (const rule of ruleSelectors) {
+                for (const selector of rule.selectors) {
+                    if (!selector)
+                        continue;
+                    if (matchSelector(node, selector, classList)) {
+                        resolved = mergeStyles(resolved, rule.declarations);
+                        break;
+                    }
+                }
+            }
+            return resolved;
+        }
+    };
+};
+exports.buildStyleLookup = buildStyleLookup;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { runA11yLens, resolveConfig } from "./engine/runA11yLens";
+export { parseTemplate } from "./parser/ast";
+export type { A11yLensConfig, A11yLensConfigOverrides, OutputFormat } from "./types/config";
+export type { Issue, FileScanResult, ProjectScanResult, Severity } from "./types/results";
+export type { Rule, RuleContext } from "./types/rules";

package/dist/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTemplate = exports.resolveConfig = exports.runA11yLens = void 0;
+var runA11yLens_1 = require("./engine/runA11yLens");
+Object.defineProperty(exports, "runA11yLens", { enumerable: true, get: function () { return runA11yLens_1.runA11yLens; } });
+Object.defineProperty(exports, "resolveConfig", { enumerable: true, get: function () { return runA11yLens_1.resolveConfig; } });
+var ast_1 = require("./parser/ast");
+Object.defineProperty(exports, "parseTemplate", { enumerable: true, get: function () { return ast_1.parseTemplate; } });

package/dist/parser/ast.d.ts

@@ -0,0 +1,25 @@
+export interface SourceLocation {
+    line: number;
+    column: number;
+}
+export type Node = ElementNode | TextNode;
+export interface RootNode {
+    type: "root";
+    children: Node[];
+}
+export interface ElementNode {
+    type: "element";
+    tagName: string;
+    attrs: Record<string, string | true>;
+    children: Node[];
+    loc?: SourceLocation;
+}
+export interface TextNode {
+    type: "text";
+    value: string;
+    loc?: SourceLocation;
+}
+export declare const parseTemplate: (input: string) => RootNode;
+export declare const traverse: (node: RootNode | Node, visit: (node: Node) => void) => void;
+export declare const getTextContent: (node: RootNode | Node) => string;
+export declare const findElementsByTag: (root: RootNode, tagName: string) => ElementNode[];

package/dist/parser/ast.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findElementsByTag = exports.getTextContent = exports.traverse = exports.parseTemplate = void 0;
+const voidTags = new Set([
+    "area",
+    "base",
+    "br",
+    "col",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "link",
+    "meta",
+    "param",
+    "source",
+    "track",
+    "wbr"
+]);
+const buildLineMap = (input) => {
+    const lineStarts = [0];
+    for (let i = 0; i < input.length; i += 1) {
+        if (input[i] === "\n") {
+            lineStarts.push(i + 1);
+        }
+    }
+    return lineStarts;
+};
+const getLocation = (lineStarts, index) => {
+    let low = 0;
+    let high = lineStarts.length - 1;
+    while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        const start = lineStarts[mid];
+        const nextStart = mid + 1 < lineStarts.length ? lineStarts[mid + 1] : Number.MAX_SAFE_INTEGER;
+        if (index >= start && index < nextStart) {
+            return { line: mid + 1, column: index - start + 1 };
+        }
+        if (index < start) {
+            high = mid - 1;
+        }
+        else {
+            low = mid + 1;
+        }
+    }
+    return { line: 1, column: 1 };
+};
+const parseAttributes = (attrText) => {
+    var _a, _b, _c;
+    const attrs = {};
+    const attrRegex = /([^\s=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|`([^`]*)`|([^\s"'=<>`]+)))?/g;
+    let match = null;
+    while ((match = attrRegex.exec(attrText)) !== null) {
+        const name = match[1];
+        const value = (_c = (_b = (_a = match[2]) !== null && _a !== void 0 ? _a : match[3]) !== null && _b !== void 0 ? _b : match[4]) !== null && _c !== void 0 ? _c : match[5];
+        attrs[name] = value === undefined ? true : value;
+    }
+    return attrs;
+};
+const parseTemplate = (input) => {
+    const root = { type: "root", children: [] };
+    const stack = [];
+    const tagRegex = /<!--[\s\S]*?-->|<\/?[a-zA-Z][^>]*?>/g;
+    const lineStarts = buildLineMap(input);
+    let lastIndex = 0;
+    let match = null;
+    const pushNode = (node) => {
+        const parent = stack[stack.length - 1];
+        if (parent) {
+            parent.children.push(node);
+        }
+        else {
+            root.children.push(node);
+        }
+    };
+    while ((match = tagRegex.exec(input)) !== null) {
+        const token = match[0];
+        const index = match.index;
+        if (index > lastIndex) {
+            const textValue = input.slice(lastIndex, index);
+            if (textValue.length > 0) {
+                pushNode({
+                    type: "text",
+                    value: textValue,
+                    loc: getLocation(lineStarts, lastIndex)
+                });
+            }
+        }
+        lastIndex = index + token.length;
+        if (token.startsWith("<!--")) {
+            continue;
+        }
+        const isEndTag = token.startsWith("</");
+        const isSelfClosing = token.endsWith("/>");
+        if (isEndTag) {
+            const name = token.slice(2, -1).trim().toLowerCase();
+            while (stack.length > 0) {
+                const current = stack.pop();
+                if (current && current.tagName === name)
+                    break;
+            }
+            continue;
+        }
+        const content = token.slice(1, isSelfClosing ? -2 : -1).trim();
+        if (content.length === 0)
+            continue;
+        const firstSpace = content.indexOf(" ");
+        const tagName = (firstSpace === -1 ? content : content.slice(0, firstSpace)).toLowerCase();
+        const attrText = firstSpace === -1 ? "" : content.slice(firstSpace + 1);
+        const element = {
+            type: "element",
+            tagName,
+            attrs: parseAttributes(attrText),
+            children: [],
+            loc: getLocation(lineStarts, index)
+        };
+        pushNode(element);
+        if (!isSelfClosing && !voidTags.has(tagName)) {
+            stack.push(element);
+        }
+    }
+    if (lastIndex < input.length) {
+        const textValue = input.slice(lastIndex);
+        if (textValue.length > 0) {
+            pushNode({
+                type: "text",
+                value: textValue,
+                loc: getLocation(lineStarts, lastIndex)
+            });
+        }
+    }
+    return root;
+};
+exports.parseTemplate = parseTemplate;
+const traverse = (node, visit) => {
+    if (node.type === "root") {
+        for (const child of node.children) {
+            (0, exports.traverse)(child, visit);
+        }
+        return;
+    }
+    visit(node);
+    if (node.type === "element") {
+        for (const child of node.children) {
+            (0, exports.traverse)(child, visit);
+        }
+    }
+};
+exports.traverse = traverse;
+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 findElementsByTag = (root, tagName) => {
+    const matches = [];
+    (0, exports.traverse)(root, (node) => {
+        if (node.type === "element" && node.tagName === tagName) {
+            matches.push(node);
+        }
+    });
+    return matches;
+};
+exports.findElementsByTag = findElementsByTag;

package/dist/parser/css.d.ts

@@ -0,0 +1,7 @@
+import type { StyleDeclaration } from "../types/style";
+export interface CssRule {
+    selectors: string[];
+    declarations: StyleDeclaration;
+}
+export declare const parseCss: (input: string) => CssRule[];
+export declare const parseInlineStyle: (styleValue: string) => StyleDeclaration;

package/dist/parser/css.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInlineStyle = exports.parseCss = void 0;
+const parseCss = (input) => {
+    const rules = [];
+    const blockRegex = /([^{}]+)\{([^{}]+)\}/g;
+    let match = null;
+    while ((match = blockRegex.exec(input)) !== null) {
+        const selectorText = match[1].trim();
+        const body = match[2].trim();
+        if (!selectorText || !body)
+            continue;
+        const selectors = selectorText
+            .split(",")
+            .map((selector) => selector.trim())
+            .filter((selector) => selector.length > 0);
+        const declarations = parseDeclarations(body);
+        if (selectors.length === 0 || Object.keys(declarations).length === 0)
+            continue;
+        rules.push({ selectors, declarations });
+    }
+    return rules;
+};
+exports.parseCss = parseCss;
+const parseInlineStyle = (styleValue) => {
+    const declarations = parseDeclarations(styleValue);
+    return declarations;
+};
+exports.parseInlineStyle = parseInlineStyle;
+const parseDeclarations = (body) => {
+    const entries = body.split(";");
+    const declarations = {};
+    for (const entry of entries) {
+        const [rawKey, rawValue] = entry.split(":").map((part) => part.trim());
+        if (!rawKey || !rawValue)
+            continue;
+        const key = rawKey.toLowerCase();
+        if (key === "color")
+            declarations.color = rawValue;
+        if (key === "background-color")
+            declarations.backgroundColor = rawValue;
+        if (key === "font-size")
+            declarations.fontSize = rawValue;
+        if (key === "font-weight")
+            declarations.fontWeight = rawValue;
+    }
+    return declarations;
+};

package/dist/reporters/consoleReporter.d.ts

@@ -0,0 +1,2 @@
+import type { ProjectScanResult } from "../types/results";
+export declare const reportConsole: (result: ProjectScanResult, cwd: string) => void;

package/dist/reporters/consoleReporter.js

@@ -0,0 +1,67 @@
+"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.reportConsole = void 0;
+const path = __importStar(require("path"));
+const reportConsole = (result, cwd) => {
+    var _a;
+    console.log("A11yLens");
+    console.log("=======");
+    console.log("");
+    if (result.files.length === 0) {
+        console.log("No matching files found.");
+        return;
+    }
+    for (const file of result.files) {
+        const relative = path.relative(cwd, file.filePath);
+        console.log(relative || file.filePath);
+        if (file.issues.length === 0) {
+            console.log("  - No issues\n");
+            continue;
+        }
+        for (const issue of file.issues) {
+            const location = issue.line ? `:${issue.line}:${(_a = issue.column) !== null && _a !== void 0 ? _a : 1}` : "";
+            console.log(`  - [${issue.severity}] ${issue.ruleId}${location} ${issue.message}`);
+        }
+        console.log("");
+    }
+    console.log("Summary");
+    console.log("-------");
+    console.log(`Errors: ${result.totals.error}`);
+    console.log(`Warnings: ${result.totals.warn}`);
+    console.log(`Info: ${result.totals.info}`);
+    console.log(`Score: ${result.score} / 100`);
+};
+exports.reportConsole = reportConsole;

package/dist/reporters/jsonReporter.d.ts

@@ -0,0 +1,2 @@
+import type { ProjectScanResult } from "../types/results";
+export declare const reportJson: (result: ProjectScanResult) => string;

package/dist/reporters/jsonReporter.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportJson = void 0;
+const reportJson = (result) => {
+    return JSON.stringify(result, null, 2);
+};
+exports.reportJson = reportJson;

package/dist/reporters/sarifReporter.d.ts

@@ -0,0 +1,2 @@
+import type { ProjectScanResult } from "../types/results";
+export declare const reportSarif: (result: ProjectScanResult) => string;

package/dist/reporters/sarifReporter.js

@@ -0,0 +1,95 @@
+"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.reportSarif = void 0;
+const path = __importStar(require("path"));
+const registry_1 = require("../rules/registry");
+const severityToLevel = {
+    error: "error",
+    warn: "warning",
+    info: "note"
+};
+const reportSarif = (result) => {
+    const rules = registry_1.builtInRules.map((rule) => ({
+        id: rule.id,
+        name: rule.id,
+        shortDescription: { text: rule.description },
+        fullDescription: { text: rule.description }
+    }));
+    const sarif = {
+        version: "2.1.0",
+        $schema: "https://json.schemastore.org/sarif-2.1.0.json",
+        runs: [
+            {
+                tool: {
+                    driver: {
+                        name: "a11ylens",
+                        informationUri: "https://github.com/madhanmonishj/a11ylens",
+                        rules
+                    }
+                },
+                results: result.files.flatMap((file) => file.issues.map((issue) => {
+                    var _a, _b;
+                    return ({
+                        ruleId: issue.ruleId,
+                        level: (_a = severityToLevel[issue.severity]) !== null && _a !== void 0 ? _a : "warning",
+                        message: { text: issue.message },
+                        locations: [
+                            {
+                                physicalLocation: {
+                                    artifactLocation: {
+                                        uri: normalizeFileUri(file.filePath)
+                                    },
+                                    region: issue.line
+                                        ? {
+                                            startLine: issue.line,
+                                            startColumn: (_b = issue.column) !== null && _b !== void 0 ? _b : 1
+                                        }
+                                        : undefined
+                                }
+                            }
+                        ]
+                    });
+                }))
+            }
+        ]
+    };
+    return JSON.stringify(sarif, null, 2);
+};
+exports.reportSarif = reportSarif;
+const normalizeFileUri = (filePath) => {
+    const resolved = path.resolve(filePath);
+    return resolved.replace(/\\/g, "/");
+};

package/dist/rules/clickableNonsemantic.d.ts

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

package/dist/rules/clickableNonsemantic.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clickableNonSemanticRule = void 0;
+const utils_1 = require("./utils");
+const isInteractive = (node) => {
+    if (node.tagName === "button")
+        return true;
+    if (node.tagName === "a") {
+        return (0, utils_1.hasAttr)(node, "href") || (0, utils_1.hasAttr)(node, "routerLink") || (0, utils_1.hasAttr)(node, "[routerLink]");
+    }
+    const role = (0, utils_1.getAttr)(node, "role");
+    if (typeof role === "string" && role.toLowerCase() === "button")
+        return true;
+    return (0, utils_1.hasAttr)(node, "tabindex");
+};
+exports.clickableNonSemanticRule = {
+    id: "clickable-nonsemantic",
+    description: "Non-semantic elements with click handlers should be accessible.",
+    severity: "warn",
+    check: (ast, context) => {
+        const issues = [];
+        (0, utils_1.walkWithAncestors)(ast, (node) => {
+            var _a, _b;
+            if (node.type !== "element")
+                return;
+            if (node.tagName !== "div" && node.tagName !== "span")
+                return;
+            if (!(0, utils_1.hasAttr)(node, "(click)"))
+                return;
+            if (isInteractive(node))
+                return;
+            issues.push({
+                ruleId: "clickable-nonsemantic",
+                message: "Clickable div/span needs semantic role or keyboard support.",
+                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/contrastRatio.d.ts

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