@spear-ai/spectral 1.3.62 → 1.3.63

package/dist/index-B2oBi8ng.js

@@ -0,0 +1,142 @@
+import "./styles/main.css";
+import * as r from "react";
+import { a as T, P as m, b as h, h as k, d as M } from "./index-BhufZRa2.js";
+import { u as b } from "./index-0ioNhtNM.js";
+import { jsx as P } from "react/jsx-runtime";
+import U from "react-dom";
+function z(n, e = globalThis?.document) {
+  const t = b(n);
+  r.useEffect(() => {
+    const i = (s) => {
+      s.key === "Escape" && t(s);
+    };
+    return e.addEventListener("keydown", i, { capture: !0 }), () => e.removeEventListener("keydown", i, { capture: !0 });
+  }, [t, e]);
+}
+var H = "DismissableLayer", p = "dismissableLayer.update", K = "dismissableLayer.pointerDownOutside", j = "dismissableLayer.focusOutside", R, B = r.createContext({
+  layers: /* @__PURE__ */ new Set(),
+  layersWithOutsidePointerEventsDisabled: /* @__PURE__ */ new Set(),
+  branches: /* @__PURE__ */ new Set()
+}), X = r.forwardRef(
+  (n, e) => {
+    const {
+      disableOutsidePointerEvents: t = !1,
+      onEscapeKeyDown: i,
+      onPointerDownOutside: s,
+      onFocusOutside: a,
+      onInteractOutside: d,
+      onDismiss: l,
+      ...E
+    } = n, c = r.useContext(B), [u, F] = r.useState(null), f = u?.ownerDocument ?? globalThis?.document, [, I] = r.useState({}), S = T(e, (o) => F(o)), D = Array.from(c.layers), [A] = [...c.layersWithOutsidePointerEventsDisabled].slice(-1), N = D.indexOf(A), O = u ? D.indexOf(u) : -1, W = c.layersWithOutsidePointerEventsDisabled.size > 0, L = O >= N, _ = G((o) => {
+      const v = o.target, w = [...c.branches].some((y) => y.contains(v));
+      !L || w || (s?.(o), d?.(o), o.defaultPrevented || l?.());
+    }, f), C = J((o) => {
+      const v = o.target;
+      [...c.branches].some((y) => y.contains(v)) || (a?.(o), d?.(o), o.defaultPrevented || l?.());
+    }, f);
+    return z((o) => {
+      O === c.layers.size - 1 && (i?.(o), !o.defaultPrevented && l && (o.preventDefault(), l()));
+    }, f), r.useEffect(() => {
+      if (u)
+        return t && (c.layersWithOutsidePointerEventsDisabled.size === 0 && (R = f.body.style.pointerEvents, f.body.style.pointerEvents = "none"), c.layersWithOutsidePointerEventsDisabled.add(u)), c.layers.add(u), g(), () => {
+          t && c.layersWithOutsidePointerEventsDisabled.size === 1 && (f.body.style.pointerEvents = R);
+        };
+    }, [u, f, t, c]), r.useEffect(() => () => {
+      u && (c.layers.delete(u), c.layersWithOutsidePointerEventsDisabled.delete(u), g());
+    }, [u, c]), r.useEffect(() => {
+      const o = () => I({});
+      return document.addEventListener(p, o), () => document.removeEventListener(p, o);
+    }, []), /* @__PURE__ */ P(
+      m.div,
+      {
+        ...E,
+        ref: S,
+        style: {
+          pointerEvents: W ? L ? "auto" : "none" : void 0,
+          ...n.style
+        },
+        onFocusCapture: h(n.onFocusCapture, C.onFocusCapture),
+        onBlurCapture: h(n.onBlurCapture, C.onBlurCapture),
+        onPointerDownCapture: h(
+          n.onPointerDownCapture,
+          _.onPointerDownCapture
+        )
+      }
+    );
+  }
+);
+X.displayName = H;
+var Y = "DismissableLayerBranch", q = r.forwardRef((n, e) => {
+  const t = r.useContext(B), i = r.useRef(null), s = T(e, i);
+  return r.useEffect(() => {
+    const a = i.current;
+    if (a)
+      return t.branches.add(a), () => {
+        t.branches.delete(a);
+      };
+  }, [t.branches]), /* @__PURE__ */ P(m.div, { ...n, ref: s });
+});
+q.displayName = Y;
+function G(n, e = globalThis?.document) {
+  const t = b(n), i = r.useRef(!1), s = r.useRef(() => {
+  });
+  return r.useEffect(() => {
+    const a = (l) => {
+      if (l.target && !i.current) {
+        let E = function() {
+          x(
+            K,
+            t,
+            c,
+            { discrete: !0 }
+          );
+        };
+        const c = { originalEvent: l };
+        l.pointerType === "touch" ? (e.removeEventListener("click", s.current), s.current = E, e.addEventListener("click", s.current, { once: !0 })) : E();
+      } else
+        e.removeEventListener("click", s.current);
+      i.current = !1;
+    }, d = window.setTimeout(() => {
+      e.addEventListener("pointerdown", a);
+    }, 0);
+    return () => {
+      window.clearTimeout(d), e.removeEventListener("pointerdown", a), e.removeEventListener("click", s.current);
+    };
+  }, [e, t]), {
+    // ensures we check React component tree (not just DOM tree)
+    onPointerDownCapture: () => i.current = !0
+  };
+}
+function J(n, e = globalThis?.document) {
+  const t = b(n), i = r.useRef(!1);
+  return r.useEffect(() => {
+    const s = (a) => {
+      a.target && !i.current && x(j, t, { originalEvent: a }, {
+        discrete: !1
+      });
+    };
+    return e.addEventListener("focusin", s), () => e.removeEventListener("focusin", s);
+  }, [e, t]), {
+    onFocusCapture: () => i.current = !0,
+    onBlurCapture: () => i.current = !1
+  };
+}
+function g() {
+  const n = new CustomEvent(p);
+  document.dispatchEvent(n);
+}
+function x(n, e, t, { discrete: i }) {
+  const s = t.originalEvent.target, a = new CustomEvent(n, { bubbles: !1, cancelable: !0, detail: t });
+  e && s.addEventListener(n, e, { once: !0 }), i ? k(s, a) : s.dispatchEvent(a);
+}
+var Q = "Portal", V = r.forwardRef((n, e) => {
+  const { container: t, ...i } = n, [s, a] = r.useState(!1);
+  M(() => a(!0), []);
+  const d = t || s && globalThis?.document?.body;
+  return d ? U.createPortal(/* @__PURE__ */ P(m.div, { ...i, ref: e }), d) : null;
+});
+V.displayName = Q;
+export {
+  X as D,
+  V as P
+};

