@aishware/react-a11y-core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aishwarya Sharma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# @aishware/react-a11y-core
+
+Platform-agnostic static-analysis engine behind
+[`@aishware/react-a11y`](https://www.npmjs.com/package/@aishware/react-a11y). Parses
+TSX/JSX with the TypeScript compiler API into a normalized `ElementNode` model,
+runs a rule engine over it, and emits diagnostics mapped to WCAG 2.2.
+Web and React Native rule packs are built on this same engine.
+
+Use it to embed accessibility checks in editor extensions, custom CI, or agents:
+
+```ts
+import { analyze } from '@aishware/react-a11y-core';
+import { webRules } from '@aishware/react-a11y-rules-web';
+
+const diagnostics = analyze({
+  code,
+  filename: 'App.tsx',
+  platform: 'web',
+  rules: webRules,
+});
+```
+
+It also exports `scanProject`, `applyFixes`, the WCAG 2.2 metadata
+(`WCAG22_TOTALS`, `MANUAL_CHECKS`), color/contrast helpers, and the SARIF
+reporter.
+
+Full documentation: <https://github.com/1aishwaryasharma/react-a11y>
+
+## License
+
+MIT

package/dist/aria.d.ts

@@ -0,0 +1,4 @@
+/** Interactive ARIA roles and HTML tags, used by the web/native rule packs. */
+export declare const INTERACTIVE_ROLES: Set<string>;
+export declare const INTERACTIVE_TAGS: Set<string>;
+//# sourceMappingURL=aria.d.ts.map

package/dist/aria.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aria.d.ts","sourceRoot":"","sources":["../src/aria.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAE/E,eAAO,MAAM,iBAAiB,aAI5B,CAAC;AAEH,eAAO,MAAM,gBAAgB,aAG3B,CAAC"}

package/dist/aria.js

@@ -0,0 +1,10 @@
+/** Interactive ARIA roles and HTML tags, used by the web/native rule packs. */
+export const INTERACTIVE_ROLES = new Set([
+    'button', 'checkbox', 'combobox', 'gridcell', 'link', 'listbox', 'menuitem',
+    'menuitemcheckbox', 'menuitemradio', 'option', 'radio', 'scrollbar',
+    'searchbox', 'slider', 'spinbutton', 'switch', 'tab', 'textbox', 'treeitem',
+]);
+export const INTERACTIVE_TAGS = new Set([
+    'a', 'area', 'audio', 'button', 'embed', 'iframe', 'input', 'label',
+    'option', 'select', 'summary', 'textarea', 'video',
+]);

package/dist/color.d.ts

@@ -0,0 +1,21 @@
+/** Color parsing + WCAG contrast math for statically-known style values. */
+export interface Rgb {
+    r: number;
+    g: number;
+    b: number;
+}
+/**
+ * Parse a statically-known color. Returns null for anything uncertain:
+ * unknown formats, named colors outside the common set, or any alpha < 1
+ * (the composited color depends on what's behind it).
+ */
+export declare function parseColor(value: unknown): Rgb | null;
+export declare function relativeLuminance(c: Rgb): number;
+/** WCAG contrast ratio between two colors, 1–21. */
+export declare function contrastRatio(a: Rgb, b: Rgb): number;
+/**
+ * WCAG 1.4.3 "large text": ≥24px, or ≥18.66px (14pt) bold.
+ * Large text needs 3:1; normal text needs 4.5:1.
+ */
+export declare function isLargeText(fontSizePx: number | undefined, bold: boolean): boolean;
+//# sourceMappingURL=color.d.ts.map

package/dist/color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../src/color.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAE5E,MAAM,WAAW,GAAG;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AA4BD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,GAAG,GAAG,IAAI,CAkCrD;AAOD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,GAAG,GAAG,MAAM,CAEhD;AAED,oDAAoD;AACpD,wBAAgB,aAAa,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM,CAKpD;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAGlF"}

package/dist/color.js

@@ -0,0 +1,93 @@
+/** Color parsing + WCAG contrast math for statically-known style values. */
+const NAMED = {
+    black: { r: 0, g: 0, b: 0 },
+    white: { r: 255, g: 255, b: 255 },
+    red: { r: 255, g: 0, b: 0 },
+    green: { r: 0, g: 128, b: 0 },
+    blue: { r: 0, g: 0, b: 255 },
+    yellow: { r: 255, g: 255, b: 0 },
+    orange: { r: 255, g: 165, b: 0 },
+    purple: { r: 128, g: 0, b: 128 },
+    gray: { r: 128, g: 128, b: 128 },
+    grey: { r: 128, g: 128, b: 128 },
+    silver: { r: 192, g: 192, b: 192 },
+    maroon: { r: 128, g: 0, b: 0 },
+    navy: { r: 0, g: 0, b: 128 },
+    teal: { r: 0, g: 128, b: 128 },
+    olive: { r: 128, g: 128, b: 0 },
+    lime: { r: 0, g: 255, b: 0 },
+    aqua: { r: 0, g: 255, b: 255 },
+    cyan: { r: 0, g: 255, b: 255 },
+    fuchsia: { r: 255, g: 0, b: 255 },
+    magenta: { r: 255, g: 0, b: 255 },
+    brown: { r: 165, g: 42, b: 42 },
+    pink: { r: 255, g: 192, b: 203 },
+    gold: { r: 255, g: 215, b: 0 },
+};
+/**
+ * Parse a statically-known color. Returns null for anything uncertain:
+ * unknown formats, named colors outside the common set, or any alpha < 1
+ * (the composited color depends on what's behind it).
+ */
+export function parseColor(value) {
+    if (typeof value !== 'string')
+        return null;
+    const v = value.trim().toLowerCase();
+    if (v in NAMED)
+        return NAMED[v];
+    const hex = /^#([0-9a-f]{3,8})$/.exec(v)?.[1];
+    if (hex) {
+        if (hex.length === 3 || hex.length === 4) {
+            if (hex.length === 4 && hex[3] !== 'f')
+                return null;
+            return {
+                r: parseInt(hex[0] + hex[0], 16),
+                g: parseInt(hex[1] + hex[1], 16),
+                b: parseInt(hex[2] + hex[2], 16),
+            };
+        }
+        if (hex.length === 6 || hex.length === 8) {
+            if (hex.length === 8 && hex.slice(6) !== 'ff')
+                return null;
+            return {
+                r: parseInt(hex.slice(0, 2), 16),
+                g: parseInt(hex.slice(2, 4), 16),
+                b: parseInt(hex.slice(4, 6), 16),
+            };
+        }
+        return null;
+    }
+    const fn = /^rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*([\d.]+)\s*)?\)$/.exec(v);
+    if (fn) {
+        if (fn[4] !== undefined && Number(fn[4]) < 1)
+            return null;
+        const [r, g, b] = [Number(fn[1]), Number(fn[2]), Number(fn[3])];
+        if (r > 255 || g > 255 || b > 255)
+            return null;
+        return { r, g, b };
+    }
+    return null;
+}
+function channel(c) {
+    const s = c / 255;
+    return s <= 0.03928 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
+}
+export function relativeLuminance(c) {
+    return 0.2126 * channel(c.r) + 0.7152 * channel(c.g) + 0.0722 * channel(c.b);
+}
+/** WCAG contrast ratio between two colors, 1–21. */
+export function contrastRatio(a, b) {
+    const la = relativeLuminance(a);
+    const lb = relativeLuminance(b);
+    const [lighter, darker] = la >= lb ? [la, lb] : [lb, la];
+    return (lighter + 0.05) / (darker + 0.05);
+}
+/**
+ * WCAG 1.4.3 "large text": ≥24px, or ≥18.66px (14pt) bold.
+ * Large text needs 3:1; normal text needs 4.5:1.
+ */
+export function isLargeText(fontSizePx, bold) {
+    if (fontSizePx === undefined)
+        return false;
+    return fontSizePx >= 24 || (bold && fontSizePx >= 18.66);
+}

