storybook 9.0.0-alpha.1 → 9.0.0-alpha.10

package/dist/actions/index.cjs

@@ -0,0 +1,127 @@
+"use strict";
+var a = Object.defineProperty;
+var x = Object.getOwnPropertyDescriptor;
+var R = Object.getOwnPropertyNames;
+var j = Object.prototype.hasOwnProperty;
+var i = (t, o) => a(t, "name", { value: o, configurable: !0 });
+var I = (t, o) => {
+  for (var n in o)
+    a(t, n, { get: o[n], enumerable: !0 });
+}, P = (t, o, n, e) => {
+  if (o && typeof o == "object" || typeof o == "function")
+    for (let r of R(o))
+      !j.call(t, r) && r !== n && a(t, r, { get: () => o[r], enumerable: !(e = x(o, r)) || e.enumerable });
+  return t;
+};
+var S = (t) => P(a({}, "__esModule", { value: !0 }), t);
+
+// src/actions/index.ts
+var K = {};
+I(K, {
+  ADDON_ID: () => l,
+  CLEAR_ID: () => F,
+  CYCLIC_KEY: () => C,
+  EVENT_ID: () => f,
+  PANEL_ID: () => k,
+  PARAM_KEY: () => T,
+  action: () => y,
+  actions: () => B,
+  config: () => s,
+  configureActions: () => V
+});
+module.exports = S(K);
+
+// src/actions/constants.ts
+var T = "actions", l = "storybook/actions", k = `${l}/panel`, f = `${l}/action-event`, F = `${l}/action-clear`, C = "$___storybook.isCyclic";
+
+// src/actions/runtime/action.ts
+var A = require("storybook/internal/preview-errors"), m = require("@storybook/global"), O = require("storybook/preview-api"), h = require("uuid");
+
+// src/actions/runtime/configureActions.ts
+var s = {
+  depth: 10,
+  clearOnStoryChange: !0,
+  limit: 50
+}, V = /* @__PURE__ */ i((t = {}) => {
+  Object.assign(s, t);
+}, "configureActions");
+
+// src/actions/runtime/action.ts
+var b = /* @__PURE__ */ i((t, o) => {
+  let n = Object.getPrototypeOf(t);
+  return !n || o(n) ? n : b(n, o);
+}, "findProto"), W = /* @__PURE__ */ i((t) => !!(typeof t == "object" && t && b(t, (o) => /^Synthetic(?:Base)?Event$/.test(o.constructor.name)) &&
+typeof t.persist == "function"), "isReactSyntheticEvent"), Y = /* @__PURE__ */ i((t) => {
+  if (W(t)) {
+    let o = Object.create(
+      t.constructor.prototype,
+      Object.getOwnPropertyDescriptors(t)
+    );
+    o.persist();
+    let n = Object.getOwnPropertyDescriptor(o, "view"), e = n?.value;
+    return typeof e == "object" && e?.constructor.name === "Window" && Object.defineProperty(o, "view", {
+      ...n,
+      value: Object.create(e.constructor.prototype)
+    }), o;
+  }
+  return t;
+}, "serializeArg"), $ = /* @__PURE__ */ i(() => typeof crypto == "object" && typeof crypto.getRandomValues == "function" ? (0, h.v4)() : (
+  // pseudo random id, example response lo1e7zm4832bkr7yfl7
+  Date.now().toString(36) + Math.random().toString(36).substring(2)
+), "generateId");
+function y(t, o = {}) {
+  let n = {
+    ...s,
+    ...o
+  }, e = /* @__PURE__ */ i(function(...c) {
+    if (o.implicit) {
+      let d = ("__STORYBOOK_PREVIEW__" in m.global ? (
+        // eslint-disable-next-line no-underscore-dangle
+        m.global.__STORYBOOK_PREVIEW__
+      ) : void 0)?.storyRenders.find(
+        (p) => p.phase === "playing" || p.phase === "rendering"
+      );
+      if (d) {
+        let p = !globalThis?.FEATURES?.disallowImplicitActionsInRenderV8, g = new A.ImplicitActionsDuringRendering({
+          phase: d.phase,
+          name: t,
+          deprecated: p
+        });
+        if (p)
+          console.warn(g);
+        else
+          throw g;
+      }
+    }
+    let w = O.addons.getChannel(), E = $(), v = 5, u = c.map(Y), _ = c.length > 1 ? u : u[0], D = {
+      id: E,
+      count: 0,
+      data: { name: t, args: _ },
+      options: {
+        ...n,
+        maxDepth: v + (n.depth || 3),
+        allowFunction: n.allowFunction || !1
+      }
+    };
+    w.emit(f, D);
+  }, "actionHandler");
+  return e.isAction = !0, e.implicit = o.implicit, e;
+}
+i(y, "action");
+
+// src/actions/runtime/actions.ts
+var B = /* @__PURE__ */ i((...t) => {
+  let o = s, n = t;
+  n.length === 1 && Array.isArray(n[0]) && ([n] = n), n.length !== 1 && typeof n[n.length - 1] != "string" && (o = {
+    ...s,
+    ...n.pop()
+  });
+  let e = n[0];
+  (n.length !== 1 || typeof e == "string") && (e = {}, n.forEach((c) => {
+    e[c] = c;
+  }));
+  let r = {};
+  return Object.keys(e).forEach((c) => {
+    r[c] = y(e[c], o);
+  }), r;
+}, "actions");

