@storybook/addon-docs 10.1.0-alpha.8 → 10.1.0-beta.0

package/dist/_browser-chunks/{chunk-74ZUTOZN.js → chunk-OATZR77O.js}

@@ -1,7 +1,3 @@
-import {
-  __name
-} from "./chunk-MM7DTO55.js";
-
 // src/DocsRenderer.tsx
 import React, { Component } from "react";
 import { renderElement, unmountElement } from "@storybook/react-dom-shim";
@@ -10,35 +6,29 @@ var defaultComponents = {
   code: CodeOrSourceMdx,
   a: AnchorMdx,
   ...HeadersMdx
-};
-var _ErrorBoundary = class _ErrorBoundary extends Component {
+}, ErrorBoundary = class extends Component {
   constructor() {
     super(...arguments);
-    this.state = { hasError: false };
+    this.state = { hasError: !1 };
   }
   static getDerivedStateFromError() {
-    return { hasError: true };
+    return { hasError: !0 };
   }
   componentDidCatch(err) {
-    const { showException } = this.props;
+    let { showException } = this.props;
     showException(err);
   }
   render() {
-    const { hasError } = this.state;
-    const { children } = this.props;
+    let { hasError } = this.state, { children } = this.props;
     return hasError ? null : React.createElement(React.Fragment, null, children);
   }
-};
-__name(_ErrorBoundary, "ErrorBoundary");
-var ErrorBoundary = _ErrorBoundary;
-var _DocsRenderer = class _DocsRenderer {
+}, DocsRenderer = class {
   constructor() {
     this.render = async (context, docsParameter, element) => {
-      const components = {
+      let components = {
         ...defaultComponents,
         ...docsParameter?.components
-      };
-      const TDocs = Docs;
+      }, TDocs = Docs;
       return new Promise((resolve, reject) => {
         import("@mdx-js/react").then(
           ({ MDXProvider }) => (
@@ -50,14 +40,11 @@ var _DocsRenderer = class _DocsRenderer {
           )
         ).then(() => resolve());
       });
-    };
-    this.unmount = (element) => {
+    }, this.unmount = (element) => {
       unmountElement(element);
     };
   }
 };
-__name(_DocsRenderer, "DocsRenderer");
-var DocsRenderer = _DocsRenderer;
 
 export {
   defaultComponents,

package/dist/_browser-chunks/chunk-UUESKCKV.js

@@ -0,0 +1,31 @@
+import {
+  __export
+} from "./chunk-A242L54C.js";
+
+// src/preview.ts
+var preview_exports = {};
+__export(preview_exports, {
+  parameters: () => parameters
+});
+var excludeTags = Object.entries(globalThis.TAGS_OPTIONS ?? {}).reduce(
+  (acc, entry) => {
+    let [tag, option] = entry;
+    return option.excludeFromDocsStories && (acc[tag] = !0), acc;
+  },
+  {}
+), parameters = {
+  docs: {
+    renderer: async () => {
+      let { DocsRenderer } = await import("./DocsRenderer-GHJI37HO.js");
+      return new DocsRenderer();
+    },
+    stories: {
+      filter: (story) => (story.tags || []).filter((tag) => excludeTags[tag]).length === 0 && !story.parameters.docs?.disable
+    }
+  }
+};
+
+export {
+  parameters,
+  preview_exports
+};

package/dist/_node-chunks/{chunk-QSBD55JK.js → chunk-OGE4GWLB.js}

@@ -1,10 +1,10 @@
-import CJS_COMPAT_NODE_URL_ggcqbc9ld7l from 'node:url';
-import CJS_COMPAT_NODE_PATH_ggcqbc9ld7l from 'node:path';
-import CJS_COMPAT_NODE_MODULE_ggcqbc9ld7l from "node:module";
+import CJS_COMPAT_NODE_URL_2pgro2geduh from 'node:url';
+import CJS_COMPAT_NODE_PATH_2pgro2geduh from 'node:path';
+import CJS_COMPAT_NODE_MODULE_2pgro2geduh from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_ggcqbc9ld7l.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_ggcqbc9ld7l.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_ggcqbc9ld7l.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_2pgro2geduh.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_2pgro2geduh.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_2pgro2geduh.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
@@ -13,22 +13,17 @@ 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 __commonJS = (cb, mod) => function __require() {
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 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") {
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __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 });
-  }
+      !__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(
@@ -36,12 +31,11 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   // 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,
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
   mod
 ));
 
 export {
-  __name,
   __commonJS,
   __export,
   __toESM

package/dist/_node-chunks/chunk-PRNIBEEO.js

@@ -0,0 +1,196 @@
+import CJS_COMPAT_NODE_URL_2pgro2geduh from 'node:url';
+import CJS_COMPAT_NODE_PATH_2pgro2geduh from 'node:path';
+import CJS_COMPAT_NODE_MODULE_2pgro2geduh from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_2pgro2geduh.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_2pgro2geduh.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_2pgro2geduh.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Storybook's esbuild configuration
+// ------------------------------------------------------------
+
+// ../../node_modules/@ungap/structured-clone/esm/deserialize.js
+var env = typeof self == "object" ? self : globalThis, deserializer = ($, _) => {
+  let as = (out, index) => ($.set(index, out), out), unpair = (index) => {
+    if ($.has(index))
+      return $.get(index);
+    let [type, value] = _[index];
+    switch (type) {
+      case 0:
+      case -1:
+        return as(value, index);
+      case 1: {
+        let arr = as([], index);
+        for (let index2 of value)
+          arr.push(unpair(index2));
+        return arr;
+      }
+      case 2: {
+        let object = as({}, index);
+        for (let [key, index2] of value)
+          object[unpair(key)] = unpair(index2);
+        return object;
+      }
+      case 3:
+        return as(new Date(value), index);
+      case 4: {
+        let { source, flags } = value;
+        return as(new RegExp(source, flags), index);
+      }
+      case 5: {
+        let map = as(/* @__PURE__ */ new Map(), index);
+        for (let [key, index2] of value)
+          map.set(unpair(key), unpair(index2));
+        return map;
+      }
+      case 6: {
+        let set = as(/* @__PURE__ */ new Set(), index);
+        for (let index2 of value)
+          set.add(unpair(index2));
+        return set;
+      }
+      case 7: {
+        let { name, message } = value;
+        return as(new env[name](message), index);
+      }
+      case 8:
+        return as(BigInt(value), index);
+      case "BigInt":
+        return as(Object(BigInt(value)), index);
+      case "ArrayBuffer":
+        return as(new Uint8Array(value).buffer, value);
+      case "DataView": {
+        let { buffer } = new Uint8Array(value);
+        return as(new DataView(buffer), value);
+      }
+    }
+    return as(new env[type](value), index);
+  };
+  return unpair;
+}, deserialize = (serialized) => deserializer(/* @__PURE__ */ new Map(), serialized)(0);
+
+// ../../node_modules/@ungap/structured-clone/esm/serialize.js
+var EMPTY = "", { toString } = {}, { keys } = Object, typeOf = (value) => {
+  let type = typeof value;
+  if (type !== "object" || !value)
+    return [0, type];
+  let asString = toString.call(value).slice(8, -1);
+  switch (asString) {
+    case "Array":
+      return [1, EMPTY];
+    case "Object":
+      return [2, EMPTY];
+    case "Date":
+      return [3, EMPTY];
+    case "RegExp":
+      return [4, EMPTY];
+    case "Map":
+      return [5, EMPTY];
+    case "Set":
+      return [6, EMPTY];
+    case "DataView":
+      return [1, asString];
+  }
+  return asString.includes("Array") ? [1, asString] : asString.includes("Error") ? [7, asString] : [2, asString];
+}, shouldSkip = ([TYPE, type]) => TYPE === 0 && (type === "function" || type === "symbol"), serializer = (strict, json, $, _) => {
+  let as = (out, value) => {
+    let index = _.push(out) - 1;
+    return $.set(value, index), index;
+  }, pair = (value) => {
+    if ($.has(value))
+      return $.get(value);
+    let [TYPE, type] = typeOf(value);
+    switch (TYPE) {
+      case 0: {
+        let entry = value;
+        switch (type) {
+          case "bigint":
+            TYPE = 8, entry = value.toString();
+            break;
+          case "function":
+          case "symbol":
+            if (strict)
+              throw new TypeError("unable to serialize " + type);
+            entry = null;
+            break;
+          case "undefined":
+            return as([-1], value);
+        }
+        return as([TYPE, entry], value);
+      }
+      case 1: {
+        if (type) {
+          let spread = value;
+          return type === "DataView" ? spread = new Uint8Array(value.buffer) : type === "ArrayBuffer" && (spread = new Uint8Array(value)), as([type, [...spread]], value);
+        }
+        let arr = [], index = as([TYPE, arr], value);
+        for (let entry of value)
+          arr.push(pair(entry));
+        return index;
+      }
+      case 2: {
+        if (type)
+          switch (type) {
+            case "BigInt":
+              return as([type, value.toString()], value);
+            case "Boolean":
+            case "Number":
+            case "String":
+              return as([type, value.valueOf()], value);
+          }
+        if (json && "toJSON" in value)
+          return pair(value.toJSON());
+        let entries = [], index = as([TYPE, entries], value);
+        for (let key of keys(value))
+          (strict || !shouldSkip(typeOf(value[key]))) && entries.push([pair(key), pair(value[key])]);
+        return index;
+      }
+      case 3:
+        return as([TYPE, value.toISOString()], value);
+      case 4: {
+        let { source, flags } = value;
+        return as([TYPE, { source, flags }], value);
+      }
+      case 5: {
+        let entries = [], index = as([TYPE, entries], value);
+        for (let [key, entry] of value)
+          (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry)))) && entries.push([pair(key), pair(entry)]);
+        return index;
+      }
+      case 6: {
+        let entries = [], index = as([TYPE, entries], value);
+        for (let entry of value)
+          (strict || !shouldSkip(typeOf(entry))) && entries.push(pair(entry));
+        return index;
+      }
+    }
+    let { message } = value;
+    return as([TYPE, { name: type, message }], value);
+  };
+  return pair;
+}, serialize = (value, { json, lossy } = {}) => {
+  let _ = [];
+  return serializer(!(json || lossy), !!json, /* @__PURE__ */ new Map(), _)(value), _;
+};
+
+// ../../node_modules/@ungap/structured-clone/esm/index.js
+var esm_default = typeof structuredClone == "function" ? (
+  /* c8 ignore start */
+  (any, options) => options && ("json" in options || "lossy" in options) ? deserialize(serialize(any, options)) : structuredClone(any)
+) : (any, options) => deserialize(serialize(any, options));
+
+// ../../node_modules/space-separated-tokens/index.js
+function parse(value) {
+  let input = String(value || "").trim();
+  return input ? input.split(/[ \t\n\r\f]+/g) : [];
+}
+function stringify(values) {
+  return values.join(" ").trim();
+}
+
+export {
+  esm_default,
+  parse,
+  stringify
+};

