@kiwa-test/component 0.2.0

package/dist/index.cjs

@@ -0,0 +1,802 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  addHandler: () => addHandler,
+  appendChild: () => appendChild,
+  buildButton: () => buildButton,
+  buildCard: () => buildCard,
+  buildForm: () => buildForm,
+  buildInput: () => buildInput,
+  buildModal: () => buildModal,
+  componentFixtures: () => componentFixtures,
+  createCanvas: () => createCanvas,
+  createChromaticVisualMock: () => createChromaticVisualMock,
+  createNode: () => createNode,
+  createPlaywrightCTMock: () => createPlaywrightCTMock,
+  createStoryRegistry: () => createStoryRegistry,
+  findByRole: () => findByRole,
+  findByText: () => findByText,
+  fireEvent: () => fireEvent,
+  hashMarkup: () => hashMarkup,
+  query: () => query,
+  renderMarkup: () => renderMarkup
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/dom.ts
+var import_node_crypto = require("crypto");
+function createNode(tag, options = {}) {
+  const node = {
+    tag,
+    attrs: options.attrs ?? {},
+    children: [],
+    handlers: {},
+    parent: null,
+    ...options.text !== void 0 ? { text: options.text } : {},
+    ...options.value !== void 0 ? { value: options.value } : {}
+  };
+  for (const child of options.children ?? []) {
+    appendChild(node, child);
+  }
+  if (options.on) {
+    for (const [event, handler] of Object.entries(options.on)) {
+      addHandler(node, event, handler);
+    }
+  }
+  return node;
+}
+function appendChild(parent, child) {
+  parent.children.push(child);
+  child.parent = parent;
+}
+function addHandler(node, event, handler) {
+  if (!node.handlers[event]) {
+    node.handlers[event] = [];
+  }
+  node.handlers[event].push(handler);
+}
+function fireEvent(node, event) {
+  const handlers = node.handlers[event.type];
+  if (!handlers) return;
+  for (const handler of handlers) {
+    handler(event);
+  }
+}
+function createCanvas(root) {
+  return {
+    root,
+    getByText: (text) => {
+      const found = findByText(root, text);
+      if (!found) {
+        throw new Error(`Canvas.getByText \u2014 no node with text ${JSON.stringify(text)}`);
+      }
+      return found;
+    },
+    getByRole: (role, options) => {
+      const found = findByRole(root, role, options?.name);
+      if (!found) {
+        const nameSuffix = options?.name ? ` name=${JSON.stringify(options.name)}` : "";
+        throw new Error(`Canvas.getByRole \u2014 no node with role=${role}${nameSuffix}`);
+      }
+      return found;
+    },
+    querySelector: (selector) => query(root, selector, false)[0] ?? null,
+    querySelectorAll: (selector) => query(root, selector, true),
+    toMarkup: () => renderMarkup(root)
+  };
+}
+function renderMarkup(node) {
+  const attrs = Object.entries(node.attrs).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => ` ${k}=${JSON.stringify(v)}`).join("");
+  const valueAttr = node.value !== void 0 ? ` value=${JSON.stringify(node.value)}` : "";
+  const openTag = `<${node.tag}${attrs}${valueAttr}>`;
+  const inner = [
+    node.text ?? "",
+    ...node.children.map(renderMarkup)
+  ].join("");
+  return `${openTag}${inner}</${node.tag}>`;
+}
+function hashMarkup(markup) {
+  return (0, import_node_crypto.createHash)("sha256").update(markup).digest("hex").slice(0, 16);
+}
+function findByText(node, text) {
+  for (const child of node.children) {
+    const found = findByText(child, text);
+    if (found) return found;
+  }
+  if (nodeText(node) === text) return node;
+  return null;
+}
+function findByRole(node, role, accessibleName) {
+  const implicit = implicitRole(node);
+  const nodeRole = node.attrs["role"] ?? implicit;
+  if (nodeRole === role) {
+    if (accessibleName === void 0) return node;
+    const name = accessibleNameOf(node);
+    if (name === accessibleName) return node;
+  }
+  for (const child of node.children) {
+    const found = findByRole(child, role, accessibleName);
+    if (found) return found;
+  }
+  return null;
+}
+function nodeText(node) {
+  if (node.text !== void 0) return node.text.trim();
+  return node.children.map((c) => c.text ?? "").join("").trim();
+}
+function implicitRole(node) {
+  switch (node.tag) {
+    case "button":
+      return "button";
+    case "a":
+      return node.attrs["href"] ? "link" : null;
+    case "h1":
+    case "h2":
+    case "h3":
+    case "h4":
+    case "h5":
+    case "h6":
+      return "heading";
+    case "input": {
+      const type = node.attrs["type"] ?? "text";
+      if (type === "checkbox") return "checkbox";
+      if (type === "radio") return "radio";
+      if (type === "submit" || type === "button") return "button";
+      return "textbox";
+    }
+    case "textarea":
+      return "textbox";
+    case "nav":
+      return "navigation";
+    case "main":
+      return "main";
+    default:
+      return null;
+  }
+}
+function accessibleNameOf(node) {
+  const label = node.attrs["aria-label"];
+  if (label) return label;
+  return nodeText(node);
+}
+function query(root, selector, all) {
+  const parts = selector.trim().split(/\s+/);
+  let candidates = collectTree(root);
+  for (const part of parts) {
+    candidates = candidates.filter((n) => matchesSimple(n, part));
+    if (!all && candidates.length > 0) {
+      return [candidates[0]];
+    }
+  }
+  return all ? candidates : candidates.length > 0 ? [candidates[0]] : [];
+}
+function collectTree(root) {
+  const out = [root];
+  for (const child of root.children) {
+    out.push(...collectTree(child));
+  }
+  return out;
+}
+function matchesSimple(node, selector) {
+  let rest = selector;
+  const tagMatch = rest.match(/^([a-zA-Z][a-zA-Z0-9_-]*)/);
+  if (tagMatch) {
+    if (node.tag !== tagMatch[1]) return false;
+    rest = rest.slice(tagMatch[0].length);
+  }
+  while (rest.length > 0) {
+    const attr = rest.match(/^\[([a-zA-Z0-9_-]+)(=(\"[^\"]*\"|'[^']*'|[^\]]+))?\]/);
+    if (attr) {
+      const name = attr[1];
+      const raw = attr[3];
+      if (raw === void 0) {
+        if (node.attrs[name] === void 0) return false;
+      } else {
+        const unquoted = raw.replace(/^["']|["']$/g, "");
+        if (node.attrs[name] !== unquoted) return false;
+      }
+      rest = rest.slice(attr[0].length);
+      continue;
+    }
+    const cls = rest.match(/^\.([a-zA-Z0-9_-]+)/);
+    if (cls) {
+      const nodeClasses = (node.attrs["class"] ?? "").split(/\s+/).filter(Boolean);
+      if (!nodeClasses.includes(cls[1])) return false;
+      rest = rest.slice(cls[0].length);
+      continue;
+    }
+    const id = rest.match(/^#([a-zA-Z0-9_-]+)/);
+    if (id) {
+      if (node.attrs["id"] !== id[1]) return false;
+      rest = rest.slice(id[0].length);
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+
+// src/storybook.ts
+function createStoryRegistry() {
+  const registry = /* @__PURE__ */ new Map();
+  const buildId = (title, storyName) => {
+    const norm = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+    return `${norm(title)}--${norm(storyName)}`;
+  };
+  const requireEntry = (title, storyName) => {
+    const id = buildId(title, storyName);
+    const entry = registry.get(id);
+    if (!entry) {
+      throw new Error(`StoryRegistry \u2014 no entry for ${id}`);
+    }
+    return entry;
+  };
+  return {
+    register(meta) {
+      for (const [storyName, story] of Object.entries(meta.stories)) {
+        const id = buildId(meta.title, storyName);
+        const mergedArgs = { ...meta.args ?? {}, ...story.args ?? {} };
+        const mergedParams = {
+          ...meta.parameters ?? {},
+          ...story.parameters ?? {},
+          ...meta.parameters?.chromatic || story.parameters?.chromatic ? {
+            chromatic: {
+              ...meta.parameters?.chromatic ?? {},
+              ...story.parameters?.chromatic ?? {}
+            }
+          } : {},
+          ...meta.parameters?.a11y || story.parameters?.a11y ? {
+            a11y: {
+              ...meta.parameters?.a11y ?? {},
+              ...story.parameters?.a11y ?? {}
+            }
+          } : {}
+        };
+        const entry = {
+          id,
+          title: meta.title,
+          storyName,
+          args: mergedArgs,
+          render: meta.render,
+          parameters: mergedParams,
+          ...story.play ? {
+            play: story.play
+          } : {}
+        };
+        registry.set(id, entry);
+      }
+    },
+    list() {
+      return Array.from(registry.values());
+    },
+    get(title, storyName) {
+      return requireEntry(title, storyName);
+    },
+    mount(title, storyName, overrideArgs) {
+      const entry = requireEntry(title, storyName);
+      const args = { ...entry.args, ...overrideArgs ?? {} };
+      const root = entry.render(args);
+      const canvas = createCanvas(root);
+      return { canvas, entry: { ...entry, args } };
+    },
+    async play(title, storyName, canvas, args) {
+      const entry = requireEntry(title, storyName);
+      const mergedArgs = { ...entry.args, ...args ?? {} };
+      const steps = [];
+      const context = {
+        canvasElement: canvas,
+        args: mergedArgs,
+        step: async (label, fn) => {
+          try {
+            await fn();
+            steps.push({ label, ok: true });
+          } catch (error) {
+            steps.push({ label, ok: false, error: error.message });
+            throw error;
+          }
+        }
+      };
+      if (!entry.play) {
+        return { steps: [], ok: true };
+      }
+      try {
+        await entry.play(context);
+        return { steps, ok: steps.every((s) => s.ok) };
+      } catch {
+        return { steps, ok: false };
+      }
+    },
+    runA11y(title, storyName, canvas) {
+      const entry = requireEntry(title, storyName);
+      if (entry.parameters.a11y?.disable) {
+        return { violations: [] };
+      }
+      const injected = entry.parameters.a11y?.injectViolations ?? [];
+      const detected = detectHeuristicViolations(canvas);
+      return { violations: [...injected, ...detected] };
+    }
+  };
+}
+function detectHeuristicViolations(canvas) {
+  const violations = [];
+  const buttons = canvas.querySelectorAll("button");
+  for (const btn of buttons) {
+    if (!hasAccessibleName(btn)) {
+      violations.push({
+        id: "button-name",
+        impact: "critical",
+        description: "Buttons must have discernible text",
+        nodes: [{ target: ["button"], html: "<button></button>" }]
+      });
+    }
+  }
+  const imgs = canvas.querySelectorAll("img");
+  for (const img of imgs) {
+    if (img.attrs["alt"] === void 0) {
+      violations.push({
+        id: "image-alt",
+        impact: "serious",
+        description: "Images must have alternate text",
+        nodes: [{ target: ["img"], html: "<img />" }]
+      });
+    }
+  }
+  const inputs = canvas.querySelectorAll("input");
+  for (const input of inputs) {
+    const type = input.attrs["type"] ?? "text";
+    if (type === "hidden" || type === "submit" || type === "button") continue;
+    if (!input.attrs["aria-label"] && !input.attrs["aria-labelledby"] && !hasAssociatedLabel(input, canvas)) {
+      violations.push({
+        id: "label",
+        impact: "critical",
+        description: "Form elements must have labels",
+        nodes: [{ target: ["input"], html: "<input />" }]
+      });
+    }
+  }
+  return violations;
+}
+function hasAccessibleName(node) {
+  if (node.attrs["aria-label"]) return true;
+  const text = collectText(node).trim();
+  return text.length > 0;
+}
+function collectText(node) {
+  const parts = [];
+  if (node.text) parts.push(node.text);
+  for (const child of node.children) {
+    parts.push(collectText(child));
+  }
+  return parts.join("");
+}
+function hasAssociatedLabel(input, canvas) {
+  const id = input.attrs["id"];
+  if (!id) return false;
+  const labels = canvas.querySelectorAll(`label[for=${JSON.stringify(id)}]`);
+  return labels.length > 0;
+}
+
+// src/playwright-ct.ts
+function createPlaywrightCTMock() {
+  const active = /* @__PURE__ */ new Set();
+  return {
+    mount(render, args) {
+      const root = render(args);
+      const canvas = createCanvas(root);
+      const record = { root, canvas };
+      active.add(record);
+      return buildLocator(record, () => active.delete(record));
+    },
+    activeMounts() {
+      return active.size;
+    },
+    unmountAll() {
+      active.clear();
+    }
+  };
+}
+function buildLocator(record, dispose) {
+  return {
+    canvas: record.canvas,
+    root: record.root,
+    getByText: (text) => createTextLocator(record.canvas, text),
+    getByRole: (role, options) => createRoleLocator(record.canvas, role, options?.name),
+    unmount: () => {
+      clearHandlers(record.root);
+      dispose();
+    }
+  };
+}
+function createTextLocator(canvas, text) {
+  return {
+    click: async () => {
+      const node = canvas.getByText(text);
+      fireEvent(node, buildEvent("click", node));
+    },
+    fill: async (value) => {
+      const node = canvas.getByText(text);
+      node.value = value;
+      fireEvent(node, buildEvent("input", node, value));
+    },
+    textContent: async () => {
+      const node = tryFind(() => canvas.getByText(text));
+      return node ? nodeText2(node) : null;
+    },
+    count: async () => {
+      return tryFind(() => canvas.getByText(text)) ? 1 : 0;
+    },
+    node: () => tryFind(() => canvas.getByText(text))
+  };
+}
+function createRoleLocator(canvas, role, name) {
+  return {
+    click: async () => {
+      const node = canvas.getByRole(role, name !== void 0 ? { name } : void 0);
+      fireEvent(node, buildEvent("click", node));
+    },
+    fill: async (value) => {
+      const node = canvas.getByRole(role, name !== void 0 ? { name } : void 0);
+      node.value = value;
+      fireEvent(node, buildEvent("input", node, value));
+    },
+    textContent: async () => {
+      const node = tryFind(() => canvas.getByRole(role, name !== void 0 ? { name } : void 0));
+      return node ? nodeText2(node) : null;
+    },
+    count: async () => {
+      return tryFind(() => canvas.getByRole(role, name !== void 0 ? { name } : void 0)) ? 1 : 0;
+    },
+    node: () => tryFind(() => canvas.getByRole(role, name !== void 0 ? { name } : void 0))
+  };
+}
+function buildEvent(type, target, value) {
+  return {
+    type,
+    target,
+    ...value !== void 0 ? { value } : {}
+  };
+}
+function tryFind(fn) {
+  try {
+    return fn();
+  } catch {
+    return null;
+  }
+}
+function nodeText2(node) {
+  const parts = [];
+  if (node.text) parts.push(node.text);
+  for (const child of node.children) {
+    parts.push(nodeText2(child));
+  }
+  return parts.join("").trim();
+}
+function clearHandlers(node) {
+  node.handlers = {};
+  for (const child of node.children) {
+    clearHandlers(child);
+  }
+}
+
+// src/chromatic.ts
+function createChromaticVisualMock(config = {}) {
+  const baselines = /* @__PURE__ */ new Map();
+  const currents = /* @__PURE__ */ new Map();
+  const reviews = [];
+  const defaultViewport = config.defaultViewport ?? "default";
+  const defaultThreshold = config.defaultDiffThreshold ?? 0;
+  const nowFn = config.now ?? (() => Date.now());
+  const keyOf = (storyId, viewport) => `${storyId}::${viewport}`;
+  return {
+    reset() {
+      baselines.clear();
+      currents.clear();
+      reviews.length = 0;
+    },
+    seedBaseline(input) {
+      const baseline = {
+        storyId: input.storyId,
+        viewport: input.viewport,
+        markup: input.markup,
+        hash: hashMarkup(input.markup),
+        capturedAt: input.capturedAt ?? nowFn()
+      };
+      baselines.set(keyOf(input.storyId, input.viewport), baseline);
+      return baseline;
+    },
+    capture(input) {
+      const viewport = input.viewport ?? defaultViewport;
+      if (input.entry.parameters.chromatic?.disable) {
+        return {
+          storyId: input.entry.id,
+          viewport,
+          baselineHash: "",
+          currentHash: "",
+          changed: false,
+          pixelDiffRatio: 0,
+          status: "passed",
+          threshold: defaultThreshold
+        };
+      }
+      const markup = input.canvas.toMarkup();
+      const current = {
+        storyId: input.entry.id,
+        viewport,
+        markup,
+        hash: hashMarkup(markup),
+        capturedAt: input.now ?? nowFn()
+      };
+      currents.set(keyOf(input.entry.id, viewport), current);
+      const baseline = baselines.get(keyOf(input.entry.id, viewport));
+      const threshold = input.entry.parameters.chromatic?.diffThreshold ?? defaultThreshold;
+      if (!baseline) {
+        baselines.set(keyOf(input.entry.id, viewport), current);
+        return {
+          storyId: input.entry.id,
+          viewport,
+          baselineHash: "",
+          currentHash: current.hash,
+          changed: false,
+          pixelDiffRatio: 0,
+          status: "new",
+          threshold
+        };
+      }
+      const changed = baseline.hash !== current.hash;
+      const pixelDiffRatio = changed ? 1 : 0;
+      const status = pixelDiffRatio > threshold ? "failed" : "passed";
+      return {
+        storyId: input.entry.id,
+        viewport,
+        baselineHash: baseline.hash,
+        currentHash: current.hash,
+        changed,
+        pixelDiffRatio,
+        status,
+        threshold
+      };
+    },
+    captureAll(input) {
+      if (input.entry.parameters.chromatic?.disable) {
+        return [];
+      }
+      const viewports = input.entry.parameters.chromatic?.viewports?.length ? input.entry.parameters.chromatic.viewports : [defaultViewport];
+      const now = input.now ?? nowFn();
+      return viewports.map(
+        (viewport) => this.capture({
+          entry: input.entry,
+          canvas: input.canvas,
+          viewport,
+          now
+        })
+      );
+    },
+    review(input) {
+      const key = keyOf(input.storyId, input.viewport);
+      const entry = {
+        storyId: input.storyId,
+        viewport: input.viewport,
+        action: input.action,
+        reviewedAt: input.reviewedAt ?? nowFn()
+      };
+      reviews.push(entry);
+      if (input.action === "accept") {
+        const current = currents.get(key);
+        if (!current) {
+          throw new Error(
+            `ChromaticVisualMock.review \u2014 cannot accept ${key}, no current capture found. Run capture() first.`
+          );
+        }
+        baselines.set(key, { ...current, capturedAt: entry.reviewedAt });
+      }
+      return entry;
+    },
+    reviewHistory() {
+      return [...reviews];
+    },
+    baselines() {
+      return Array.from(baselines.values());
+    }
+  };
+}
+
+// src/fixture.ts
+var buildButton = (args) => {
+  const variant = args.variant ?? "primary";
+  const attrs = {
+    class: `btn btn-${variant}`,
+    type: "button"
+  };
+  if (args.disabled) {
+    attrs["disabled"] = "true";
+    attrs["aria-disabled"] = "true";
+  }
+  return createNode("button", {
+    attrs,
+    text: args.label,
+    ...args.onClick && !args.disabled ? { on: { click: args.onClick } } : {}
+  });
+};
+var buildInput = (args) => {
+  const wrapper = createNode("div", { attrs: { class: "input-group" } });
+  const label = createNode("label", {
+    attrs: { for: args.id, class: "input-label" },
+    text: args.label
+  });
+  const inputAttrs = {
+    id: args.id,
+    name: args.id,
+    type: args.type ?? "text",
+    class: "input-field"
+  };
+  if (args.required) inputAttrs["required"] = "true";
+  if (args.placeholder) inputAttrs["placeholder"] = args.placeholder;
+  const input = createNode("input", {
+    attrs: inputAttrs,
+    value: args.value ?? "",
+    ...args.onChange ? { on: { input: args.onChange } } : {}
+  });
+  appendChild(wrapper, label);
+  appendChild(wrapper, input);
+  return wrapper;
+};
+var buildForm = (args) => {
+  const form = createNode("form", {
+    attrs: { class: "form", role: "form" }
+  });
+  const heading = createNode("h2", {
+    attrs: { class: "form-title" },
+    text: args.title
+  });
+  appendChild(form, heading);
+  const fieldValues = /* @__PURE__ */ new Map();
+  for (const field of args.fields) {
+    fieldValues.set(field.id, field.value ?? "");
+    const wrapper = buildInput({
+      id: field.id,
+      label: field.label,
+      ...field.type !== void 0 ? { type: field.type } : {},
+      ...field.required !== void 0 ? { required: field.required } : {},
+      value: field.value ?? "",
+      onChange: (event) => {
+        if (event.value !== void 0) {
+          fieldValues.set(field.id, event.value);
+        }
+      }
+    });
+    appendChild(form, wrapper);
+  }
+  const submit = createNode("button", {
+    attrs: {
+      type: "submit",
+      class: "form-submit btn btn-primary"
+    },
+    text: args.submitLabel ?? "Submit",
+    on: {
+      click: () => {
+        for (const field of args.fields) {
+          if (field.required && !fieldValues.get(field.id)) {
+            return;
+          }
+        }
+        args.onSubmit?.(Object.fromEntries(fieldValues));
+      }
+    }
+  });
+  appendChild(form, submit);
+  return form;
+};
+var buildModal = (args) => {
+  if (!args.open) {
+    return createNode("div", {
+      attrs: { class: "modal modal-closed", "aria-hidden": "true" }
+    });
+  }
+  const backdrop = createNode("div", {
+    attrs: { class: "modal-backdrop", role: "presentation" },
+    ...args.closeOnBackdrop !== false && args.onClose ? { on: { click: () => args.onClose?.() } } : {}
+  });
+  const dialog = createNode("div", {
+    attrs: {
+      class: "modal-dialog",
+      role: "dialog",
+      "aria-modal": "true",
+      "aria-labelledby": "modal-title"
+    }
+  });
+  const heading = createNode("h2", {
+    attrs: { id: "modal-title", class: "modal-title" },
+    text: args.title
+  });
+  const body = createNode("p", {
+    attrs: { class: "modal-body" },
+    text: args.body
+  });
+  const closeBtn = createNode("button", {
+    attrs: {
+      type: "button",
+      class: "modal-close",
+      "aria-label": "Close"
+    },
+    text: "x",
+    ...args.onClose ? { on: { click: () => args.onClose?.() } } : {}
+  });
+  appendChild(dialog, heading);
+  appendChild(dialog, body);
+  appendChild(dialog, closeBtn);
+  appendChild(backdrop, dialog);
+  return backdrop;
+};
+var buildCard = (args) => {
+  const variant = args.variant ?? "default";
+  const card = createNode("article", {
+    attrs: { class: `card card-${variant}` }
+  });
+  const heading = createNode("h3", {
+    attrs: { class: "card-title" },
+    text: args.title
+  });
+  const body = createNode("p", {
+    attrs: { class: "card-body" },
+    text: args.body
+  });
+  appendChild(card, heading);
+  appendChild(card, body);
+  if (args.footer) {
+    const footer = createNode("footer", {
+      attrs: { class: "card-footer" },
+      text: args.footer
+    });
+    appendChild(card, footer);
+  }
+  return card;
+};
+var componentFixtures = {
+  Button: buildButton,
+  Input: buildInput,
+  Form: buildForm,
+  Modal: buildModal,
+  Card: buildCard
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addHandler,
+  appendChild,
+  buildButton,
+  buildCard,
+  buildForm,
+  buildInput,
+  buildModal,
+  componentFixtures,
+  createCanvas,
+  createChromaticVisualMock,
+  createNode,
+  createPlaywrightCTMock,
+  createStoryRegistry,
+  findByRole,
+  findByText,
+  fireEvent,
+  hashMarkup,
+  query,
+  renderMarkup
+});
+//# sourceMappingURL=index.cjs.map