storybook 10.2.0-alpha.9 → 10.2.0-beta.0

package/dist/_browser-chunks/{Color-E5XDEOX4.js → Color-XESOIGZP.js}

@@ -4,9 +4,6 @@ import {
 import {
   require_color_convert
 } from "./chunk-VIJ7SQRO.js";
-import {
-  debounce
-} from "./chunk-HPYUT3WS.js";
 import "./chunk-NZMVUW5T.js";
 import {
   __toESM
@@ -18,6 +15,63 @@ import React, { useCallback, useEffect, useMemo, useState } from "react";
 import { Button, Form, PopoverProvider } from "storybook/internal/components";
 import { MarkupIcon } from "@storybook/icons";
 
+// ../../node_modules/es-toolkit/dist/function/debounce.mjs
+function debounce(func, debounceMs, { signal, edges } = {}) {
+  let pendingThis, pendingArgs = null, leading = edges != null && edges.includes("leading"), trailing = edges == null || edges.includes("trailing"), invoke = () => {
+    pendingArgs !== null && (func.apply(pendingThis, pendingArgs), pendingThis = void 0, pendingArgs = null);
+  }, onTimerEnd = () => {
+    trailing && invoke(), cancel();
+  }, timeoutId = null, schedule = () => {
+    timeoutId != null && clearTimeout(timeoutId), timeoutId = setTimeout(() => {
+      timeoutId = null, onTimerEnd();
+    }, debounceMs);
+  }, cancelTimer = () => {
+    timeoutId !== null && (clearTimeout(timeoutId), timeoutId = null);
+  }, cancel = () => {
+    cancelTimer(), pendingThis = void 0, pendingArgs = null;
+  }, flush = () => {
+    invoke();
+  }, debounced = function(...args) {
+    if (signal?.aborted)
+      return;
+    pendingThis = this, pendingArgs = args;
+    let isFirstCall = timeoutId == null;
+    schedule(), leading && isFirstCall && invoke();
+  };
+  return debounced.schedule = schedule, debounced.cancel = cancel, debounced.flush = flush, signal?.addEventListener("abort", cancel, { once: !0 }), debounced;
+}
+
+// ../../node_modules/es-toolkit/dist/function/partial.mjs
+function partial(func, ...partialArgs) {
+  return partialImpl(func, placeholderSymbol, ...partialArgs);
+}
+function partialImpl(func, placeholder, ...partialArgs) {
+  let partialed = function(...providedArgs) {
+    let providedArgsIndex = 0, substitutedArgs = partialArgs.slice().map((arg) => arg === placeholder ? providedArgs[providedArgsIndex++] : arg), remainingArgs = providedArgs.slice(providedArgsIndex);
+    return func.apply(this, substitutedArgs.concat(remainingArgs));
+  };
+  return func.prototype && (partialed.prototype = Object.create(func.prototype)), partialed;
+}
+var placeholderSymbol = Symbol("partial.placeholder");
+partial.placeholder = placeholderSymbol;
+
+// ../../node_modules/es-toolkit/dist/function/partialRight.mjs
+function partialRight(func, ...partialArgs) {
+  return partialRightImpl(func, placeholderSymbol2, ...partialArgs);
+}
+function partialRightImpl(func, placeholder, ...partialArgs) {
+  let partialedRight = function(...providedArgs) {
+    let placeholderLength = partialArgs.filter((arg) => arg === placeholder).length, rangeLength = Math.max(providedArgs.length - placeholderLength, 0), remainingArgs = providedArgs.slice(0, rangeLength), providedArgsIndex = rangeLength, substitutedArgs = partialArgs.slice().map((arg) => arg === placeholder ? providedArgs[providedArgsIndex++] : arg);
+    return func.apply(this, remainingArgs.concat(substitutedArgs));
+  };
+  return func.prototype && (partialedRight.prototype = Object.create(func.prototype)), partialedRight;
+}
+var placeholderSymbol2 = Symbol("partialRight.placeholder");
+partialRight.placeholder = placeholderSymbol2;
+
+// ../../node_modules/es-toolkit/dist/function/retry.mjs
+var DEFAULT_RETRIES = Number.POSITIVE_INFINITY;
+
 // ../../node_modules/react-colorful/dist/index.mjs
 import e, { useRef as r, useMemo as t, useEffect as n, useState as o, useCallback as a, useLayoutEffect as l } from "react";
 function u() {

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

@@ -0,0 +1,23 @@
+// src/shared/constants/tags.ts
+var Tag = {
+  /** Indicates that autodocs should be generated for this component */
+  AUTODOCS: "autodocs",
+  /** MDX documentation attached to a component's stories file */
+  ATTACHED_MDX: "attached-mdx",
+  /** Standalone MDX documentation not attached to stories */
+  UNATTACHED_MDX: "unattached-mdx",
+  /** Story has a play function */
+  PLAY_FN: "play-fn",
+  /** Story has a test function */
+  TEST_FN: "test-fn",
+  /** Development environment tag */
+  DEV: "dev",
+  /** Test environment tag */
+  TEST: "test",
+  /** Manifest generation tag */
+  MANIFEST: "manifest"
+};
+
+export {
+  Tag
+};

package/dist/_browser-chunks/{chunk-3PJE6VLG.js → chunk-ASKQZAOS.js}

@@ -259,19 +259,8 @@ var INITIAL_VIEWPORTS = {
   }
 };
 
-// src/viewport/responsiveViewport.tsx
-var responsiveViewport = {
-  name: "Reset viewport",
-  styles: {
-    height: "100%",
-    width: "100%"
-  },
-  type: "desktop"
-};
-
 export {
   INITIAL_VIEWPORTS,
   DEFAULT_VIEWPORT,
-  MINIMAL_VIEWPORTS,
-  responsiveViewport
+  MINIMAL_VIEWPORTS
 };

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

@@ -0,0 +1,171 @@
+import {
+  noop
+} from "./chunk-NZMVUW5T.js";
+import {
+  argumentsTag,
+  arrayBufferTag,
+  arrayTag,
+  bigInt64ArrayTag,
+  bigUint64ArrayTag,
+  booleanTag,
+  dataViewTag,
+  dateTag,
+  errorTag,
+  float32ArrayTag,
+  float64ArrayTag,
+  functionTag,
+  getSymbols,
+  getTag,
+  int16ArrayTag,
+  int32ArrayTag,
+  int8ArrayTag,
+  isPlainObject,
+  mapTag,
+  numberTag,
+  objectTag,
+  regexpTag,
+  setTag,
+  stringTag,
+  symbolTag,
+  uint16ArrayTag,
+  uint32ArrayTag,
+  uint8ArrayTag,
+  uint8ClampedArrayTag
+} from "./chunk-LCHBOIHN.js";
+
+// ../../node_modules/es-toolkit/dist/compat/util/eq.mjs
+function eq(value, other) {
+  return value === other || Number.isNaN(value) && Number.isNaN(other);
+}
+
+// ../../node_modules/es-toolkit/dist/predicate/isEqualWith.mjs
+function isEqualWith(a, b, areValuesEqual) {
+  return isEqualWithImpl(a, b, void 0, void 0, void 0, void 0, areValuesEqual);
+}
+function isEqualWithImpl(a, b, property, aParent, bParent, stack, areValuesEqual) {
+  let result = areValuesEqual(a, b, property, aParent, bParent, stack);
+  if (result !== void 0)
+    return result;
+  if (typeof a == typeof b)
+    switch (typeof a) {
+      case "bigint":
+      case "string":
+      case "boolean":
+      case "symbol":
+      case "undefined":
+        return a === b;
+      case "number":
+        return a === b || Object.is(a, b);
+      case "function":
+        return a === b;
+      case "object":
+        return areObjectsEqual(a, b, stack, areValuesEqual);
+    }
+  return areObjectsEqual(a, b, stack, areValuesEqual);
+}
+function areObjectsEqual(a, b, stack, areValuesEqual) {
+  if (Object.is(a, b))
+    return !0;
+  let aTag = getTag(a), bTag = getTag(b);
+  if (aTag === argumentsTag && (aTag = objectTag), bTag === argumentsTag && (bTag = objectTag), aTag !== bTag)
+    return !1;
+  switch (aTag) {
+    case stringTag:
+      return a.toString() === b.toString();
+    case numberTag: {
+      let x = a.valueOf(), y = b.valueOf();
+      return eq(x, y);
+    }
+    case booleanTag:
+    case dateTag:
+    case symbolTag:
+      return Object.is(a.valueOf(), b.valueOf());
+    case regexpTag:
+      return a.source === b.source && a.flags === b.flags;
+    case functionTag:
+      return a === b;
+  }
+  stack = stack ?? /* @__PURE__ */ new Map();
+  let aStack = stack.get(a), bStack = stack.get(b);
+  if (aStack != null && bStack != null)
+    return aStack === b;
+  stack.set(a, b), stack.set(b, a);
+  try {
+    switch (aTag) {
+      case mapTag: {
+        if (a.size !== b.size)
+          return !1;
+        for (let [key, value] of a.entries())
+          if (!b.has(key) || !isEqualWithImpl(value, b.get(key), key, a, b, stack, areValuesEqual))
+            return !1;
+        return !0;
+      }
+      case setTag: {
+        if (a.size !== b.size)
+          return !1;
+        let aValues = Array.from(a.values()), bValues = Array.from(b.values());
+        for (let i = 0; i < aValues.length; i++) {
+          let aValue = aValues[i], index = bValues.findIndex((bValue) => isEqualWithImpl(aValue, bValue, void 0, a, b, stack, areValuesEqual));
+          if (index === -1)
+            return !1;
+          bValues.splice(index, 1);
+        }
+        return !0;
+      }
+      case arrayTag:
+      case uint8ArrayTag:
+      case uint8ClampedArrayTag:
+      case uint16ArrayTag:
+      case uint32ArrayTag:
+      case bigUint64ArrayTag:
+      case int8ArrayTag:
+      case int16ArrayTag:
+      case int32ArrayTag:
+      case bigInt64ArrayTag:
+      case float32ArrayTag:
+      case float64ArrayTag: {
+        if (typeof Buffer < "u" && Buffer.isBuffer(a) !== Buffer.isBuffer(b) || a.length !== b.length)
+          return !1;
+        for (let i = 0; i < a.length; i++)
+          if (!isEqualWithImpl(a[i], b[i], i, a, b, stack, areValuesEqual))
+            return !1;
+        return !0;
+      }
+      case arrayBufferTag:
+        return a.byteLength !== b.byteLength ? !1 : areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
+      case dataViewTag:
+        return a.byteLength !== b.byteLength || a.byteOffset !== b.byteOffset ? !1 : areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
+      case errorTag:
+        return a.name === b.name && a.message === b.message;
+      case objectTag: {
+        if (!(areObjectsEqual(a.constructor, b.constructor, stack, areValuesEqual) || isPlainObject(a) && isPlainObject(b)))
+          return !1;
+        let aKeys = [...Object.keys(a), ...getSymbols(a)], bKeys = [...Object.keys(b), ...getSymbols(b)];
+        if (aKeys.length !== bKeys.length)
+          return !1;
+        for (let i = 0; i < aKeys.length; i++) {
+          let propKey = aKeys[i], aProp = a[propKey];
+          if (!Object.hasOwn(b, propKey))
+            return !1;
+          let bProp = b[propKey];
+          if (!isEqualWithImpl(aProp, bProp, propKey, a, b, stack, areValuesEqual))
+            return !1;
+        }
+        return !0;
+      }
+      default:
+        return !1;
+    }
+  } finally {
+    stack.delete(a), stack.delete(b);
+  }
+}
+
+// ../../node_modules/es-toolkit/dist/predicate/isEqual.mjs
+function isEqual(a, b) {
+  return isEqualWith(a, b, noop);
+}
+
+export {
+  isEqual
+};

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

@@ -0,0 +1,64 @@
+// ../../node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
+function isPlainObject(value) {
+  if (!value || typeof value != "object")
+    return !1;
+  let proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype || Object.getPrototypeOf(proto) === null ? Object.prototype.toString.call(value) === "[object Object]" : !1;
+}
+
+// ../../node_modules/es-toolkit/dist/predicate/isPrimitive.mjs
+function isPrimitive(value) {
+  return value == null || typeof value != "object" && typeof value != "function";
+}
+
+// ../../node_modules/es-toolkit/dist/predicate/isTypedArray.mjs
+function isTypedArray(x) {
+  return ArrayBuffer.isView(x) && !(x instanceof DataView);
+}
+
+// ../../node_modules/es-toolkit/dist/compat/_internal/getSymbols.mjs
+function getSymbols(object) {
+  return Object.getOwnPropertySymbols(object).filter((symbol) => Object.prototype.propertyIsEnumerable.call(object, symbol));
+}
+
+// ../../node_modules/es-toolkit/dist/compat/_internal/getTag.mjs
+function getTag(value) {
+  return value == null ? value === void 0 ? "[object Undefined]" : "[object Null]" : Object.prototype.toString.call(value);
+}
+
+// ../../node_modules/es-toolkit/dist/compat/_internal/tags.mjs
+var regexpTag = "[object RegExp]", stringTag = "[object String]", numberTag = "[object Number]", booleanTag = "[object Boolean]", argumentsTag = "[object Arguments]", symbolTag = "[object Symbol]", dateTag = "[object Date]", mapTag = "[object Map]", setTag = "[object Set]", arrayTag = "[object Array]", functionTag = "[object Function]", arrayBufferTag = "[object ArrayBuffer]", objectTag = "[object Object]", errorTag = "[object Error]", dataViewTag = "[object DataView]", uint8ArrayTag = "[object Uint8Array]", uint8ClampedArrayTag = "[object Uint8ClampedArray]", uint16ArrayTag = "[object Uint16Array]", uint32ArrayTag = "[object Uint32Array]", bigUint64ArrayTag = "[object BigUint64Array]", int8ArrayTag = "[object Int8Array]", int16ArrayTag = "[object Int16Array]", int32ArrayTag = "[object Int32Array]", bigInt64ArrayTag = "[object BigInt64Array]", float32ArrayTag = "[object Float32Array]", float64ArrayTag = "[object Float64Array]";
+
+export {
+  isPrimitive,
+  isTypedArray,
+  getSymbols,
+  getTag,
+  regexpTag,
+  stringTag,
+  numberTag,
+  booleanTag,
+  argumentsTag,
+  symbolTag,
+  dateTag,
+  mapTag,
+  setTag,
+  arrayTag,
+  functionTag,
+  arrayBufferTag,
+  objectTag,
+  errorTag,
+  dataViewTag,
+  uint8ArrayTag,
+  uint8ClampedArrayTag,
+  uint16ArrayTag,
+  uint32ArrayTag,
+  bigUint64ArrayTag,
+  int8ArrayTag,
+  int16ArrayTag,
+  int32ArrayTag,
+  bigInt64ArrayTag,
+  float32ArrayTag,
+  float64ArrayTag,
+  isPlainObject
+};

package/dist/_browser-chunks/{chunk-IPA5A322.js → chunk-MEXTPDJG.js}

@@ -40,7 +40,7 @@ async function waitForAnimations(signal) {
           if (timedOut || signal?.aborted)
             return;
           let runningAnimations = animationRoots.flatMap((el) => el?.getAnimations?.() || []).filter((a) => a.playState === "running" && !isInfiniteAnimation(a));
-          runningAnimations.length > 0 && (await Promise.all(runningAnimations.map((a) => a.finished)), await checkAnimationsFinished());
+          runningAnimations.length > 0 && (await Promise.allSettled(runningAnimations.map(async (a) => a.finished)), await checkAnimationsFinished());
         };
         checkAnimationsFinished().then(resolve);
       }, 100);

