@blockbite/ui 1.0.5 → 2.0.0

package/dist/node_modules/@wordpress/compose/build-module/utils/debounce/index.js

@@ -0,0 +1,63 @@
+const F = (D, r, t) => {
+  let u, l, h = 0, a, f, c, d = 0, v = !1, o = !1, x = !0;
+  t && (v = !!t.leading, o = "maxWait" in t, t.maxWait !== void 0 && (h = Math.max(t.maxWait, r)), x = "trailing" in t ? !!t.trailing : x);
+  function k(n) {
+    const e = u, i = l;
+    return u = void 0, l = void 0, d = n, a = D.apply(i, e), a;
+  }
+  function s(n, e) {
+    f = setTimeout(n, e);
+  }
+  function E() {
+    f !== void 0 && clearTimeout(f);
+  }
+  function b(n) {
+    return d = n, s(m, r), v ? k(n) : a;
+  }
+  function I(n) {
+    return n - (c || 0);
+  }
+  function A(n) {
+    const e = I(n), i = n - d, C = r - e;
+    return o ? Math.min(C, h - i) : C;
+  }
+  function W(n) {
+    const e = I(n), i = n - d;
+    return c === void 0 || e >= r || e < 0 || o && i >= h;
+  }
+  function m() {
+    const n = Date.now();
+    if (W(n))
+      return S(n);
+    s(m, A(n));
+  }
+  function L() {
+    f = void 0;
+  }
+  function S(n) {
+    return L(), x && u ? k(n) : (u = l = void 0, a);
+  }
+  function M() {
+    E(), d = 0, L(), u = c = l = void 0;
+  }
+  function y() {
+    return g() ? S(Date.now()) : a;
+  }
+  function g() {
+    return f !== void 0;
+  }
+  function T(...n) {
+    const e = Date.now(), i = W(e);
+    if (u = n, l = this, c = e, i) {
+      if (!g())
+        return b(c);
+      if (o)
+        return s(m, r), k(c);
+    }
+    return g() || s(m, r), a;
+  }
+  return T.cancel = M, T.flush = y, T.pending = g, T;
+};
+export {
+  F as debounce
+};

package/dist/node_modules/@wordpress/compose/build-module/utils/observable-map/index.js

@@ -0,0 +1,29 @@
+function l() {
+  const n = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map();
+  function i(e) {
+    const s = r.get(e);
+    if (s)
+      for (const t of s)
+        t();
+  }
+  return {
+    get(e) {
+      return n.get(e);
+    },
+    set(e, s) {
+      n.set(e, s), i(e);
+    },
+    delete(e) {
+      n.delete(e), i(e);
+    },
+    subscribe(e, s) {
+      let t = r.get(e);
+      return t || (t = /* @__PURE__ */ new Set(), r.set(e, t)), t.add(s), () => {
+        t.delete(s), t.size === 0 && r.delete(e);
+      };
+    }
+  };
+}
+export {
+  l as observableMap
+};

package/dist/node_modules/@wordpress/compose/build-module/utils/throttle/index.js

@@ -0,0 +1,9 @@
+import { debounce as r } from "../debounce/index.js";
+const a = (e, t, i) => r(e, t, {
+  leading: !0,
+  trailing: !0,
+  maxWait: t
+});
+export {
+  a as throttle
+};

package/dist/node_modules/@wordpress/data/build-module/components/async-mode-provider/context.js

@@ -0,0 +1,9 @@
+import { createContext as t } from "@wordpress/element";
+const e = t(!1), {
+  Consumer: r,
+  Provider: n
+} = e;
+export {
+  e as Context,
+  n as default
+};

package/dist/node_modules/@wordpress/data/build-module/components/async-mode-provider/use-async-mode.js

@@ -0,0 +1,8 @@
+import { useContext as t } from "@wordpress/element";
+import { Context as o } from "./context.js";
+function n() {
+  return t(o);
+}
+export {
+  n as default
+};

