storybook 9.0.0-alpha.2 → 9.0.0-alpha.4

package/dist/test/spy.cjs

@@ -0,0 +1,258 @@
+"use strict";
+var x = Object.defineProperty;
+var _ = Object.getOwnPropertyDescriptor;
+var N = Object.getOwnPropertyNames;
+var K = Object.prototype.hasOwnProperty;
+var n = (t, e) => x(t, "name", { value: e, configurable: !0 });
+var U = (t, e) => {
+  for (var r in e)
+    x(t, r, { get: e[r], enumerable: !0 });
+}, W = (t, e, r, l) => {
+  if (e && typeof e == "object" || typeof e == "function")
+    for (let o of N(e))
+      !K.call(t, o) && o !== r && x(t, o, { get: () => e[o], enumerable: !(l = _(e, o)) || l.enumerable });
+  return t;
+};
+var Y = (t) => W(x({}, "__esModule", { value: !0 }), t);
+
+// src/test/spy.ts
+var oe = {};
+U(oe, {
+  clearAllMocks: () => Z,
+  fn: () => X,
+  isMockFunction: () => E,
+  mocked: () => ne,
+  mocks: () => T,
+  onMockCall: () => J,
+  resetAllMocks: () => ee,
+  restoreAllMocks: () => te,
+  spyOn: () => Q
+});
+module.exports = Y(oe);
+
+// ../node_modules/tinyspy/dist/index.js
+function O(t, e) {
+  if (!t)
+    throw new Error(e);
+}
+n(O, "d");
+function g(t, e) {
+  return typeof e === t;
+}
+n(g, "y");
+function $(t) {
+  return t instanceof Promise;
+}
+n($, "w");
+function w(t, e, r) {
+  Object.defineProperty(t, e, r);
+}
+n(w, "f");
+function M(t, e, r) {
+  Object.defineProperty(t, e, { value: r });
+}
+n(M, "l");
+var v = Symbol.for("tinyspy:spy"), q = /* @__PURE__ */ new Set(), z = /* @__PURE__ */ n((t) => {
+  t.called = !1, t.callCount = 0, t.calls = [], t.results = [], t.resolves = [], t.next = [];
+}, "P"), B = /* @__PURE__ */ n((t) => (w(t, v, { value: { reset: /* @__PURE__ */ n(() => z(t[v]), "reset") } }), t[v]), "K"), h = /* @__PURE__ */ n(
+(t) => t[v] || B(t), "T");
+function G(t) {
+  O(
+    g("function", t) || g("undefined", t),
+    "cannot spy on a non-function value"
+  );
+  let e = /* @__PURE__ */ n(function(...l) {
+    let o = h(e);
+    o.called = !0, o.callCount++, o.calls.push(l);
+    let p = o.next.shift();
+    if (p) {
+      o.results.push(p);
+      let [i, f] = p;
+      if (i === "ok")
+        return f;
+      throw f;
+    }
+    let c, y = "ok", a = o.results.length;
+    if (o.impl)
+      try {
+        new.target ? c = Reflect.construct(o.impl, l, new.target) : c = o.impl.apply(this, l), y = "ok";
+      } catch (i) {
+        throw c = i, y = "error", o.results.push([y, i]), i;
+      }
+    let m = [y, c];
+    return $(c) && c.then(
+      (i) => o.resolves[a] = ["ok", i],
+      (i) => o.resolves[a] = ["error", i]
+    ), o.results.push(m), c;
+  }, "t");
+  M(e, "_isMockFunction", !0), M(e, "length", t ? t.length : 0), M(e, "name", t && t.name || "spy");
+  let r = h(e);
+  return r.reset(), r.impl = t, e;
+}
+n(G, "m");
+var C = /* @__PURE__ */ n((t, e) => Object.getOwnPropertyDescriptor(t, e), "k"), j = /* @__PURE__ */ n((t, e) => {
+  e != null && typeof e == "function" && e.prototype != null && Object.setPrototypeOf(t.prototype, e.prototype);
+}, "O");
+function R(t, e, r) {
+  O(
+    !g("undefined", t),
+    "spyOn could not find an object to spy upon"
+  ), O(
+    g("object", t) || g("function", t),
+    "cannot spyOn on a primitive value"
+  );
+  let [l, o] = (() => {
+    if (!g("object", e))
+      return [e, "value"];
+    if ("getter" in e && "setter" in e)
+      throw new Error("cannot spy on both getter and setter");
+    if ("getter" in e)
+      return [e.getter, "get"];
+    if ("setter" in e)
+      return [e.setter, "set"];
+    throw new Error("specify getter or setter to spy on");
+  })(), p = C(t, l), c = Object.getPrototypeOf(t), y = c && C(c, l), a = p || y;
+  O(
+    a || l in t,
+    `${String(l)} does not exist`
+  );
+  let m = !1;
+  o === "value" && a && !a.value && a.get && (o = "get", m = !0, r = a.get());
+  let i;
+  a ? i = a[o] : o !== "value" ? i = /* @__PURE__ */ n(() => t[l], "o") : i = t[l];
+  let f = /* @__PURE__ */ n((k) => {
+    let { value: b, ...d } = a || {
+      configurable: !0,
+      writable: !0
+    };
+    o !== "value" && delete d.writable, d[o] = k, w(t, l, d);
+  }, "g"), I = /* @__PURE__ */ n(() => a ? w(t, l, a) : f(i), "b");
+  r || (r = i);
+  let s = G(r);
+  o === "value" && j(s, i);
+  let u = s[v];
+  return M(u, "restore", I), M(u, "getOriginal", () => m ? i() : i), M(u, "willCall", (k) => (u.impl = k, s)), f(
+    m ? () => (j(s, r), s) : s
+  ), q.add(s), s;
+}
+n(R, "C");
+
+// ../node_modules/@vitest/spy/dist/index.js
+var T = /* @__PURE__ */ new Set();
+function E(t) {
+  return typeof t == "function" && "_isMockFunction" in t && t._isMockFunction;
+}
+n(E, "isMockFunction");
+function V(t, e, r) {
+  let o = r ? { [{
+    get: "getter",
+    set: "setter"
+  }[r]]: e } : e, p = R(t, o);
+  return D(p);
+}
+n(V, "spyOn");
+var H = 0;
+function D(t) {
+  let e = t, r, l = [], o = [], p = [], c = h(t), y = {
+    get calls() {
+      return c.calls;
+    },
+    get contexts() {
+      return o;
+    },
+    get instances() {
+      return l;
+    },
+    get invocationCallOrder() {
+      return p;
+    },
+    get results() {
+      return c.results.map(([s, u]) => ({ type: s === "error" ? "throw" : "return", value: u }));
+    },
+    get settledResults() {
+      return c.resolves.map(([s, u]) => ({ type: s === "error" ? "rejected" : "fulfilled", value: u }));
+    },
+    get lastCall() {
+      return c.calls[c.calls.length - 1];
+    }
+  }, a = [], m = !1;
+  function i(...s) {
+    return l.push(this), o.push(this), p.push(++H), (m ? r : a.shift() || r || c.getOriginal() || (() => {
+    })).apply(this, s);
+  }
+  n(i, "mockCall");
+  let f = e.name;
+  e.getMockName = () => f || "vi.fn()", e.mockName = (s) => (f = s, e), e.mockClear = () => (c.reset(), l = [], o = [], p = [], e), e.mockReset =
+  () => (e.mockClear(), r = /* @__PURE__ */ n(() => {
+  }, "implementation"), a = [], e), e.mockRestore = () => (e.mockReset(), c.restore(), r = void 0, e), e.getMockImplementation = () => r, e.
+  mockImplementation = (s) => (r = s, c.willCall(i), e), e.mockImplementationOnce = (s) => (a.push(s), e);
+  function I(s, u) {
+    let k = r;
+    r = s, c.willCall(i), m = !0;
+    let b = /* @__PURE__ */ n(() => {
+      r = k, m = !1;
+    }, "reset"), d = u();
+    return d instanceof Promise ? d.then(() => (b(), e)) : (b(), e);
+  }
+  return n(I, "withImplementation"), e.withImplementation = I, e.mockReturnThis = () => e.mockImplementation(function() {
+    return this;
+  }), e.mockReturnValue = (s) => e.mockImplementation(() => s), e.mockReturnValueOnce = (s) => e.mockImplementationOnce(() => s), e.mockResolvedValue =
+  (s) => e.mockImplementation(() => Promise.resolve(s)), e.mockResolvedValueOnce = (s) => e.mockImplementationOnce(() => Promise.resolve(s)),
+  e.mockRejectedValue = (s) => e.mockImplementation(() => Promise.reject(s)), e.mockRejectedValueOnce = (s) => e.mockImplementationOnce(() => Promise.
+  reject(s)), Object.defineProperty(e, "mock", {
+    get: /* @__PURE__ */ n(() => y, "get")
+  }), c.willCall(i), T.add(e), e;
+}
+n(D, "enhanceSpy");
+function P(t) {
+  let e = D(R({
+    spy: t || function() {
+    }
+  }, "spy"));
+  return t && e.mockImplementation(t), e;
+}
+n(P, "fn");
+
+// src/test/spy.ts
+var S = /* @__PURE__ */ new Set();
+function J(t) {
+  return S.add(t), () => void S.delete(t);
+}
+n(J, "onMockCall");
+var Q = /* @__PURE__ */ n((...t) => {
+  let e = V(...t);
+  return L(e);
+}, "spyOn");
+function X(t) {
+  let e = t ? P(t) : P();
+  return L(e);
+}
+n(X, "fn");
+function L(t) {
+  let e = F(t), r = e.mockImplementation.bind(null);
+  return e.mockImplementation = (l) => F(r(l)), e;
+}
+n(L, "reactiveMock");
+function F(t) {
+  let e = h(t), r = e.impl;
+  return e.willCall(function(...l) {
+    return S.forEach((o) => o(t, l)), r?.apply(this, l);
+  }), t;
+}
+n(F, "listenWhenCalled");
+function Z() {
+  T.forEach((t) => t.mockClear());
+}
+n(Z, "clearAllMocks");
+function ee() {
+  T.forEach((t) => t.mockReset());
+}
+n(ee, "resetAllMocks");
+function te() {
+  T.forEach((t) => t.mockRestore());
+}
+n(te, "restoreAllMocks");
+function ne(t, e = {}) {
+  return t;
+}
+n(ne, "mocked");

