@aishware/react-a11y-core 0.1.0

package/dist/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C,wBAAgB,OAAO,CAAC,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAE5E;AAED,wBAAgB,OAAO,CAAC,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED,+DAA+D;AAC/D,wBAAgB,WAAW,CAAC,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAGvG;AAED,0EAA0E;AAC1E,wBAAgB,YAAY,CAAC,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAG9E;AAED,kEAAkE;AAClE,wBAAgB,YAAY,CAAC,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAEnE;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAGnE;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO,CAErD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAKxE;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO,CAU5D;AAED,mEAAmE;AACnE,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO,CAM1D;AAID,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,WAAW,GAAG,OAAO,CAGzD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAa3F;AAED,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGnF;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,WAAW,GAAG,MAAM,GAAG,IAAI,CAW7D;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,aAAa,EAAE,OAAO,CAAC;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,WAAW,GAAG,YAAY,GAAG,IAAI,CAkBxE;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,WAAW,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,QAAQ,CAAA;CAAE,GAAG,IAAI,CAYpG;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,mBAAmB,GAAG,IAAI,CAKtG;AAED,wFAAwF;AACxF,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAYzF"}

package/dist/helpers.js

@@ -0,0 +1,209 @@
+import ts from 'typescript';
+import { contrastRatio, isLargeText, parseColor } from './color.js';
+export function getAttr(el, name) {
+    return el.attrs.get(name);
+}
+export function hasAttr(el, name) {
+    return el.attrs.has(name);
+}
+/** Static value when statically known, otherwise undefined. */
+export function staticValue(el, name) {
+    const attr = el.attrs.get(name);
+    return attr?.kind === 'static' ? attr.value : undefined;
+}
+/** Static string value (trimmed) when statically known to be a string. */
+export function staticString(el, name) {
+    const v = staticValue(el, name);
+    return typeof v === 'string' ? v : undefined;
+}
+/** True when the attribute is present as a dynamic expression. */
+export function isExpression(el, name) {
+    return el.attrs.get(name)?.kind === 'expression';
+}
+export function isStaticTrue(el, name) {
+    const v = staticValue(el, name);
+    return v === true || v === 'true';
+}
+export function isAriaHidden(el) {
+    return isStaticTrue(el, 'aria-hidden');
+}
+/**
+ * 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 function attrProvidesValue(el, name) {
+    const attr = el.attrs.get(name);
+    if (!attr)
+        return false;
+    if (attr.kind === 'expression')
+        return true;
+    return typeof attr.value === 'string' ? attr.value.trim().length > 0 : attr.value != null && attr.value !== false;
+}
+/**
+ * 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 function contentProvidesName(el) {
+    if (el.hasTextChild || el.hasExpressionChild)
+        return true;
+    if (hasAttr(el, 'dangerouslySetInnerHTML'))
+        return true;
+    return el.childElements.some((child) => {
+        if (isAriaHidden(child))
+            return false;
+        if (child.isComponent)
+            return true;
+        if (child.hasSpread)
+            return true;
+        if (child.name === 'img' && attrProvidesValue(child, 'alt'))
+            return true;
+        return contentProvidesName(child);
+    });
+}
+/** Accessible name via attributes or content, for web elements. */
+export function hasAccessibleName(el) {
+    if (el.hasSpread)
+        return true;
+    if (attrProvidesValue(el, 'aria-label'))
+        return true;
+    if (attrProvidesValue(el, 'aria-labelledby'))
+        return true;
+    if (attrProvidesValue(el, 'title'))
+        return true;
+    return contentProvidesName(el);
+}
+const PRESENTATION_ROLES = new Set(['presentation', 'none']);
+export function isPresentational(el) {
+    const role = staticString(el, 'role');
+    return role !== undefined && PRESENTATION_ROLES.has(role.trim().toLowerCase());
+}
+/**
+ * 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 function inlineStyleValue(el, prop) {
+    const style = el.attrs.get('style');
+    if (style?.kind !== 'expression' || !style.node || !ts.isObjectLiteralExpression(style.node))
+        return undefined;
+    for (const p of style.node.properties) {
+        if (!ts.isPropertyAssignment(p))
+            continue;
+        const name = ts.isIdentifier(p.name) || ts.isStringLiteral(p.name) ? p.name.text : undefined;
+        if (name !== prop)
+            continue;
+        const init = p.initializer;
+        if (ts.isStringLiteralLike(init))
+            return init.text;
+        if (ts.isNumericLiteral(init))
+            return Number(init.text);
+        return undefined;
+    }
+    return undefined;
+}
+export function inlineStyleNumber(el, prop) {
+    const v = inlineStyleValue(el, prop);
+    return typeof v === 'number' ? v : 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 function deepStaticText(el) {
+    if (el.hasExpressionChild)
+        return null;
+    const parts = el.directText ? [el.directText] : [];
+    for (const child of el.childElements) {
+        if (isAriaHidden(child))
+            continue;
+        if (child.isComponent || child.hasSpread)
+            return null;
+        const childText = deepStaticText(child);
+        if (childText === null)
+            return null;
+        if (childText)
+            parts.push(childText);
+    }
+    return parts.join(' ').replace(/\s+/g, ' ').trim();
+}
+/**
+ * Contrast of statically-known inline color/backgroundColor on the same
+ * element. Null when either color is dynamic, unparseable or translucent.
+ */
+export function inlineStyleContrast(el) {
+    const fgRaw = inlineStyleValue(el, 'color');
+    const bgRaw = inlineStyleValue(el, 'backgroundColor') ?? inlineStyleValue(el, 'background');
+    const fg = parseColor(fgRaw);
+    const bg = parseColor(bgRaw);
+    if (!fg || !bg)
+        return null;
+    const fontSize = inlineStyleNumber(el, 'fontSize');
+    const weight = inlineStyleValue(el, 'fontWeight');
+    const bold = weight === 'bold' || weight === 700 || weight === '700' || weight === 800 || weight === '800' || weight === 900 || weight === '900';
+    const large = isLargeText(fontSize, bold);
+    return {
+        ratio: contrastRatio(fg, bg),
+        required: large ? 3 : 4.5,
+        large,
+        fontSizeKnown: fontSize !== undefined,
+        fg: String(fgRaw),
+        bg: String(bgRaw),
+    };
+}
+/**
+ * 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 function colorContrastFinding(el) {
+    const info = inlineStyleContrast(el);
+    if (!info)
+        return null;
+    if (info.ratio >= 4.5)
+        return null;
+    if (info.ratio >= 3 && (info.large || !info.fontSizeKnown))
+        return null;
+    if (info.ratio >= info.required && info.fontSizeKnown)
+        return null;
+    const fmt = (n) => (Math.round(n * 100) / 100).toFixed(2);
+    const requirement = info.large ? '3:1 (large text)' : '4.5:1';
+    return {
+        message: `Contrast between ${info.fg} and ${info.bg} is ${fmt(info.ratio)}:1 — below the ${requirement} required by WCAG 1.4.3.`,
+        severity: info.ratio < 3 ? 'serious' : 'moderate',
+    };
+}
+/**
+ * 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 function targetSizeTier(width, height) {
+    const min = Math.min(width, height);
+    if (min < 24)
+        return 'below-min';
+    if (min < 44)
+        return 'below-recommended';
+    return null;
+}
+/** Statically-known keys of an object-literal prop, e.g. accessibilityState={{...}}. */
+export function objectLiteralKeys(el, attrName) {
+    const attr = el.attrs.get(attrName);
+    if (attr?.kind !== 'expression' || !attr.node || !ts.isObjectLiteralExpression(attr.node))
+        return undefined;
+    const keys = [];
+    for (const p of attr.node.properties) {
+        if (ts.isSpreadAssignment(p))
+            return undefined; // unknowable
+        if ((ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) &&
+            (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name))) {
+            keys.push(p.name.text);
+        }
+    }
+    return keys;
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export * from './types.js';
+export * from './element.js';
+export * from './helpers.js';
+export * from './aria.js';
+export { WCAG, WCAG22_TOTALS, WCAG22_A_AA, MANUAL_CHECKS, resolveWcag } from './wcag.js';
+export { parseColor, contrastRatio, relativeLuminance, isLargeText, type Rgb } from './color.js';
+export { parseSource } from './parse.js';
+export { analyze, analyzeModel, type AnalyzeOptions, type AnalyzeModelOptions } from './engine.js';
+export { applyFixes, fixRemoveAttr, fixRenameAttr } from './fixes.js';
+export { scanProject, collectFiles, detectPlatform, type ScanOptions } from './scanner.js';
+export { loadConfig, globToRegExp } from './config.js';
+export { readPackageMeta, readOwnPackageMeta, type PackageMeta } from './pkg-meta.js';
+export { toJson } from './reporters/json.js';
+export { toSarif } from './reporters/sarif.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,WAAW,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACzF,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,iBAAiB,EAAE,WAAW,EAAE,KAAK,GAAG,EAAE,MAAM,YAAY,CAAC;AACjG,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,KAAK,cAAc,EAAE,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACnG,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACtE,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,cAAc,EAAE,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3F,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AACtF,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,14 @@
+export * from './types.js';
+export * from './element.js';
+export * from './helpers.js';
+export * from './aria.js';
+export { WCAG, WCAG22_TOTALS, WCAG22_A_AA, MANUAL_CHECKS, resolveWcag } from './wcag.js';
+export { parseColor, contrastRatio, relativeLuminance, isLargeText } from './color.js';
+export { parseSource } from './parse.js';
+export { analyze, analyzeModel } from './engine.js';
+export { applyFixes, fixRemoveAttr, fixRenameAttr } from './fixes.js';
+export { scanProject, collectFiles, detectPlatform } from './scanner.js';
+export { loadConfig, globToRegExp } from './config.js';
+export { readPackageMeta, readOwnPackageMeta } from './pkg-meta.js';
+export { toJson } from './reporters/json.js';
+export { toSarif } from './reporters/sarif.js';