package/dist/_node-chunks/chunk-SEBYU7IP.js

@@ -0,0 +1,168 @@
+import CJS_COMPAT_NODE_URL_2pgro2geduh from 'node:url';
+import CJS_COMPAT_NODE_PATH_2pgro2geduh from 'node:path';
+import CJS_COMPAT_NODE_MODULE_2pgro2geduh from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_2pgro2geduh.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_2pgro2geduh.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_2pgro2geduh.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Storybook's esbuild configuration
+// ------------------------------------------------------------
+
+// ../../node_modules/unist-util-is/lib/index.js
+var convert = (
+  // Note: overloads in JSDoc can’t yet use different `@template`s.
+  /**
+   * @type {(
+   *   (<Condition extends string>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &
+   *   (<Condition extends Props>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &
+   *   (<Condition extends TestFunction>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &
+   *   ((test?: null | undefined) => (node?: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &
+   *   ((test?: Test) => Check)
+   * )}
+   */
+  /**
+   * @param {Test} [test]
+   * @returns {Check}
+   */
+  (function(test) {
+    if (test == null)
+      return ok;
+    if (typeof test == "function")
+      return castFactory(test);
+    if (typeof test == "object")
+      return Array.isArray(test) ? anyFactory(test) : (
+        // Cast because `ReadonlyArray` goes into the above but `isArray`
+        // narrows to `Array`.
+        propertiesFactory(
+          /** @type {Props} */
+          test
+        )
+      );
+    if (typeof test == "string")
+      return typeFactory(test);
+    throw new Error("Expected function, string, or object as test");
+  })
+);
+function anyFactory(tests) {
+  let checks = [], index = -1;
+  for (; ++index < tests.length; )
+    checks[index] = convert(tests[index]);
+  return castFactory(any);
+  function any(...parameters) {
+    let index2 = -1;
+    for (; ++index2 < checks.length; )
+      if (checks[index2].apply(this, parameters)) return !0;
+    return !1;
+  }
+}
+function propertiesFactory(check) {
+  let checkAsRecord = (
+    /** @type {Record<string, unknown>} */
+    check
+  );
+  return castFactory(all);
+  function all(node) {
+    let nodeAsRecord = (
+      /** @type {Record<string, unknown>} */
+      /** @type {unknown} */
+      node
+    ), key;
+    for (key in check)
+      if (nodeAsRecord[key] !== checkAsRecord[key]) return !1;
+    return !0;
+  }
+}
+function typeFactory(check) {
+  return castFactory(type);
+  function type(node) {
+    return node && node.type === check;
+  }
+}
+function castFactory(testFunction) {
+  return check;
+  function check(value, index, parent) {
+    return !!(looksLikeANode(value) && testFunction.call(
+      this,
+      value,
+      typeof index == "number" ? index : void 0,
+      parent || void 0
+    ));
+  }
+}
+function ok() {
+  return !0;
+}
+function looksLikeANode(value) {
+  return value !== null && typeof value == "object" && "type" in value;
+}
+
+// ../../node_modules/unist-util-visit-parents/lib/color.node.js
+function color(d) {
+  return "\x1B[33m" + d + "\x1B[39m";
+}
+
+// ../../node_modules/unist-util-visit-parents/lib/index.js
+var empty = [], CONTINUE = !0, EXIT = !1, SKIP = "skip";
+function visitParents(tree, test, visitor, reverse) {
+  let check;
+  typeof test == "function" && typeof visitor != "function" ? (reverse = visitor, visitor = test) : check = test;
+  let is2 = convert(check), step = reverse ? -1 : 1;
+  factory(tree, void 0, [])();
+  function factory(node, index, parents) {
+    let value = (
+      /** @type {Record<string, unknown>} */
+      node && typeof node == "object" ? node : {}
+    );
+    if (typeof value.type == "string") {
+      let name = (
+        // `hast`
+        typeof value.tagName == "string" ? value.tagName : (
+          // `xast`
+          typeof value.name == "string" ? value.name : void 0
+        )
+      );
+      Object.defineProperty(visit2, "name", {
+        value: "node (" + color(node.type + (name ? "<" + name + ">" : "")) + ")"
+      });
+    }
+    return visit2;
+    function visit2() {
+      let result = empty, subresult, offset, grandparents;
+      if ((!test || is2(node, index, parents[parents.length - 1] || void 0)) && (result = toResult(visitor(node, parents)), result[0] === EXIT))
+        return result;
+      if ("children" in node && node.children) {
+        let nodeAsParent = (
+          /** @type {UnistParent} */
+          node
+        );
+        if (nodeAsParent.children && result[0] !== SKIP)
+          for (offset = (reverse ? nodeAsParent.children.length : -1) + step, grandparents = parents.concat(nodeAsParent); offset > -1 && offset < nodeAsParent.children.length; ) {
+            let child = nodeAsParent.children[offset];
+            if (subresult = factory(child, offset, grandparents)(), subresult[0] === EXIT)
+              return subresult;
+            offset = typeof subresult[1] == "number" ? subresult[1] : offset + step;
+          }
+      }
+      return result;
+    }
+  }
+}
+function toResult(value) {
+  return Array.isArray(value) ? value : typeof value == "number" ? [CONTINUE, value] : value == null ? empty : [value];
+}
+
+// ../../node_modules/unist-util-visit/lib/index.js
+function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {
+  let reverse, test, visitor;
+  typeof testOrVisitor == "function" && typeof visitorOrReverse != "function" ? (test = void 0, visitor = testOrVisitor, reverse = visitorOrReverse) : (test = testOrVisitor, visitor = visitorOrReverse, reverse = maybeReverse), visitParents(tree, test, overload, reverse);
+  function overload(node, parents) {
+    let parent = parents[parents.length - 1], index = parent ? parent.children.indexOf(node) : void 0;
+    return visitor(node, index, parent);
+  }
+}
+
+export {
+  visit
+};