package/dist/test/spy.d.ts

@@ -0,0 +1,66 @@
+import { MockInstance, spyOn as spyOn$1, Mock as Mock$1, MaybeMocked, MaybeMockedDeep, MaybePartiallyMocked, MaybePartiallyMockedDeep } from '@vitest/spy';
+export * from '@vitest/spy';
+export { isMockFunction, mocks } from '@vitest/spy';
+
+type Listener = (mock: MockInstance, args: unknown[]) => void;
+declare function onMockCall(callback: Listener): () => void;
+declare const spyOn: typeof spyOn$1;
+type Procedure = (...args: any[]) => any;
+type Mock<T extends Procedure | any[] = any[], R = any> = T extends Procedure ? Mock$1<T> : T extends any[] ? Mock$1<(...args: T) => R> : never;
+declare function fn<T extends Procedure = Procedure>(implementation?: T): Mock<T>;
+declare function fn<TArgs extends any[] = any, R = any>(): Mock<(...args: TArgs) => R>;
+declare function fn<TArgs extends any[] = any[], R = any>(implementation: (...args: TArgs) => R): Mock<(...args: TArgs) => R>;
+declare function fn<TArgs extends any[] = any[], R = any>(implementation?: (...args: TArgs) => R): Mock<(...args: TArgs) => R>;
+/**
+ * Calls [`.mockClear()`](https://vitest.dev/api/mock#mockclear) on every mocked function. This will
+ * only empty `.mock` state, it will not reset implementation.
+ *
+ * It is useful if you need to clean up mock between different assertions.
+ */
+declare function clearAllMocks(): void;
+/**
+ * Calls [`.mockReset()`](https://vitest.dev/api/mock#mockreset) on every mocked function. This will
+ * empty `.mock` state, reset "once" implementations and force the base implementation to return
+ * `undefined` when invoked.
+ *
+ * This is useful when you want to completely reset a mock to the default state.
+ */
+declare function resetAllMocks(): void;
+/**
+ * Calls [`.mockRestore()`](https://vitest.dev/api/mock#mockrestore) on every mocked function. This
+ * will restore all original implementations.
+ */
+declare function restoreAllMocks(): void;
+/**
+ * Type helper for TypeScript. Just returns the object that was passed.
+ *
+ * When `partial` is `true` it will expect a `Partial<T>` as a return value. By default, this will
+ * only make TypeScript believe that the first level values are mocked. You can pass down `{ deep:
+ * true }` as a second argument to tell TypeScript that the whole object is mocked, if it actually
+ * is.
+ *
+ * @param item Anything that can be mocked
+ * @param deep If the object is deeply mocked
+ * @param options If the object is partially or deeply mocked
+ */
+declare function mocked<T>(item: T, deep?: false): MaybeMocked<T>;
+declare function mocked<T>(item: T, deep: true): MaybeMockedDeep<T>;
+declare function mocked<T>(item: T, options: {
+    partial?: false;
+    deep?: false;
+}): MaybeMocked<T>;
+declare function mocked<T>(item: T, options: {
+    partial?: false;
+    deep: true;
+}): MaybeMockedDeep<T>;
+declare function mocked<T>(item: T, options: {
+    partial: true;
+    deep?: false;
+}): MaybePartiallyMocked<T>;
+declare function mocked<T>(item: T, options: {
+    partial: true;
+    deep: true;
+}): MaybePartiallyMockedDeep<T>;
+declare function mocked<T>(item: T): MaybeMocked<T>;
+
+export { type Mock, clearAllMocks, fn, mocked, onMockCall, resetAllMocks, restoreAllMocks, spyOn };