package/dist/index-BIpuW_o8.js

@@ -0,0 +1,146 @@
+import "./styles/main.css";
+import { jsx as w, Fragment as N } from "react/jsx-runtime";
+import * as v from "react";
+import { useId as T, useRef as P, useContext as D, useInsertionEffect as S, useMemo as $, Children as U, isValidElement as V, useState as z } from "react";
+import { M as X, i as _, u as W, P as B, a as F, b as G, L as O } from "./proxy-C9AqCss6.js";
+function A(e, s) {
+  if (typeof e == "function")
+    return e(s);
+  e != null && (e.current = s);
+}
+function Y(...e) {
+  return (s) => {
+    let t = !1;
+    const o = e.map((r) => {
+      const n = A(r, s);
+      return !t && typeof n == "function" && (t = !0), n;
+    });
+    if (t)
+      return () => {
+        for (let r = 0; r < o.length; r++) {
+          const n = o[r];
+          typeof n == "function" ? n() : A(e[r], null);
+        }
+      };
+  };
+}
+function q(...e) {
+  return v.useCallback(Y(...e), e);
+}
+class J extends v.Component {
+  getSnapshotBeforeUpdate(s) {
+    const t = this.props.childRef.current;
+    if (t && s.isPresent && !this.props.isPresent) {
+      const o = t.offsetParent, r = _(o) && o.offsetWidth || 0, n = this.props.sizeRef.current;
+      n.height = t.offsetHeight || 0, n.width = t.offsetWidth || 0, n.top = t.offsetTop, n.left = t.offsetLeft, n.right = r - n.width - n.left;
+    }
+    return null;
+  }
+  /**
+   * Required with getSnapshotBeforeUpdate to stop React complaining.
+   */
+  componentDidUpdate() {
+  }
+  render() {
+    return this.props.children;
+  }
+}
+function Q({ children: e, isPresent: s, anchorX: t, root: o }) {
+  const r = T(), n = P(null), p = P({
+    width: 0,
+    height: 0,
+    top: 0,
+    left: 0,
+    right: 0
+  }), { nonce: C } = D(X), x = q(n, e?.ref);
+  return S(() => {
+    const { width: i, height: g, top: c, left: u, right: a } = p.current;
+    if (s || !n.current || !i || !g)
+      return;
+    const h = t === "left" ? `left: ${u}` : `right: ${a}`;
+    n.current.dataset.motionPopId = r;
+    const l = document.createElement("style");
+    C && (l.nonce = C);
+    const R = o ?? document.head;
+    return R.appendChild(l), l.sheet && l.sheet.insertRule(`
+          [data-motion-pop-id="${r}"] {
+            position: absolute !important;
+            width: ${i}px !important;
+            height: ${g}px !important;
+            ${h}px !important;
+            top: ${c}px !important;
+          }
+        `), () => {
+      R.contains(l) && R.removeChild(l);
+    };
+  }, [s]), w(J, { isPresent: s, childRef: n, sizeRef: p, children: v.cloneElement(e, { ref: x }) });
+}
+const Z = ({ children: e, initial: s, isPresent: t, onExitComplete: o, custom: r, presenceAffectsLayout: n, mode: p, anchorX: C, root: x }) => {
+  const i = W(ee), g = T();
+  let c = !0, u = $(() => (c = !1, {
+    id: g,
+    initial: s,
+    isPresent: t,
+    custom: r,
+    onExitComplete: (a) => {
+      i.set(a, !0);
+      for (const h of i.values())
+        if (!h)
+          return;
+      o && o();
+    },
+    register: (a) => (i.set(a, !1), () => i.delete(a))
+  }), [t, i, o]);
+  return n && c && (u = { ...u }), $(() => {
+    i.forEach((a, h) => i.set(h, !1));
+  }, [t]), v.useEffect(() => {
+    !t && !i.size && o && o();
+  }, [t]), p === "popLayout" && (e = w(Q, { isPresent: t, anchorX: C, root: x, children: e })), w(B.Provider, { value: u, children: e });
+};
+function ee() {
+  return /* @__PURE__ */ new Map();
+}
+const E = (e) => e.key || "";
+function I(e) {
+  const s = [];
+  return U.forEach(e, (t) => {
+    V(t) && s.push(t);
+  }), s;
+}
+const oe = ({ children: e, custom: s, initial: t = !0, onExitComplete: o, presenceAffectsLayout: r = !0, mode: n = "sync", propagate: p = !1, anchorX: C = "left", root: x }) => {
+  const [i, g] = F(p), c = $(() => I(e), [e]), u = p && !i ? [] : c.map(E), a = P(!0), h = P(c), l = W(() => /* @__PURE__ */ new Map()), [R, j] = z(c), [m, b] = z(c);
+  G(() => {
+    a.current = !1, h.current = c;
+    for (let d = 0; d < m.length; d++) {
+      const f = E(m[d]);
+      u.includes(f) ? l.delete(f) : l.get(f) !== !0 && l.set(f, !1);
+    }
+  }, [m, u.length, u.join("-")]);
+  const M = [];
+  if (c !== R) {
+    let d = [...c];
+    for (let f = 0; f < m.length; f++) {
+      const y = m[f], L = E(y);
+      u.includes(L) || (d.splice(f, 0, y), M.push(y));
+    }
+    return n === "wait" && M.length && (d = M), b(I(d)), j(c), null;
+  }
+  process.env.NODE_ENV !== "production" && n === "wait" && m.length > 1 && console.warn(`You're attempting to animate multiple children within AnimatePresence, but its mode is set to "wait". This will lead to odd visual behaviour.`);
+  const { forceRender: H } = D(O);
+  return w(N, { children: m.map((d) => {
+    const f = E(d), y = p && !i ? !1 : c === m || u.includes(f), L = () => {
+      if (l.has(f))
+        l.set(f, !0);
+      else
+        return;
+      let k = !0;
+      l.forEach((K) => {
+        K || (k = !1);
+      }), k && (H?.(), b(h.current), p && g?.(), o && o());
+    };
+    return w(Z, { isPresent: y, initial: !a.current || t ? void 0 : !1, custom: s, presenceAffectsLayout: r, mode: n, root: x, onExitComplete: y ? void 0 : L, anchorX: C, children: d }, f);
+  }) });
+};
+export {
+  oe as A
+};