package/dist/parse.d.ts

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+export declare function parseSource(code: string, filename: string): ts.SourceFile;
+//# sourceMappingURL=parse.d.ts.map

package/dist/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAU5B,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,EAAE,CAAC,UAAU,CAEzE"}

package/dist/parse.js

@@ -0,0 +1,14 @@
+import ts from 'typescript';
+function scriptKindFor(filename) {
+    if (filename.endsWith('.tsx'))
+        return ts.ScriptKind.TSX;
+    if (filename.endsWith('.mts') || filename.endsWith('.cts'))
+        return ts.ScriptKind.TS;
+    if (filename.endsWith('.ts'))
+        return ts.ScriptKind.TS;
+    // .js / .jsx / .mjs / .cjs — parse permissively so JSX in plain JS works.
+    return ts.ScriptKind.JSX;
+}
+export function parseSource(code, filename) {
+    return ts.createSourceFile(filename, code, ts.ScriptTarget.Latest, true, scriptKindFor(filename));
+}

package/dist/pkg-meta.d.ts

@@ -0,0 +1,21 @@
+export interface PackageMeta {
+    name?: string;
+    version?: string;
+    homepage?: string;
+}
+/**
+ * Read a package's own metadata so names, versions and URLs live in one
+ * place (package.json) instead of being duplicated in source.
+ *
+ * Call with `new URL('../package.json', import.meta.url)` — resolves
+ * correctly from both src/ (tests) and dist/ (builds).
+ */
+export declare function readPackageMeta(packageJsonUrl: URL | string): PackageMeta;
+/**
+ * Like readPackageMeta, but safe when `import.meta.url` is unavailable
+ * (e.g. the package was bundled to CJS for a VS Code extension) — the URL
+ * construction itself is guarded, returning {} instead of throwing at
+ * module load.
+ */
+export declare function readOwnPackageMeta(importMetaUrl: string | undefined, rel?: string): PackageMeta;
+//# sourceMappingURL=pkg-meta.d.ts.map