package/dist/config.d.ts

@@ -0,0 +1,5 @@
+import type { A11yConfig } from './types.js';
+export declare function loadConfig(root: string): A11yConfig;
+/** Minimal glob support: `*` (within a segment) and `**` (across segments). */
+export declare function globToRegExp(glob: string): RegExp;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAI7C,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAmBnD;AAMD,+EAA+E;AAC/E,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAUjD"}

package/dist/config.js

@@ -0,0 +1,39 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const CONFIG_FILES = ['react-a11y.config.json', '.react-a11yrc.json'];
+export function loadConfig(root) {
+    for (const file of CONFIG_FILES) {
+        const full = path.join(root, file);
+        if (fs.existsSync(full)) {
+            return JSON.parse(fs.readFileSync(full, 'utf8'));
+        }
+    }
+    const pkgPath = path.join(root, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            if (pkg['react-a11y'] && typeof pkg['react-a11y'] === 'object') {
+                return pkg['react-a11y'];
+            }
+        }
+        catch {
+            // malformed package.json — fall through to defaults
+        }
+    }
+    return {};
+}
+// Placeholders keep the globstar expansions safe from the later `*`/`?` passes.
+const GLOBSTAR_SLASH = '\u0000';
+const GLOBSTAR = '\u0001';
+/** Minimal glob support: `*` (within a segment) and `**` (across segments). */
+export function globToRegExp(glob) {
+    const escaped = glob
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*\//g, GLOBSTAR_SLASH)
+        .replace(/\*\*/g, GLOBSTAR)
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '[^/]')
+        .replaceAll(GLOBSTAR_SLASH, '(?:.*/)?')
+        .replaceAll(GLOBSTAR, '.*');
+    return new RegExp(`^${escaped}$`);
+}