package/dist/actions/index.d.ts

@@ -0,0 +1,105 @@
+declare const PARAM_KEY = "actions";
+declare const ADDON_ID = "storybook/actions";
+declare const PANEL_ID = "storybook/actions/panel";
+declare const EVENT_ID = "storybook/actions/action-event";
+declare const CLEAR_ID = "storybook/actions/action-clear";
+declare const CYCLIC_KEY = "$___storybook.isCyclic";
+
+interface Options$1 {
+    allowRegExp: boolean;
+    allowFunction: boolean;
+    allowSymbol: boolean;
+    allowDate: boolean;
+    allowUndefined: boolean;
+    allowClass: boolean;
+    allowError: boolean;
+    maxDepth: number;
+    space: number | undefined;
+    lazyEval: boolean;
+}
+
+interface Options {
+    depth: number;
+    clearOnStoryChange: boolean;
+    limit: number;
+    implicit: boolean;
+    id: string;
+}
+type ActionOptions = Partial<Options> & Partial<Options$1>;
+
+interface ActionDisplay {
+    id: string;
+    data: {
+        name: string;
+        args: any[];
+    };
+    count: number;
+    options: ActionOptions;
+}
+
+type HandlerFunction = (...args: any[]) => void;
+
+type ActionsMap<T extends string = string> = Record<T, HandlerFunction>;
+
+interface ActionsFunction {
+    <T extends string>(handlerMap: Record<T, string>, options?: ActionOptions): ActionsMap<T>;
+    <T extends string>(...handlers: T[]): ActionsMap<T>;
+    <T extends string>(handler1: T, options?: ActionOptions): ActionsMap<T>;
+    <T extends string>(handler1: T, handler2: T, options?: ActionOptions): ActionsMap<T>;
+    <T extends string>(handler1: T, handler2: T, handler3: T, options?: ActionOptions): ActionsMap<T>;
+    <T extends string>(handler1: T, handler2: T, handler3: T, handler4: T, options?: ActionOptions): ActionsMap<T>;
+    <T extends string>(handler1: T, handler2: T, handler3: T, handler4: T, handler5: T, options?: ActionOptions): ActionsMap<T>;
+    <T extends string>(handler1: T, handler2: T, handler3: T, handler4: T, handler5: T, handler6: T, options?: ActionOptions): ActionsMap<T>;
+    <T extends string>(handler1: T, handler2: T, handler3: T, handler4: T, handler5: T, handler6: T, handler7: T, options?: ActionOptions): ActionsMap<T>;
+    <T extends string>(handler1: T, handler2: T, handler3: T, handler4: T, handler5: T, handler6: T, handler7: T, handler8: T, options?: ActionOptions): ActionsMap<T>;
+    <T extends string>(handler1: T, handler2: T, handler3: T, handler4: T, handler5: T, handler6: T, handler7: T, handler8: T, handler9: T, options?: ActionOptions): ActionsMap<T>;
+    <T extends string>(handler1: T, handler2: T, handler3: T, handler4: T, handler5: T, handler6: T, handler7: T, handler8: T, handler9: T, handler10: T, options?: ActionOptions): ActionsMap<T>;
+}
+
+type DecoratorFunction = (args: any[]) => any[];
+
+declare function action(name: string, options?: ActionOptions): HandlerFunction;
+
+declare const actions: ActionsFunction;
+
+declare const config: ActionOptions;
+declare const configureActions: (options?: ActionOptions) => void;
+
+interface ActionsParameters {
+    /**
+     * Actions configuration
+     *
+     * @see https://storybook.js.org/docs/essentials/actions#parameters
+     */
+    actions: {
+        /**
+         * Create actions for each arg that matches the regex. (**NOT recommended, see below**)
+         *
+         * This is quite useful when your component has dozens (or hundreds) of methods and you do not
+         * want to manually apply the fn utility for each of those methods. However, this is not the
+         * recommended way of writing actions. That's because automatically inferred args are not
+         * available as spies in your play function. If you use argTypesRegex and your stories have play
+         * functions, you will need to also define args with the fn utility to test them in your play
+         * function.
+         *
+         * @example `argTypesRegex: '^on.*'`
+         */
+        argTypesRegex?: string;
+        /** Remove the addon panel and disable the addon's behavior */
+        disable?: boolean;
+        /**
+         * Binds a standard HTML event handler to the outermost HTML element rendered by your component
+         * and triggers an action when the event is called for a given selector. The format is
+         * `<eventname> <selector>`. The selector is optional; it defaults to all elements.
+         *
+         * **To enable this feature, you must use the `withActions` decorator.**
+         *
+         * @example `handles: ['mouseover', 'click .btn']`
+         *
+         * @see https://storybook.js.org/docs/essentials/actions#action-event-handlers
+         */
+        handles?: string[];
+    };
+}
+
+export { ADDON_ID, type ActionDisplay, type ActionOptions, type ActionsFunction, type ActionsMap, type ActionsParameters, CLEAR_ID, CYCLIC_KEY, type DecoratorFunction, EVENT_ID, type HandlerFunction, PANEL_ID, PARAM_KEY, action, actions, config, configureActions };