package/dist/node_modules/@wordpress/data/build-module/components/registry-provider/context.js

@@ -0,0 +1,10 @@
+import { createContext as t } from "@wordpress/element";
+import o from "../../default-registry.js";
+const e = t(o), {
+  Consumer: n,
+  Provider: s
+} = e;
+export {
+  e as Context,
+  s as default
+};

package/dist/node_modules/@wordpress/data/build-module/components/registry-provider/use-registry.js

@@ -0,0 +1,8 @@
+import { useContext as t } from "@wordpress/element";
+import { Context as e } from "./context.js";
+function n() {
+  return t(e);
+}
+export {
+  n as default
+};

package/dist/node_modules/@wordpress/data/build-module/components/use-dispatch/use-dispatch-with-map.js

@@ -0,0 +1,15 @@
+import { useRef as u, useMemo as f } from "@wordpress/element";
+import p from "../registry-provider/use-registry.js";
+import a from "../../../../compose/build-module/hooks/use-isomorphic-layout-effect/index.js";
+const d = (s, c) => {
+  const t = p(), r = u(s);
+  return a(() => {
+    r.current = s;
+  }), f(() => {
+    const n = r.current(t.dispatch, t);
+    return Object.fromEntries(Object.entries(n).map(([e, o]) => (typeof o != "function" && console.warn(`Property ${e} returned from dispatchMap in useDispatchWithMap must be a function.`), [e, (...i) => r.current(t.dispatch, t)[e](...i)])));
+  }, [t, ...c]);
+};
+export {
+  d as default
+};

package/dist/node_modules/@wordpress/data/build-module/components/use-dispatch/use-dispatch.js

@@ -0,0 +1,10 @@
+import i from "../registry-provider/use-registry.js";
+const u = (t) => {
+  const {
+    dispatch: s
+  } = i();
+  return t === void 0 ? s : s(t);
+};
+export {
+  u as default
+};

package/dist/node_modules/@wordpress/data/build-module/components/use-select/index.js

@@ -0,0 +1,112 @@
+import { createQueue as C } from "../../../../priority-queue/build-module/index.js";
+import { useRef as V, useMemo as j, useCallback as E, useSyncExternalStore as T, useDebugValue as $ } from "@wordpress/element";
+import _ from "../../../../is-shallow-equal/build-module/index.js";
+import k from "../registry-provider/use-registry.js";
+import q from "../async-mode-provider/use-async-mode.js";
+const R = C();
+function O(e, r) {
+  if (!e || !r)
+    return;
+  const s = typeof e == "object" && typeof r == "object" ? Object.keys(e).filter((t) => e[t] !== r[t]) : [];
+  console.warn(`The \`useSelect\` hook returns different values when called with the same state and parameters.
+This can lead to unnecessary re-renders and performance issues if not fixed.
+
+Non-equal value keys: %s
+
+`, s.join(", "));
+}
+function U(e, r) {
+  const s = e.select, t = {};
+  let d, c, u = !1, S, f, m;
+  const h = /* @__PURE__ */ new Map();
+  function v(a) {
+    var o;
+    return (o = e.stores[a]?.store?.getState?.()) !== null && o !== void 0 ? o : {};
+  }
+  const x = (a) => {
+    const o = [...a], b = /* @__PURE__ */ new Set();
+    function M(i) {
+      if (u)
+        for (const l of o)
+          h.get(l) !== v(l) && (u = !1);
+      h.clear();
+      const n = () => {
+        u = !1, i();
+      }, g = () => {
+        S ? R.add(t, n) : n();
+      }, y = [];
+      function w(l) {
+        y.push(e.subscribe(g, l));
+      }
+      for (const l of o)
+        w(l);
+      return b.add(w), () => {
+        b.delete(w);
+        for (const l of y.values())
+          l?.();
+        R.cancel(t);
+      };
+    }
+    function p(i) {
+      for (const n of i)
+        if (!o.includes(n)) {
+          o.push(n);
+          for (const g of b)
+            g(n);
+        }
+    }
+    return {
+      subscribe: M,
+      updateStores: p
+    };
+  };
+  return (a, o) => {
+    function b() {
+      if (u && a === d)
+        return c;
+      const p = {
+        current: null
+      }, i = e.__unstableMarkListeningStores(() => a(s, e), p);
+      if (globalThis.SCRIPT_DEBUG && !m) {
+        const n = a(s, e);
+        _(i, n) || (O(i, n), m = !0);
+      }
+      if (f)
+        f.updateStores(p.current);
+      else {
+        for (const n of p.current)
+          h.set(n, v(n));
+        f = x(p.current);
+      }
+      _(c, i) || (c = i), d = a, u = !0;
+    }
+    function M() {
+      return b(), c;
+    }
+    return S && !o && (u = !1, R.cancel(t)), b(), S = o, {
+      subscribe: f.subscribe,
+      getValue: M
+    };
+  };
+}
+function A(e) {
+  return k().select(e);
+}
+function D(e, r, s) {
+  const t = k(), d = q(), c = j(() => U(t), [t, e]), u = E(r, s), {
+    subscribe: S,
+    getValue: f
+  } = c(u, d), m = T(S, f, f);
+  return $(m), m;
+}
+function L(e, r) {
+  const s = typeof e != "function", t = V(s);
+  if (s !== t.current) {
+    const d = t.current ? "static" : "mapping", c = s ? "static" : "mapping";
+    throw new Error(`Switching useSelect from ${d} to ${c} is not allowed`);
+  }
+  return s ? A(e) : D(!1, e, r);
+}
+export {
+  L as default
+};

