@chromatic-com/vitest 0.0.0 → 0.12.8

package/dist/setupFile.mjs

@@ -0,0 +1,109 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/browser/setupFile.ts
+import { beforeEach } from "vitest";
+import { commands as commands3 } from "vitest/browser";
+
+// src/browser/public/takeSnapshot.ts
+import { assert } from "vitest";
+import { commands } from "vitest/browser";
+import { snapshot } from "@chromaui/rrweb-snapshot";
+
+// src/browser/getCurrentTest.ts
+import * as vitest from "vitest";
+var hooks = vitest.TestRunner ? vitest.TestRunner : await import("vitest/suite");
+function getCurrentTest() {
+  return hooks.getCurrentTest();
+}
+__name(getCurrentTest, "getCurrentTest");
+
+// src/browser/public/takeSnapshot.ts
+async function takeSnapshot(name) {
+  const test = getCurrentTest();
+  assert(test, "takeSnapshot() must be called within a test()");
+  test.meta.__chromatic_isTakeSnapshotCalled = true;
+  if (!test.meta.__chromatic_isRegistered) {
+    throw new Error("takeSnapshot() cannot be called in a test that is not registered for Chromatic plugin");
+  }
+  const domSnapshot = snapshot(document, {
+    recordCanvas: true
+  });
+  assert(domSnapshot, "Failed to capture DOM snapshot");
+  await replaceBlobUrls(domSnapshot);
+  await commands.__chromatic_uploadDOMSnapshot(test.id, domSnapshot, name);
+}
+__name(takeSnapshot, "takeSnapshot");
+async function replaceBlobUrls(node) {
+  if (!("childNodes" in node)) {
+    return;
+  }
+  await Promise.all(node.childNodes.map(async (childNode) => {
+    if ("tagName" in childNode && childNode.tagName === "img" && typeof childNode.attributes.src === "string" && childNode.attributes.src?.startsWith("blob:")) {
+      const base64Url = await toDataURL(childNode.attributes.src);
+      childNode.attributes.src = base64Url;
+    }
+    if ("childNodes" in childNode && childNode.childNodes?.length) {
+      await replaceBlobUrls(childNode);
+    }
+  }));
+}
+__name(replaceBlobUrls, "replaceBlobUrls");
+async function toDataURL(url) {
+  const blob = await fetch(url).then((res) => res.blob());
+  return new Promise((resolveFileRead, reject) => {
+    const reader = new FileReader();
+    reader.onloadend = () => resolveFileRead(reader.result?.toString() || "");
+    reader.onerror = reject;
+    reader.readAsDataURL(blob);
+  });
+}
+__name(toDataURL, "toDataURL");
+
+// src/browser/public/waitForIdleNetwork.ts
+import { assert as assert2 } from "vitest";
+import { commands as commands2 } from "vitest/browser";
+async function waitForIdleNetwork(timeout) {
+  const test = getCurrentTest();
+  assert2(test, "waitForIdleNetwork() must be called within a test()");
+  assert2(test.meta.__chromatic_isRegistered, "Cannot call waitForIdleNetwork for a test that hasn't been registered with the Chromatic plugin");
+  return await commands2.__chromatic_waitForIdleNetwork(test.id, timeout);
+}
+__name(waitForIdleNetwork, "waitForIdleNetwork");
+
+// src/browser/setupFile.ts
+beforeEach(async ({ task }) => {
+  const options = await commands3.__chromatic_getOptions();
+  if (options.tags) {
+    const hasMatchingTag = task.tags?.some((tag) => options.tags?.includes(tag));
+    if (!hasMatchingTag) {
+      task.meta.__chromatic_isRegistered = false;
+      return cleanup;
+    }
+  }
+  task.meta.__chromatic_isRegistered = true;
+  task.meta.__chromatic_isTakeSnapshotCalled = false;
+  task.meta.__chromatic_autoSnapshot ??= !options.disableAutoSnapshot;
+  await commands3.__chromatic_interceptFetch(task.id);
+  return /* @__PURE__ */ __name(async function afterEach() {
+    const { __chromatic_autoSnapshot: autoSnapshot, __chromatic_isTakeSnapshotCalled: isTakeSnapshotCalled } = task.meta;
+    if (!autoSnapshot && !isTakeSnapshotCalled) {
+      await commands3.__chromatic_stopWithoutSnapshots(task.id);
+      return cleanup();
+    }
+    if (options.resourceArchiveTimeout !== 0) {
+      await waitForIdleNetwork(options.resourceArchiveTimeout);
+    }
+    if (autoSnapshot) {
+      await takeSnapshot();
+    }
+    await commands3.__chromatic_writeTestResult(task.id);
+    return cleanup();
+  }, "afterEach");
+  function cleanup() {
+    task.meta.__chromatic_autoSnapshot = void 0;
+    task.meta.__chromatic_isTakeSnapshotCalled = void 0;
+    task.meta.__chromatic_isRegistered = void 0;
+  }
+  __name(cleanup, "cleanup");
+});