package/dist/element.d.ts

@@ -0,0 +1,50 @@
+import ts from 'typescript';
+export type AttrValue = {
+    kind: 'static';
+    value: string | number | boolean | null | undefined;
+    attrNode?: ts.JsxAttribute;
+} | {
+    kind: 'expression';
+    text: string;
+    node?: ts.Expression;
+    attrNode?: ts.JsxAttribute;
+};
+export interface SourceLocation {
+    line: number;
+    column: number;
+    endLine: number;
+    endColumn: number;
+}
+/**
+ * Normalized JSX element. This is the platform-agnostic surface rules are
+ * written against — the same model backs React DOM, Next.js and React Native.
+ */
+export interface ElementNode {
+    /** Tag as written: "img", "Image", "Animated.View" */
+    name: string;
+    /** True for components (uppercase / member expressions), false for DOM tags. */
+    isComponent: boolean;
+    /** Module the component's root identifier was imported from, if resolvable. */
+    importSource: string | null;
+    attrs: Map<string, AttrValue>;
+    hasSpread: boolean;
+    parent: ElementNode | null;
+    childElements: ElementNode[];
+    /** Direct non-whitespace JSX text child. */
+    hasTextChild: boolean;
+    /** Concatenated direct JSX text, whitespace-collapsed. */
+    directText: string;
+    /** Direct `{expression}` child. */
+    hasExpressionChild: boolean;
+    selfClosing: boolean;
+    loc: SourceLocation;
+}
+export interface FileModel {
+    elements: ElementNode[];
+    imports: Map<string, string>;
+    sourceFile: ts.SourceFile;
+}
+export declare function buildFileModel(sf: ts.SourceFile): FileModel;
+export declare function walkDescendants(el: ElementNode, cb: (child: ElementNode) => void): void;
+export declare function findAncestor(el: ElementNode, predicate: (ancestor: ElementNode) => boolean): ElementNode | null;
+//# sourceMappingURL=element.d.ts.map