package/dist/node_modules/@wordpress/data/build-module/components/with-dispatch/index.js

@@ -0,0 +1,13 @@
+import { j as o } from "../../../../../react/jsx-runtime.js";
+import c from "../use-dispatch/use-dispatch-with-map.js";
+import { createHigherOrderComponent as e } from "../../../../compose/build-module/utils/create-higher-order-component/index.js";
+const f = (p) => e((s) => (t) => {
+  const i = c((r, a) => p(r, t, a), []);
+  return /* @__PURE__ */ o.jsx(s, {
+    ...t,
+    ...i
+  });
+}, "withDispatch");
+export {
+  f as default
+};

package/dist/node_modules/@wordpress/data/build-module/components/with-select/index.js

@@ -0,0 +1,14 @@
+import c from "../use-select/index.js";
+import { j as s } from "../../../../../react/jsx-runtime.js";
+import { createHigherOrderComponent as i } from "../../../../compose/build-module/utils/create-higher-order-component/index.js";
+import a from "../../../../compose/build-module/higher-order/pure/index.js";
+const x = (t) => i((r) => a((e) => {
+  const o = c((m, p) => t(m, e, p));
+  return /* @__PURE__ */ s.jsx(r, {
+    ...e,
+    ...o
+  });
+}), "withSelect");
+export {
+  x as default
+};

package/dist/node_modules/@wordpress/data/build-module/controls.js

@@ -0,0 +1,24 @@
+import { createRegistryControl as s } from "./factory.js";
+const n = "@@data/SELECT", S = "@@data/RESOLVE_SELECT", a = "@@data/DISPATCH", C = {
+  [n]: s((t) => ({
+    storeKey: o,
+    selectorName: e,
+    args: E
+  }) => t.select(o)[e](...E)),
+  [S]: s((t) => ({
+    storeKey: o,
+    selectorName: e,
+    args: E
+  }) => {
+    const c = t.select(o)[e].hasResolver ? "resolveSelect" : "select";
+    return t[c](o)[e](...E);
+  }),
+  [a]: s((t) => ({
+    storeKey: o,
+    actionName: e,
+    args: E
+  }) => t.dispatch(o)[e](...E))
+};
+export {
+  C as builtinControls
+};