package/dist/storybook-config/main.js

@@ -0,0 +1,145 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/storybook-config/main.ts
+var main_exports = {};
+__export(main_exports, {
+  default: () => main_default
+});
+module.exports = __toCommonJS(main_exports);
+var import_path2 = __toESM(require("path"), 1);
+
+// ../shared/dist/utils/filePaths.mjs
+var import_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_crypto = require("crypto");
+var import_path = __toESM(require("path"), 1);
+var v = Object.defineProperty;
+var r = /* @__PURE__ */ __name((e, t) => v(e, "name", { value: t, configurable: true }), "r");
+function L() {
+  return process.cwd();
+}
+__name(L, "L");
+r(L, "rootDir");
+function g() {
+  let { CHROMATIC_ARCHIVE_LOCATION: e } = process.env;
+  return e;
+}
+__name(g, "g");
+r(g, "outputDirOverride");
+function h(e) {
+  let t = g() || e;
+  return import_path.default.resolve(L(), t, "chromatic-archives");
+}
+__name(h, "h");
+r(h, "archivesDir");
+function k(e) {
+  return import_path.default.resolve(h(e), "archive");
+}
+__name(k, "k");
+r(k, "assetsDir");
+function J(e) {
+  let t = h(e);
+  if (!(0, import_fs.existsSync)(t))
+    throw new Error(`Chromatic archives directory cannot be found: ${t}
+
+Please make sure that you have run your E2E tests, or have set the CHROMATIC_ARCHIVE_LOCATION env var if the output directory for the tests is not in the standard location.`);
+}
+__name(J, "J");
+r(J, "checkArchivesDirExists");
+function B(e) {
+  (0, import_fs.existsSync)(e) || (0, import_fs.mkdirSync)(e, { recursive: true });
+}
+__name(B, "B");
+r(B, "ensureDir");
+async function C(e, t) {
+  return B(import_path.default.dirname(e)), (0, import_promises.writeFile)(e, t, { mode: 511 });
+}
+__name(C, "C");
+r(C, "outputFile");
+async function M(e, t) {
+  return C(e, JSON.stringify(t));
+}
+__name(M, "M");
+r(M, "outputJSONFile");
+async function j(e) {
+  let t = await (0, import_promises.readFile)(e);
+  return JSON.parse(t.toString());
+}
+__name(j, "j");
+r(j, "readJSONFile");
+function w(e) {
+  return (0, import_crypto.createHash)("shake256", { outputLength: 2 }).update(e).digest("hex");
+}
+__name(w, "w");
+r(w, "hash");
+var D = 255;
+function U(e, t = D) {
+  let n = new TextEncoder(), d = new TextDecoder(), a = e.split("/"), o = a.pop();
+  if (n.encode(o).byteLength <= t)
+    return e;
+  let i = w(o), [p, ...m] = o.split("."), l = n.encode(p), s = m.join("."), f = s.length === 0 ? 0 : n.encode(s).byteLength + 1, y = n.encode(i).byteLength + f, N = l.slice(0, t - y), x = [`${d.decode(N)}${i}`, s].filter(Boolean).join(".");
+  return [...a, x].join("/");
+}
+__name(U, "U");
+r(U, "truncateFileName");
+var $ = r((e) => {
+  let t;
+  try {
+    return t = new URL(e), t.hostname === "localhost" ? t.pathname + t.search + t.hash : e;
+  } catch {
+    return e;
+  }
+}, "removeLocalhostFromBaseUrl");
+
+// src/constants.ts
+var DEFAULT_OUTPUT_DIR = process.cwd();
+
+// src/storybook-config/main.ts
+function getAbsolutePath(value) {
+  return import_path2.default.dirname(require.resolve(import_path2.default.join(value, "package.json")));
+}
+__name(getAbsolutePath, "getAbsolutePath");
+var main_default = {
+  stories: [
+    import_path2.default.resolve(h(DEFAULT_OUTPUT_DIR), "*.stories.json")
+  ],
+  addons: [
+    getAbsolutePath("@storybook/addon-essentials"),
+    "."
+  ],
+  framework: {
+    name: getAbsolutePath("@storybook/server-webpack5"),
+    options: {}
+  },
+  staticDirs: [
+    import_path2.default.resolve(h(DEFAULT_OUTPUT_DIR), "archive")
+  ]
+};