package/dist/element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"element.d.ts","sourceRoot":"","sources":["../src/element.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,MAAM,MAAM,SAAS,GACjB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,CAAC,YAAY,CAAA;CAAE,GACnG;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,CAAC,YAAY,CAAA;CAAE,CAAC;AAE3F,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,sDAAsD;IACtD,IAAI,EAAE,MAAM,CAAC;IACb,gFAAgF;IAChF,WAAW,EAAE,OAAO,CAAC;IACrB,+EAA+E;IAC/E,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC9B,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;IAC3B,aAAa,EAAE,WAAW,EAAE,CAAC;IAC7B,4CAA4C;IAC5C,YAAY,EAAE,OAAO,CAAC;IACtB,0DAA0D;IAC1D,UAAU,EAAE,MAAM,CAAC;IACnB,mCAAmC;IACnC,kBAAkB,EAAE,OAAO,CAAC;IAC5B,WAAW,EAAE,OAAO,CAAC;IACrB,GAAG,EAAE,cAAc,CAAC;CACrB;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC;CAC3B;AAoDD,wBAAgB,cAAc,CAAC,EAAE,EAAE,EAAE,CAAC,UAAU,GAAG,SAAS,CAwF3D;AAED,wBAAgB,eAAe,CAAC,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,GAAG,IAAI,CAKvF;AAED,wBAAgB,YAAY,CAC1B,EAAE,EAAE,WAAW,EACf,SAAS,EAAE,CAAC,QAAQ,EAAE,WAAW,KAAK,OAAO,GAC5C,WAAW,GAAG,IAAI,CAOpB"}

package/dist/element.js

@@ -0,0 +1,162 @@
+import ts from 'typescript';
+function collectImports(sf) {
+    const imports = new Map();
+    for (const stmt of sf.statements) {
+        if (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier))
+            continue;
+        const source = stmt.moduleSpecifier.text;
+        const clause = stmt.importClause;
+        if (!clause)
+            continue;
+        if (clause.name)
+            imports.set(clause.name.text, source);
+        const bindings = clause.namedBindings;
+        if (bindings) {
+            if (ts.isNamespaceImport(bindings)) {
+                imports.set(bindings.name.text, source);
+            }
+            else {
+                for (const spec of bindings.elements)
+                    imports.set(spec.name.text, source);
+            }
+        }
+    }
+    return imports;
+}
+function attrValue(init) {
+    if (init === undefined)
+        return { kind: 'static', value: true };
+    if (ts.isStringLiteral(init))
+        return { kind: 'static', value: init.text };
+    if (ts.isJsxExpression(init)) {
+        const expr = init.expression;
+        if (!expr)
+            return { kind: 'expression', text: '' };
+        if (ts.isStringLiteralLike(expr))
+            return { kind: 'static', value: expr.text };
+        if (ts.isNumericLiteral(expr))
+            return { kind: 'static', value: Number(expr.text) };
+        if (expr.kind === ts.SyntaxKind.TrueKeyword)
+            return { kind: 'static', value: true };
+        if (expr.kind === ts.SyntaxKind.FalseKeyword)
+            return { kind: 'static', value: false };
+        if (expr.kind === ts.SyntaxKind.NullKeyword)
+            return { kind: 'static', value: null };
+        if (ts.isIdentifier(expr) && expr.text === 'undefined')
+            return { kind: 'static', value: undefined };
+        if (ts.isPrefixUnaryExpression(expr) &&
+            expr.operator === ts.SyntaxKind.MinusToken &&
+            ts.isNumericLiteral(expr.operand)) {
+            return { kind: 'static', value: -Number(expr.operand.text) };
+        }
+        return { kind: 'expression', text: expr.getText(), node: expr };
+    }
+    return { kind: 'expression', text: init.getText() };
+}
+function rootIdentifier(tag) {
+    let node = tag;
+    while (ts.isPropertyAccessExpression(node))
+        node = node.expression;
+    return ts.isIdentifier(node) ? node.text : node.getText();
+}
+export function buildFileModel(sf) {
+    const imports = collectImports(sf);
+    const elements = [];
+    function makeElement(opening, parent, selfClosing) {
+        const name = opening.tagName.getText(sf);
+        const root = rootIdentifier(opening.tagName);
+        const isComponent = !/^[a-z]/.test(name);
+        const attrs = new Map();
+        let hasSpread = false;
+        for (const prop of opening.attributes.properties) {
+            if (ts.isJsxSpreadAttribute(prop)) {
+                hasSpread = true;
+            }
+            else if (ts.isJsxAttribute(prop)) {
+                const value = attrValue(prop.initializer);
+                value.attrNode = prop;
+                attrs.set(prop.name.getText(sf), value);
+            }
+        }
+        const start = sf.getLineAndCharacterOfPosition(opening.getStart(sf));
+        const end = sf.getLineAndCharacterOfPosition(opening.getEnd());
+        const el = {
+            name,
+            isComponent,
+            importSource: isComponent ? imports.get(root) ?? null : null,
+            attrs,
+            hasSpread,
+            parent,
+            childElements: [],
+            hasTextChild: false,
+            directText: '',
+            hasExpressionChild: false,
+            selfClosing,
+            loc: {
+                line: start.line + 1,
+                column: start.character + 1,
+                endLine: end.line + 1,
+                endColumn: end.character + 1,
+            },
+        };
+        if (parent)
+            parent.childElements.push(el);
+        elements.push(el);
+        return el;
+    }
+    function markDirectChildren(children, el) {
+        const textParts = [];
+        for (const child of children) {
+            if (ts.isJsxText(child)) {
+                const text = child.text.replace(/\s+/g, ' ').trim();
+                if (text.length > 0) {
+                    el.hasTextChild = true;
+                    textParts.push(text);
+                }
+            }
+            else if (ts.isJsxExpression(child) && child.expression !== undefined) {
+                if (ts.isStringLiteralLike(child.expression)) {
+                    // {"literal"} children are still static text
+                    const text = child.expression.text.replace(/\s+/g, ' ').trim();
+                    if (text.length > 0) {
+                        el.hasTextChild = true;
+                        textParts.push(text);
+                    }
+                }
+                else {
+                    el.hasExpressionChild = true;
+                }
+            }
+        }
+        el.directText = textParts.join(' ');
+    }
+    function visit(node, parentEl) {
+        let nextParent = parentEl;
+        if (ts.isJsxElement(node)) {
+            const el = makeElement(node.openingElement, parentEl, false);
+            markDirectChildren(node.children, el);
+            nextParent = el;
+        }
+        else if (ts.isJsxSelfClosingElement(node)) {
+            nextParent = makeElement(node, parentEl, true);
+        }
+        node.forEachChild((c) => visit(c, nextParent));
+    }
+    visit(sf, null);
+    return { elements, imports, sourceFile: sf };
+}
+export function walkDescendants(el, cb) {
+    for (const child of el.childElements) {
+        cb(child);
+        walkDescendants(child, cb);
+    }
+}
+export function findAncestor(el, predicate) {
+    let cur = el.parent;
+    while (cur) {
+        if (predicate(cur))
+            return cur;
+        cur = cur.parent;
+    }
+    return null;
+}

