storybook 10.0.0-rc.1 → 10.0.0-rc.2

package/dist/_browser-chunks/{Color-KPLIACXP.js → Color-7ZNS6F6B.js}

@@ -1,10 +1,7 @@
 import {
-  debounce,
   getControlId
-} from "./chunk-KSCAWCCE.js";
-import "./chunk-G33S6YM3.js";
-import "./chunk-QK3L5AXO.js";
-import "./chunk-JJZMHC3A.js";
+} from "./chunk-U46RQHA4.js";
+import "./chunk-AB7OOPUX.js";
 import {
   __commonJS,
   __name,
@@ -983,6 +980,116 @@ import React, { useCallback, useEffect, useMemo, useState } from "react";
 import { Form, TooltipNote, WithTooltip } 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 = void 0;
+  let pendingArgs = null;
+  const leading = edges != null && edges.includes("leading");
+  const trailing = edges == null || edges.includes("trailing");
+  const invoke = /* @__PURE__ */ __name(() => {
+    if (pendingArgs !== null) {
+      func.apply(pendingThis, pendingArgs);
+      pendingThis = void 0;
+      pendingArgs = null;
+    }
+  }, "invoke");
+  const onTimerEnd = /* @__PURE__ */ __name(() => {
+    if (trailing) {
+      invoke();
+    }
+    cancel();
+  }, "onTimerEnd");
+  let timeoutId = null;
+  const schedule = /* @__PURE__ */ __name(() => {
+    if (timeoutId != null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      timeoutId = null;
+      onTimerEnd();
+    }, debounceMs);
+  }, "schedule");
+  const cancelTimer = /* @__PURE__ */ __name(() => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  }, "cancelTimer");
+  const cancel = /* @__PURE__ */ __name(() => {
+    cancelTimer();
+    pendingThis = void 0;
+    pendingArgs = null;
+  }, "cancel");
+  const flush = /* @__PURE__ */ __name(() => {
+    invoke();
+  }, "flush");
+  const debounced = /* @__PURE__ */ __name(function(...args) {
+    if (signal?.aborted) {
+      return;
+    }
+    pendingThis = this;
+    pendingArgs = args;
+    const isFirstCall = timeoutId == null;
+    schedule();
+    if (leading && isFirstCall) {
+      invoke();
+    }
+  }, "debounced");
+  debounced.schedule = schedule;
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  signal?.addEventListener("abort", cancel, { once: true });
+  return debounced;
+}
+__name(debounce, "debounce");
+
+// ../node_modules/es-toolkit/dist/function/partial.mjs
+function partial(func, ...partialArgs) {
+  return partialImpl(func, placeholderSymbol, ...partialArgs);
+}
+__name(partial, "partial");
+function partialImpl(func, placeholder, ...partialArgs) {
+  const partialed = /* @__PURE__ */ __name(function(...providedArgs) {
+    let providedArgsIndex = 0;
+    const substitutedArgs = partialArgs.slice().map((arg) => arg === placeholder ? providedArgs[providedArgsIndex++] : arg);
+    const remainingArgs = providedArgs.slice(providedArgsIndex);
+    return func.apply(this, substitutedArgs.concat(remainingArgs));
+  }, "partialed");
+  if (func.prototype) {
+    partialed.prototype = Object.create(func.prototype);
+  }
+  return partialed;
+}
+__name(partialImpl, "partialImpl");
+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);
+}
+__name(partialRight, "partialRight");
+function partialRightImpl(func, placeholder, ...partialArgs) {
+  const partialedRight = /* @__PURE__ */ __name(function(...providedArgs) {
+    const placeholderLength = partialArgs.filter((arg) => arg === placeholder).length;
+    const rangeLength = Math.max(providedArgs.length - placeholderLength, 0);
+    const remainingArgs = providedArgs.slice(0, rangeLength);
+    let providedArgsIndex = rangeLength;
+    const substitutedArgs = partialArgs.slice().map((arg) => arg === placeholder ? providedArgs[providedArgsIndex++] : arg);
+    return func.apply(this, remainingArgs.concat(substitutedArgs));
+  }, "partialedRight");
+  if (func.prototype) {
+    partialedRight.prototype = Object.create(func.prototype);
+  }
+  return partialedRight;
+}
+__name(partialRightImpl, "partialRightImpl");
+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-AB7OOPUX.js

@@ -0,0 +1,12 @@
+import {
+  __name
+} from "./chunk-MM7DTO55.js";
+
+// ../node_modules/es-toolkit/dist/function/noop.mjs
+function noop() {
+}
+__name(noop, "noop");
+
+export {
+  noop
+};