package/dist/storybook-config/manager.js

@@ -0,0 +1,10 @@
+"use strict";
+
+// src/storybook-config/shared/manager.ts
+var import_manager_api = require("@storybook/manager-api");
+import_manager_api.addons.setConfig({
+  sidebar: {
+    // this ensures we use folders at the root-level instead of categories
+    showRoots: false
+  }
+});

package/dist/storybook-config/preview.d.ts

@@ -0,0 +1,278 @@
+declare global {
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+interface SBBaseType {
+    required?: boolean;
+    raw?: string;
+}
+type SBScalarType = SBBaseType & {
+    name: 'boolean' | 'string' | 'number' | 'function' | 'symbol';
+};
+type SBArrayType = SBBaseType & {
+    name: 'array';
+    value: SBType;
+};
+type SBObjectType = SBBaseType & {
+    name: 'object';
+    value: Record<string, SBType>;
+};
+type SBEnumType = SBBaseType & {
+    name: 'enum';
+    value: (string | number)[];
+};
+type SBIntersectionType = SBBaseType & {
+    name: 'intersection';
+    value: SBType[];
+};
+type SBUnionType = SBBaseType & {
+    name: 'union';
+    value: SBType[];
+};
+type SBOtherType = SBBaseType & {
+    name: 'other';
+    value: string;
+};
+type SBType = SBScalarType | SBEnumType | SBArrayType | SBObjectType | SBIntersectionType | SBUnionType | SBOtherType;
+
+type StoryId = string;
+type ComponentId = string;
+type ComponentTitle = string;
+type StoryName = string;
+type Tag$1 = string;
+interface StoryIdentifier {
+    componentId: ComponentId;
+    title: ComponentTitle;
+    /** @deprecated */
+    kind: ComponentTitle;
+    id: StoryId;
+    name: StoryName;
+    /** @deprecated */
+    story: StoryName;
+    tags: Tag$1[];
+}
+interface Parameters {
+    [name: string]: any;
+}
+type ControlType = 'object' | 'boolean' | 'check' | 'inline-check' | 'radio' | 'inline-radio' | 'select' | 'multi-select' | 'number' | 'range' | 'file' | 'color' | 'date' | 'text';
+type ConditionalTest = {
+    truthy?: boolean;
+} | {
+    exists: boolean;
+} | {
+    eq: any;
+} | {
+    neq: any;
+};
+type ConditionalValue = {
+    arg: string;
+} | {
+    global: string;
+};
+type Conditional = ConditionalValue & ConditionalTest;
+interface ControlBase {
+    [key: string]: any;
+    /**
+     * @see https://storybook.js.org/docs/api/arg-types#controltype
+     */
+    type?: ControlType;
+    disable?: boolean;
+}
+type Control = ControlType | false | (ControlBase & (ControlBase | {
+    type: 'color';
+    /**
+     * @see https://storybook.js.org/docs/api/arg-types#controlpresetcolors
+     */
+    presetColors?: string[];
+} | {
+    type: 'file';
+    /**
+     * @see https://storybook.js.org/docs/api/arg-types#controlaccept
+     */
+    accept?: string;
+} | {
+    type: 'inline-check' | 'radio' | 'inline-radio' | 'select' | 'multi-select';
+    /**
+     * @see https://storybook.js.org/docs/api/arg-types#controllabels
+     */
+    labels?: {
+        [options: string]: string;
+    };
+} | {
+    type: 'number' | 'range';
+    /**
+     * @see https://storybook.js.org/docs/api/arg-types#controlmax
+     */
+    max?: number;
+    /**
+     * @see https://storybook.js.org/docs/api/arg-types#controlmin
+     */
+    min?: number;
+    /**
+     * @see https://storybook.js.org/docs/api/arg-types#controlstep
+     */
+    step?: number;
+}));
+interface InputType {
+    /**
+     * @see https://storybook.js.org/docs/api/arg-types#control
+     */
+    control?: Control;
+    /**
+     * @see https://storybook.js.org/docs/api/arg-types#description
+     */
+    description?: string;
+    /**
+     * @see https://storybook.js.org/docs/api/arg-types#if
+     */
+    if?: Conditional;
+    /**
+     * @see https://storybook.js.org/docs/api/arg-types#mapping
+     */
+    mapping?: {
+        [key: string]: any;
+    };
+    /**
+     * @see https://storybook.js.org/docs/api/arg-types#name
+     */
+    name?: string;
+    /**
+     * @see https://storybook.js.org/docs/api/arg-types#options
+     */
+    options?: readonly any[];
+    /**
+     * @see https://storybook.js.org/docs/api/arg-types#table
+     */
+    table?: {
+        [key: string]: unknown;
+        /**
+         * @see https://storybook.js.org/docs/api/arg-types#tablecategory
+         */
+        category?: string;
+        /**
+         * @see https://storybook.js.org/docs/api/arg-types#tabledefaultvalue
+         */
+        defaultValue?: {
+            summary?: string;
+            detail?: string;
+        };
+        /**
+         * @see https://storybook.js.org/docs/api/arg-types#tabledisable
+         */
+        disable?: boolean;
+        /**
+         * @see https://storybook.js.org/docs/api/arg-types#tablesubcategory
+         */
+        subcategory?: string;
+        /**
+         * @see https://storybook.js.org/docs/api/arg-types#tabletype
+         */
+        type?: {
+            summary?: string;
+            detail?: string;
+        };
+    };
+    /**
+     * @see https://storybook.js.org/docs/api/arg-types#type
+     */
+    type?: SBType | SBScalarType['name'];
+    /**
+     * @see https://storybook.js.org/docs/api/arg-types#defaultvalue
+     *
+     * @deprecated Use `table.defaultValue.summary` instead.
+     */
+    defaultValue?: any;
+    [key: string]: any;
+}
+interface StrictInputType extends InputType {
+    name: string;
+    type?: SBType;
+}
+interface Args {
+    [name: string]: any;
+}
+type StrictArgTypes<TArgs = Args> = {
+    [name in keyof TArgs]: StrictInputType;
+};
+interface Globals {
+    [name: string]: any;
+}
+type Renderer = {
+    /** What is the type of the `component` annotation in this renderer? */
+    component: unknown;
+    /** What does the story function return in this renderer? */
+    storyResult: unknown;
+    /** What type of element does this renderer render to? */
+    canvasElement: unknown;
+    T?: unknown;
+};
+interface StoryContextForEnhancers<TRenderer extends Renderer = Renderer, TArgs = Args> extends StoryIdentifier {
+    component?: (TRenderer & {
+        T: any;
+    })['component'];
+    subcomponents?: Record<string, (TRenderer & {
+        T: any;
+    })['component']>;
+    parameters: Parameters;
+    initialArgs: TArgs;
+    argTypes: StrictArgTypes<TArgs>;
+}
+interface StoryContextUpdate<TArgs = Args> {
+    args?: TArgs;
+    globals?: Globals;
+    [key: string]: any;
+}
+type ViewMode$1 = 'story' | 'docs';
+interface StoryContextForLoaders<TRenderer extends Renderer = Renderer, TArgs = Args> extends StoryContextForEnhancers<TRenderer, TArgs>, Required<StoryContextUpdate<TArgs>> {
+    hooks: unknown;
+    viewMode: ViewMode$1;
+    originalStoryFn: StoryFn<TRenderer>;
+}
+interface StoryContext<TRenderer extends Renderer = Renderer, TArgs = Args> extends StoryContextForLoaders<TRenderer, TArgs> {
+    loaded: Record<string, any>;
+    abortSignal: AbortSignal;
+    canvasElement: TRenderer['canvasElement'];
+}
+type PartialStoryFn<TRenderer extends Renderer = Renderer, TArgs = Args> = (update?: StoryContextUpdate<Partial<TArgs>>) => TRenderer['storyResult'];
+type LegacyStoryFn<TRenderer extends Renderer = Renderer, TArgs = Args> = (context: StoryContext<TRenderer, TArgs>) => TRenderer['storyResult'];
+type ArgsStoryFn<TRenderer extends Renderer = Renderer, TArgs = Args> = (args: TArgs, context: StoryContext<TRenderer, TArgs>) => (TRenderer & {
+    T: TArgs;
+})['storyResult'];
+type StoryFn<TRenderer extends Renderer = Renderer, TArgs = Args> = LegacyStoryFn<TRenderer, TArgs> | ArgsStoryFn<TRenderer, TArgs>;
+
+interface WebRenderer extends Renderer {
+    canvasElement: HTMLElement;
+}
+type MaybePromise<T> = Promise<T> | T;
+type TeardownRenderToCanvas = () => MaybePromise<void>;
+type RenderToCanvas<TRenderer extends Renderer> = (context: RenderContext<TRenderer>, element: TRenderer['canvasElement']) => MaybePromise<void | TeardownRenderToCanvas>;
+declare type RenderContext<TRenderer extends Renderer = Renderer> = StoryIdentifier & {
+    showMain: () => void;
+    showError: (error: {
+        title: string;
+        description: string;
+    }) => void;
+    showException: (err: Error) => void;
+    forceRemount: boolean;
+    storyContext: StoryContext<TRenderer>;
+    storyFn: PartialStoryFn<TRenderer>;
+    unboundStoryFn: LegacyStoryFn<TRenderer>;
+};
+
+interface RRWebFramework extends WebRenderer {
+    component: undefined;
+    storyResult: Record<string, never>;
+}
+declare const _default: {
+    renderToCanvas: RenderToCanvas<RRWebFramework>;
+    parameters: {
+        server: {
+            url: string;
+        };
+        layout: string;
+    };
+};
+
+export { type RRWebFramework, _default as default };

package/dist/storybook-config/preview.mjs

@@ -0,0 +1,81 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// ../../node_modules/@rrweb/types/dist/types.js
+var NodeType = /* @__PURE__ */ ((NodeType2) => {
+  NodeType2[NodeType2["Document"] = 0] = "Document";
+  NodeType2[NodeType2["DocumentType"] = 1] = "DocumentType";
+  NodeType2[NodeType2["Element"] = 2] = "Element";
+  NodeType2[NodeType2["Text"] = 3] = "Text";
+  NodeType2[NodeType2["CDATA"] = 4] = "CDATA";
+  NodeType2[NodeType2["Comment"] = 5] = "Comment";
+  return NodeType2;
+})(NodeType || {});
+
+// src/storybook-config/shared/preview.ts
+import { rebuild } from "@chromaui/rrweb-snapshot";
+var pageUrl = new URL(window.location.href);
+pageUrl.pathname = "";
+pageUrl.search = "";
+var strippedUrl = pageUrl.toString().replace(/\/$/, "");
+var findHtmlNode = /* @__PURE__ */ __name((node) => {
+  if (node.type === NodeType.Element && node.tagName === "html") {
+    return node;
+  }
+  if ("childNodes" in node) {
+    return node.childNodes.find((childNode) => {
+      return findHtmlNode(childNode);
+    });
+  }
+  return void 0;
+}, "findHtmlNode");
+function snapshotFileName(snapshotId, viewport) {
+  const fileNameParts = [
+    snapshotId,
+    viewport,
+    "snapshot.json"
+  ];
+  return fileNameParts.join(".");
+}
+__name(snapshotFileName, "snapshotFileName");
+async function fetchSnapshot(context) {
+  const { url, id } = context.storyContext.parameters.server;
+  const { viewport } = context.storyContext.globals;
+  let viewportName;
+  if (typeof viewport === "string") {
+    viewportName = viewport;
+  } else {
+    viewportName = `w${viewport.width}h${viewport.height}`;
+  }
+  let response = await fetch(`${url}/${snapshotFileName(id, viewportName)}`);
+  if (!response.ok) {
+    const { defaultViewport } = context.storyContext.parameters.viewport;
+    response = await fetch(`${url}/${snapshotFileName(id, defaultViewport)}`);
+  }
+  return response.json();
+}
+__name(fetchSnapshot, "fetchSnapshot");
+var renderToCanvas = /* @__PURE__ */ __name(async (context, element) => {
+  const snapshot = await fetchSnapshot(context);
+  const htmlNode = findHtmlNode(snapshot);
+  const html = await rebuild(htmlNode, {
+    doc: document
+  });
+  document.replaceChild(html, document.children[0]);
+  document.head.innerHTML += '<script id="storybook-root"><\/script><script id="storybook-docs"><\/script>';
+  context.showMain();
+  return () => {
+  };
+}, "renderToCanvas");
+var preview_default = {
+  renderToCanvas,
+  parameters: {
+    server: {
+      url: strippedUrl
+    },
+    layout: "fullscreen"
+  }
+};
+export {
+  preview_default as default
+};