package/dist/index-BZPx6jYI.js

@@ -0,0 +1,8 @@
+import * as u from "react";
+function t(r) {
+  const e = u.useRef({ value: r, previous: r });
+  return u.useMemo(() => (e.current.value !== r && (e.current.previous = e.current.value, e.current.value = r), e.current.previous), [r]);
+}
+export {
+  t as u
+};

package/dist/index-BhufZRa2.js

@@ -0,0 +1,232 @@
+import "./styles/main.css";
+import * as s from "react";
+import { jsx as p, Fragment as x } from "react/jsx-runtime";
+import * as g from "react-dom";
+function W(e, t) {
+  const n = s.createContext(t), c = (r) => {
+    const { children: u, ...i } = r, l = s.useMemo(() => i, Object.values(i));
+    return /* @__PURE__ */ p(n.Provider, { value: l, children: u });
+  };
+  c.displayName = e + "Provider";
+  function o(r) {
+    const u = s.useContext(n);
+    if (u) return u;
+    if (t !== void 0) return t;
+    throw new Error(`\`${r}\` must be used within \`${e}\``);
+  }
+  return [c, o];
+}
+function A(e, t = []) {
+  let n = [];
+  function c(r, u) {
+    const i = s.createContext(u), l = n.length;
+    n = [...n, u];
+    const f = (a) => {
+      const { scope: v, children: C, ...m } = a, E = v?.[e]?.[l] || i, b = s.useMemo(() => m, Object.values(m));
+      return /* @__PURE__ */ p(E.Provider, { value: b, children: C });
+    };
+    f.displayName = r + "Provider";
+    function d(a, v) {
+      const C = v?.[e]?.[l] || i, m = s.useContext(C);
+      if (m) return m;
+      if (u !== void 0) return u;
+      throw new Error(`\`${a}\` must be used within \`${r}\``);
+    }
+    return [f, d];
+  }
+  const o = () => {
+    const r = n.map((u) => s.createContext(u));
+    return function(i) {
+      const l = i?.[e] || r;
+      return s.useMemo(
+        () => ({ [`__scope${e}`]: { ...i, [e]: l } }),
+        [i, l]
+      );
+    };
+  };
+  return o.scopeName = e, [c, P(o, ...t)];
+}
+function P(...e) {
+  const t = e[0];
+  if (e.length === 1) return t;
+  const n = () => {
+    const c = e.map((o) => ({
+      useScope: o(),
+      scopeName: o.scopeName
+    }));
+    return function(r) {
+      const u = c.reduce((i, { useScope: l, scopeName: f }) => {
+        const a = l(r)[`__scope${f}`];
+        return { ...i, ...a };
+      }, {});
+      return s.useMemo(() => ({ [`__scope${t.scopeName}`]: u }), [u]);
+    };
+  };
+  return n.scopeName = t.scopeName, n;
+}
+function h(e, t) {
+  if (typeof e == "function")
+    return e(t);
+  e != null && (e.current = t);
+}
+function S(...e) {
+  return (t) => {
+    let n = !1;
+    const c = e.map((o) => {
+      const r = h(o, t);
+      return !n && typeof r == "function" && (n = !0), r;
+    });
+    if (n)
+      return () => {
+        for (let o = 0; o < c.length; o++) {
+          const r = c[o];
+          typeof r == "function" ? r() : h(e[o], null);
+        }
+      };
+  };
+}
+function F(...e) {
+  return s.useCallback(S(...e), e);
+}
+// @__NO_SIDE_EFFECTS__
+function R(e) {
+  const t = /* @__PURE__ */ w(e), n = s.forwardRef((c, o) => {
+    const { children: r, ...u } = c, i = s.Children.toArray(r), l = i.find($);
+    if (l) {
+      const f = l.props.children, d = i.map((a) => a === l ? s.Children.count(f) > 1 ? s.Children.only(null) : s.isValidElement(f) ? f.props.children : null : a);
+      return /* @__PURE__ */ p(t, { ...u, ref: o, children: s.isValidElement(f) ? s.cloneElement(f, void 0, d) : null });
+    }
+    return /* @__PURE__ */ p(t, { ...u, ref: o, children: r });
+  });
+  return n.displayName = `${e}.Slot`, n;
+}
+// @__NO_SIDE_EFFECTS__
+function w(e) {
+  const t = s.forwardRef((n, c) => {
+    const { children: o, ...r } = n;
+    if (s.isValidElement(o)) {
+      const u = N(o), i = _(r, o.props);
+      return o.type !== s.Fragment && (i.ref = c ? S(c, u) : u), s.cloneElement(o, i);
+    }
+    return s.Children.count(o) > 1 ? s.Children.only(null) : null;
+  });
+  return t.displayName = `${e}.SlotClone`, t;
+}
+var y = Symbol("radix.slottable");
+// @__NO_SIDE_EFFECTS__
+function H(e) {
+  const t = ({ children: n }) => /* @__PURE__ */ p(x, { children: n });
+  return t.displayName = `${e}.Slottable`, t.__radixId = y, t;
+}
+function $(e) {
+  return s.isValidElement(e) && typeof e.type == "function" && "__radixId" in e.type && e.type.__radixId === y;
+}
+function _(e, t) {
+  const n = { ...t };
+  for (const c in t) {
+    const o = e[c], r = t[c];
+    /^on[A-Z]/.test(c) ? o && r ? n[c] = (...i) => {
+      const l = r(...i);
+      return o(...i), l;
+    } : o && (n[c] = o) : c === "style" ? n[c] = { ...o, ...r } : c === "className" && (n[c] = [o, r].filter(Boolean).join(" "));
+  }
+  return { ...e, ...n };
+}
+function N(e) {
+  let t = Object.getOwnPropertyDescriptor(e.props, "ref")?.get, n = t && "isReactWarning" in t && t.isReactWarning;
+  return n ? e.ref : (t = Object.getOwnPropertyDescriptor(e, "ref")?.get, n = t && "isReactWarning" in t && t.isReactWarning, n ? e.props.ref : e.props.ref || e.ref);
+}
+function L(e, t, { checkForDefaultPrevented: n = !0 } = {}) {
+  return function(o) {
+    if (e?.(o), n === !1 || !o.defaultPrevented)
+      return t?.(o);
+  };
+}
+var O = globalThis?.document ? s.useLayoutEffect : () => {
+}, I = s[" useInsertionEffect ".trim().toString()] || O;
+function T({
+  prop: e,
+  defaultProp: t,
+  onChange: n = () => {
+  },
+  caller: c
+}) {
+  const [o, r, u] = D({
+    defaultProp: t,
+    onChange: n
+  }), i = e !== void 0, l = i ? e : o;
+  {
+    const d = s.useRef(e !== void 0);
+    s.useEffect(() => {
+      const a = d.current;
+      a !== i && console.warn(
+        `${c} is changing from ${a ? "controlled" : "uncontrolled"} to ${i ? "controlled" : "uncontrolled"}. Components should not switch from controlled to uncontrolled (or vice versa). Decide between using a controlled or uncontrolled value for the lifetime of the component.`
+      ), d.current = i;
+    }, [i, c]);
+  }
+  const f = s.useCallback(
+    (d) => {
+      if (i) {
+        const a = j(d) ? d(e) : d;
+        a !== e && u.current?.(a);
+      } else
+        r(d);
+    },
+    [i, e, r, u]
+  );
+  return [l, f];
+}
+function D({
+  defaultProp: e,
+  onChange: t
+}) {
+  const [n, c] = s.useState(e), o = s.useRef(n), r = s.useRef(t);
+  return I(() => {
+    r.current = t;
+  }, [t]), s.useEffect(() => {
+    o.current !== n && (r.current?.(n), o.current = n);
+  }, [n, o]), [n, c, r];
+}
+function j(e) {
+  return typeof e == "function";
+}
+var V = [
+  "a",
+  "button",
+  "div",
+  "form",
+  "h2",
+  "h3",
+  "img",
+  "input",
+  "label",
+  "li",
+  "nav",
+  "ol",
+  "p",
+  "select",
+  "span",
+  "svg",
+  "ul"
+], k = V.reduce((e, t) => {
+  const n = /* @__PURE__ */ R(`Primitive.${t}`), c = s.forwardRef((o, r) => {
+    const { asChild: u, ...i } = o, l = u ? n : t;
+    return typeof window < "u" && (window[Symbol.for("radix-ui")] = !0), /* @__PURE__ */ p(l, { ...i, ref: r });
+  });
+  return c.displayName = `Primitive.${t}`, { ...e, [t]: c };
+}, {});
+function B(e, t) {
+  e && g.flushSync(() => e.dispatchEvent(t));
+}
+export {
+  k as P,
+  F as a,
+  L as b,
+  A as c,
+  O as d,
+  R as e,
+  H as f,
+  W as g,
+  B as h,
+  T as u
+};