package/dist/node_modules/@wordpress/data/build-module/default-registry.js

@@ -0,0 +1,5 @@
+import { createRegistry as t } from "./registry.js";
+const r = t();
+export {
+  r as default
+};

package/dist/node_modules/@wordpress/data/build-module/factory.js

@@ -0,0 +1,14 @@
+function i(t) {
+  const s = /* @__PURE__ */ new WeakMap(), e = (...c) => {
+    let r = s.get(e.registry);
+    return r || (r = t(e.registry.select), s.set(e.registry, r)), r(...c);
+  };
+  return e.isRegistrySelector = !0, e;
+}
+function o(t) {
+  return t.isRegistryControl = !0, t;
+}
+export {
+  o as createRegistryControl,
+  i as createRegistrySelector
+};

package/dist/node_modules/@wordpress/data/build-module/index.js

@@ -0,0 +1,15 @@
+import e from "./default-registry.js";
+import { combineReducers as r } from "./redux-store/combine-reducers.js";
+const o = r;
+e.resolveSelect;
+e.suspendSelect;
+e.subscribe;
+e.registerGenericStore;
+const c = e.registerStore;
+e.use;
+const i = e.register;
+export {
+  o as combineReducers,
+  i as register,
+  c as registerStore
+};

package/dist/node_modules/@wordpress/data/build-module/lock-unlock.js

@@ -0,0 +1,9 @@
+import { __dangerousOptInToUnstableAPIsOnlyForCoreModules as o } from "../../private-apis/build-module/implementation.js";
+const {
+  lock: r,
+  unlock: n
+} = o("I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.", "@wordpress/data");
+export {
+  r as lock,
+  n as unlock
+};

package/dist/node_modules/@wordpress/data/build-module/promise-middleware.js

@@ -0,0 +1,8 @@
+import i from "../../../is-promise/index.js";
+const s = () => (e) => (r) => i(r) ? r.then((f) => {
+  if (f)
+    return e(f);
+}) : e(r);
+export {
+  s as default
+};

package/dist/node_modules/@wordpress/data/build-module/redux-store/combine-reducers.js

@@ -0,0 +1,15 @@
+function d(n) {
+  const u = Object.keys(n);
+  return function(o = {}, a) {
+    const c = {};
+    let e = !1;
+    for (const t of u) {
+      const f = n[t], r = o[t], s = f(r, a);
+      c[t] = s, e = e || s !== r;
+    }
+    return e ? c : o;
+  };
+}
+export {
+  d as combineReducers
+};

package/dist/node_modules/@wordpress/data/build-module/redux-store/index.js

