@techsio/storybook-better-a11y 0.0.5 → 0.0.7

package/dist/100.js

@@ -0,0 +1,122 @@
+const ADDON_ID = 'storybook/a11y';
+const PANEL_ID = `${ADDON_ID}/panel`;
+"a11y";
+"vision";
+const RESULT = `${ADDON_ID}/result`;
+const REQUEST = `${ADDON_ID}/request`;
+const RUNNING = `${ADDON_ID}/running`;
+const ERROR = `${ADDON_ID}/error`;
+const MANUAL = `${ADDON_ID}/manual`;
+const SELECT = `${ADDON_ID}/select`;
+const DOCUMENTATION_LINK = 'writing-tests/accessibility-testing';
+const DOCUMENTATION_DISCREPANCY_LINK = `${DOCUMENTATION_LINK}#why-are-my-tests-failing-in-different-environments`;
+const EVENTS = {
+    RESULT: RESULT,
+    REQUEST: REQUEST,
+    RUNNING: RUNNING,
+    ERROR: ERROR,
+    MANUAL: MANUAL,
+    SELECT: SELECT
+};
+const STATUS_TYPE_ID_COMPONENT_TEST = 'storybook/component-test';
+const STATUS_TYPE_ID_A11Y = 'storybook/a11y';
+const filters = {
+    blurred: {
+        label: 'Blurred vision',
+        filter: 'blur(2px)',
+        percentage: 22.9
+    },
+    deuteranomaly: {
+        label: 'Deuteranomaly',
+        filter: 'url("#storybook-a11y-vision-deuteranomaly")',
+        percentage: 2.7
+    },
+    deuteranopia: {
+        label: 'Deuteranopia',
+        filter: 'url("#storybook-a11y-vision-deuteranopia")',
+        percentage: 0.56
+    },
+    protanomaly: {
+        label: 'Protanomaly',
+        filter: 'url("#storybook-a11y-vision-protanomaly")',
+        percentage: 0.66
+    },
+    protanopia: {
+        label: 'Protanopia',
+        filter: 'url("#storybook-a11y-vision-protanopia")',
+        percentage: 0.59
+    },
+    tritanomaly: {
+        label: 'Tritanomaly',
+        filter: 'url("#storybook-a11y-vision-tritanomaly")',
+        percentage: 0.01
+    },
+    tritanopia: {
+        label: 'Tritanopia',
+        filter: 'url("#storybook-a11y-vision-tritanopia")',
+        percentage: 0.016
+    },
+    achromatopsia: {
+        label: 'Achromatopsia',
+        filter: 'url("#storybook-a11y-vision-achromatopsia")',
+        percentage: 0.0001
+    },
+    grayscale: {
+        label: 'Grayscale',
+        filter: 'grayscale(100%)'
+    }
+};
+const filterDefs = `<svg id="storybook-a11y-vision-filters" style="display: none !important;">
+  <defs>
+    <filter id="storybook-a11y-vision-protanopia">
+      <feColorMatrix
+        in="SourceGraphic"
+        type="matrix"
+        values="0.567, 0.433, 0, 0, 0 0.558, 0.442, 0, 0, 0 0, 0.242, 0.758, 0, 0 0, 0, 0, 1, 0"
+      />
+    </filter>
+    <filter id="storybook-a11y-vision-protanomaly">
+      <feColorMatrix
+        in="SourceGraphic"
+        type="matrix"
+        values="0.817, 0.183, 0, 0, 0 0.333, 0.667, 0, 0, 0 0, 0.125, 0.875, 0, 0 0, 0, 0, 1, 0"
+      />
+    </filter>
+    <filter id="storybook-a11y-vision-deuteranopia">
+      <feColorMatrix
+        in="SourceGraphic"
+        type="matrix"
+        values="0.625, 0.375, 0, 0, 0 0.7, 0.3, 0, 0, 0 0, 0.3, 0.7, 0, 0 0, 0, 0, 1, 0"
+      />
+    </filter>
+    <filter id="storybook-a11y-vision-deuteranomaly">
+      <feColorMatrix
+        in="SourceGraphic"
+        type="matrix"
+        values="0.8, 0.2, 0, 0, 0 0.258, 0.742, 0, 0, 0 0, 0.142, 0.858, 0, 0 0, 0, 0, 1, 0"
+      />
+    </filter>
+    <filter id="storybook-a11y-vision-tritanopia">
+      <feColorMatrix
+        in="SourceGraphic"
+        type="matrix"
+        values="0.95, 0.05,  0, 0, 0 0,  0.433, 0.567, 0, 0 0,  0.475, 0.525, 0, 0 0,  0, 0, 1, 0"
+      />
+    </filter>
+    <filter id="storybook-a11y-vision-tritanomaly">
+      <feColorMatrix
+        in="SourceGraphic"
+        type="matrix"
+        values="0.967, 0.033, 0, 0, 0 0, 0.733, 0.267, 0, 0 0, 0.183, 0.817, 0, 0 0, 0, 0, 1, 0"
+      />
+    </filter>
+    <filter id="storybook-a11y-vision-achromatopsia">
+      <feColorMatrix
+        in="SourceGraphic"
+        type="matrix"
+        values="0.299, 0.587, 0.114, 0, 0 0.299, 0.587, 0.114, 0, 0 0.299, 0.587, 0.114, 0, 0 0, 0, 0, 1, 0"
+      />
+    </filter>
+  </defs>
+</svg>`;
+export { ADDON_ID, DOCUMENTATION_DISCREPANCY_LINK, EVENTS, PANEL_ID, STATUS_TYPE_ID_A11Y, STATUS_TYPE_ID_COMPONENT_TEST, filterDefs, filters };