package/dist/actions/index.js

@@ -0,0 +1,112 @@
+var E = Object.defineProperty;
+var i = (o, n) => E(o, "name", { value: n, configurable: !0 });
+
+// src/actions/constants.ts
+var S = "actions", a = "storybook/actions", T = `${a}/panel`, y = `${a}/action-event`, k = `${a}/action-clear`, F = "$___storybook.isCyclic";
+
+// src/actions/runtime/action.ts
+import { ImplicitActionsDuringRendering as v } from "storybook/internal/preview-errors";
+import { global as u } from "@storybook/global";
+import { addons as _ } from "storybook/preview-api";
+import { v4 as D } from "uuid";
+
+// src/actions/runtime/configureActions.ts
+var c = {
+  depth: 10,
+  clearOnStoryChange: !0,
+  limit: 50
+}, V = /* @__PURE__ */ i((o = {}) => {
+  Object.assign(c, o);
+}, "configureActions");
+
+// src/actions/runtime/action.ts
+var d = /* @__PURE__ */ i((o, n) => {
+  let t = Object.getPrototypeOf(o);
+  return !t || n(t) ? t : d(t, n);
+}, "findProto"), x = /* @__PURE__ */ i((o) => !!(typeof o == "object" && o && d(o, (n) => /^Synthetic(?:Base)?Event$/.test(n.constructor.name)) &&
+typeof o.persist == "function"), "isReactSyntheticEvent"), R = /* @__PURE__ */ i((o) => {
+  if (x(o)) {
+    let n = Object.create(
+      o.constructor.prototype,
+      Object.getOwnPropertyDescriptors(o)
+    );
+    n.persist();
+    let t = Object.getOwnPropertyDescriptor(n, "view"), e = t?.value;
+    return typeof e == "object" && e?.constructor.name === "Window" && Object.defineProperty(n, "view", {
+      ...t,
+      value: Object.create(e.constructor.prototype)
+    }), n;
+  }
+  return o;
+}, "serializeArg"), j = /* @__PURE__ */ i(() => typeof crypto == "object" && typeof crypto.getRandomValues == "function" ? D() : (
+  // pseudo random id, example response lo1e7zm4832bkr7yfl7
+  Date.now().toString(36) + Math.random().toString(36).substring(2)
+), "generateId");
+function g(o, n = {}) {
+  let t = {
+    ...c,
+    ...n
+  }, e = /* @__PURE__ */ i(function(...r) {
+    if (n.implicit) {
+      let f = ("__STORYBOOK_PREVIEW__" in u ? (
+        // eslint-disable-next-line no-underscore-dangle
+        u.__STORYBOOK_PREVIEW__
+      ) : void 0)?.storyRenders.find(
+        (s) => s.phase === "playing" || s.phase === "rendering"
+      );
+      if (f) {
+        let s = !globalThis?.FEATURES?.disallowImplicitActionsInRenderV8, m = new v({
+          phase: f.phase,
+          name: o,
+          deprecated: s
+        });
+        if (s)
+          console.warn(m);
+        else
+          throw m;
+      }
+    }
+    let A = _.getChannel(), O = j(), h = 5, l = r.map(R), b = r.length > 1 ? l : l[0], w = {
+      id: O,
+      count: 0,
+      data: { name: o, args: b },
+      options: {
+        ...t,
+        maxDepth: h + (t.depth || 3),
+        allowFunction: t.allowFunction || !1
+      }
+    };
+    A.emit(y, w);
+  }, "actionHandler");
+  return e.isAction = !0, e.implicit = n.implicit, e;
+}
+i(g, "action");
+
+// src/actions/runtime/actions.ts
+var G = /* @__PURE__ */ i((...o) => {
+  let n = c, t = o;
+  t.length === 1 && Array.isArray(t[0]) && ([t] = t), t.length !== 1 && typeof t[t.length - 1] != "string" && (n = {
+    ...c,
+    ...t.pop()
+  });
+  let e = t[0];
+  (t.length !== 1 || typeof e == "string") && (e = {}, t.forEach((r) => {
+    e[r] = r;
+  }));
+  let p = {};
+  return Object.keys(e).forEach((r) => {
+    p[r] = g(e[r], n);
+  }), p;
+}, "actions");
+export {
+  a as ADDON_ID,
+  k as CLEAR_ID,
+  F as CYCLIC_KEY,
+  y as EVENT_ID,
+  T as PANEL_ID,
+  S as PARAM_KEY,
+  g as action,
+  G as actions,
+  c as config,
+  V as configureActions
+};