package/dist/engine.d.ts

@@ -0,0 +1,18 @@
+import { type FileModel } from './element.js';
+import type { Diagnostic, Platform, Rule, RuleSetting } from './types.js';
+export interface AnalyzeOptions {
+    code: string;
+    filename: string;
+    platform: Platform;
+    rules: Rule[];
+    ruleSettings?: Record<string, RuleSetting>;
+}
+export type AnalyzeModelOptions = Omit<AnalyzeOptions, 'code'>;
+/** Run rules over an already-built file model (lets callers reuse the parse). */
+export declare function analyzeModel(model: FileModel, options: AnalyzeModelOptions): Diagnostic[];
+/**
+ * Analyze a single file. Pure and synchronous — this is the unit both the CLI
+ * and any editor/CI integration build on.
+ */
+export declare function analyze(options: AnalyzeOptions): Diagnostic[];
+//# sourceMappingURL=engine.d.ts.map

package/dist/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAG9D,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE1E,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC;IACnB,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;CAC5C;AAED,MAAM,MAAM,mBAAmB,GAAG,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;AAE/D,iFAAiF;AACjF,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,mBAAmB,GAAG,UAAU,EAAE,CAwCzF;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,UAAU,EAAE,CAG7D"}

package/dist/engine.js

@@ -0,0 +1,52 @@
+import { buildFileModel } from './element.js';
+import { parseSource } from './parse.js';
+import { resolveWcag } from './wcag.js';
+/** Run rules over an already-built file model (lets callers reuse the parse). */
+export function analyzeModel(model, options) {
+    const { filename, platform, rules, ruleSettings = {} } = options;
+    if (model.elements.length === 0)
+        return [];
+    const diagnostics = [];
+    for (const rule of rules) {
+        if (!rule.meta.platforms.includes(platform))
+            continue;
+        const setting = ruleSettings[rule.meta.id];
+        if (setting === 'off')
+            continue;
+        const wcag = resolveWcag(rule.meta.wcag);
+        const visitor = rule.create({
+            filename,
+            platform,
+            sourceFile: model.sourceFile,
+            report({ el, message, severity, fix }) {
+                diagnostics.push({
+                    ruleId: rule.meta.id,
+                    message,
+                    severity: setting ?? severity ?? rule.meta.severity,
+                    file: filename,
+                    line: el.loc.line,
+                    column: el.loc.column,
+                    endLine: el.loc.endLine,
+                    endColumn: el.loc.endColumn,
+                    wcag,
+                    helpUrl: rule.meta.helpUrl,
+                    ...(fix ? { fix } : {}),
+                });
+            },
+        });
+        if (visitor.element) {
+            for (const el of model.elements)
+                visitor.element(el);
+        }
+    }
+    diagnostics.sort((a, b) => a.line - b.line || a.column - b.column || a.ruleId.localeCompare(b.ruleId));
+    return diagnostics;
+}
+/**
+ * Analyze a single file. Pure and synchronous — this is the unit both the CLI
+ * and any editor/CI integration build on.
+ */
+export function analyze(options) {
+    const model = buildFileModel(parseSource(options.code, options.filename));
+    return analyzeModel(model, options);
+}

