@konstructio/ui 0.1.2-alpha.111 → 0.1.2-alpha.113

package/dist/dist-rsFD9q_X.js

@@ -0,0 +1,484 @@
+import { a as V, n as U } from "./dist-CK8FUUUn.js";
+import { i as X, n as te } from "./dist-DbeY0Pzx.js";
+import * as l from "react";
+import { jsx as S } from "react/jsx-runtime";
+var ne = Object.defineProperty, u = (r, e) => ne(r, "name", {
+  value: e,
+  configurable: !0
+});
+// @__NO_SIDE_EFFECTS__
+function oe(r) {
+  const e = r + "CollectionProvider", [t, o] = X(e), [n, i] = t(e, {
+    collectionRef: { current: null },
+    itemMap: /* @__PURE__ */ new Map()
+  }), c = /* @__PURE__ */ u((v) => {
+    const { scope: m, children: x } = v, C = l.useRef(null), O = l.useRef(/* @__PURE__ */ new Map()).current;
+    return /* @__PURE__ */ S(n, {
+      scope: m,
+      itemMap: O,
+      collectionRef: C,
+      children: x
+    });
+  }, "CollectionProvider");
+  c.displayName = e;
+  const h = r + "CollectionSlot", N = U(h), w = l.forwardRef((v, m) => {
+    const { scope: x, children: C } = v, O = i(h, x), I = V(m, O.collectionRef);
+    return /* @__PURE__ */ S(N, {
+      ref: I,
+      children: C
+    });
+  });
+  w.displayName = h;
+  const p = r + "CollectionItemSlot", D = "data-radix-collection-item", W = U(p), k = l.forwardRef((v, m) => {
+    const { scope: x, children: C, ...O } = v, I = l.useRef(null), d = V(m, I), f = i(p, x);
+    return l.useEffect(() => (f.itemMap.set(I, {
+      ref: I,
+      ...O
+    }), () => {
+      f.itemMap.delete(I);
+    })), /* @__PURE__ */ S(W, {
+      [D]: "",
+      ref: d,
+      children: C
+    });
+  });
+  k.displayName = p;
+  function A(v) {
+    const m = i(r + "CollectionConsumer", v);
+    return l.useCallback(() => {
+      const x = m.collectionRef.current;
+      if (!x) return [];
+      const C = Array.from(x.querySelectorAll(`[${D}]`));
+      return Array.from(m.itemMap.values()).sort((O, I) => C.indexOf(O.ref.current) - C.indexOf(I.ref.current));
+    }, [m.collectionRef, m.itemMap]);
+  }
+  return u(A, "useCollection"), [
+    {
+      Provider: c,
+      Slot: w,
+      ItemSlot: k
+    },
+    A,
+    o
+  ];
+}
+u(oe, "createCollection");
+var Q = /* @__PURE__ */ new WeakMap(), B = class P extends Map {
+  static {
+    u(this, "OrderedDict");
+  }
+  #e;
+  constructor(e) {
+    super(e), this.#e = [...super.keys()], Q.set(this, !0);
+  }
+  set(e, t) {
+    return Q.get(this) && !this.has(e) && this.#e.push(e), super.set(e, t), this;
+  }
+  insert(e, t, o) {
+    const n = this.has(t), i = n ? this.size : this.size + 1, c = J(e), h = c >= 0 ? Math.min(c, i - 1) : Math.max(i + c, 0);
+    if (n ? this.#e.indexOf(t) === h : h === this.size)
+      return this.set(t, o), this;
+    const N = this.#e.filter((p) => p !== t);
+    N.splice(h, 0, t);
+    const w = N.map((p) => [p, p === t ? o : this.get(p)]);
+    this.clear();
+    for (const [p, D] of w) this.set(p, D);
+    return this;
+  }
+  with(e, t, o) {
+    const n = new P(this);
+    return n.insert(e, t, o), n;
+  }
+  before(e) {
+    const t = this.#e.indexOf(e) - 1;
+    if (!(t < 0))
+      return this.entryAt(t);
+  }
+  setBefore(e, t, o) {
+    const n = this.#e.indexOf(e);
+    if (n === -1) return this;
+    const i = this.#e.indexOf(t), c = i !== -1 && i < n ? n - 1 : n;
+    return this.insert(c, t, o);
+  }
+  after(e) {
+    let t = this.#e.indexOf(e);
+    if (t = t === -1 || t === this.size - 1 ? -1 : t + 1, t !== -1)
+      return this.entryAt(t);
+  }
+  setAfter(e, t, o) {
+    const n = this.#e.indexOf(e);
+    if (n === -1) return this;
+    const i = this.#e.indexOf(t), c = i !== -1 && i <= n ? n : n + 1;
+    return this.insert(c, t, o);
+  }
+  first() {
+    return this.entryAt(0);
+  }
+  last() {
+    return this.entryAt(-1);
+  }
+  clear() {
+    return this.#e = [], super.clear();
+  }
+  delete(e) {
+    const t = super.delete(e);
+    return t && this.#e.splice(this.#e.indexOf(e), 1), t;
+  }
+  deleteAt(e) {
+    const t = this.keyAt(e);
+    return t !== void 0 ? this.delete(t) : !1;
+  }
+  at(e) {
+    const t = G(this.#e, e);
+    if (t !== void 0) return this.get(t);
+  }
+  entryAt(e) {
+    const t = G(this.#e, e);
+    if (t !== void 0) return [t, this.get(t)];
+  }
+  indexOf(e) {
+    return this.#e.indexOf(e);
+  }
+  keyAt(e) {
+    return G(this.#e, e);
+  }
+  from(e, t) {
+    const o = this.indexOf(e);
+    if (o === -1) return;
+    let n = o + t;
+    return n < 0 && (n = 0), n >= this.size && (n = this.size - 1), this.at(n);
+  }
+  keyFrom(e, t) {
+    const o = this.indexOf(e);
+    if (o === -1) return;
+    let n = o + t;
+    return n < 0 && (n = 0), n >= this.size && (n = this.size - 1), this.keyAt(n);
+  }
+  find(e, t) {
+    let o = 0;
+    for (const n of this) {
+      if (Reflect.apply(e, t, [
+        n,
+        o,
+        this
+      ])) return n;
+      o++;
+    }
+  }
+  findIndex(e, t) {
+    let o = 0;
+    for (const n of this) {
+      if (Reflect.apply(e, t, [
+        n,
+        o,
+        this
+      ])) return o;
+      o++;
+    }
+    return -1;
+  }
+  filter(e, t) {
+    const o = [];
+    let n = 0;
+    for (const i of this)
+      Reflect.apply(e, t, [
+        i,
+        n,
+        this
+      ]) && o.push(i), n++;
+    return new P(o);
+  }
+  map(e, t) {
+    const o = [];
+    let n = 0;
+    for (const i of this)
+      o.push([i[0], Reflect.apply(e, t, [
+        i,
+        n,
+        this
+      ])]), n++;
+    return new P(o);
+  }
+  reduce(...e) {
+    const [t, o] = e, n = e.length > 1;
+    if (!n && this.size === 0) throw new TypeError("Reduce of empty OrderedDict with no initial value");
+    let i = 0, c = o;
+    for (const h of this)
+      i === 0 && !n ? c = h : c = Reflect.apply(t, this, [
+        c,
+        h,
+        i,
+        this
+      ]), i++;
+    return c;
+  }
+  reduceRight(...e) {
+    const [t, o] = e, n = e.length > 1;
+    if (!n && this.size === 0) throw new TypeError("Reduce of empty OrderedDict with no initial value");
+    let i = o;
+    for (let c = this.size - 1; c >= 0; c--) {
+      const h = this.entryAt(c);
+      c === this.size - 1 && !n ? i = h : i = Reflect.apply(t, this, [
+        i,
+        h,
+        c,
+        this
+      ]);
+    }
+    return i;
+  }
+  sort(e) {
+    if (typeof e != "function") throw new TypeError("OrderedDict.sort requires a compare function");
+    const t = [...this.entries()].sort(e);
+    this.clear();
+    for (const [o, n] of t) this.set(o, n);
+    return this;
+  }
+  toSorted(e) {
+    if (typeof e != "function") throw new TypeError("OrderedDict.toSorted requires a compare function");
+    const t = [...this.entries()].sort(e);
+    return new P(t);
+  }
+  toReversed() {
+    const e = new P();
+    for (let t = this.size - 1; t >= 0; t--) {
+      const o = this.keyAt(t), n = this.get(o);
+      e.set(o, n);
+    }
+    return e;
+  }
+  toSpliced(...e) {
+    const t = [...this.entries()];
+    return t.splice(...e), new P(t);
+  }
+  slice(e, t) {
+    const o = new P();
+    for (const n of this.#e.slice(e, t)) o.set(n, this.get(n));
+    return o;
+  }
+  every(e, t) {
+    let o = 0;
+    for (const n of this) {
+      if (!Reflect.apply(e, t, [
+        n,
+        o,
+        this
+      ])) return !1;
+      o++;
+    }
+    return !0;
+  }
+  some(e, t) {
+    let o = 0;
+    for (const n of this) {
+      if (Reflect.apply(e, t, [
+        n,
+        o,
+        this
+      ])) return !0;
+      o++;
+    }
+    return !1;
+  }
+};
+function G(r, e) {
+  if ("at" in Array.prototype) return Array.prototype.at.call(r, e);
+  const t = Y(r, e);
+  return t === -1 ? void 0 : r[t];
+}
+u(G, "at");
+function Y(r, e) {
+  const t = r.length, o = J(e), n = o >= 0 ? o : t + o;
+  return n < 0 || n >= t ? -1 : n;
+}
+u(Y, "toSafeIndex");
+function J(r) {
+  return r !== r || r === 0 ? 0 : Math.trunc(r);
+}
+u(J, "toSafeInteger");
+// @__NO_SIDE_EFFECTS__
+function re(r) {
+  const e = r + "CollectionProvider", [t, o] = X(e), [n, i] = t(e);
+  n.displayName = r + "CollectionStableContextProvider";
+  const [c, h] = t(e);
+  c.displayName = r + "CollectionStatefulContextProvider";
+  const N = /* @__PURE__ */ u(({ state: d, ...f }) => d ? /* @__PURE__ */ S(p, {
+    ...f,
+    state: d
+  }) : /* @__PURE__ */ S(w, { ...f }), "CollectionProvider");
+  N.displayName = e;
+  const w = /* @__PURE__ */ u((d) => {
+    const f = C();
+    return /* @__PURE__ */ S(p, {
+      ...d,
+      state: f
+    });
+  }, "CollectionInit");
+  w.displayName = r + "CollectionInit";
+  const p = /* @__PURE__ */ u((d) => {
+    const { scope: f, children: b, state: L } = d, g = l.useRef(null), [y, z] = l.useState(null), T = V(g, z), [M, E] = L, q = l.useRef(new B()), H = l.useCallback(() => {
+      const R = q.current;
+      return K(R) || R.sort($), R;
+    }, []);
+    return l.useEffect(() => {
+      if (!y) return;
+      const R = ee(() => {
+        E((s) => {
+          const a = s.toSorted($);
+          return a.some(([_], j) => s.keyAt(j) !== _) ? a : s;
+        });
+      });
+      return R.observe(y, {
+        childList: !0,
+        subtree: !0
+      }), () => {
+        R.disconnect();
+      };
+    }, [y, E]), /* @__PURE__ */ S(n, {
+      scope: f,
+      collectionElementRef: T,
+      collectionElementRefObject: g,
+      getCollection: H,
+      setCollection: E,
+      registryRef: q,
+      children: /* @__PURE__ */ S(c, {
+        scope: f,
+        collectionElement: y,
+        collection: M,
+        children: b
+      })
+    });
+  }, "CollectionProviderImpl");
+  p.displayName = r + "CollectionProviderImpl";
+  const D = r + "CollectionSlot", W = U(D), k = l.forwardRef((d, f) => {
+    const { scope: b, children: L } = d, g = i(D, b), y = V(f, g.collectionElementRef);
+    return /* @__PURE__ */ S(W, {
+      ref: y,
+      children: L
+    });
+  });
+  k.displayName = D;
+  const A = r + "CollectionItemSlot", v = "data-radix-collection-item", m = U(A), x = l.forwardRef((d, f) => {
+    const { scope: b, children: L, ...g } = d, y = l.useRef(null), { setCollection: z, registryRef: T } = i(A, b), M = l.useRef(g);
+    Z(M.current, g) || (M.current = g);
+    const E = M.current, q = l.useCallback((s) => {
+      const a = T.current;
+      s ? a.set(s, {
+        ...M.current,
+        element: s
+      }) : y.current && a.delete(y.current);
+    }, [T]), H = V(f, q, y);
+    te(() => {
+      const s = y.current, a = T.current;
+      s && a.has(s) && a.set(s, {
+        ...E,
+        element: s
+      });
+    }, [E, T]);
+    const R = l.useRef(null);
+    return l.useEffect(() => {
+      const s = y.current, a = R.current;
+      (a?.element ?? null) === s && (!s || a?.itemData === E) || (R.current = s ? {
+        element: s,
+        itemData: E
+      } : null, z((_) => {
+        const j = new B(_);
+        return a && a.element !== s && j.delete(a.element), s && j.set(s, {
+          ...E,
+          element: s
+        }), j.sort($);
+      }));
+    }), l.useEffect(() => () => {
+      const s = R.current;
+      R.current = null, s && z((a) => {
+        if (!a.has(s.element)) return a;
+        const _ = new B(a);
+        return _.delete(s.element), _;
+      });
+    }, [z]), /* @__PURE__ */ S(m, {
+      [v]: "",
+      ref: H,
+      children: L
+    });
+  });
+  x.displayName = A;
+  function C() {
+    return l.useState(new B());
+  }
+  u(C, "useInitCollection");
+  function O(d) {
+    const { collection: f } = h(r + "CollectionConsumer", d);
+    return f;
+  }
+  u(O, "useCollection");
+  function I(d) {
+    const { getCollection: f } = i(r + "CollectionConsumer", d);
+    return f;
+  }
+  return u(I, "useGetCollection"), [{
+    Provider: N,
+    Slot: k,
+    ItemSlot: x
+  }, {
+    createCollectionScope: o,
+    useCollection: O,
+    useGetCollection: I,
+    useInitCollection: C
+  }];
+}
+u(re, "createCollection");
+function Z(r, e) {
+  if (r === e) return !0;
+  if (typeof r != "object" || typeof e != "object" || r == null || e == null) return !1;
+  const t = Object.keys(r), o = Object.keys(e);
+  if (t.length !== o.length) return !1;
+  for (const n of t)
+    if (!Object.prototype.hasOwnProperty.call(e, n) || r[n] !== e[n]) return !1;
+  return !0;
+}
+u(Z, "shallowEqual");
+function F(r, e) {
+  return !!(e.compareDocumentPosition(r) & Node.DOCUMENT_POSITION_PRECEDING);
+}
+u(F, "isElementPreceding");
+function K(r) {
+  let e;
+  for (const t of r.keys()) {
+    if (e) {
+      const o = e.compareDocumentPosition(t);
+      if (!(o & Node.DOCUMENT_POSITION_DISCONNECTED) && o & Node.DOCUMENT_POSITION_PRECEDING) return !1;
+    }
+    e = t;
+  }
+  return !0;
+}
+u(K, "isInDocumentOrder");
+function $(r, e) {
+  return !r[1].element || !e[1].element ? 0 : F(r[1].element, e[1].element) ? -1 : 1;
+}
+u($, "sortByDocumentPosition");
+function ee(r) {
+  return new MutationObserver((e) => {
+    for (const t of e) if (t.type === "childList") {
+      r();
+      return;
+    }
+  });
+}
+u(ee, "getChildListObserver");
+var ie = Object.defineProperty, se = (r, e) => ie(r, "name", {
+  value: e,
+  configurable: !0
+}), ce = {
+  LTR: "ltr",
+  RTL: "rtl"
+}, le = l.createContext(void 0);
+function ue(r) {
+  const e = l.useContext(le);
+  return r || e || ce.LTR;
+}
+se(ue, "useDirection");
+export {
+  oe as n,
+  ue as t
+};

package/dist/{dist-BUocnzkM.js → dist-uuWgjOcO.js}

@@ -1,4 +1,4 @@
-import { n as y } from "./dist-D-yS0HN8.js";
+import { n as y } from "./dist-DbeY0Pzx.js";
 import * as o from "react";
 var P = Object.defineProperty, f = (n, e) => P(n, "name", {
   value: e,

package/dist/dist-vDSmnSS_.js

@@ -0,0 +1,41 @@
+import { n as b } from "./dist-DbeY0Pzx.js";
+import * as u from "react";
+var z = Object.defineProperty, h = (e, r) => z(e, "name", {
+  value: r,
+  configurable: !0
+});
+function S(e) {
+  const [r, i] = u.useState(void 0);
+  return b(() => {
+    if (e) {
+      i({
+        width: e.offsetWidth,
+        height: e.offsetHeight
+      });
+      let o = 0;
+      const f = new ResizeObserver((t) => {
+        if (!Array.isArray(t) || !t.length) return;
+        const d = t[0];
+        window.cancelAnimationFrame(o), o = window.requestAnimationFrame(() => {
+          let s, n;
+          if ("borderBoxSize" in d) {
+            const a = d.borderBoxSize, c = Array.isArray(a) ? a[0] : a;
+            s = c.inlineSize, n = c.blockSize;
+          } else
+            s = e.offsetWidth, n = e.offsetHeight;
+          i({
+            width: s,
+            height: n
+          });
+        });
+      });
+      return f.observe(e, { box: "border-box" }), () => {
+        window.cancelAnimationFrame(o), f.unobserve(e);
+      };
+    } else i(void 0);
+  }, [e]), r;
+}
+h(S, "useSize");
+export {
+  S as t
+};