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

package/dist/dist-DZ_SU77k.js

@@ -0,0 +1,437 @@
+import { a as _, n as z } from "./dist-xCbHbMLA.js";
+import { i as K } from "./dist-D-yS0HN8.js";
+import * as u from "react";
+import { jsx as M } from "react/jsx-runtime";
+var H = Object.defineProperty, f = (r, e) => H(r, "name", {
+  value: e,
+  configurable: !0
+});
+// @__NO_SIDE_EFFECTS__
+function J(r) {
+  const e = r + "CollectionProvider", [t, o] = K(e), [n, i] = t(e, {
+    collectionRef: { current: null },
+    itemMap: /* @__PURE__ */ new Map()
+  }), c = /* @__PURE__ */ f((m) => {
+    const { scope: h, children: I } = m, s = u.useRef(null), l = u.useRef(/* @__PURE__ */ new Map()).current;
+    return /* @__PURE__ */ M(n, {
+      scope: h,
+      itemMap: l,
+      collectionRef: s,
+      children: I
+    });
+  }, "CollectionProvider");
+  c.displayName = e;
+  const a = r + "CollectionSlot", v = z(a), E = u.forwardRef((m, h) => {
+    const { scope: I, children: s } = m, l = i(a, I), p = _(h, l.collectionRef);
+    return /* @__PURE__ */ M(v, {
+      ref: p,
+      children: s
+    });
+  });
+  E.displayName = a;
+  const x = r + "CollectionItemSlot", S = "data-radix-collection-item", A = z(x), d = u.forwardRef((m, h) => {
+    const { scope: I, children: s, ...l } = m, p = u.useRef(null), w = _(h, p), R = i(x, I);
+    return u.useEffect(() => (R.itemMap.set(p, {
+      ref: p,
+      ...l
+    }), () => {
+      R.itemMap.delete(p);
+    })), /* @__PURE__ */ M(A, {
+      [S]: "",
+      ref: w,
+      children: s
+    });
+  });
+  d.displayName = x;
+  function y(m) {
+    const h = i(r + "CollectionConsumer", m);
+    return u.useCallback(() => {
+      const I = h.collectionRef.current;
+      if (!I) return [];
+      const s = Array.from(I.querySelectorAll(`[${S}]`));
+      return Array.from(h.itemMap.values()).sort((l, p) => s.indexOf(l.ref.current) - s.indexOf(p.ref.current));
+    }, [h.collectionRef, h.itemMap]);
+  }
+  return f(y, "useCollection"), [
+    {
+      Provider: c,
+      Slot: E,
+      ItemSlot: d
+    },
+    y,
+    o
+  ];
+}
+f(J, "createCollection");
+var q = /* @__PURE__ */ new WeakMap(), L = class g extends Map {
+  static {
+    f(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[this.#e.indexOf(e)] = e : this.#e.push(e)), super.set(e, t), this;
+  }
+  insert(e, t, o) {
+    const n = this.has(t), i = this.#e.length, c = V(e);
+    let a = c >= 0 ? c : i + c;
+    const v = a < 0 || a >= i ? -1 : a;
+    if (v === this.size || n && v === this.size - 1 || v === -1)
+      return this.set(t, o), this;
+    const E = this.size + (n ? 0 : 1);
+    c < 0 && a++;
+    const x = [...this.#e];
+    let S, A = !1;
+    for (let d = a; d < E; d++) if (a === d) {
+      let y = x[d];
+      x[d] === t && (y = x[d + 1]), n && this.delete(t), S = this.get(y), this.set(t, o);
+    } else {
+      !A && x[d - 1] === t && (A = !0);
+      const y = x[A ? d : d - 1], m = S;
+      S = this.get(y), this.delete(y), this.set(y, m);
+    }
+    return this;
+  }
+  with(e, t, o) {
+    const n = new g(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);
+    return n === -1 ? this : this.insert(n, 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);
+    return n === -1 ? this : this.insert(n + 1, 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 = T(this.#e, e);
+    if (t !== void 0) return this.get(t);
+  }
+  entryAt(e) {
+    const t = T(this.#e, e);
+    if (t !== void 0) return [t, this.get(t)];
+  }
+  indexOf(e) {
+    return this.#e.indexOf(e);
+  }
+  keyAt(e) {
+    return T(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 g(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 g(o);
+  }
+  reduce(...e) {
+    const [t, o] = e;
+    let n = 0, i = o ?? this.at(0);
+    for (const c of this)
+      n === 0 && e.length === 1 ? i = c : i = Reflect.apply(t, this, [
+        i,
+        c,
+        n,
+        this
+      ]), n++;
+    return i;
+  }
+  reduceRight(...e) {
+    const [t, o] = e;
+    let n = o ?? this.at(-1);
+    for (let i = this.size - 1; i >= 0; i--) {
+      const c = this.at(i);
+      i === this.size - 1 && e.length === 1 ? n = c : n = Reflect.apply(t, this, [
+        n,
+        c,
+        i,
+        this
+      ]);
+    }
+    return n;
+  }
+  toSorted(e) {
+    const t = [...this.entries()].sort(e);
+    return new g(t);
+  }
+  toReversed() {
+    const e = new g();
+    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 g(t);
+  }
+  slice(e, t) {
+    const o = new g();
+    let n = this.size - 1;
+    if (e === void 0) return o;
+    e < 0 && (e = e + this.size), t !== void 0 && t > 0 && (n = t - 1);
+    for (let i = e; i <= n; i++) {
+      const c = this.keyAt(i), a = this.get(c);
+      o.set(c, a);
+    }
+    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 T(r, e) {
+  if ("at" in Array.prototype) return Array.prototype.at.call(r, e);
+  const t = F(r, e);
+  return t === -1 ? void 0 : r[t];
+}
+f(T, "at");
+function F(r, e) {
+  const t = r.length, o = V(e), n = o >= 0 ? o : t + o;
+  return n < 0 || n >= t ? -1 : n;
+}
+f(F, "toSafeIndex");
+function V(r) {
+  return r !== r || r === 0 ? 0 : Math.trunc(r);
+}
+f(V, "toSafeInteger");
+// @__NO_SIDE_EFFECTS__
+function Q(r) {
+  const e = r + "CollectionProvider", [t, o] = K(e), [n, i] = t(e, {
+    collectionElement: null,
+    collectionRef: { current: null },
+    collectionRefObject: { current: null },
+    itemMap: new L(),
+    setItemMap: /* @__PURE__ */ f(() => {
+    }, "setItemMap")
+  }), c = /* @__PURE__ */ f(({ state: s, ...l }) => s ? /* @__PURE__ */ M(v, {
+    ...l,
+    state: s
+  }) : /* @__PURE__ */ M(a, { ...l }), "CollectionProvider");
+  c.displayName = e;
+  const a = /* @__PURE__ */ f((s) => {
+    const l = h();
+    return /* @__PURE__ */ M(v, {
+      ...s,
+      state: l
+    });
+  }, "CollectionInit");
+  a.displayName = e + "Init";
+  const v = /* @__PURE__ */ f((s) => {
+    const { scope: l, children: p, state: w } = s, R = u.useRef(null), [P, C] = u.useState(null), k = _(R, C), [b, D] = w;
+    return u.useEffect(() => {
+      if (!P) return;
+      const N = W(() => {
+      });
+      return N.observe(P, {
+        childList: !0,
+        subtree: !0
+      }), () => {
+        N.disconnect();
+      };
+    }, [P]), /* @__PURE__ */ M(n, {
+      scope: l,
+      itemMap: b,
+      setItemMap: D,
+      collectionRef: k,
+      collectionRefObject: R,
+      collectionElement: P,
+      children: p
+    });
+  }, "CollectionProviderImpl");
+  v.displayName = e + "Impl";
+  const E = r + "CollectionSlot", x = z(E), S = u.forwardRef((s, l) => {
+    const { scope: p, children: w } = s, R = i(E, p), P = _(l, R.collectionRef);
+    return /* @__PURE__ */ M(x, {
+      ref: P,
+      children: w
+    });
+  });
+  S.displayName = E;
+  const A = r + "CollectionItemSlot", d = "data-radix-collection-item", y = z(A), m = u.forwardRef((s, l) => {
+    const { scope: p, children: w, ...R } = s, P = u.useRef(null), [C, k] = u.useState(null), b = _(l, P, k), { setItemMap: D } = i(A, p), N = u.useRef(R);
+    G(N.current, R) || (N.current = R);
+    const B = N.current;
+    return u.useEffect(() => {
+      const $ = B;
+      return D((O) => C ? O.has(C) ? O.set(C, {
+        ...$,
+        element: C
+      }).toSorted(j) : (O.set(C, {
+        ...$,
+        element: C
+      }), O.toSorted(j)) : O), () => {
+        D((O) => !C || !O.has(C) ? O : (O.delete(C), new L(O)));
+      };
+    }, [
+      C,
+      B,
+      D
+    ]), /* @__PURE__ */ M(y, {
+      [d]: "",
+      ref: b,
+      children: w
+    });
+  });
+  m.displayName = A;
+  function h() {
+    return u.useState(new L());
+  }
+  f(h, "useInitCollection");
+  function I(s) {
+    const { itemMap: l } = i(r + "CollectionConsumer", s);
+    return l;
+  }
+  return f(I, "useCollection"), [{
+    Provider: c,
+    Slot: S,
+    ItemSlot: m
+  }, {
+    createCollectionScope: o,
+    useCollection: I,
+    useInitCollection: h
+  }];
+}
+f(Q, "createCollection");
+function G(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;
+}
+f(G, "shallowEqual");
+function U(r, e) {
+  return !!(e.compareDocumentPosition(r) & Node.DOCUMENT_POSITION_PRECEDING);
+}
+f(U, "isElementPreceding");
+function j(r, e) {
+  return !r[1].element || !e[1].element ? 0 : U(r[1].element, e[1].element) ? -1 : 1;
+}
+f(j, "sortByDocumentPosition");
+function W(r) {
+  return new MutationObserver((e) => {
+    for (const t of e) if (t.type === "childList") {
+      r();
+      return;
+    }
+  });
+}
+f(W, "getChildListObserver");
+var X = Object.defineProperty, Y = (r, e) => X(r, "name", {
+  value: e,
+  configurable: !0
+}), Z = u.createContext(void 0);
+function ee(r) {
+  const e = u.useContext(Z);
+  return r || e || "ltr";
+}
+Y(ee, "useDirection");
+export {
+  J as n,
+  ee as t
+};