@pismo/marola 2.1.18 → 2.1.20

package/dist/react-BvI-Sw9b.js

@@ -0,0 +1,509 @@
+import te, { useRef as ue, createElement as de, createContext as fe, useReducer as ae, useEffect as ve, useDebugValue as _e, useCallback as he, useContext as we } from "react";
+const I = {}, Y = (e, t) => e.unstable_is ? e.unstable_is(t) : t === e, Z = (e) => "init" in e, $ = (e) => !!e.write, k = (e) => "v" in e || "e" in e, V = (e) => {
+  if ("e" in e)
+    throw e.e;
+  if ((I ? "production" : void 0) !== "production" && !("v" in e))
+    throw new Error("[Bug] atom state is not initialized");
+  return e.v;
+}, j = /* @__PURE__ */ new WeakMap(), B = (e) => {
+  var t;
+  return x(e) && !!((t = j.get(e)) != null && t[0]);
+}, Se = (e) => {
+  const t = j.get(e);
+  t != null && t[0] && (t[0] = !1, t[1].forEach((n) => n()));
+}, ne = (e, t) => {
+  let n = j.get(e);
+  if (!n) {
+    n = [!0, /* @__PURE__ */ new Set()], j.set(e, n);
+    const o = () => {
+      n[0] = !1;
+    };
+    e.then(o, o);
+  }
+  n[1].add(t);
+}, x = (e) => typeof (e == null ? void 0 : e.then) == "function", re = (e, t, n) => {
+  n.p.has(e) || (n.p.add(e), t.then(
+    () => {
+      n.p.delete(e);
+    },
+    () => {
+      n.p.delete(e);
+    }
+  ));
+}, C = (e, t, n) => {
+  const o = n(e), u = "v" in o, f = o.v;
+  if (x(t))
+    for (const a of o.d.keys())
+      re(e, t, n(a));
+  o.v = t, delete o.e, (!u || !Object.is(f, o.v)) && (++o.n, x(f) && Se(f));
+}, H = (e, t, n) => {
+  var o;
+  const u = /* @__PURE__ */ new Set();
+  for (const f of ((o = n.get(e)) == null ? void 0 : o.t) || [])
+    n.has(f) && u.add(f);
+  for (const f of t.p)
+    u.add(f);
+  return u;
+}, ge = () => {
+  const e = /* @__PURE__ */ new Set(), t = () => {
+    e.forEach((n) => n());
+  };
+  return t.add = (n) => (e.add(n), () => {
+    e.delete(n);
+  }), t;
+}, G = () => {
+  const e = {}, t = /* @__PURE__ */ new WeakMap(), n = (o) => {
+    var u, f;
+    (u = t.get(e)) == null || u.forEach((a) => a(o)), (f = t.get(o)) == null || f.forEach((a) => a());
+  };
+  return n.add = (o, u) => {
+    const f = o || e, a = (t.has(f) ? t : t.set(f, /* @__PURE__ */ new Set())).get(f);
+    return a.add(u), () => {
+      a == null || a.delete(u), a.size || t.delete(f);
+    };
+  }, n;
+}, ye = (e) => (e.c || (e.c = G()), e.m || (e.m = G()), e.u || (e.u = G()), e.f || (e.f = ge()), e), pe = Symbol(), be = (e = /* @__PURE__ */ new WeakMap(), t = /* @__PURE__ */ new WeakMap(), n = /* @__PURE__ */ new WeakMap(), o = /* @__PURE__ */ new Set(), u = /* @__PURE__ */ new Set(), f = /* @__PURE__ */ new Set(), a = {}, S = (_, ...b) => _.read(...b), y = (_, ...b) => _.write(...b), v = (_, b) => {
+  var A;
+  return (A = _.unstable_onInit) == null ? void 0 : A.call(_, b);
+}, h = (_, b) => {
+  var A;
+  return (A = _.onMount) == null ? void 0 : A.call(_, b);
+}, ...g) => {
+  const _ = g[0] || ((r) => {
+    if ((I ? "production" : void 0) !== "production" && !r)
+      throw new Error("Atom is undefined or null");
+    let d = e.get(r);
+    return d || (d = { d: /* @__PURE__ */ new Map(), p: /* @__PURE__ */ new Set(), n: 0 }, e.set(r, d), v == null || v(r, U)), d;
+  }), b = g[1] || (() => {
+    const r = [], d = (l) => {
+      try {
+        l();
+      } catch (s) {
+        r.push(s);
+      }
+    };
+    do {
+      a.f && d(a.f);
+      const l = /* @__PURE__ */ new Set(), s = l.add.bind(l);
+      o.forEach((i) => {
+        var c;
+        return (c = t.get(i)) == null ? void 0 : c.l.forEach(s);
+      }), o.clear(), f.forEach(s), f.clear(), u.forEach(s), u.clear(), l.forEach(d), o.size && A();
+    } while (o.size || f.size || u.size);
+    if (r.length)
+      throw new AggregateError(r);
+  }), A = g[2] || (() => {
+    const r = [], d = /* @__PURE__ */ new WeakSet(), l = /* @__PURE__ */ new WeakSet(), s = Array.from(o);
+    for (; s.length; ) {
+      const i = s[s.length - 1], c = _(i);
+      if (l.has(i)) {
+        s.pop();
+        continue;
+      }
+      if (d.has(i)) {
+        if (n.get(i) === c.n)
+          r.push([i, c]);
+        else if ((I ? "production" : void 0) !== "production" && n.has(i))
+          throw new Error("[Bug] invalidated atom exists");
+        l.add(i), s.pop();
+        continue;
+      }
+      d.add(i);
+      for (const p of H(i, c, t))
+        d.has(p) || s.push(p);
+    }
+    for (let i = r.length - 1; i >= 0; --i) {
+      const [c, p] = r[i];
+      let E = !1;
+      for (const R of p.d.keys())
+        if (R !== c && o.has(R)) {
+          E = !0;
+          break;
+        }
+      E && (P(c), L(c)), n.delete(c);
+    }
+  }), P = g[3] || ((r) => {
+    var d;
+    const l = _(r);
+    if (k(l) && (t.has(r) && n.get(r) !== l.n || Array.from(l.d).every(
+      ([w, N]) => (
+        // Recursively, read the atom state of the dependency, and
+        // check if the atom epoch number is unchanged
+        P(w).n === N
+      )
+    )))
+      return l;
+    l.d.clear();
+    let s = !0;
+    const i = () => {
+      t.has(r) && (L(r), A(), b());
+    }, c = (w) => {
+      var N;
+      if (Y(r, w)) {
+        const X = _(w);
+        if (!k(X))
+          if (Z(w))
+            C(w, w.init, _);
+          else
+            throw new Error("no atom init");
+        return V(X);
+      }
+      const J = P(w);
+      try {
+        return V(J);
+      } finally {
+        l.d.set(w, J.n), B(l.v) && re(r, l.v, J), (N = t.get(w)) == null || N.t.add(r), s || i();
+      }
+    };
+    let p, E;
+    const R = {
+      get signal() {
+        return p || (p = new AbortController()), p.signal;
+      },
+      get setSelf() {
+        return (I ? "production" : void 0) !== "production" && !$(r) && console.warn("setSelf function cannot be used with read-only atom"), !E && $(r) && (E = (...w) => {
+          if ((I ? "production" : void 0) !== "production" && s && console.warn("setSelf function cannot be called in sync"), !s)
+            try {
+              return T(r, ...w);
+            } finally {
+              A(), b();
+            }
+        }), E;
+      }
+    }, O = l.n;
+    try {
+      const w = S(r, c, R);
+      return C(r, w, _), x(w) && (ne(w, () => p == null ? void 0 : p.abort()), w.then(
+        i,
+        i
+      )), l;
+    } catch (w) {
+      return delete l.v, l.e = w, ++l.n, l;
+    } finally {
+      s = !1, O !== l.n && n.get(r) === O && (n.set(r, l.n), o.add(r), (d = a.c) == null || d.call(a, r));
+    }
+  }), M = g[4] || ((r) => {
+    const d = [r];
+    for (; d.length; ) {
+      const l = d.pop(), s = _(l);
+      for (const i of H(l, s, t)) {
+        const c = _(i);
+        n.set(i, c.n), d.push(i);
+      }
+    }
+  }), T = g[5] || ((r, ...d) => {
+    let l = !0;
+    const s = (c) => V(P(c)), i = (c, ...p) => {
+      var E;
+      const R = _(c);
+      try {
+        if (Y(r, c)) {
+          if (!Z(c))
+            throw new Error("atom not writable");
+          const O = R.n, w = p[0];
+          C(c, w, _), L(c), O !== R.n && (o.add(c), (E = a.c) == null || E.call(a, c), M(c));
+          return;
+        } else
+          return T(c, ...p);
+      } finally {
+        l || (A(), b());
+      }
+    };
+    try {
+      return y(r, s, i, ...d);
+    } finally {
+      l = !1;
+    }
+  }), L = g[6] || ((r) => {
+    var d;
+    const l = _(r), s = t.get(r);
+    if (s && !B(l.v)) {
+      for (const [i, c] of l.d)
+        if (!s.d.has(i)) {
+          const p = _(i);
+          W(i).t.add(r), s.d.add(i), c !== p.n && (o.add(i), (d = a.c) == null || d.call(a, i), M(i));
+        }
+      for (const i of s.d || [])
+        if (!l.d.has(i)) {
+          s.d.delete(i);
+          const c = z(i);
+          c == null || c.t.delete(r);
+        }
+    }
+  }), W = g[7] || ((r) => {
+    var d;
+    const l = _(r);
+    let s = t.get(r);
+    if (!s) {
+      P(r);
+      for (const i of l.d.keys())
+        W(i).t.add(r);
+      if (s = {
+        l: /* @__PURE__ */ new Set(),
+        d: new Set(l.d.keys()),
+        t: /* @__PURE__ */ new Set()
+      }, t.set(r, s), (d = a.m) == null || d.call(a, r), $(r)) {
+        const i = () => {
+          let c = !0;
+          const p = (...E) => {
+            try {
+              return T(r, ...E);
+            } finally {
+              c || (A(), b());
+            }
+          };
+          try {
+            const E = h(r, p);
+            E && (s.u = () => {
+              c = !0;
+              try {
+                E();
+              } finally {
+                c = !1;
+              }
+            });
+          } finally {
+            c = !1;
+          }
+        };
+        u.add(i);
+      }
+    }
+    return s;
+  }), z = g[8] || ((r) => {
+    var d;
+    const l = _(r);
+    let s = t.get(r);
+    if (s && !s.l.size && !Array.from(s.t).some((i) => {
+      var c;
+      return (c = t.get(i)) == null ? void 0 : c.d.has(r);
+    })) {
+      s.u && f.add(s.u), s = void 0, t.delete(r), (d = a.u) == null || d.call(a, r);
+      for (const i of l.d.keys()) {
+        const c = z(i);
+        c == null || c.t.delete(r);
+      }
+      return;
+    }
+    return s;
+  }), le = [
+    // store state
+    e,
+    t,
+    n,
+    o,
+    u,
+    f,
+    a,
+    // atom interceptors
+    S,
+    y,
+    v,
+    h,
+    // building-block functions
+    _,
+    b,
+    A,
+    P,
+    M,
+    T,
+    L,
+    W,
+    z
+  ], U = {
+    get: (r) => V(P(r)),
+    set: (r, ...d) => {
+      try {
+        return T(r, ...d);
+      } finally {
+        A(), b();
+      }
+    },
+    sub: (r, d) => {
+      const s = W(r).l;
+      return s.add(d), b(), () => {
+        s.delete(d), z(r), b();
+      };
+    }
+  };
+  return Object.defineProperty(U, pe, { value: le }), U;
+}, oe = be, Ee = ye, m = ne, Q = {};
+let Ae = 0;
+function Ne(e, t) {
+  const n = `atom${++Ae}`, o = {
+    toString() {
+      return (Q ? "production" : void 0) !== "production" && this.debugLabel ? n + ":" + this.debugLabel : n;
+    }
+  };
+  return o.init = e, o.read = Pe, o.write = Re, o;
+}
+function Pe(e) {
+  return e(this);
+}
+function Re(e, t, n) {
+  return t(
+    this,
+    typeof n == "function" ? n(e(this)) : n
+  );
+}
+const Te = () => {
+  let e = 0;
+  const t = Ee({}), n = /* @__PURE__ */ new WeakMap(), o = /* @__PURE__ */ new WeakMap(), u = oe(
+    n,
+    o,
+    void 0,
+    void 0,
+    void 0,
+    void 0,
+    t,
+    void 0,
+    (S, y, v, ...h) => e ? v(S, ...h) : S.write(y, v, ...h)
+  ), f = /* @__PURE__ */ new Set();
+  return t.m.add(void 0, (S) => {
+    f.add(S);
+    const y = n.get(S);
+    y.m = o.get(S);
+  }), t.u.add(void 0, (S) => {
+    f.delete(S);
+    const y = n.get(S);
+    delete y.m;
+  }), Object.assign(u, {
+    // store dev methods (these are tentative and subject to change without notice)
+    dev4_get_internal_weak_map: () => (console.log("Deprecated: Use devstore from the devtools library"), n),
+    dev4_get_mounted_atoms: () => f,
+    dev4_restore_atoms: (S) => {
+      const y = {
+        read: () => null,
+        write: (v, h) => {
+          ++e;
+          try {
+            for (const [g, _] of S)
+              "init" in g && h(g, _);
+          } finally {
+            --e;
+          }
+        }
+      };
+      u.set(y);
+    }
+  });
+};
+function ie() {
+  return (Q ? "production" : void 0) !== "production" ? Te() : oe();
+}
+let D;
+function De() {
+  return D || (D = ie(), (Q ? "production" : void 0) !== "production" && (globalThis.__JOTAI_DEFAULT_STORE__ || (globalThis.__JOTAI_DEFAULT_STORE__ = D), globalThis.__JOTAI_DEFAULT_STORE__ !== D && console.warn(
+    "Detected multiple Jotai instances. It may cause unexpected behavior with the default store. https://github.com/pmndrs/jotai/discussions/2044"
+  ))), D;
+}
+const Ie = {}, se = fe(
+  void 0
+);
+function ce(e) {
+  return we(se) || De();
+}
+function Ve({
+  children: e,
+  store: t
+}) {
+  const n = ue(void 0);
+  return !t && !n.current && (n.current = ie()), de(
+    se.Provider,
+    {
+      value: t || n.current
+    },
+    e
+  );
+}
+const q = (e) => typeof (e == null ? void 0 : e.then) == "function", F = (e) => {
+  e.status || (e.status = "pending", e.then(
+    (t) => {
+      e.status = "fulfilled", e.value = t;
+    },
+    (t) => {
+      e.status = "rejected", e.reason = t;
+    }
+  ));
+}, Le = te.use || // A shim for older React versions
+((e) => {
+  if (e.status === "pending")
+    throw e;
+  if (e.status === "fulfilled")
+    return e.value;
+  throw e.status === "rejected" ? e.reason : (F(e), e);
+}), K = /* @__PURE__ */ new WeakMap(), ee = (e, t) => {
+  let n = K.get(e);
+  return n || (n = new Promise((o, u) => {
+    let f = e;
+    const a = (v) => (h) => {
+      f === v && o(h);
+    }, S = (v) => (h) => {
+      f === v && u(h);
+    }, y = () => {
+      try {
+        const v = t();
+        q(v) ? (K.set(v, n), f = v, v.then(a(v), S(v)), m(v, y)) : o(v);
+      } catch (v) {
+        u(v);
+      }
+    };
+    e.then(a(e), S(e)), m(e, y);
+  }), K.set(e, n)), n;
+};
+function We(e, t) {
+  const { delay: n, unstable_promiseStatus: o = !te.use } = {}, u = ce(), [[f, a, S], y] = ae(
+    (h) => {
+      const g = u.get(e);
+      return Object.is(h[0], g) && h[1] === u && h[2] === e ? h : [g, u, e];
+    },
+    void 0,
+    () => [u.get(e), u, e]
+  );
+  let v = f;
+  if ((a !== u || S !== e) && (y(), v = u.get(e)), ve(() => {
+    const h = u.sub(e, () => {
+      if (o)
+        try {
+          const g = u.get(e);
+          q(g) && F(
+            ee(g, () => u.get(e))
+          );
+        } catch {
+        }
+      if (typeof n == "number") {
+        setTimeout(y, n);
+        return;
+      }
+      y();
+    });
+    return y(), h;
+  }, [u, e, n, o]), _e(v), q(v)) {
+    const h = ee(v, () => u.get(e));
+    return o && F(h), Le(h);
+  }
+  return v;
+}
+function ze(e, t) {
+  const n = ce();
+  return he(
+    (...u) => {
+      if ((Ie ? "production" : void 0) !== "production" && !("write" in e))
+        throw new Error("not writable atom");
+      return n.set(e, ...u);
+    },
+    [n, e]
+  );
+}
+function je(e, t) {
+  return [
+    We(e),
+    // We do wrong type assertion here, which results in throwing an error.
+    ze(e)
+  ];
+}
+export {
+  Ve as P,
+  Ne as a,
+  je as u
+};