package/dist/_browser-chunks/{chunk-54PNNATT.js → chunk-NQJGOFZV.js}

@@ -62,7 +62,24 @@ function partition(arr, isInTruthy) {
   return [truthy, falsy];
 }
 
+// ../../node_modules/es-toolkit/dist/array/countBy.mjs
+function countBy(arr, mapper) {
+  let result = {};
+  for (let i = 0; i < arr.length; i++) {
+    let item = arr[i], key = mapper(item);
+    result[key] = (result[key] ?? 0) + 1;
+  }
+  return result;
+}
+
+// ../../node_modules/es-toolkit/dist/array/uniq.mjs
+function uniq(arr) {
+  return [...new Set(arr)];
+}
+
 export {
   dequal,
-  partition
+  countBy,
+  partition,
+  uniq
 };

package/dist/_browser-chunks/{chunk-VUZYLZ4B.js → chunk-QOXZ7W26.js}

@@ -2,14 +2,20 @@ import {
   isTestEnvironment,
   pauseAnimations,
   waitForAnimations
-} from "./chunk-IPA5A322.js";
+} from "./chunk-MEXTPDJG.js";
+import {
+  Tag
+} from "./chunk-AFVOZMXQ.js";
 import {
   require_main
 } from "./chunk-XLJZ7AOP.js";
 import {
   SNIPPET_RENDERED,
   combineParameters
-} from "./chunk-LOTN4ZCW.js";
+} from "./chunk-SI6AKD4S.js";
+import {
+  isEqual
+} from "./chunk-IYCKG66Y.js";
 import {
   invariant
 } from "./chunk-IWQGIXJS.js";