package/dist/test/spy.js

@@ -0,0 +1,240 @@
+var F = Object.defineProperty;
+var n = (t, e) => F(t, "name", { value: e, configurable: !0 });
+
+// ../node_modules/tinyspy/dist/index.js
+function x(t, e) {
+  if (!t)
+    throw new Error(e);
+}
+n(x, "d");
+function g(t, e) {
+  return typeof e === t;
+}
+n(g, "y");
+function L(t) {
+  return t instanceof Promise;
+}
+n(L, "w");
+function b(t, e, r) {
+  Object.defineProperty(t, e, r);
+}
+n(b, "f");
+function M(t, e, r) {
+  Object.defineProperty(t, e, { value: r });
+}
+n(M, "l");
+var T = Symbol.for("tinyspy:spy"), _ = /* @__PURE__ */ new Set(), N = /* @__PURE__ */ n((t) => {
+  t.called = !1, t.callCount = 0, t.calls = [], t.results = [], t.resolves = [], t.next = [];
+}, "P"), K = /* @__PURE__ */ n((t) => (b(t, T, { value: { reset: /* @__PURE__ */ n(() => N(t[T]), "reset") } }), t[T]), "K"), h = /* @__PURE__ */ n(
+(t) => t[T] || K(t), "T");
+function U(t) {
+  x(
+    g("function", t) || g("undefined", t),
+    "cannot spy on a non-function value"
+  );
+  let e = /* @__PURE__ */ n(function(...l) {
+    let s = h(e);
+    s.called = !0, s.callCount++, s.calls.push(l);
+    let p = s.next.shift();
+    if (p) {
+      s.results.push(p);
+      let [i, f] = p;
+      if (i === "ok")
+        return f;
+      throw f;
+    }
+    let c, y = "ok", a = s.results.length;
+    if (s.impl)
+      try {
+        new.target ? c = Reflect.construct(s.impl, l, new.target) : c = s.impl.apply(this, l), y = "ok";
+      } catch (i) {
+        throw c = i, y = "error", s.results.push([y, i]), i;
+      }
+    let m = [y, c];
+    return L(c) && c.then(
+      (i) => s.resolves[a] = ["ok", i],
+      (i) => s.resolves[a] = ["error", i]
+    ), s.results.push(m), c;
+  }, "t");
+  M(e, "_isMockFunction", !0), M(e, "length", t ? t.length : 0), M(e, "name", t && t.name || "spy");
+  let r = h(e);
+  return r.reset(), r.impl = t, e;
+}
+n(U, "m");
+var S = /* @__PURE__ */ n((t, e) => Object.getOwnPropertyDescriptor(t, e), "k"), C = /* @__PURE__ */ n((t, e) => {
+  e != null && typeof e == "function" && e.prototype != null && Object.setPrototypeOf(t.prototype, e.prototype);
+}, "O");
+function w(t, e, r) {
+  x(
+    !g("undefined", t),
+    "spyOn could not find an object to spy upon"
+  ), x(
+    g("object", t) || g("function", t),
+    "cannot spyOn on a primitive value"
+  );
+  let [l, s] = (() => {
+    if (!g("object", e))
+      return [e, "value"];
+    if ("getter" in e && "setter" in e)
+      throw new Error("cannot spy on both getter and setter");
+    if ("getter" in e)
+      return [e.getter, "get"];
+    if ("setter" in e)
+      return [e.setter, "set"];
+    throw new Error("specify getter or setter to spy on");
+  })(), p = S(t, l), c = Object.getPrototypeOf(t), y = c && S(c, l), a = p || y;
+  x(
+    a || l in t,
+    `${String(l)} does not exist`
+  );
+  let m = !1;
+  s === "value" && a && !a.value && a.get && (s = "get", m = !0, r = a.get());
+  let i;
+  a ? i = a[s] : s !== "value" ? i = /* @__PURE__ */ n(() => t[l], "o") : i = t[l];
+  let f = /* @__PURE__ */ n((k) => {
+    let { value: I, ...d } = a || {
+      configurable: !0,
+      writable: !0
+    };
+    s !== "value" && delete d.writable, d[s] = k, b(t, l, d);
+  }, "g"), O = /* @__PURE__ */ n(() => a ? b(t, l, a) : f(i), "b");
+  r || (r = i);
+  let o = U(r);
+  s === "value" && C(o, i);
+  let u = o[T];
+  return M(u, "restore", O), M(u, "getOriginal", () => m ? i() : i), M(u, "willCall", (k) => (u.impl = k, o)), f(
+    m ? () => (C(o, r), o) : o
+  ), _.add(o), o;
+}
+n(w, "C");
+
+// ../node_modules/@vitest/spy/dist/index.js
+var v = /* @__PURE__ */ new Set();
+function W(t) {
+  return typeof t == "function" && "_isMockFunction" in t && t._isMockFunction;
+}
+n(W, "isMockFunction");
+function A(t, e, r) {
+  let s = r ? { [{
+    get: "getter",
+    set: "setter"
+  }[r]]: e } : e, p = w(t, s);
+  return E(p);
+}
+n(A, "spyOn");
+var Y = 0;
+function E(t) {
+  let e = t, r, l = [], s = [], p = [], c = h(t), y = {
+    get calls() {
+      return c.calls;
+    },
+    get contexts() {
+      return s;
+    },
+    get instances() {
+      return l;
+    },
+    get invocationCallOrder() {
+      return p;
+    },
+    get results() {
+      return c.results.map(([o, u]) => ({ type: o === "error" ? "throw" : "return", value: u }));
+    },
+    get settledResults() {
+      return c.resolves.map(([o, u]) => ({ type: o === "error" ? "rejected" : "fulfilled", value: u }));
+    },
+    get lastCall() {
+      return c.calls[c.calls.length - 1];
+    }
+  }, a = [], m = !1;
+  function i(...o) {
+    return l.push(this), s.push(this), p.push(++Y), (m ? r : a.shift() || r || c.getOriginal() || (() => {
+    })).apply(this, o);
+  }
+  n(i, "mockCall");
+  let f = e.name;
+  e.getMockName = () => f || "vi.fn()", e.mockName = (o) => (f = o, e), e.mockClear = () => (c.reset(), l = [], s = [], p = [], e), e.mockReset =
+  () => (e.mockClear(), r = /* @__PURE__ */ n(() => {
+  }, "implementation"), a = [], e), e.mockRestore = () => (e.mockReset(), c.restore(), r = void 0, e), e.getMockImplementation = () => r, e.
+  mockImplementation = (o) => (r = o, c.willCall(i), e), e.mockImplementationOnce = (o) => (a.push(o), e);
+  function O(o, u) {
+    let k = r;
+    r = o, c.willCall(i), m = !0;
+    let I = /* @__PURE__ */ n(() => {
+      r = k, m = !1;
+    }, "reset"), d = u();
+    return d instanceof Promise ? d.then(() => (I(), e)) : (I(), e);
+  }
+  return n(O, "withImplementation"), e.withImplementation = O, e.mockReturnThis = () => e.mockImplementation(function() {
+    return this;
+  }), e.mockReturnValue = (o) => e.mockImplementation(() => o), e.mockReturnValueOnce = (o) => e.mockImplementationOnce(() => o), e.mockResolvedValue =
+  (o) => e.mockImplementation(() => Promise.resolve(o)), e.mockResolvedValueOnce = (o) => e.mockImplementationOnce(() => Promise.resolve(o)),
+  e.mockRejectedValue = (o) => e.mockImplementation(() => Promise.reject(o)), e.mockRejectedValueOnce = (o) => e.mockImplementationOnce(() => Promise.
+  reject(o)), Object.defineProperty(e, "mock", {
+    get: /* @__PURE__ */ n(() => y, "get")
+  }), c.willCall(i), v.add(e), e;
+}
+n(E, "enhanceSpy");
+function R(t) {
+  let e = E(w({
+    spy: t || function() {
+    }
+  }, "spy"));
+  return t && e.mockImplementation(t), e;
+}
+n(R, "fn");
+
+// src/test/spy.ts
+var P = /* @__PURE__ */ new Set();
+function H(t) {
+  return P.add(t), () => void P.delete(t);
+}
+n(H, "onMockCall");
+var J = /* @__PURE__ */ n((...t) => {
+  let e = A(...t);
+  return D(e);
+}, "spyOn");
+function Q(t) {
+  let e = t ? R(t) : R();
+  return D(e);
+}
+n(Q, "fn");
+function D(t) {
+  let e = V(t), r = e.mockImplementation.bind(null);
+  return e.mockImplementation = (l) => V(r(l)), e;
+}
+n(D, "reactiveMock");
+function V(t) {
+  let e = h(t), r = e.impl;
+  return e.willCall(function(...l) {
+    return P.forEach((s) => s(t, l)), r?.apply(this, l);
+  }), t;
+}
+n(V, "listenWhenCalled");
+function X() {
+  v.forEach((t) => t.mockClear());
+}
+n(X, "clearAllMocks");
+function Z() {
+  v.forEach((t) => t.mockReset());
+}
+n(Z, "resetAllMocks");
+function ee() {
+  v.forEach((t) => t.mockRestore());
+}
+n(ee, "restoreAllMocks");
+function te(t, e = {}) {
+  return t;
+}
+n(te, "mocked");
+export {
+  X as clearAllMocks,
+  Q as fn,
+  W as isMockFunction,
+  te as mocked,
+  v as mocks,
+  H as onMockCall,
+  Z as resetAllMocks,
+  ee as restoreAllMocks,
+  J as spyOn
+};