@konstructio/ui 0.1.2-alpha.101 → 0.1.2-alpha.104

package/dist/dist-CzKqHuqJ2.js

@@ -0,0 +1,427 @@
+import { a as D, n as z } from "./dist-xCbHbMLA.js";
+import { i as $ } 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] = $(e), [n, i] = t(e, {
+    collectionRef: { current: null },
+    itemMap: /* @__PURE__ */ new Map()
+  }), c = /* @__PURE__ */ f((p) => {
+    const { scope: h, children: I } = p, 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", S = z(a), E = u.forwardRef((p, h) => {
+    const { scope: I, children: s } = p, l = D(h, i(a, I).collectionRef);
+    return /* @__PURE__ */ M(S, {
+      ref: l,
+      children: s
+    });
+  });
+  E.displayName = a;
+  const y = r + "CollectionItemSlot", v = "data-radix-collection-item", A = z(y), d = u.forwardRef((p, h) => {
+    const { scope: I, children: s, ...l } = p, m = u.useRef(null), w = D(h, m), R = i(y, I);
+    return u.useEffect(() => (R.itemMap.set(m, {
+      ref: m,
+      ...l
+    }), () => {
+      R.itemMap.delete(m);
+    })), /* @__PURE__ */ M(A, {
+      [v]: "",
+      ref: w,
+      children: s
+    });
+  });
+  d.displayName = y;
+  function x(p) {
+    const h = i(r + "CollectionConsumer", p);
+    return u.useCallback(() => {
+      const I = h.collectionRef.current;
+      if (!I) return [];
+      const s = Array.from(I.querySelectorAll(`[${v}]`));
+      return Array.from(h.itemMap.values()).sort((l, m) => s.indexOf(l.ref.current) - s.indexOf(m.ref.current));
+    }, [h.collectionRef, h.itemMap]);
+  }
+  return f(x, "useCollection"), [
+    {
+      Provider: c,
+      Slot: E,
+      ItemSlot: d
+    },
+    x,
+    o
+  ];
+}
+f(J, "createCollection");
+var K = /* @__PURE__ */ new WeakMap(), b = class P extends Map {
+  static {
+    f(this, "OrderedDict");
+  }
+  #e;
+  constructor(e) {
+    super(e), this.#e = [...super.keys()], K.set(this, !0);
+  }
+  set(e, t) {
+    return K.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 S = a < 0 || a >= i ? -1 : a;
+    if (S === this.size || n && S === this.size - 1 || S === -1)
+      return this.set(t, o), this;
+    const E = this.size + (n ? 0 : 1);
+    c < 0 && a++;
+    const y = [...this.#e];
+    let v, A = !1;
+    for (let d = a; d < E; d++) if (a === d) {
+      let x = y[d];
+      y[d] === t && (x = y[d + 1]), n && this.delete(t), v = this.get(x), this.set(t, o);
+    } else {
+      !A && y[d - 1] === t && (A = !0);
+      const x = y[A ? d : d - 1], p = v;
+      v = this.get(x), this.delete(x), this.set(x, p);
+    }
+    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);
+    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 = _(this.#e, e);
+    if (t !== void 0) return this.get(t);
+  }
+  entryAt(e) {
+    const t = _(this.#e, e);
+    if (t !== void 0) return [t, this.get(t)];
+  }
+  indexOf(e) {
+    return this.#e.indexOf(e);
+  }
+  keyAt(e) {
+    return _(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;
+    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 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();
+    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 _(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(_, "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] = $(e), [n, i] = t(e, {
+    collectionElement: null,
+    collectionRef: { current: null },
+    collectionRefObject: { current: null },
+    itemMap: new b(),
+    setItemMap: /* @__PURE__ */ f(() => {
+    }, "setItemMap")
+  }), c = /* @__PURE__ */ f(({ state: s, ...l }) => s ? /* @__PURE__ */ M(S, {
+    ...l,
+    state: s
+  }) : /* @__PURE__ */ M(a, { ...l }), "CollectionProvider");
+  c.displayName = e;
+  const a = /* @__PURE__ */ f((s) => {
+    const l = h();
+    return /* @__PURE__ */ M(S, {
+      ...s,
+      state: l
+    });
+  }, "CollectionInit");
+  a.displayName = e + "Init";
+  const S = /* @__PURE__ */ f((s) => {
+    const { scope: l, children: m, state: w } = s, R = u.useRef(null), [N, C] = u.useState(null), k = D(R, C), [L, T] = w;
+    return u.useEffect(() => {
+      if (!N) return;
+      const g = W(() => {
+      });
+      return g.observe(N, {
+        childList: !0,
+        subtree: !0
+      }), () => {
+        g.disconnect();
+      };
+    }, [N]), /* @__PURE__ */ M(n, {
+      scope: l,
+      itemMap: L,
+      setItemMap: T,
+      collectionRef: k,
+      collectionRefObject: R,
+      collectionElement: N,
+      children: m
+    });
+  }, "CollectionProviderImpl");
+  S.displayName = e + "Impl";
+  const E = r + "CollectionSlot", y = z(E), v = u.forwardRef((s, l) => {
+    const { scope: m, children: w } = s, R = D(l, i(E, m).collectionRef);
+    return /* @__PURE__ */ M(y, {
+      ref: R,
+      children: w
+    });
+  });
+  v.displayName = E;
+  const A = r + "CollectionItemSlot", d = "data-radix-collection-item", x = z(A), p = u.forwardRef((s, l) => {
+    const { scope: m, children: w, ...R } = s, N = u.useRef(null), [C, k] = u.useState(null), L = D(l, N, k), { setItemMap: T } = i(A, m), g = u.useRef(R);
+    G(g.current, R) || (g.current = R);
+    const B = g.current;
+    return u.useEffect(() => {
+      const q = B;
+      return T((O) => C ? O.has(C) ? O.set(C, {
+        ...q,
+        element: C
+      }).toSorted(j) : (O.set(C, {
+        ...q,
+        element: C
+      }), O.toSorted(j)) : O), () => {
+        T((O) => !C || !O.has(C) ? O : (O.delete(C), new b(O)));
+      };
+    }, [
+      C,
+      B,
+      T
+    ]), /* @__PURE__ */ M(x, {
+      [d]: "",
+      ref: L,
+      children: w
+    });
+  });
+  p.displayName = A;
+  function h() {
+    return u.useState(new b());
+  }
+  f(h, "useInitCollection");
+  function I(s) {
+    const { itemMap: l } = i(r + "CollectionConsumer", s);
+    return l;
+  }
+  return f(I, "useCollection"), [{
+    Provider: c,
+    Slot: v,
+    ItemSlot: p
+  }, {
+    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");
+export {
+  J as t
+};

package/dist/dist-D-yS0HN8.js

@@ -0,0 +1,228 @@
+import * as r from "react";
+import { jsx as P } from "react/jsx-runtime";
+var N = Object.defineProperty, f = (e, t) => N(e, "name", {
+  value: t,
+  configurable: !0
+});
+// @__NO_SIDE_EFFECTS__
+function T(e, t) {
+  const n = r.createContext(t);
+  n.displayName = e + "Context";
+  const i = /* @__PURE__ */ f((c) => {
+    const { children: s, ...u } = c, l = r.useMemo(() => u, Object.values(u));
+    return /* @__PURE__ */ P(n.Provider, {
+      value: l,
+      children: s
+    });
+  }, "Provider");
+  i.displayName = e + "Provider";
+  function o(c, s = {}) {
+    const { optional: u = !1 } = s, l = r.useContext(n);
+    if (l) return l;
+    if (t !== void 0) return t;
+    if (!u)
+      throw new Error(`\`${c}\` must be used within \`${e}\``);
+  }
+  return f(o, "useContext"), [i, o];
+}
+f(T, "createContext");
+// @__NO_SIDE_EFFECTS__
+function U(e, t = []) {
+  let n = [];
+  function i(c, s) {
+    const u = r.createContext(s);
+    u.displayName = c + "Context";
+    const l = n.length;
+    n = [...n, s];
+    const a = /* @__PURE__ */ f((m) => {
+      const { scope: w, children: v, ...p } = m, h = w?.[e]?.[l] || u, C = r.useMemo(() => p, Object.values(p));
+      return /* @__PURE__ */ P(h.Provider, {
+        value: C,
+        children: v
+      });
+    }, "Provider");
+    a.displayName = c + "Provider";
+    function d(m, w, v = {}) {
+      const { optional: p = !1 } = v, h = w?.[e]?.[l] || u, C = r.useContext(h);
+      if (C) return C;
+      if (s !== void 0) return s;
+      if (!p)
+        throw new Error(`\`${m}\` must be used within \`${c}\``);
+    }
+    return f(d, "useContext"), [a, d];
+  }
+  f(i, "createContext");
+  const o = /* @__PURE__ */ f(() => {
+    const c = n.map((s) => r.createContext(s));
+    return /* @__PURE__ */ f(function(u) {
+      const l = u?.[e] || c;
+      return r.useMemo(() => ({ [`__scope${e}`]: {
+        ...u,
+        [e]: l
+      } }), [u, l]);
+    }, "useScope");
+  }, "createScope");
+  return o.scopeName = e, [i, y(o, ...t)];
+}
+f(U, "createContextScope");
+function y(...e) {
+  const t = e[0];
+  if (e.length === 1) return t;
+  const n = /* @__PURE__ */ f(() => {
+    const i = e.map((o) => ({
+      useScope: o(),
+      scopeName: o.scopeName
+    }));
+    return /* @__PURE__ */ f(function(c) {
+      const s = i.reduce((u, { useScope: l, scopeName: a }) => {
+        const d = l(c)[`__scope${a}`];
+        return {
+          ...u,
+          ...d
+        };
+      }, {});
+      return r.useMemo(() => ({ [`__scope${t.scopeName}`]: s }), [s]);
+    }, "useComposedScopes");
+  }, "createScope");
+  return n.scopeName = t.scopeName, n;
+}
+f(y, "composeContextScopes");
+var H = Object.defineProperty, E = (e, t) => H(e, "name", {
+  value: t,
+  configurable: !0
+}), O = !!(typeof window < "u" && window.document && window.document.createElement);
+function B(e, t, { checkForDefaultPrevented: n = !0 } = {}) {
+  return /* @__PURE__ */ E(function(o) {
+    if (e?.(o), n === !1 || !o || !o.defaultPrevented) return t?.(o);
+  }, "handleEvent");
+}
+E(B, "composeEventHandlers");
+function L(e) {
+  if (!O) throw new Error("Cannot access window outside of the DOM");
+  return e?.ownerDocument?.defaultView ?? window;
+}
+E(L, "getOwnerWindow");
+function x(e) {
+  if (!O) throw new Error("Cannot access document outside of the DOM");
+  return e?.ownerDocument ?? document;
+}
+E(x, "getOwnerDocument");
+function D(e, t = !1) {
+  const { activeElement: n } = x(e);
+  if (!n?.nodeName) return null;
+  if (M(n) && n.contentDocument) return D(n.contentDocument.body, t);
+  if (t) {
+    const i = n.getAttribute("aria-activedescendant");
+    if (i) {
+      const o = x(n).getElementById(i);
+      if (o) return o;
+    }
+  }
+  return n;
+}
+E(D, "getActiveElement");
+function M(e) {
+  return e.tagName === "IFRAME";
+}
+E(M, "isFrame");
+var j = globalThis?.document ? r.useLayoutEffect : () => {
+}, W = Object.defineProperty, Y = (e, t) => W(e, "name", {
+  value: t,
+  configurable: !0
+}), $ = r[" useEffectEvent ".trim().toString()], b = r[" useInsertionEffect ".trim().toString()];
+function A(e) {
+  if (typeof $ == "function") return $(e);
+  const t = r.useRef(() => {
+    throw new Error("Cannot call an event handler while rendering.");
+  });
+  return typeof b == "function" ? b(() => {
+    t.current = e;
+  }) : j(() => {
+    t.current = e;
+  }), r.useMemo(() => ((...n) => t.current?.(...n)), []);
+}
+Y(A, "useEffectEvent");
+var V = Object.defineProperty, S = (e, t) => V(e, "name", {
+  value: t,
+  configurable: !0
+}), X = r[" useInsertionEffect ".trim().toString()] || j;
+function k({ prop: e, defaultProp: t, onChange: n = /* @__PURE__ */ S(() => {
+}, "onChange"), caller: i }) {
+  const [o, c, s] = I({
+    defaultProp: t,
+    onChange: n
+  }), u = e !== void 0;
+  return [u ? e : o, r.useCallback((a) => {
+    if (u) {
+      const d = F(a) ? a(e) : a;
+      d !== e && s.current?.(d);
+    } else c(a);
+  }, [
+    u,
+    e,
+    c,
+    s
+  ])];
+}
+S(k, "useControllableState");
+function I({ defaultProp: e, onChange: t }) {
+  const [n, i] = r.useState(e), o = r.useRef(n), c = r.useRef(t);
+  return X(() => {
+    c.current = t;
+  }, [t]), r.useEffect(() => {
+    o.current !== n && (c.current?.(n), o.current = n);
+  }, [n, o]), [
+    n,
+    i,
+    c
+  ];
+}
+S(I, "useUncontrolledState");
+function F(e) {
+  return typeof e == "function";
+}
+S(F, "isFunction");
+var _ = /* @__PURE__ */ Symbol("RADIX:SYNC_STATE");
+function q(e, t, n, i) {
+  const { prop: o, defaultProp: c, onChange: s, caller: u } = t, l = o !== void 0, a = A(s), d = [{
+    ...n,
+    state: c
+  }];
+  i && d.push(i);
+  const [m, w] = r.useReducer((C, g) => {
+    if (g.type === _) return {
+      ...C,
+      state: g.state
+    };
+    const R = e(C, g);
+    return l && !Object.is(R.state, C.state) && a(R.state), R;
+  }, ...d), v = m.state, p = r.useRef(v);
+  r.useEffect(() => {
+    p.current !== v && (p.current = v, l || a(v));
+  }, [
+    v,
+    p,
+    l
+  ]);
+  const h = r.useMemo(() => o !== void 0 ? {
+    ...m,
+    state: o
+  } : m, [m, o]);
+  return r.useEffect(() => {
+    l && !Object.is(o, m.state) && w({
+      type: _,
+      state: o
+    });
+  }, [
+    o,
+    m.state,
+    l
+  ]), [h, w];
+}
+S(q, "useControllableStateReducer");
+export {
+  U as i,
+  j as n,
+  B as r,
+  k as t
+};

package/dist/dist-D5XYRjmR.js

@@ -0,0 +1,15 @@
+import * as t from "react";
+var f = Object.defineProperty, u = (e, r) => f(e, "name", {
+  value: r,
+  configurable: !0
+});
+function c(e) {
+  const r = t.useRef(e);
+  return t.useEffect(() => {
+    r.current = e;
+  }), t.useMemo(() => ((...a) => r.current?.(...a)), []);
+}
+u(c, "useCallbackRef");
+export {
+  c as t
+};