package/dist/pkg-meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pkg-meta.d.ts","sourceRoot":"","sources":["../src/pkg-meta.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,cAAc,EAAE,GAAG,GAAG,MAAM,GAAG,WAAW,CAOzE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,EAAE,GAAG,SAAoB,GAAG,WAAW,CAM1G"}

package/dist/pkg-meta.js

@@ -0,0 +1,31 @@
+import fs from 'node:fs';
+/**
+ * Read a package's own metadata so names, versions and URLs live in one
+ * place (package.json) instead of being duplicated in source.
+ *
+ * Call with `new URL('../package.json', import.meta.url)` — resolves
+ * correctly from both src/ (tests) and dist/ (builds).
+ */
+export function readPackageMeta(packageJsonUrl) {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(packageJsonUrl, 'utf8'));
+        return { name: pkg.name, version: pkg.version, homepage: pkg.homepage };
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Like readPackageMeta, but safe when `import.meta.url` is unavailable
+ * (e.g. the package was bundled to CJS for a VS Code extension) — the URL
+ * construction itself is guarded, returning {} instead of throwing at
+ * module load.
+ */
+export function readOwnPackageMeta(importMetaUrl, rel = '../package.json') {
+    try {
+        return readPackageMeta(new URL(rel, importMetaUrl));
+    }
+    catch {
+        return {};
+    }
+}