package/dist/fixes.d.ts

@@ -0,0 +1,15 @@
+import type { ElementNode } from './element.js';
+import type { Fix } from './types.js';
+/** Fix that deletes an attribute (including its leading whitespace). */
+export declare function fixRemoveAttr(el: ElementNode, name: string): Fix | undefined;
+/** Fix that renames an attribute, keeping its value untouched. */
+export declare function fixRenameAttr(el: ElementNode, name: string, newName: string): Fix | undefined;
+/**
+ * Apply fixes to a source string. Fixes are applied last-to-first so offsets
+ * stay valid; overlapping fixes are skipped (re-run to converge).
+ */
+export declare function applyFixes(source: string, fixes: Fix[]): {
+    output: string;
+    applied: number;
+};
+//# sourceMappingURL=fixes.d.ts.map

package/dist/fixes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixes.d.ts","sourceRoot":"","sources":["../src/fixes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAEtC,wEAAwE;AACxE,wBAAgB,aAAa,CAAC,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,CAI5E;AAED,kEAAkE;AAClE,wBAAgB,aAAa,CAAC,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,CAI7F;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAY5F"}

package/dist/fixes.js

@@ -0,0 +1,32 @@
+/** Fix that deletes an attribute (including its leading whitespace). */
+export function fixRemoveAttr(el, name) {
+    const node = el.attrs.get(name)?.attrNode;
+    if (!node)
+        return undefined;
+    return { start: node.getFullStart(), end: node.getEnd(), replacement: '' };
+}
+/** Fix that renames an attribute, keeping its value untouched. */
+export function fixRenameAttr(el, name, newName) {
+    const node = el.attrs.get(name)?.attrNode;
+    if (!node)
+        return undefined;
+    return { start: node.name.getStart(), end: node.name.getEnd(), replacement: newName };
+}
+/**
+ * Apply fixes to a source string. Fixes are applied last-to-first so offsets
+ * stay valid; overlapping fixes are skipped (re-run to converge).
+ */
+export function applyFixes(source, fixes) {
+    const sorted = [...fixes].sort((a, b) => b.start - a.start || b.end - a.end);
+    let output = source;
+    let applied = 0;
+    let lastStart = Infinity;
+    for (const fix of sorted) {
+        if (fix.end > lastStart || fix.start > fix.end)
+            continue;
+        output = output.slice(0, fix.start) + fix.replacement + output.slice(fix.end);
+        lastStart = fix.start;
+        applied++;
+    }
+    return { output, applied };
+}