package/dist/{useButton-B8Y1xR88.js → useButton-CezPDte8.js}

@@ -1,6 +1,6 @@
-import { u as S, b as D, f as k } from "./useSlotProps-C7dqSmdM.js";
+import { u as L, _ as D, f as k } from "./useSlotProps-CYHDC4TN.js";
 import * as i from "react";
-import { u as _ } from "./useIsFocusVisible-BH4IAdcw.js";
+import { u as S } from "./useIsFocusVisible-BH4IAdcw.js";
 function v(p) {
   const {
     rootElementName: n = "",
@@ -30,7 +30,7 @@ function W(p = {}) {
     onFocus: F,
     onBlur: M,
     ref: U
-  } = _(), [d, R] = i.useState(!1);
+  } = S(), [d, R] = i.useState(!1);
   n && !l && d && R(!1), i.useEffect(() => {
     E.current = d;
   }, [d, E]);
@@ -71,13 +71,13 @@ function W(p = {}) {
       var r;
       (r = t.onClick) == null || r.call(t, e), e.preventDefault();
     }
-  }, L = (t) => (e) => {
+  }, _ = (t) => (e) => {
     var o;
     if (e.target === e.currentTarget && N(!1), (o = t.onKeyUp) == null || o.call(t, e), e.target === e.currentTarget && !g() && !n && e.key === " " && !e.defaultMuiPrevented) {
       var r;
       (r = t.onClick) == null || r.call(t, e);
     }
-  }, x = S(V, y, U, b), a = {};
+  }, x = L(V, y, U, b), a = {};
   return u !== void 0 && (a.tabIndex = u), f === "BUTTON" ? (a.type = s ?? "button", l ? a["aria-disabled"] = n : a.disabled = n) : f === "INPUT" ? s && ["button", "submit", "reset"].includes(s) && (l ? a["aria-disabled"] = n : a.disabled = n) : f !== "" && (!c && !m && (a.role = "button", a.tabIndex = u ?? 0), n && (a["aria-disabled"] = n, a.tabIndex = l ? u ?? 0 : -1)), {
     getRootProps: (t = {}) => {
       const e = D({}, k(p), k(t)), o = D({
@@ -87,7 +87,7 @@ function W(p = {}) {
         onClick: I(e),
         onFocus: P(e),
         onKeyDown: C(e),
-        onKeyUp: L(e),
+        onKeyUp: _(e),
         onMouseDown: $(e),
         onMouseLeave: w(e),
         ref: x

package/dist/{useList-9gbS2r78.js → useList-nqLfZem8.js}

@@ -1,6 +1,6 @@
-import { b as p, u as re, f as ie } from "./useSlotProps-C7dqSmdM.js";
+import { _ as p, u as re, f as ie } from "./useSlotProps-CYHDC4TN.js";
 import * as f from "react";
-import { L as x } from "./combineHooksSlotProps-CNWfgylM.js";
+import { L as x } from "./combineHooksSlotProps-BhQ14uyD.js";
 function W(t, e, r = (n, l) => n === l) {
   return t.length === e.length && t.every((n, l) => r(n, e[l]));
 }

package/dist/{useSlotProps-C7dqSmdM.js → useSlotProps-CYHDC4TN.js}

@@ -820,9 +820,9 @@ function nr(e) {
 }
 export {
   Qe as P,
-  We as _,
+  Y as _,
   rr as a,
-  Y as b,
+  We as b,
   nr as c,
   er as d,
   tr as e,

package/dist/utils/draggable.d.ts

@@ -0,0 +1,8 @@
+type DeepKeys<T> = {
+    [K in keyof T]: T[K] extends object ? `${K & string}` | `${K & string}.${DeepKeys<T[K]>}` : `${K & string}`;
+}[keyof T];
+export declare const replaceItemsByIndex: <T>(items: T[], from: number, to: number) => T[];
+export declare const sortItemsByIndex: <T>(items: T[], from: number, to: number, direction: 'up' | 'down') => T[];
+export declare const sortItemsByKey: <T>(items: T[], key: DeepKeys<T>, from: number, to: number, direction: 'up' | 'down') => T[];
+export declare const replaceItemsByKey: <T>(items: T[], key: DeepKeys<T>, from: number, to: number) => T[];
+export {};

package/dist/utils/draggable.js

@@ -0,0 +1,30 @@
+const f = (o, r) => {
+  const c = r.split(".");
+  let n = o;
+  for (const e of c)
+    n && typeof n == "object" && e in n && (n = n[e]);
+  return n;
+}, x = (o, r, c) => {
+  const n = [...o], e = r, t = c;
+  return e < 0 || e >= n.length || t < 0 || t >= n.length || e !== t && (n[t] = n[e], n[e] = o[c]), n;
+}, l = (o, r, c, n) => {
+  const e = [...o], t = r, s = c;
+  if (t < 0 || t >= e.length || s < 0 || s >= e.length || t === s)
+    return e;
+  const I = e[t];
+  e.splice(t, 1);
+  let d = s;
+  return n === "up" ? d = s : n === "down" && (d = t < s ? s : s + 1), e.splice(d, 0, I), e;
+}, i = (o, r, c, n, e) => {
+  const t = [...o], s = o.findIndex((d) => f(d, r) === c), I = o.findIndex((d) => f(d, r) === n);
+  return l(t, s, I, e);
+}, u = (o, r, c, n) => {
+  const e = [...o], t = o.findIndex((I) => f(I, r) === c), s = o.findIndex((I) => f(I, r) === n);
+  return x(e, t, s);
+};
+export {
+  x as replaceItemsByIndex,
+  u as replaceItemsByKey,
+  l as sortItemsByIndex,
+  i as sortItemsByKey
+};

package/dist/utils/draggable.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pismo/marola",
   "description": "CDX tribe component library",
-  "version": "2.1.18",
+  "version": "2.1.20",
   "type": "module",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",
@@ -96,8 +96,10 @@
   },
   "dependencies": {
     "@base-ui-components/react": "^1.0.0-alpha.6",
+    "@floating-ui/dom": "^1.7.2",
     "@mui/base": "^5.0.0-beta.40",
-    "@mui/material": "^5.15.15"
+    "@mui/material": "^5.15.15",
+    "jotai": "^2.12.5"
   },
   "resolutions": {
     "@babel/helpers": "^7.27.1",