package/dist/reporters/json.d.ts

@@ -0,0 +1,3 @@
+import type { ScanResult } from '../types.js';
+export declare function toJson(result: ScanResult): string;
+//# sourceMappingURL=json.d.ts.map

package/dist/reporters/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/reporters/json.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,wBAAgB,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAYjD"}

package/dist/reporters/json.js

@@ -0,0 +1,9 @@
+export function toJson(result) {
+    return JSON.stringify({
+        platform: result.platform,
+        filesScanned: result.filesScanned,
+        durationMs: result.durationMs,
+        issueCount: result.diagnostics.length,
+        issues: result.diagnostics,
+    }, null, 2);
+}

package/dist/reporters/sarif.d.ts

@@ -0,0 +1,9 @@
+import type { Rule, ScanResult } from '../types.js';
+export interface SarifToolInfo {
+    name?: string;
+    version?: string;
+    informationUri?: string;
+}
+/** SARIF 2.1.0 output, compatible with GitHub code scanning. */
+export declare function toSarif(result: ScanResult, rules: Rule[], tool?: SarifToolInfo): string;
+//# sourceMappingURL=sarif.d.ts.map

package/dist/reporters/sarif.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sarif.d.ts","sourceRoot":"","sources":["../../src/reporters/sarif.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAY,MAAM,aAAa,CAAC;AAS9D,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,gEAAgE;AAChE,wBAAgB,OAAO,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,IAAI,GAAE,aAAkB,GAAG,MAAM,CAsD3F"}

package/dist/reporters/sarif.js

@@ -0,0 +1,61 @@
+const SARIF_LEVEL = {
+    critical: 'error',
+    serious: 'error',
+    moderate: 'warning',
+    minor: 'note',
+};
+/** SARIF 2.1.0 output, compatible with GitHub code scanning. */
+export function toSarif(result, rules, tool = {}) {
+    const usedRuleIds = new Set(result.diagnostics.map((d) => d.ruleId));
+    const ruleDescriptors = rules
+        .filter((r) => usedRuleIds.has(r.meta.id))
+        .map((r) => ({
+        id: r.meta.id,
+        shortDescription: { text: r.meta.description },
+        helpUri: r.meta.helpUrl,
+        properties: {
+            severity: r.meta.severity,
+            wcag: r.meta.wcag,
+            tags: ['accessibility', ...r.meta.wcag.map((sc) => `wcag-${sc.replace(/\./g, '')}`)],
+        },
+    }));
+    const ruleIndex = new Map(ruleDescriptors.map((r, i) => [r.id, i]));
+    const sarif = {
+        $schema: 'https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json',
+        version: '2.1.0',
+        runs: [
+            {
+                tool: {
+                    driver: {
+                        name: tool.name ?? 'react-a11y',
+                        ...(tool.version ? { version: tool.version } : {}),
+                        ...(tool.informationUri ? { informationUri: tool.informationUri } : {}),
+                        rules: ruleDescriptors,
+                    },
+                },
+                results: result.diagnostics.map((d) => ({
+                    ruleId: d.ruleId,
+                    ruleIndex: ruleIndex.get(d.ruleId),
+                    level: SARIF_LEVEL[d.severity],
+                    message: {
+                        text: `${d.message} (WCAG ${d.wcag.map((w) => `${w.sc} ${w.name}, Level ${w.level}`).join('; ')})`,
+                    },
+                    locations: [
+                        {
+                            physicalLocation: {
+                                artifactLocation: { uri: d.file },
+                                region: {
+                                    startLine: d.line,
+                                    startColumn: d.column,
+                                    endLine: d.endLine,
+                                    endColumn: d.endColumn,
+                                },
+                            },
+                        },
+                    ],
+                })),
+            },
+        ],
+    };
+    return JSON.stringify(sarif, null, 2);
+}

package/dist/scanner.d.ts

@@ -0,0 +1,16 @@
+import type { A11yConfig, Platform, ProjectPass, Rule, ScanResult } from './types.js';
+export interface ScanOptions {
+    root: string;
+    rules: Rule[];
+    platform: Platform;
+    config?: A11yConfig;
+    /** Cross-file analyses run alongside the per-file rules. */
+    projectPasses?: ProjectPass[];
+    /** Restrict the scan to these files (e.g. --changed); still extension-filtered. */
+    files?: string[];
+}
+/** Detect web vs native from package.json dependencies. */
+export declare function detectPlatform(root: string): Platform;
+export declare function collectFiles(root: string, ignore?: string[]): string[];
+export declare function scanProject(options: ScanOptions): ScanResult;
+//# sourceMappingURL=scanner.d.ts.map

