@storybook/react 9.2.0-alpha.2 → 10.0.0-beta.0

package/README.md

@@ -1 +1,3 @@
 # Storybook React renderer
+
+Learn more about Storybook at [storybook.js.org](https://storybook.js.org/?ref=readme).

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

@@ -0,0 +1,14 @@
+import {
+  __name
+} from "./chunk-L5NVL7MD.js";
+
+// src/applyDecorators.ts
+import React from "react";
+import { defaultDecorateStory } from "storybook/preview-api";
+var applyDecorators = /* @__PURE__ */ __name((storyFn, decorators) => {
+  return defaultDecorateStory((context) => React.createElement(storyFn, context), decorators);
+}, "applyDecorators");
+
+export {
+  applyDecorators
+};

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

@@ -0,0 +1,209 @@
+import {
+  applyDecorators
+} from "./chunk-BUAOEMNB.js";
+import {
+  isForwardRef,
+  isMemo,
+  reactElementToJsxString
+} from "./chunk-VVH2AMAL.js";
+import {
+  __export,
+  __name
+} from "./chunk-L5NVL7MD.js";
+
+// src/entry-preview-docs.ts
+var entry_preview_docs_exports = {};
+__export(entry_preview_docs_exports, {
+  applyDecorators: () => applyDecorators2,
+  decorators: () => decorators,
+  parameters: () => parameters
+});
+
+// src/docs/jsxDecorator.tsx
+import React, { createElement, isValidElement } from "react";
+import { logger } from "storybook/internal/client-logger";
+import { SourceType, getDocgenSection } from "storybook/internal/docs-tools";
+import { emitTransformCode, useEffect, useRef } from "storybook/preview-api";
+var reactElementToJSXString = reactElementToJsxString;
+var toPascalCase = /* @__PURE__ */ __name((str) => str.charAt(0).toUpperCase() + str.slice(1), "toPascalCase");
+var getReactSymbolName = /* @__PURE__ */ __name((elementType) => {
+  const elementName = elementType.$$typeof || elementType;
+  const symbolDescription = elementName.toString().replace(/^Symbol\((.*)\)$/, "$1");
+  const reactComponentName = symbolDescription.split(".").map((segment) => {
+    return segment.split("_").map(toPascalCase).join("");
+  }).join(".");
+  return reactComponentName;
+}, "getReactSymbolName");
+function simplifyNodeForStringify(node) {
+  if (isValidElement(node)) {
+    const props = Object.keys(node.props).reduce((acc, cur) => {
+      acc[cur] = simplifyNodeForStringify(node.props[cur]);
+      return acc;
+    }, {});
+    return {
+      ...node,
+      props,
+      // @ts-expect-error (this is an internal or removed api)
+      _owner: null
+    };
+  }
+  if (Array.isArray(node)) {
+    return node.map(simplifyNodeForStringify);
+  }
+  return node;
+}
+__name(simplifyNodeForStringify, "simplifyNodeForStringify");
+var renderJsx = /* @__PURE__ */ __name((code, options) => {
+  if (typeof code === "undefined") {
+    logger.warn("Too many skip or undefined component");
+    return null;
+  }
+  let renderedJSX = code;
+  const Type = renderedJSX.type;
+  for (let i = 0; i < options?.skip; i += 1) {
+    if (typeof renderedJSX === "undefined") {
+      logger.warn("Cannot skip undefined element");
+      return null;
+    }
+    if (React.Children.count(renderedJSX) > 1) {
+      logger.warn("Trying to skip an array of elements");
+      return null;
+    }
+    if (typeof renderedJSX.props.children === "undefined") {
+      logger.warn("Not enough children to skip elements.");
+      if (typeof renderedJSX.type === "function" && renderedJSX.type.name === "") {
+        renderedJSX = React.createElement(Type, { ...renderedJSX.props });
+      }
+    } else if (typeof renderedJSX.props.children === "function") {
+      renderedJSX = renderedJSX.props.children();
+    } else {
+      renderedJSX = renderedJSX.props.children;
+    }
+  }
+  let displayNameDefaults;
+  if (typeof options?.displayName === "string") {
+    displayNameDefaults = { showFunctions: true, displayName: /* @__PURE__ */ __name(() => options.displayName, "displayName") };
+  } else {
+    displayNameDefaults = {
+      // To get exotic component names resolving properly
+      displayName: /* @__PURE__ */ __name((el) => {
+        if (el.type.displayName) {
+          return el.type.displayName;
+        } else if (getDocgenSection(el.type, "displayName")) {
+          return getDocgenSection(el.type, "displayName");
+        } else if (el.type.render?.displayName) {
+          return el.type.render.displayName;
+        } else if (typeof el.type === "symbol" || el.type.$$typeof && typeof el.type.$$typeof === "symbol") {
+          return getReactSymbolName(el.type);
+        } else if (el.type.name && el.type.name !== "_default") {
+          return el.type.name;
+        } else if (typeof el.type === "function") {
+          return "No Display Name";
+        } else if (isForwardRef(el.type)) {
+          return el.type.render.name;
+        } else if (isMemo(el.type)) {
+          return el.type.type.name;
+        } else {
+          return el.type;
+        }
+      }, "displayName")
+    };
+  }
+  const filterDefaults = {
+    filterProps: /* @__PURE__ */ __name((value, key) => value !== void 0, "filterProps")
+  };
+  const opts = {
+    ...displayNameDefaults,
+    ...filterDefaults,
+    ...options
+  };
+  const result = React.Children.map(code, (c) => {
+    const child = typeof c === "number" ? c.toString() : c;
+    const toJSXString = typeof reactElementToJSXString === "function" ? reactElementToJSXString : (
+      // @ts-expect-error (Converted from ts-ignore)
+      reactElementToJSXString.default
+    );
+    let string = toJSXString(simplifyNodeForStringify(child), opts);
+    if (string.indexOf("&quot;") > -1) {
+      const matches = string.match(/\S+=\\"([^"]*)\\"/g);
+      if (matches) {
+        matches.forEach((match) => {
+          string = string.replace(match, match.replace(/&quot;/g, "'"));
+        });
+      }
+    }
+    return string;
+  }).join("\n");
+  return result.replace(/function\s+noRefCheck\(\)\s*\{\}/g, "() => {}");
+}, "renderJsx");
+var defaultOpts = {
+  skip: 0,
+  showFunctions: false,
+  enableBeautify: true,
+  showDefaultProps: false
+};
+var skipJsxRender = /* @__PURE__ */ __name((context) => {
+  const sourceParams = context?.parameters.docs?.source;
+  const isArgsStory = context?.parameters.__isArgsStory;
+  if (sourceParams?.type === SourceType.DYNAMIC) {
+    return false;
+  }
+  return !isArgsStory || sourceParams?.code || sourceParams?.type === SourceType.CODE;
+}, "skipJsxRender");
+var isMdx = /* @__PURE__ */ __name((node) => node.type?.displayName === "MDXCreateElement" && !!node.props?.mdxType, "isMdx");
+var mdxToJsx = /* @__PURE__ */ __name((node) => {
+  if (!isMdx(node)) {
+    return node;
+  }
+  const { mdxType, originalType, children, ...rest } = node.props;
+  let jsxChildren = [];
+  if (children) {
+    const array = Array.isArray(children) ? children : [children];
+    jsxChildren = array.map(mdxToJsx);
+  }
+  return createElement(originalType, rest, ...jsxChildren);
+}, "mdxToJsx");
+var jsxDecorator = /* @__PURE__ */ __name((storyFn, context) => {
+  const jsx = useRef(void 0);
+  const story = storyFn();
+  const skip = skipJsxRender(context);
+  const options = {
+    ...defaultOpts,
+    ...context?.parameters.jsx || {}
+  };
+  const storyJsx = context.originalStoryFn(context.args, context);
+  useEffect(() => {
+    if (skip) {
+      return;
+    }
+    const sourceJsx = mdxToJsx(storyJsx);
+    const rendered = renderJsx(sourceJsx, options);
+    if (rendered && jsx.current !== rendered) {
+      emitTransformCode(rendered, context);
+      jsx.current = rendered;
+    }
+  });
+  return story;
+}, "jsxDecorator");
+
+// src/docs/applyDecorators.ts
+var applyDecorators2 = /* @__PURE__ */ __name((storyFn, decorators2) => {
+  const jsxIndex = decorators2.findIndex((d) => d.originalFn === jsxDecorator);
+  const reorderedDecorators = jsxIndex === -1 ? decorators2 : [...decorators2.splice(jsxIndex, 1), ...decorators2];
+  return applyDecorators(storyFn, reorderedDecorators);
+}, "applyDecorators");
+
+// src/entry-preview-docs.ts
+var decorators = [jsxDecorator];
+var parameters = {
+  docs: {
+    story: { inline: true }
+  }
+};
+
+export {
+  applyDecorators2 as applyDecorators,
+  decorators,
+  parameters,
+  entry_preview_docs_exports
+};

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