package/dist/699.js

@@ -0,0 +1,540 @@
+import { __webpack_require__ } from "./rslib-runtime.js";
+import { expect } from "storybook/test";
+import { ElementA11yParameterError } from "storybook/internal/preview-errors";
+import { global } from "@storybook/global";
+import { addons, useCallback, useEffect, waitForAnimations } from "storybook/preview-api";
+import { EVENTS, filters, filterDefs, PANEL_ID } from "./100.js";
+var preview_namespaceObject = {};
+__webpack_require__.r(preview_namespaceObject);
+__webpack_require__.d(preview_namespaceObject, {
+    afterEach: ()=>afterEach,
+    decorators: ()=>decorators,
+    initialGlobals: ()=>initialGlobals,
+    parameters: ()=>preview_parameters
+});
+const { document: a11yRunnerUtils_document } = global;
+const withLinkPaths = (results, storyId)=>{
+    const pathname = a11yRunnerUtils_document.location.pathname.replace(/iframe\.html$/, '');
+    const enhancedResults = {
+        ...results
+    };
+    const propertiesToAugment = [
+        'incomplete',
+        'passes',
+        'violations'
+    ];
+    propertiesToAugment.forEach((key)=>{
+        if (Array.isArray(results[key])) enhancedResults[key] = results[key].map((result)=>({
+                ...result,
+                nodes: result.nodes.map((node, index)=>{
+                    const id = `${key}.${result.id}.${index + 1}`;
+                    const linkPath = `${pathname}?path=/story/${storyId}&addonPanel=${PANEL_ID}&a11ySelection=${id}`;
+                    return {
+                        id,
+                        ...node,
+                        linkPath
+                    };
+                })
+            }));
+    });
+    return enhancedResults;
+};
+const { document: apcaChecker_document } = global;
+const DEFAULT_APCA_OPTIONS = {
+    level: 'bronze',
+    useCase: 'body'
+};
+const APCA_LC_STEPS = [
+    15,
+    20,
+    25,
+    30,
+    35,
+    40,
+    45,
+    50,
+    55,
+    60,
+    65,
+    70,
+    75,
+    80,
+    85,
+    90,
+    95,
+    100,
+    105,
+    110,
+    115,
+    120,
+    125
+];
+const APCA_MAX_CONTRAST_LC = 90;
+function getComputedColor(element, property) {
+    const computed = global.getComputedStyle(element);
+    return computed[property] || '';
+}
+function getEffectiveBackgroundColor(element) {
+    let current = element;
+    while(current && current !== apcaChecker_document.body){
+        const bgColor = getComputedColor(current, 'backgroundColor');
+        if (bgColor && 'rgba(0, 0, 0, 0)' !== bgColor && 'transparent' !== bgColor) return bgColor;
+        current = current.parentElement;
+    }
+    return 'rgb(255, 255, 255)';
+}
+function parseColor(color) {
+    const match = color.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
+    if (!match) return null;
+    return [
+        parseInt(match[1], 10),
+        parseInt(match[2], 10),
+        parseInt(match[3], 10)
+    ];
+}
+function normalizeUseCase(value, fallback) {
+    if (!value) return fallback;
+    const normalized = value.toLowerCase().replace(/\s+/g, '-');
+    if (normalized.includes('body')) return 'body';
+    if (normalized.includes('sub') || normalized.includes('logo')) return 'sub-fluent';
+    if (normalized.includes('non') || normalized.includes('incidental') || normalized.includes('spot')) return 'non-fluent';
+    if (normalized.includes('fluent')) return 'fluent';
+    return fallback;
+}
+function getUseCaseForElement(element, fallback) {
+    const attr = element.getAttribute('data-apca-usecase') ?? element.getAttribute('data-apca-use-case') ?? element.getAttribute('data-apca-usage');
+    return normalizeUseCase(attr, fallback);
+}
+function normalizeWeightBucket(fontWeight) {
+    const weight = Number.isFinite(fontWeight) ? fontWeight : 400;
+    const clamped = Math.max(100, Math.min(900, weight));
+    return 100 * Math.round(clamped / 100);
+}
+function getBronzeThreshold(useCase, fontSize) {
+    if ('body' === useCase) return {
+        threshold: 75,
+        preferred: 90
+    };
+    if ('fluent' === useCase) {
+        if (fontSize > 32) return {
+            threshold: 45
+        };
+        if (fontSize >= 16) return {
+            threshold: 60
+        };
+        return {
+            threshold: 75
+        };
+    }
+    return null;
+}
+function getMinFontSize(level, useCase) {
+    if ('bronze' === level) return;
+    if ('sub-fluent' === useCase) return 'gold' === level ? 12 : 10;
+    if ('fluent' === useCase || 'body' === useCase) return 'gold' === level ? 16 : 14;
+}
+function getMaxContrast(level, useCase, fontSize, fontWeight) {
+    if ('bronze' === level) {
+        if ('fluent' === useCase && fontSize > 32 && fontWeight >= 700) return APCA_MAX_CONTRAST_LC;
+        return;
+    }
+    if (('body' === useCase || 'fluent' === useCase) && fontSize > 36) return APCA_MAX_CONTRAST_LC;
+}
+function getBaseThresholdFromLookup(fontSize, fontWeight, allowNonContent, fontLookupAPCA) {
+    const weightBucket = normalizeWeightBucket(fontWeight);
+    const weightIndex = Math.round(weightBucket / 100);
+    for (const lc of APCA_LC_STEPS){
+        const row = fontLookupAPCA(lc, 2);
+        const requiredSize = Number(row[weightIndex]);
+        if (!Number.isFinite(requiredSize)) continue;
+        if (999 === requiredSize) continue;
+        if (777 === requiredSize && !allowNonContent) continue;
+        const minSize = 777 === requiredSize ? 0 : requiredSize;
+        if (fontSize >= minSize) return lc;
+    }
+    return null;
+}
+function getApcaThreshold(level, useCase, fontSize, fontWeight, fontLookupAPCA) {
+    if ('bronze' === level) {
+        const bronzeThreshold = getBronzeThreshold(useCase, fontSize);
+        if (!bronzeThreshold) return {
+            threshold: null,
+            skip: true
+        };
+        return {
+            threshold: bronzeThreshold.threshold,
+            maxContrast: getMaxContrast(level, useCase, fontSize, fontWeight)
+        };
+    }
+    const minFontSize = getMinFontSize(level, useCase);
+    const baseThreshold = getBaseThresholdFromLookup(fontSize, fontWeight, 'non-fluent' === useCase, fontLookupAPCA);
+    if (null === baseThreshold) return {
+        threshold: null,
+        minFontSize,
+        note: 'Font size/weight is below the minimums in the APCA lookup table for this use case.'
+    };
+    let threshold = baseThreshold;
+    if ('sub-fluent' === useCase) threshold = Math.max(threshold - 15, 'silver' === level ? 40 : 45);
+    else if ('non-fluent' === useCase) threshold = Math.max(threshold - ('silver' === level ? 30 : 20), 30);
+    if ('body' === useCase && 'gold' === level && threshold < 75) threshold += 15;
+    return {
+        threshold,
+        minFontSize,
+        maxContrast: getMaxContrast(level, useCase, fontSize, fontWeight)
+    };
+}
+function hasReadableText(element) {
+    const text = element.textContent?.trim() || '';
+    return text.length > 0 && !element.hasAttribute('aria-hidden');
+}
+function isVisible(element) {
+    const computed = global.getComputedStyle(element);
+    return 'none' !== computed.display && 'hidden' !== computed.visibility && '0' !== computed.opacity;
+}
+async function runAPCACheck(context = apcaChecker_document, options = DEFAULT_APCA_OPTIONS, excludeSelectors = []) {
+    const { APCAcontrast, sRGBtoY, fontLookupAPCA } = await import("apca-w3");
+    const apcaOptions = {
+        ...DEFAULT_APCA_OPTIONS,
+        ...options
+    };
+    const violations = [];
+    const root = context instanceof Document ? context.body : context;
+    const textElements = root.querySelectorAll('p, span, div, h1, h2, h3, h4, h5, h6, a, button, label, td, th, li, input, textarea');
+    textElements.forEach((element)=>{
+        if (excludeSelectors.length > 0) {
+            const isExcluded = excludeSelectors.some((selector)=>{
+                try {
+                    return null !== element.closest(selector);
+                } catch  {
+                    return false;
+                }
+            });
+            if (isExcluded) return;
+        }
+        if (!isVisible(element) || !hasReadableText(element)) return;
+        const foreground = getComputedColor(element, 'color');
+        const background = getEffectiveBackgroundColor(element);
+        const fgColor = parseColor(foreground);
+        const bgColor = parseColor(background);
+        if (!fgColor || !bgColor) return;
+        const computed = global.getComputedStyle(element);
+        const fontSize = parseFloat(computed.fontSize);
+        const fontWeight = parseInt(computed.fontWeight, 10);
+        try {
+            const fgLuminance = sRGBtoY(fgColor);
+            const bgLuminance = sRGBtoY(bgColor);
+            const contrastValue = Math.abs(APCAcontrast(fgLuminance, bgLuminance));
+            const useCase = getUseCaseForElement(element, apcaOptions.useCase);
+            const level = apcaOptions.level;
+            const { threshold, minFontSize, maxContrast, note, skip } = getApcaThreshold(level, useCase, fontSize, fontWeight, fontLookupAPCA);
+            if (skip) return;
+            const messages = [];
+            if (null === threshold) {
+                if (note) messages.push(note);
+            } else {
+                if (contrastValue < threshold) messages.push(`APCA contrast of ${contrastValue.toFixed(1)} Lc is below the minimum of ${threshold} Lc for ${level} ${useCase} text.`);
+                if (void 0 !== maxContrast && contrastValue > maxContrast) messages.push(`APCA contrast of ${contrastValue.toFixed(1)} Lc exceeds the maximum of ${maxContrast} Lc for ${level} ${useCase} text at ${fontSize.toFixed(1)}px.`);
+            }
+            if (minFontSize && fontSize < minFontSize) messages.push(`Font size ${fontSize.toFixed(1)}px is below the minimum ${minFontSize}px for ${level} ${useCase} text.`);
+            if (messages.length > 0) violations.push({
+                element,
+                foreground,
+                background,
+                contrastValue,
+                fontSize,
+                fontWeight,
+                threshold,
+                maxContrast,
+                useCase,
+                level,
+                minFontSize,
+                note
+            });
+        } catch (error) {
+            console.warn('APCA calculation error:', error);
+        }
+    });
+    const nodes = violations.map((violation)=>{
+        const impact = getImpact(violation.contrastValue, violation.threshold, violation.maxContrast);
+        const messages = [];
+        if (violation.note) messages.push(violation.note);
+        else if (null !== violation.threshold && violation.contrastValue < violation.threshold) messages.push(`APCA contrast of ${violation.contrastValue.toFixed(1)} Lc is below the minimum of ${violation.threshold} Lc for ${violation.level} ${violation.useCase} text.`);
+        if (void 0 !== violation.maxContrast && violation.contrastValue > violation.maxContrast) messages.push(`APCA contrast of ${violation.contrastValue.toFixed(1)} Lc exceeds the maximum of ${violation.maxContrast} Lc for ${violation.level} ${violation.useCase} text at ${violation.fontSize.toFixed(1)}px.`);
+        if (violation.minFontSize && violation.fontSize < violation.minFontSize) messages.push(`Font size ${violation.fontSize.toFixed(1)}px is below the minimum ${violation.minFontSize}px for ${violation.level} ${violation.useCase} text.`);
+        const rules = messages.map((message)=>({
+                id: 'apca-contrast',
+                impact,
+                message,
+                data: null,
+                relatedNodes: []
+            }));
+        const failureSummary = `Fix any of the following:\n  ${messages.join('\n  ')}`;
+        return {
+            html: violation.element.outerHTML,
+            target: [
+                getSelector(violation.element)
+            ],
+            any: rules,
+            all: [],
+            none: [],
+            impact,
+            failureSummary
+        };
+    });
+    return {
+        id: 'apca-contrast',
+        impact: nodes.length > 0 ? 'serious' : null,
+        tags: [
+            'wcag3',
+            'wcag30',
+            'apca',
+            'contrast'
+        ],
+        description: 'Ensures text has sufficient contrast using APCA (WCAG 3.0 method)',
+        help: 'Elements must have sufficient color contrast using APCA',
+        helpUrl: 'https://git.apcacontrast.com/',
+        nodes
+    };
+}
+function getSelector(element) {
+    if (element.id) return `#${element.id}`;
+    const path = [];
+    let current = element;
+    while(current && current !== apcaChecker_document.body){
+        let selector = current.tagName.toLowerCase();
+        if (current.className) {
+            const classes = current.className.split(' ').filter(Boolean);
+            if (classes.length > 0) selector += `.${classes[0]}`;
+        }
+        const parent = current.parentElement;
+        if (parent) {
+            const siblings = Array.from(parent.children);
+            const index = siblings.indexOf(current) + 1;
+            selector += `:nth-child(${index})`;
+        }
+        path.unshift(selector);
+        current = parent;
+    }
+    return path.join(' > ');
+}
+function getImpact(contrastValue, threshold, maxContrast) {
+    if (null === threshold && void 0 === maxContrast) return 'serious';
+    const difference = void 0 !== maxContrast && contrastValue > maxContrast ? contrastValue - maxContrast : (threshold ?? 0) - contrastValue;
+    if (difference > 30) return 'critical';
+    if (difference > 20) return 'serious';
+    if (difference > 10) return 'moderate';
+    return 'minor';
+}
+const { document: a11yRunner_document } = global;
+const channel = addons.getChannel();
+const DEFAULT_PARAMETERS = {
+    config: {},
+    options: {}
+};
+const DISABLED_RULES = [
+    'region'
+];
+const queue = [];
+let isRunning = false;
+const runNext = async ()=>{
+    if (0 === queue.length) {
+        isRunning = false;
+        return;
+    }
+    isRunning = true;
+    const next = queue.shift();
+    if (next) await next();
+    runNext();
+};
+const run = async (input = DEFAULT_PARAMETERS, storyId)=>{
+    const axeCore = await import("axe-core");
+    const axe = axeCore?.default || globalThis.axe;
+    const { config = {}, options = {} } = input;
+    if (input.element) throw new ElementA11yParameterError();
+    const context = {
+        include: a11yRunner_document?.body,
+        exclude: [
+            '.sb-wrapper',
+            '#storybook-docs',
+            '#storybook-highlights-root'
+        ]
+    };
+    if (input.context) {
+        const hasInclude = 'object' == typeof input.context && 'include' in input.context && void 0 !== input.context.include;
+        const hasExclude = 'object' == typeof input.context && 'exclude' in input.context && void 0 !== input.context.exclude;
+        if (hasInclude) context.include = input.context.include;
+        else if (!hasInclude && !hasExclude) context.include = input.context;
+        if (hasExclude) context.exclude = context.exclude.concat(input.context.exclude);
+    }
+    axe.reset();
+    const configWithDefault = {
+        ...config,
+        rules: [
+            ...DISABLED_RULES.map((id)=>({
+                    id,
+                    enabled: false
+                })),
+            ...config?.rules ?? []
+        ]
+    };
+    axe.configure(configWithDefault);
+    return new Promise((resolve, reject)=>{
+        const highlightsRoot = a11yRunner_document?.getElementById('storybook-highlights-root');
+        if (highlightsRoot) highlightsRoot.style.display = 'none';
+        const task = async ()=>{
+            try {
+                const result = await axe.run(context, options);
+                let contextElement = a11yRunner_document;
+                if (context.include instanceof Element) contextElement = context.include;
+                else if (Array.isArray(context.include)) {
+                    const first = context.include[0];
+                    if (first instanceof Element) contextElement = first;
+                    else if ('string' == typeof first) contextElement = a11yRunner_document.querySelector(first) || a11yRunner_document;
+                } else if ('string' == typeof context.include) contextElement = a11yRunner_document.querySelector(context.include) || a11yRunner_document;
+                const excludeSelectors = Array.isArray(context.exclude) ? context.exclude.filter((value)=>'string' == typeof value) : 'string' == typeof context.exclude ? [
+                    context.exclude
+                ] : [];
+                const apcaResult = await runAPCACheck(contextElement, input.apca, excludeSelectors);
+                if (apcaResult.nodes.length > 0) result.violations.push(apcaResult);
+                else result.passes.push(apcaResult);
+                const resultWithLinks = withLinkPaths(result, storyId);
+                globalThis.__TECHSIO_A11Y_RESULTS__ = {
+                    storyId,
+                    results: resultWithLinks,
+                    timestamp: Date.now()
+                };
+                resolve(resultWithLinks);
+            } catch (error) {
+                reject(error);
+            }
+        };
+        queue.push(task);
+        if (!isRunning) runNext();
+        if (highlightsRoot) highlightsRoot.style.display = '';
+    });
+};
+channel.on(EVENTS.MANUAL, async (storyId, input = DEFAULT_PARAMETERS)=>{
+    try {
+        await waitForAnimations();
+        const result = await run(input, storyId);
+        const resultJson = JSON.parse(JSON.stringify(result));
+        channel.emit(EVENTS.RESULT, resultJson, storyId);
+    } catch (error) {
+        channel.emit(EVENTS.ERROR, error);
+    }
+});
+function getIsVitestStandaloneRun() {
+    try {
+        return 'false' === ({
+            MODE: "production",
+            DEV: false,
+            PROD: true,
+            BASE_URL: "/",
+            ASSET_PREFIX: "auto"
+        }).VITEST_STORYBOOK;
+    } catch (e) {
+        return false;
+    }
+}
+const knownFilters = Object.values(filters).map((f)=>f.filter);
+const knownFiltersRegExp = new RegExp(`\\b(${knownFilters.join('|')})\\b`, 'g');
+const withVisionSimulator = (StoryFn, { globals })=>{
+    const { vision } = globals;
+    const applyVisionFilter = useCallback(()=>{
+        const existingFilters = document.body.style.filter.replaceAll(knownFiltersRegExp, '').trim();
+        const visionFilter = filters[vision]?.filter;
+        if (visionFilter && document.body.classList.contains('sb-show-main')) if (existingFilters && 'none' !== existingFilters) document.body.style.filter = `${existingFilters} ${visionFilter}`;
+        else document.body.style.filter = visionFilter;
+        else document.body.style.filter = existingFilters || 'none';
+        return ()=>document.body.style.filter = existingFilters || 'none';
+    }, [
+        vision
+    ]);
+    useEffect(()=>{
+        const cleanup = applyVisionFilter();
+        const observer = new MutationObserver(()=>applyVisionFilter());
+        observer.observe(document.body, {
+            attributeFilter: [
+                'class'
+            ]
+        });
+        return ()=>{
+            cleanup();
+            observer.disconnect();
+        };
+    }, [
+        applyVisionFilter
+    ]);
+    useEffect(()=>{
+        document.body.insertAdjacentHTML('beforeend', filterDefs);
+        return ()=>{
+            const filterDefsElement = document.getElementById('storybook-a11y-vision-filters');
+            filterDefsElement?.parentElement?.removeChild(filterDefsElement);
+        };
+    }, []);
+    return StoryFn();
+};
+let vitestMatchersExtended = false;
+const decorators = [
+    withVisionSimulator
+];
+const afterEach = async ({ id: storyId, reporting, parameters, globals, viewMode })=>{
+    const a11yParameter = parameters.a11y;
+    const a11yGlobals = globals.a11y;
+    const shouldRunEnvironmentIndependent = a11yParameter?.disable !== true && a11yParameter?.test !== 'off' && a11yGlobals?.manual !== true;
+    const getMode = ()=>{
+        switch(a11yParameter?.test){
+            case 'todo':
+                return 'warning';
+            case 'error':
+            default:
+                return 'failed';
+        }
+    };
+    if (shouldRunEnvironmentIndependent && 'story' === viewMode) try {
+        const result = await run(a11yParameter, storyId);
+        if (result) {
+            const hasViolations = (result?.violations.length ?? 0) > 0;
+            reporting.addReport({
+                type: 'a11y',
+                version: 1,
+                result,
+                status: hasViolations ? getMode() : 'passed'
+            });
+            if (getIsVitestStandaloneRun()) {
+                if (hasViolations && 'failed' === getMode()) {
+                    if (!vitestMatchersExtended) {
+                        const { toHaveNoViolations } = await import("vitest-axe/matchers");
+                        expect.extend({
+                            toHaveNoViolations
+                        });
+                        vitestMatchersExtended = true;
+                    }
+                    expect(result).toHaveNoViolations();
+                }
+            }
+        }
+    } catch (e) {
+        reporting.addReport({
+            type: 'a11y',
+            version: 1,
+            result: {
+                error: e
+            },
+            status: 'failed'
+        });
+        if (getIsVitestStandaloneRun()) throw e;
+    }
+};
+const initialGlobals = {
+    a11y: {
+        manual: false
+    },
+    vision: void 0
+};
+const preview_parameters = {
+    a11y: {
+        test: 'todo'
+    }
+};
+export { afterEach, decorators, initialGlobals, preview_namespaceObject, preview_parameters as parameters };

package/dist/index.js

@@ -1,6 +1,7 @@
 import { definePreviewAddon } from "storybook/internal/csf";
-import { PARAM_KEY } from "./constants.js";
-export * from "./params.js";
-import * as __rspack_external__preview_js_3b21eac2 from "./preview.js";
-const src = ()=>definePreviewAddon(__rspack_external__preview_js_3b21eac2);
-export { PARAM_KEY, src as default };
+import { preview_namespaceObject } from "./699.js";
+import "./100.js";
+const src = ()=>definePreviewAddon(preview_namespaceObject);
+var src_PARAM_KEY = "a11y";
+export default src;
+export { src_PARAM_KEY as PARAM_KEY };