package/dist/scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanner.d.ts","sourceRoot":"","sources":["../src/scanner.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAc,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAWlG,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,QAAQ,EAAE,QAAQ,CAAC;IACnB,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,4DAA4D;IAC5D,aAAa,CAAC,EAAE,WAAW,EAAE,CAAC;IAC9B,mFAAmF;IACnF,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,2DAA2D;AAC3D,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CASrD;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,EAAO,GAAG,MAAM,EAAE,CA+B1E;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,UAAU,CA+C5D"}

package/dist/scanner.js

@@ -0,0 +1,113 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { analyzeModel } from './engine.js';
+import { buildFileModel } from './element.js';
+import { parseSource } from './parse.js';
+import { globToRegExp } from './config.js';
+const SCAN_EXTENSIONS = new Set(['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs']);
+const IGNORED_DIRS = new Set([
+    'node_modules', '.git', 'dist', 'build', 'out', 'coverage',
+    '.next', '.expo', '.turbo', '.cache', 'android', 'ios', 'vendor',
+]);
+const MAX_FILE_SIZE = 1.5 * 1024 * 1024;
+/** Detect web vs native from package.json dependencies. */
+export function detectPlatform(root) {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies, ...pkg.peerDependencies };
+        if (deps['react-native'] || deps['expo'])
+            return 'native';
+    }
+    catch {
+        // no package.json — default to web
+    }
+    return 'web';
+}
+export function collectFiles(root, ignore = []) {
+    const ignoreRes = ignore.map(globToRegExp);
+    const files = [];
+    function walk(dir) {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith('.') && entry.name !== '.')
+                continue;
+            const full = path.join(dir, entry.name);
+            const rel = path.relative(root, full).split(path.sep).join('/');
+            if (ignoreRes.some((re) => re.test(rel)))
+                continue;
+            if (entry.isDirectory()) {
+                if (!IGNORED_DIRS.has(entry.name))
+                    walk(full);
+            }
+            else if (entry.isFile()) {
+                const ext = path.extname(entry.name);
+                if (!SCAN_EXTENSIONS.has(ext))
+                    continue;
+                if (entry.name.endsWith('.d.ts'))
+                    continue;
+                files.push(full);
+            }
+        }
+    }
+    const stat = fs.statSync(root);
+    if (stat.isFile())
+        return [root];
+    walk(root);
+    return files.sort();
+}
+export function scanProject(options) {
+    const { root, rules, platform, config = {}, projectPasses = [] } = options;
+    const started = performance.now();
+    const files = options.files
+        ? options.files
+            .map((f) => (path.isAbsolute(f) ? f : path.resolve(root, f)))
+            .filter((f) => SCAN_EXTENSIONS.has(path.extname(f)) && !f.endsWith('.d.ts') && fs.existsSync(f))
+            .sort()
+        : collectFiles(root, config.ignore ?? []);
+    const diagnostics = [];
+    for (const file of files) {
+        let code;
+        try {
+            if (fs.statSync(file).size > MAX_FILE_SIZE)
+                continue;
+            code = fs.readFileSync(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        // Fast pre-filter: skip files with no JSX-ish content.
+        if (!code.includes('<'))
+            continue;
+        const filename = path.relative(root, file).split(path.sep).join('/') || path.basename(file);
+        const model = buildFileModel(parseSource(code, filename));
+        diagnostics.push(...analyzeModel(model, { filename, platform, rules, ruleSettings: config.rules }));
+        for (const pass of projectPasses)
+            pass.collect(model, filename);
+    }
+    for (const pass of projectPasses)
+        diagnostics.push(...pass.finalize());
+    for (const rule of rules) {
+        if (!rule.projectCheck || !rule.meta.platforms.includes(platform))
+            continue;
+        const setting = config.rules?.[rule.meta.id];
+        if (setting === 'off')
+            continue;
+        for (const diag of rule.projectCheck(root)) {
+            diagnostics.push(setting ? { ...diag, severity: setting } : diag);
+        }
+    }
+    diagnostics.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line || a.column - b.column);
+    return {
+        diagnostics,
+        filesScanned: files.length,
+        durationMs: Math.round(performance.now() - started),
+        platform,
+        root,
+    };
+}