package/dist/_browser-chunks/{chunk-6E2SHJSL.js → chunk-B4A3ADP3.js}

@@ -1,9 +1,9 @@
 import {
   mapValues
-} from "./chunk-QK3L5AXO.js";
+} from "./chunk-UTNZYD2N.js";
 import {
   isPlainObject
-} from "./chunk-JJZMHC3A.js";
+} from "./chunk-FSBVR7H5.js";
 import {
   __commonJS,
   __name,

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

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

@@ -80,6 +80,43 @@ function dequal(foo, bar) {
 }
 __name(dequal, "dequal");
 
+// ../node_modules/es-toolkit/dist/array/partition.mjs
+function partition(arr, isInTruthy) {
+  const truthy = [];
+  const falsy = [];
+  for (let i = 0; i < arr.length; i++) {
+    const item = arr[i];
+    if (isInTruthy(item)) {
+      truthy.push(item);
+    } else {
+      falsy.push(item);
+    }
+  }
+  return [truthy, falsy];
+}
+__name(partition, "partition");
+
+// ../node_modules/es-toolkit/dist/array/countBy.mjs
+function countBy(arr, mapper) {
+  const result = {};
+  for (let i = 0; i < arr.length; i++) {
+    const item = arr[i];
+    const key = mapper(item);
+    result[key] = (result[key] ?? 0) + 1;
+  }
+  return result;
+}
+__name(countBy, "countBy");
+
+// ../node_modules/es-toolkit/dist/array/uniq.mjs
+function uniq(arr) {
+  return Array.from(new Set(arr));
+}
+__name(uniq, "uniq");
+
 export {
-  dequal
+  dequal,
+  countBy,
+  partition,
+  uniq
 };

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

@@ -0,0 +1,12 @@
+import {
+  __name
+} from "./chunk-MM7DTO55.js";
+
+// ../addons/docs/src/blocks/controls/helpers.ts
+var getControlId = /* @__PURE__ */ __name((value) => `control-${value.replace(/\s+/g, "-")}`, "getControlId");
+var getControlSetterButtonId = /* @__PURE__ */ __name((value) => `set-${value.replace(/\s+/g, "-")}`, "getControlSetterButtonId");
+
+export {
+  getControlId,
+  getControlSetterButtonId
+};

package/dist/_browser-chunks/{chunk-QK3L5AXO.js → chunk-UTNZYD2N.js}

@@ -12,6 +12,7 @@ import {
   int16ArrayTag,
   int32ArrayTag,
   int8ArrayTag,
+  isPlainObject,
   isPrimitive,
   isTypedArray,
   mapTag,
@@ -25,7 +26,7 @@ import {
   uint32ArrayTag,
   uint8ArrayTag,
   uint8ClampedArrayTag
-} from "./chunk-JJZMHC3A.js";
+} from "./chunk-FSBVR7H5.js";
 import {
   __name
 } from "./chunk-MM7DTO55.js";
@@ -43,93 +44,72 @@ function mapValues(object, getNewValue) {
 }
 __name(mapValues, "mapValues");
 
+// ../node_modules/es-toolkit/dist/_internal/isUnsafeProperty.mjs
+function isUnsafeProperty(key) {
+  return key === "__proto__";
+}
+__name(isUnsafeProperty, "isUnsafeProperty");
+
 // ../node_modules/es-toolkit/dist/compat/predicate/isObjectLike.mjs
 function isObjectLike(value) {
   return typeof value === "object" && value !== null;
 }
 __name(isObjectLike, "isObjectLike");
 
-// ../node_modules/es-toolkit/dist/compat/predicate/isArray.mjs
-function isArray(value) {
-  return Array.isArray(value);
-}
-__name(isArray, "isArray");
-
-// ../node_modules/es-toolkit/dist/compat/predicate/isPlainObject.mjs
-function isPlainObject(object) {
-  if (typeof object !== "object") {
-    return false;
-  }
-  if (object == null) {
-    return false;
-  }
-  if (Object.getPrototypeOf(object) === null) {
-    return true;
-  }
-  if (Object.prototype.toString.call(object) !== "[object Object]") {
-    const tag = object[Symbol.toStringTag];
-    if (tag == null) {
-      return false;
+// ../node_modules/es-toolkit/dist/object/mergeWith.mjs
+function mergeWith(target, source, merge2) {
+  const sourceKeys = Object.keys(source);
+  for (let i = 0; i < sourceKeys.length; i++) {
+    const key = sourceKeys[i];
+    if (isUnsafeProperty(key)) {
+      continue;
     }
-    const isTagReadonly = !Object.getOwnPropertyDescriptor(object, Symbol.toStringTag)?.writable;
-    if (isTagReadonly) {
-      return false;
+    const sourceValue = source[key];
+    const targetValue = target[key];
+    const merged = merge2(targetValue, sourceValue, key, target, source);
+    if (merged !== void 0) {
+      target[key] = merged;
+    } else if (Array.isArray(sourceValue)) {
+      target[key] = mergeWith(targetValue ?? [], sourceValue, merge2);
+    } else if (isObjectLike(targetValue) && isObjectLike(sourceValue)) {
+      target[key] = mergeWith(targetValue ?? {}, sourceValue, merge2);
+    } else if (targetValue === void 0 || sourceValue !== void 0) {
+      target[key] = sourceValue;
     }
-    return object.toString() === `[object ${tag}]`;
   }
-  let proto = object;
-  while (Object.getPrototypeOf(proto) !== null) {
-    proto = Object.getPrototypeOf(proto);
-  }
-  return Object.getPrototypeOf(object) === proto;
+  return target;
 }
-__name(isPlainObject, "isPlainObject");
+__name(mergeWith, "mergeWith");
 
-// ../node_modules/es-toolkit/dist/object/clone.mjs
-function clone(obj) {
-  if (isPrimitive(obj)) {
-    return obj;
-  }
-  if (Array.isArray(obj) || isTypedArray(obj) || obj instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && obj instanceof SharedArrayBuffer) {
-    return obj.slice(0);
-  }
-  const prototype = Object.getPrototypeOf(obj);
-  const Constructor = prototype.constructor;
-  if (obj instanceof Date || obj instanceof Map || obj instanceof Set) {
-    return new Constructor(obj);
-  }
-  if (obj instanceof RegExp) {
-    const newRegExp = new Constructor(obj);
-    newRegExp.lastIndex = obj.lastIndex;
-    return newRegExp;
-  }
-  if (obj instanceof DataView) {
-    return new Constructor(obj.buffer.slice(0));
-  }
-  if (obj instanceof Error) {
-    const newError = new Constructor(obj.message);
-    newError.stack = obj.stack;
-    newError.name = obj.name;
-    newError.cause = obj.cause;
-    return newError;
-  }
-  if (typeof File !== "undefined" && obj instanceof File) {
-    const newFile = new Constructor([obj], obj.name, { type: obj.type, lastModified: obj.lastModified });
-    return newFile;
+// ../node_modules/es-toolkit/dist/object/pick.mjs
+function pick(obj, keys) {
+  const result = {};
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (Object.hasOwn(obj, key)) {
+      result[key] = obj[key];
+    }
   }
-  if (typeof obj === "object") {
-    const newObject = Object.create(prototype);
-    return Object.assign(newObject, obj);
+  return result;
+}
+__name(pick, "pick");
+
+// ../node_modules/es-toolkit/dist/object/pickBy.mjs
+function pickBy(obj, shouldPick) {
+  const result = {};
+  const keys = Object.keys(obj);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const value = obj[key];
+    if (shouldPick(value, key)) {
+      result[key] = value;
+    }
   }
-  return obj;
+  return result;
 }
-__name(clone, "clone");
+__name(pickBy, "pickBy");
 
 // ../node_modules/es-toolkit/dist/object/cloneDeepWith.mjs
-function cloneDeepWith(obj, cloneValue) {
-  return cloneDeepWithImpl(obj, void 0, obj, /* @__PURE__ */ new Map(), cloneValue);
-}
-__name(cloneDeepWith, "cloneDeepWith");
 function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = /* @__PURE__ */ new Map(), cloneValue = void 0) {
   const cloned = cloneValue?.(valueToClone, keyToClone, objectToClone, stack);
   if (cloned !== void 0) {
@@ -282,91 +262,50 @@ function cloneDeep(obj) {
 }
 __name(cloneDeep, "cloneDeep");
 
-// ../node_modules/es-toolkit/dist/object/findKey.mjs
-function findKey(obj, predicate) {
-  const keys = Object.keys(obj);
-  return keys.find((key) => predicate(obj[key], key, obj));
-}
-__name(findKey, "findKey");
-
-// ../node_modules/es-toolkit/dist/object/invert.mjs
-function invert(obj) {
-  const result = {};
-  const keys = Object.keys(obj);
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
-    const value = obj[key];
-    result[value] = key;
-  }
-  return result;
-}
-__name(invert, "invert");
-
-// ../node_modules/es-toolkit/dist/object/mapKeys.mjs
-function mapKeys(object, getNewKey) {
-  const result = {};
-  const keys = Object.keys(object);
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
-    const value = object[key];
-    result[getNewKey(value, key, object)] = value;
+// ../node_modules/es-toolkit/dist/object/merge.mjs
+function merge(target, source) {
+  const sourceKeys = Object.keys(source);
+  for (let i = 0; i < sourceKeys.length; i++) {
+    const key = sourceKeys[i];
+    if (isUnsafeProperty(key)) {
+      continue;
+    }
+    const sourceValue = source[key];
+    const targetValue = target[key];
+    if (Array.isArray(sourceValue)) {
+      if (Array.isArray(targetValue)) {
+        target[key] = merge(targetValue, sourceValue);
+      } else {
+        target[key] = merge([], sourceValue);
+      }
+    } else if (isPlainObject(sourceValue)) {
+      if (isPlainObject(targetValue)) {
+        target[key] = merge(targetValue, sourceValue);
+      } else {
+        target[key] = merge({}, sourceValue);
+      }
+    } else if (targetValue === void 0 || sourceValue !== void 0) {
+      target[key] = sourceValue;
+    }
   }
-  return result;
+  return target;
 }
-__name(mapKeys, "mapKeys");
-
-// ../node_modules/es-toolkit/dist/_internal/isUnsafeProperty.mjs
-function isUnsafeProperty(key) {
-  return key === "__proto__";
-}
-__name(isUnsafeProperty, "isUnsafeProperty");
-
-// ../node_modules/es-toolkit/dist/string/capitalize.mjs
-function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
-}
-__name(capitalize, "capitalize");
+__name(merge, "merge");
 
 // ../node_modules/es-toolkit/dist/string/words.mjs
 var CASE_SPLIT_PATTERN = new RegExp("\\p{Lu}?\\p{Ll}+|[0-9]+|\\p{Lu}+(?!\\p{Ll})|\\p{Emoji_Presentation}|\\p{Extended_Pictographic}|\\p{L}+", "gu");
-function words(str) {
-  return Array.from(str.match(CASE_SPLIT_PATTERN) ?? []);
-}
-__name(words, "words");
 
-// ../node_modules/es-toolkit/dist/string/camelCase.mjs
-function camelCase(str) {
-  const words$1 = words(str);
-  if (words$1.length === 0) {
-    return "";
-  }
-  const [first, ...rest] = words$1;
-  return `${first.toLowerCase()}${rest.map((word) => capitalize(word)).join("")}`;
-}
-__name(camelCase, "camelCase");
-
-// ../node_modules/es-toolkit/dist/string/snakeCase.mjs
-function snakeCase(str) {
-  const words$1 = words(str);
-  return words$1.map((word) => word.toLowerCase()).join("_");
+// ../node_modules/es-toolkit/dist/object/toMerged.mjs
+function toMerged(target, source) {
+  return merge(cloneDeep(target), source);
 }
-__name(snakeCase, "snakeCase");
+__name(toMerged, "toMerged");
 
 export {
-  clone,
-  cloneDeepWith,
-  copyProperties,
   cloneDeep,
-  findKey,
-  invert,
-  mapKeys,
   mapValues,
-  isUnsafeProperty,
-  isObjectLike,
-  isArray,
-  capitalize,
-  words,
-  camelCase,
-  isPlainObject,
-  snakeCase
+  mergeWith,
+  pick,
+  pickBy,
+  toMerged
 };

package/dist/_browser-chunks/{chunk-OTSQMN22.js → chunk-W4QKLQSC.js}

@@ -4,10 +4,10 @@ import {
 import {
   SNIPPET_RENDERED,
   combineParameters
-} from "./chunk-6E2SHJSL.js";
+} from "./chunk-B4A3ADP3.js";
 import {
-  pickBy
-} from "./chunk-FA42P6MO.js";
+  isEqual
+} from "./chunk-ZNRFDIVA.js";
 import {
   invariant
 } from "./chunk-FUOHXXZT.js";
@@ -20,12 +20,12 @@ import {
   waitForAnimations
 } from "./chunk-LYCSRYYR.js";
 import {
-  mapValues
-} from "./chunk-QK3L5AXO.js";
+  mapValues,
+  pickBy
+} from "./chunk-UTNZYD2N.js";
 import {
-  isEqual,
   isPlainObject
-} from "./chunk-JJZMHC3A.js";
+} from "./chunk-FSBVR7H5.js";
 import {
   require_memoizerific
 } from "./chunk-NVV6MIOE.js";