@@ -0,0 +1,43 @@
+import {
+  entry_preview_exports
+} from "./chunk-XNNKYNNU.js";
+import {
+  entry_preview_argtypes_exports
+} from "./chunk-V6XFC4HM.js";
+import {
+  entry_preview_docs_exports
+} from "./chunk-HBQ5Y6GW.js";
+import {
+  __name
+} from "./chunk-L5NVL7MD.js";
+
+// src/preview.tsx
+import { definePreview as definePreviewBase } from "storybook/internal/csf";
+function __definePreview(input) {
+  const preview = definePreviewBase({
+    ...input,
+    addons: [
+      entry_preview_exports,
+      entry_preview_argtypes_exports,
+      entry_preview_docs_exports,
+      ...input.addons ?? []
+    ]
+  });
+  const defineMeta = preview.meta.bind(preview);
+  preview.meta = (_input) => {
+    const meta = defineMeta(_input);
+    const defineStory = meta.story.bind(meta);
+    meta.story = (__input) => {
+      const story = defineStory(__input);
+      story.Component = story.__compose();
+      return story;
+    };
+    return meta;
+  };
+  return preview;
+}
+__name(__definePreview, "__definePreview");
+
+export {
+  __definePreview
+};

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

@@ -0,0 +1,37 @@
+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() {
+  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") {
+    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
+));
+
+export {
+  __name,
+  __commonJS,
+  __export,
+  __toESM
+};