@@ -19,11 +25,10 @@ import {
 import {
   mapValues,
   pickBy
-} from "./chunk-CLSHX4VX.js";
+} from "./chunk-YK43Z22A.js";
 import {
-  isEqual,
   isPlainObject
-} from "./chunk-2NDLAB5X.js";
+} from "./chunk-LCHBOIHN.js";
 import {
   require_memoizerific
 } from "./chunk-ZCFV7BZB.js";
@@ -657,14 +662,26 @@ function mountDestructured(playFunction) {
   return playFunction != null && getUsedProps(playFunction).includes("mount");
 }
 function getUsedProps(fn) {
-  let match = fn.toString().match(/[^(]*\(([^)]*)/);
-  if (!match)
+  let [, args, body] = fn.toString().match(/[^(]*\(([^)]+)\)(?:.*{([^]+)})?/) || [];
+  if (!args)
     return [];
-  let args = splitByComma(match[1]);
-  if (!args.length)
+  let [firstArg] = splitByComma(args);
+  if (!firstArg)
     return [];
-  let first = args[0];
-  return first.startsWith("{") && first.endsWith("}") ? splitByComma(first.slice(1, -1).replace(/\s/g, "")).map((prop) => prop.replace(/:.*|=.*/g, "")) : [];
+  let [, destructuredProps] = firstArg.match(/^{([^]+)}$/) || [];
+  if (destructuredProps)
+    return splitByComma(stripComments(destructuredProps)).map(
+      (prop) => prop.replace(/:.*|=.*/g, "").trim()
+    );
+  if (!firstArg.match(/^[a-z_$][0-9a-z_$]*$/i))
+    return [];
+  let escapedArg = firstArg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), [, destructuredArg] = body?.trim()?.match(new RegExp(`^(?:const|let|var)\\s*{([^}]+)}\\s*=\\s*${escapedArg};`)) || [];
+  return destructuredArg ? splitByComma(stripComments(destructuredArg)).map(
+    (prop) => prop.replace(/:.*|=.*/g, "").trim()
+  ) : [];
+}
+function stripComments(s) {
+  return s = s.replace(/\/\/.*$/gm, ""), s = s.replace(/\/\*[\s\S]*?\*\//g, ""), s;
 }
 function splitByComma(s) {
   let result = [], stack = [], start = 0;
@@ -794,7 +811,7 @@ function prepareMeta(componentAnnotations, projectAnnotations, moduleExport) {
   };
 }
 function preparePartialAnnotations(storyAnnotations, componentAnnotations, projectAnnotations) {
-  let defaultTags = ["dev", "test"], extraTags = globalThis2.DOCS_OPTIONS?.autodocs === !0 ? ["autodocs"] : [], overrideTags = storyAnnotations?.tags?.includes("test-fn") ? ["!autodocs"] : [], tags = combineTags(
+  let defaultTags = [Tag.DEV, Tag.TEST], extraTags = globalThis2.DOCS_OPTIONS?.autodocs === !0 ? [Tag.AUTODOCS] : [], overrideTags = storyAnnotations?.tags?.includes(Tag.TEST_FN) ? [`!${Tag.AUTODOCS}`] : [], tags = combineTags(
     ...defaultTags,
     ...extraTags,
     ...projectAnnotations.tags ?? [],
@@ -2406,9 +2423,8 @@ function focusInInput(event) {
   let target = event.composedPath && event.composedPath()[0] || event.target;
   return /input|textarea/i.test(target.tagName) || target.getAttribute("contenteditable") !== null;
 }
-var ATTACHED_MDX_TAG = "attached-mdx", UNATTACHED_MDX_TAG = "unattached-mdx";
 function isMdxEntry({ tags }) {
-  return tags?.includes(UNATTACHED_MDX_TAG) || tags?.includes(ATTACHED_MDX_TAG);
+  return tags?.includes(Tag.UNATTACHED_MDX) || tags?.includes(Tag.ATTACHED_MDX);
 }
 function isStoryRender(r) {
   return r.type === "story";
@@ -2586,7 +2602,7 @@ var PreviewWithSelection = class extends Preview {
         initialGlobals,
         storyGlobals: {},
         userGlobals: globals
-      }), isCsfDocsRender(render) || render.entry.tags?.includes(ATTACHED_MDX_TAG)) {
+      }), isCsfDocsRender(render) || render.entry.tags?.includes(Tag.ATTACHED_MDX)) {
         if (!render.csfFiles)
           throw new MdxFileWithNoCsfReferencesError({ storyId });
         ({ parameters } = this.storyStoreValue.preparedMetaFromCSFFile({

package/dist/_browser-chunks/{chunk-LOTN4ZCW.js → chunk-SI6AKD4S.js}

@@ -1,9 +1,9 @@
 import {
   mapValues
-} from "./chunk-CLSHX4VX.js";
+} from "./chunk-YK43Z22A.js";
 import {
   isPlainObject
-} from "./chunk-2NDLAB5X.js";
+} from "./chunk-LCHBOIHN.js";
 import {
   __commonJS,
   __toESM