package/dist/helpers.d.ts

@@ -0,0 +1,74 @@
+import type { AttrValue, ElementNode } from './element.js';
+import type { Severity } from './types.js';
+export declare function getAttr(el: ElementNode, name: string): AttrValue | undefined;
+export declare function hasAttr(el: ElementNode, name: string): boolean;
+/** Static value when statically known, otherwise undefined. */
+export declare function staticValue(el: ElementNode, name: string): string | number | boolean | null | undefined;
+/** Static string value (trimmed) when statically known to be a string. */
+export declare function staticString(el: ElementNode, name: string): string | undefined;
+/** True when the attribute is present as a dynamic expression. */
+export declare function isExpression(el: ElementNode, name: string): boolean;
+export declare function isStaticTrue(el: ElementNode, name: string): boolean;
+export declare function isAriaHidden(el: ElementNode): boolean;
+/**
+ * True when the attribute could plausibly carry a usable value: present as a
+ * non-empty static string, or dynamic (benefit of the doubt to avoid false
+ * positives in a purely static analysis).
+ */
+export declare function attrProvidesValue(el: ElementNode, name: string): boolean;
+/**
+ * Conservative check that an element's *content* can supply an accessible
+ * name: direct text, dynamic children, unknown components (which may render
+ * text), spreads, or an <img> with non-empty alt.
+ */
+export declare function contentProvidesName(el: ElementNode): boolean;
+/** Accessible name via attributes or content, for web elements. */
+export declare function hasAccessibleName(el: ElementNode): boolean;
+export declare function isPresentational(el: ElementNode): boolean;
+/**
+ * Statically-known value of a property in an inline style object literal,
+ * e.g. style={{ width: 20 }}. Returns undefined for dynamic styles,
+ * StyleSheet references, or non-literal values.
+ */
+export declare function inlineStyleValue(el: ElementNode, prop: string): string | number | undefined;
+export declare function inlineStyleNumber(el: ElementNode, prop: string): number | undefined;
+/**
+ * The full visible text of an element, when it is entirely static. Returns
+ * null as soon as an expression child or component child makes the text
+ * unknowable. aria-hidden subtrees are excluded (they are not "visible
+ * label" for 2.5.3 purposes).
+ */
+export declare function deepStaticText(el: ElementNode): string | null;
+export interface ContrastInfo {
+    ratio: number;
+    required: number;
+    large: boolean;
+    fontSizeKnown: boolean;
+    fg: string;
+    bg: string;
+}
+/**
+ * Contrast of statically-known inline color/backgroundColor on the same
+ * element. Null when either color is dynamic, unparseable or translucent.
+ */
+export declare function inlineStyleContrast(el: ElementNode): ContrastInfo | null;
+/**
+ * WCAG 1.4.3 contrast check for an element's inline literal color/background.
+ * Returns the finding (message + severity) to report, or null when it passes,
+ * the colors aren't static, or the size makes it indeterminate. Shared by the
+ * web and native `color-contrast` rules so the thresholds live in one place.
+ */
+export declare function colorContrastFinding(el: ElementNode): {
+    message: string;
+    severity: Severity;
+} | null;
+/**
+ * The WCAG target-size tier for a pointer target, by its smaller dimension.
+ * `below-min` < 24px (WCAG 2.5.8 AA), `below-recommended` < 44px (2.5.5 AAA /
+ * Apple HIG / Material). Keeps the 24/44 thresholds in one place; each rule
+ * maps the tier to its own severity and platform wording.
+ */
+export declare function targetSizeTier(width: number, height: number): 'below-min' | 'below-recommended' | null;
+/** Statically-known keys of an object-literal prop, e.g. accessibilityState={{...}}. */
+export declare function objectLiteralKeys(el: ElementNode, attrName: string): string[] | undefined;
+//# sourceMappingURL=helpers.d.ts.map