@@ -0,0 +1,250 @@
+import { applyMiddleware as W, createStore as $ } from "../../../../redux/dist/redux.js";
+import q from "../../../../equivalent-key-map/equivalent-key-map.js";
+import H from "../../../redux-routine/build-module/index.js";
+import { combineReducers as K } from "./combine-reducers.js";
+import { builtinControls as J } from "../controls.js";
+import { lock as P } from "../lock-unlock.js";
+import Q from "../promise-middleware.js";
+import Y from "../resolvers-cache-middleware.js";
+import Z from "./thunk-middleware.js";
+import N from "./metadata/reducer.js";
+import * as tt from "./metadata/selectors.js";
+import { hasStartedResolution as et } from "./metadata/selectors.js";
+import * as nt from "./metadata/actions.js";
+import { startResolution as it, finishResolution as rt, failResolution as ot } from "./metadata/actions.js";
+import st from "../../../compose/build-module/higher-order/compose.js";
+const x = (e) => {
+  const t = [...e];
+  for (let n = t.length - 1; n >= 0; n--)
+    t[n] === void 0 && t.splice(n, 1);
+  return t;
+}, R = (e, t) => Object.fromEntries(Object.entries(e ?? {}).map(([n, o]) => [n, t(o, n)])), ct = (e, t) => t instanceof Map ? Object.fromEntries(t) : t instanceof window.HTMLElement ? null : t;
+function lt() {
+  const e = {};
+  return {
+    isRunning(t, n) {
+      return e[t] && e[t].get(x(n));
+    },
+    clear(t, n) {
+      e[t] && e[t].delete(x(n));
+    },
+    markAsRunning(t, n) {
+      e[t] || (e[t] = new q()), e[t].set(x(n), !0);
+    }
+  };
+}
+function V(e) {
+  const t = /* @__PURE__ */ new WeakMap();
+  return {
+    get(n, o) {
+      let a = t.get(n);
+      return a || (a = e(n, o), t.set(n, a)), a;
+    }
+  };
+}
+function Ft(e, t) {
+  const n = {}, o = {}, a = {
+    privateActions: n,
+    registerPrivateActions: (u) => {
+      Object.assign(n, u);
+    },
+    privateSelectors: o,
+    registerPrivateSelectors: (u) => {
+      Object.assign(o, u);
+    }
+  }, f = {
+    name: e,
+    instantiate: (u) => {
+      const r = /* @__PURE__ */ new Set(), m = t.reducer, i = at(e, t, u, {
+        registry: u,
+        get dispatch() {
+          return M;
+        },
+        get select() {
+          return z;
+        },
+        get resolveSelect() {
+          return D();
+        }
+      });
+      P(i, a);
+      const p = lt();
+      function _(s) {
+        return (...l) => Promise.resolve(i.dispatch(s(...l)));
+      }
+      const h = {
+        ...R(nt, _),
+        ...R(t.actions, _)
+      }, v = V(_), d = new Proxy(() => {
+      }, {
+        get: (s, l) => {
+          const c = n[l];
+          return c ? v.get(c, l) : h[l];
+        }
+      }), M = new Proxy(d, {
+        apply: (s, l, [c]) => i.dispatch(c)
+      });
+      P(h, d);
+      const A = t.resolvers ? dt(t.resolvers) : {};
+      function w(s, l) {
+        s.isRegistrySelector && (s.registry = u);
+        const c = (...g) => {
+          g = C(s, g);
+          const T = i.__unstableOriginalGetState();
+          return s.isRegistrySelector && (s.registry = u), s(T.root, ...g);
+        };
+        c.__unstableNormalizeArgs = s.__unstableNormalizeArgs;
+        const F = A[l];
+        return F ? St(c, l, F, i, p) : (c.hasResolver = !1, c);
+      }
+      function O(s) {
+        const l = (...c) => {
+          const F = i.__unstableOriginalGetState(), g = c && c[0], T = c && c[1], j = t?.selectors?.[g];
+          return g && j && (c[1] = C(j, T)), s(F.metadata, ...c);
+        };
+        return l.hasResolver = !1, l;
+      }
+      const S = {
+        ...R(tt, O),
+        ...R(t.selectors, w)
+      }, y = V(w);
+      for (const [s, l] of Object.entries(o))
+        y.get(l, s);
+      const E = new Proxy(() => {
+      }, {
+        get: (s, l) => {
+          const c = o[l];
+          return c ? y.get(c, l) : S[l];
+        }
+      }), z = new Proxy(E, {
+        apply: (s, l, [c]) => c(i.__unstableOriginalGetState())
+      });
+      P(S, E);
+      const k = ut(S, i), G = ft(S, i), X = () => S, L = () => h, D = () => k, U = () => G;
+      i.__unstableOriginalGetState = i.getState, i.getState = () => i.__unstableOriginalGetState().root;
+      const B = i && ((s) => (r.add(s), () => r.delete(s)));
+      let I = i.__unstableOriginalGetState();
+      return i.subscribe(() => {
+        const s = i.__unstableOriginalGetState(), l = s !== I;
+        if (I = s, l)
+          for (const c of r)
+            c();
+      }), {
+        reducer: m,
+        store: i,
+        actions: h,
+        selectors: S,
+        resolvers: A,
+        getSelectors: X,
+        getResolveSelectors: D,
+        getSuspendSelectors: U,
+        getActions: L,
+        subscribe: B
+      };
+    }
+  };
+  return P(f, a), f;
+}
+function at(e, t, n, o) {
+  const a = {
+    ...t.controls,
+    ...J
+  }, f = R(a, (p) => p.isRegistryControl ? p(n) : p), u = [Y(n, e), Q, H(f), Z(o)], r = [W(...u)];
+  typeof window < "u" && window.__REDUX_DEVTOOLS_EXTENSION__ && r.push(window.__REDUX_DEVTOOLS_EXTENSION__({
+    name: e,
+    instanceId: e,
+    serialize: {
+      replacer: ct
+    }
+  }));
+  const {
+    reducer: m,
+    initialState: b
+  } = t, i = K({
+    metadata: N,
+    root: m
+  });
+  return $(i, {
+    root: b
+  }, st(r));
+}
+function ut(e, t) {
+  const {
+    getIsResolving: n,
+    hasStartedResolution: o,
+    hasFinishedResolution: a,
+    hasResolutionFailed: f,
+    isResolving: u,
+    getCachedResolvers: r,
+    getResolutionState: m,
+    getResolutionError: b,
+    hasResolvingSelectors: i,
+    countSelectorsByStatus: p,
+    ..._
+  } = e;
+  return R(_, (h, v) => h.hasResolver ? (...d) => new Promise((M, A) => {
+    const w = () => e.hasFinishedResolution(v, d), O = (z) => {
+      if (e.hasResolutionFailed(v, d)) {
+        const G = e.getResolutionError(v, d);
+        A(G);
+      } else
+        M(z);
+    }, S = () => h.apply(null, d), y = S();
+    if (w())
+      return O(y);
+    const E = t.subscribe(() => {
+      w() && (E(), O(S()));
+    });
+  }) : async (...d) => h.apply(null, d));
+}
+function ft(e, t) {
+  return R(e, (n, o) => n.hasResolver ? (...a) => {
+    const f = n.apply(null, a);
+    if (e.hasFinishedResolution(o, a)) {
+      if (e.hasResolutionFailed(o, a))
+        throw e.getResolutionError(o, a);
+      return f;
+    }
+    throw new Promise((u) => {
+      const r = t.subscribe(() => {
+        e.hasFinishedResolution(o, a) && (u(), r());
+      });
+    });
+  } : n);
+}
+function dt(e) {
+  return R(e, (t) => t.fulfill ? t : {
+    ...t,
+    // Copy the enumerable properties of the resolver function.
+    fulfill: t
+    // Add the fulfill method.
+  });
+}
+function St(e, t, n, o, a) {
+  function f(r) {
+    const m = o.getState();
+    if (a.isRunning(t, r) || typeof n.isFulfilled == "function" && n.isFulfilled(m, ...r))
+      return;
+    const {
+      metadata: b
+    } = o.__unstableOriginalGetState();
+    et(b, t, r) || (a.markAsRunning(t, r), setTimeout(async () => {
+      a.clear(t, r), o.dispatch(it(t, r));
+      try {
+        const i = n.fulfill(...r);
+        i && await o.dispatch(i), o.dispatch(rt(t, r));
+      } catch (i) {
+        o.dispatch(ot(t, r, i));
+      }
+    }, 0));
+  }
+  const u = (...r) => (r = C(e, r), f(r), e(...r));
+  return u.hasResolver = !0, u;
+}
+function C(e, t) {
+  return e.__unstableNormalizeArgs && typeof e.__unstableNormalizeArgs == "function" && t?.length ? e.__unstableNormalizeArgs(t) : t;
+}
+export {
+  K as combineReducers,
+  Ft as default
+};