storybook 10.0.0-beta.1 → 10.0.0-beta.10

package/dist/_browser-chunks/{chunk-PYK5ZTFK.js → chunk-PS3AOQI4.js}

@@ -1,31 +1,31 @@
-import {
-  isTestEnvironment,
-  pauseAnimations,
-  waitForAnimations
-} from "./chunk-LYCSRYYR.js";
 import {
   require_main
-} from "./chunk-T7RCAJIX.js";
+} from "./chunk-Y3M7TW6K.js";
 import {
   SNIPPET_RENDERED,
   combineParameters
-} from "./chunk-YY5GICNT.js";
+} from "./chunk-6E2SHJSL.js";
 import {
   pickBy
-} from "./chunk-YWDKX534.js";
+} from "./chunk-FA42P6MO.js";
 import {
   invariant
 } from "./chunk-FUOHXXZT.js";
 import {
   require_ansi_to_html
 } from "./chunk-F4Q6SGTB.js";
+import {
+  isTestEnvironment,
+  pauseAnimations,
+  waitForAnimations
+} from "./chunk-LYCSRYYR.js";
 import {
   mapValues
-} from "./chunk-E7VLET3C.js";
+} from "./chunk-QK3L5AXO.js";
 import {
   isEqual,
   isPlainObject
-} from "./chunk-4QPX7WIQ.js";
+} from "./chunk-JJZMHC3A.js";
 import {
   require_memoizerific
 } from "./chunk-NVV6MIOE.js";
@@ -511,6 +511,13 @@ var map = /* @__PURE__ */ __name((arg, argType) => {
         const mapped = map(val, { type: type.value[key] });
         return mapped === INCOMPATIBLE ? acc : Object.assign(acc, { [key]: mapped });
       }, {});
+    case "other": {
+      const isPrimitiveArg = typeof arg === "string" || typeof arg === "number" || typeof arg === "boolean";
+      if (type.value === "ReactNode" && isPrimitiveArg) {
+        return arg;
+      }
+      return INCOMPATIBLE;
+    }
     default:
       return INCOMPATIBLE;
   }
@@ -880,7 +887,7 @@ __name(normalizeStory, "normalizeStory");
 
 // src/preview-api/modules/store/csf/processCSFFile.ts
 import { logger as logger4 } from "storybook/internal/client-logger";
-import { isExportStory, isStory } from "storybook/internal/csf";
+import { getStoryChildren, isExportStory, isStory, toTestId } from "storybook/internal/csf";
 
 // src/preview-api/modules/store/csf/normalizeComponentAnnotations.ts
 import { sanitize } from "storybook/internal/csf";
@@ -934,9 +941,17 @@ function processCSFFile(moduleExports, importPath, title) {
     const csfFile2 = { meta: meta2, stories: {}, moduleExports };
     Object.keys(namedExports).forEach((key) => {
       if (isExportStory(key, meta2)) {
-        const storyMeta = normalizeStory(key, namedExports[key].input, meta2);
+        const story = namedExports[key];
+        const storyMeta = normalizeStory(key, story.input, meta2);
         checkDisallowedParameters(storyMeta.parameters);
         csfFile2.stories[storyMeta.id] = storyMeta;
+        getStoryChildren(story).forEach((child) => {
+          const name = child.input.name;
+          const childId = toTestId(storyMeta.id, name);
+          child.input.parameters ??= {};
+          child.input.parameters.__id = childId;
+          csfFile2.stories[childId] = normalizeStory(name, child.input, meta2);
+        });
       }
     });
     csfFile2.projectAnnotations = firstStory.meta.preview.composed;
@@ -1167,11 +1182,13 @@ __name(prepareMeta, "prepareMeta");
 function preparePartialAnnotations(storyAnnotations, componentAnnotations, projectAnnotations) {
   const defaultTags = ["dev", "test"];
   const extraTags = globalThis2.DOCS_OPTIONS?.autodocs === true ? ["autodocs"] : [];
+  const overrideTags = storyAnnotations?.tags?.includes("test-fn") ? ["!autodocs"] : [];
   const tags = combineTags(
     ...defaultTags,
     ...extraTags,
     ...projectAnnotations.tags ?? [],
     ...componentAnnotations.tags ?? [],
+    ...overrideTags,
     ...storyAnnotations?.tags ?? []
   );
   const parameters = combineParameters(
@@ -1542,13 +1559,13 @@ __name(_ReporterAPI, "ReporterAPI");
 var ReporterAPI = _ReporterAPI;
 
 // src/preview-api/modules/store/csf/csf-factory-utils.ts
-import { isStory as isStory2 } from "storybook/internal/csf";
+import { isMeta, isStory as isStory2 } from "storybook/internal/csf";
 function getCsfFactoryAnnotations(story, meta, projectAnnotations) {
   return isStory2(story) ? {
     story: story.input,
     meta: story.meta.input,
     preview: story.meta.preview.composed
-  } : { story, meta, preview: projectAnnotations };
+  } : { story, meta: isMeta(meta) ? meta.input : meta, preview: projectAnnotations };
 }
 __name(getCsfFactoryAnnotations, "getCsfFactoryAnnotations");
 
@@ -1947,7 +1964,7 @@ var _StoryStore = class _StoryStore {
     return { entryExports, csfFiles };
   }
   // A prepared story does not include args, globals or hooks. These are stored in the story store
-  // and updated separtely to the (immutable) story.
+  // and updated separately to the (immutable) story.
   getStoryContext(story, { forceInitialArgs = false } = {}) {
     const userGlobals = this.userGlobals.get();
     const { initialGlobals } = this.userGlobals;
@@ -1981,21 +1998,25 @@ var _StoryStore = class _StoryStore {
   }
   extract(options = { includeDocsOnly: false }) {
     const { cachedCSFFiles } = this;
+    console.log("extract: extracting stories", cachedCSFFiles);
     if (!cachedCSFFiles) {
       throw new CalledExtractOnStoreError();
     }
-    return Object.entries(this.storyIndex.entries).reduce(
-      (acc, [storyId, { type, importPath }]) => {
-        if (type === "docs") {
+    const stories = Object.entries(this.storyIndex.entries).reduce(
+      (acc, [storyId, entry]) => {
+        if (entry.type === "docs") {
           return acc;
         }
-        const csfFile = cachedCSFFiles[importPath];
+        const csfFile = cachedCSFFiles[entry.importPath];
         const story = this.storyFromCSFFile({ storyId, csfFile });
         if (!options.includeDocsOnly && story.parameters.docsOnly) {
           return acc;
         }
         acc[storyId] = Object.entries(story).reduce(
           (storyAcc, [key, value]) => {
+            if (key === "story" && entry.subtype === "test") {
+              return { ...storyAcc, story: entry.parentName };
+            }
             if (key === "moduleExport") {
               return storyAcc;
             }
@@ -2008,19 +2029,21 @@ var _StoryStore = class _StoryStore {
             return Object.assign(storyAcc, { [key]: value });
           },
           {
-            //
             args: story.initialArgs,
             globals: {
               ...this.userGlobals.initialGlobals,
               ...this.userGlobals.globals,
               ...story.storyGlobals
-            }
+            },
+            storyId: entry.parent ? entry.parent : storyId
           }
         );
         return acc;
       },
       {}
     );
+    console.log("extract: stories", stories);
+    return stories;
   }
 };
 __name(_StoryStore, "StoryStore");
@@ -2181,7 +2204,7 @@ var sortStoriesV7 = /* @__PURE__ */ __name((stories, storySortParameter, fileNam
     Error sorting stories with sort parameter ${storySortParameter}:
 
     > ${err.message}
-    
+
     Are you using a V6-style sort function in V7 mode?
 
     More info: https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#v7-style-story-sort
@@ -2277,16 +2300,15 @@ var _StoryRender = class _StoryRender {
     }
   }
   checkIfAborted(signal) {
-    if (signal.aborted) {
+    if (signal.aborted && !["finished", "aborted", "errored"].includes(this.phase)) {
       this.phase = "aborted";
       this.channel.emit(STORY_RENDER_PHASE_CHANGED, {
         newPhase: this.phase,
         renderId: this.renderId,
         storyId: this.id
       });
-      return true;
     }
-    return false;
+    return signal.aborted;
   }
   async prepare() {
     await this.runPhase(this.abortController.signal, "preparing", async () => {
@@ -4123,6 +4145,7 @@ export {
   combineArgs,
   normalizeArrays,
   normalizeStory,
+  mountDestructured,
   decorateStory,
   sanitizeStoryContextUpdate,
   defaultDecorateStory,

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

@@ -0,0 +1,372 @@
+import {
+  argumentsTag,
+  arrayBufferTag,
+  arrayTag,
+  booleanTag,
+  dataViewTag,
+  dateTag,
+  float32ArrayTag,
+  float64ArrayTag,
+  getSymbols,
+  getTag,
+  int16ArrayTag,
+  int32ArrayTag,
+  int8ArrayTag,
+  isPrimitive,
+  isTypedArray,
+  mapTag,
+  numberTag,
+  objectTag,
+  regexpTag,
+  setTag,
+  stringTag,
+  symbolTag,
+  uint16ArrayTag,
+  uint32ArrayTag,
+  uint8ArrayTag,
+  uint8ClampedArrayTag
+} from "./chunk-JJZMHC3A.js";
+import {
+  __name
+} from "./chunk-MM7DTO55.js";
+
+// ../node_modules/es-toolkit/dist/object/mapValues.mjs
+function mapValues(object, getNewValue) {
+  const result = {};
+  const keys = Object.keys(object);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const value = object[key];
+    result[key] = getNewValue(value, key, object);
+  }
+  return result;
+}
+__name(mapValues, "mapValues");
+
+// ../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;
+    }
+    const isTagReadonly = !Object.getOwnPropertyDescriptor(object, Symbol.toStringTag)?.writable;
+    if (isTagReadonly) {
+      return false;
+    }
+    return object.toString() === `[object ${tag}]`;
+  }
+  let proto = object;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(object) === proto;
+}
+__name(isPlainObject, "isPlainObject");
+
+// ../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;
+  }
+  if (typeof obj === "object") {
+    const newObject = Object.create(prototype);
+    return Object.assign(newObject, obj);
+  }
+  return obj;
+}
+__name(clone, "clone");
+
+// ../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) {
+    return cloned;
+  }
+  if (isPrimitive(valueToClone)) {
+    return valueToClone;
+  }
+  if (stack.has(valueToClone)) {
+    return stack.get(valueToClone);
+  }
+  if (Array.isArray(valueToClone)) {
+    const result = new Array(valueToClone.length);
+    stack.set(valueToClone, result);
+    for (let i = 0; i < valueToClone.length; i++) {
+      result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
+    }
+    if (Object.hasOwn(valueToClone, "index")) {
+      result.index = valueToClone.index;
+    }
+    if (Object.hasOwn(valueToClone, "input")) {
+      result.input = valueToClone.input;
+    }
+    return result;
+  }
+  if (valueToClone instanceof Date) {
+    return new Date(valueToClone.getTime());
+  }
+  if (valueToClone instanceof RegExp) {
+    const result = new RegExp(valueToClone.source, valueToClone.flags);
+    result.lastIndex = valueToClone.lastIndex;
+    return result;
+  }
+  if (valueToClone instanceof Map) {
+    const result = /* @__PURE__ */ new Map();
+    stack.set(valueToClone, result);
+    for (const [key, value] of valueToClone) {
+      result.set(key, cloneDeepWithImpl(value, key, objectToClone, stack, cloneValue));
+    }
+    return result;
+  }
+  if (valueToClone instanceof Set) {
+    const result = /* @__PURE__ */ new Set();
+    stack.set(valueToClone, result);
+    for (const value of valueToClone) {
+      result.add(cloneDeepWithImpl(value, void 0, objectToClone, stack, cloneValue));
+    }
+    return result;
+  }
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(valueToClone)) {
+    return valueToClone.subarray();
+  }
+  if (isTypedArray(valueToClone)) {
+    const result = new (Object.getPrototypeOf(valueToClone)).constructor(valueToClone.length);
+    stack.set(valueToClone, result);
+    for (let i = 0; i < valueToClone.length; i++) {
+      result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
+    }
+    return result;
+  }
+  if (valueToClone instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && valueToClone instanceof SharedArrayBuffer) {
+    return valueToClone.slice(0);
+  }
+  if (valueToClone instanceof DataView) {
+    const result = new DataView(valueToClone.buffer.slice(0), valueToClone.byteOffset, valueToClone.byteLength);
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (typeof File !== "undefined" && valueToClone instanceof File) {
+    const result = new File([valueToClone], valueToClone.name, {
+      type: valueToClone.type
+    });
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (valueToClone instanceof Blob) {
+    const result = new Blob([valueToClone], { type: valueToClone.type });
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (valueToClone instanceof Error) {
+    const result = new valueToClone.constructor();
+    stack.set(valueToClone, result);
+    result.message = valueToClone.message;
+    result.name = valueToClone.name;
+    result.stack = valueToClone.stack;
+    result.cause = valueToClone.cause;
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (typeof valueToClone === "object" && isCloneableObject(valueToClone)) {
+    const result = Object.create(Object.getPrototypeOf(valueToClone));
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  return valueToClone;
+}
+__name(cloneDeepWithImpl, "cloneDeepWithImpl");
+function copyProperties(target, source, objectToClone = target, stack, cloneValue) {
+  const keys = [...Object.keys(source), ...getSymbols(source)];
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const descriptor = Object.getOwnPropertyDescriptor(target, key);
+    if (descriptor == null || descriptor.writable) {
+      target[key] = cloneDeepWithImpl(source[key], key, objectToClone, stack, cloneValue);
+    }
+  }
+}
+__name(copyProperties, "copyProperties");
+function isCloneableObject(object) {
+  switch (getTag(object)) {
+    case argumentsTag:
+    case arrayTag:
+    case arrayBufferTag:
+    case dataViewTag:
+    case booleanTag:
+    case dateTag:
+    case float32ArrayTag:
+    case float64ArrayTag:
+    case int8ArrayTag:
+    case int16ArrayTag:
+    case int32ArrayTag:
+    case mapTag:
+    case numberTag:
+    case objectTag:
+    case regexpTag:
+    case setTag:
+    case stringTag:
+    case symbolTag:
+    case uint8ArrayTag:
+    case uint8ClampedArrayTag:
+    case uint16ArrayTag:
+    case uint32ArrayTag: {
+      return true;
+    }
+    default: {
+      return false;
+    }
+  }
+}
+__name(isCloneableObject, "isCloneableObject");
+
+// ../node_modules/es-toolkit/dist/object/cloneDeep.mjs
+function cloneDeep(obj) {
+  return cloneDeepWithImpl(obj, void 0, obj, /* @__PURE__ */ new Map(), void 0);
+}
+__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;
+  }
+  return result;
+}
+__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");
+
+// ../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("_");
+}
+__name(snakeCase, "snakeCase");
+
+export {
+  clone,
+  cloneDeepWith,
+  copyProperties,
+  cloneDeep,
+  findKey,
+  invert,
+  mapKeys,
+  mapValues,
+  isUnsafeProperty,
+  isObjectLike,
+  isArray,
+  capitalize,
+  words,
+  camelCase,
+  isPlainObject,
+  snakeCase
+};