@synnaxlabs/pluto 0.40.1 → 0.41.0

package/dist/external-DHmQqAfL.js

@@ -0,0 +1,435 @@
+import { F as he, a as V } from "./index-CSKP1UPN.js";
+import { A as K } from "./toArray-Dvn9FA_3.js";
+import { j as C } from "./jsx-runtime-C5mzlN2N.js";
+import { y as J, M as me, e as pe, a as ge, f as ye, d as xe } from "./Divider-Bpe7zJig.js";
+import { memo as Ce, useState as Ne, useCallback as N, useMemo as be } from "react";
+import { B as Te, c as ve } from "./Toggle-CZd8L4GI.js";
+import { L as je } from "./Link-BEheZd26.js";
+import { C as f } from "./css-Dyt-QnKy.js";
+import { u as Ie } from "./Haul-Bw54Yj6J.js";
+import { u as Ee, a as $e, C as Y, L as we, S as Le } from "./Text-3PiRcn8q.js";
+import "./Stack-D50qN0Vu.js";
+import { b as Oe } from "./state-CjGemC7S.js";
+import { a as Se, C as _e } from "./ContextMenu-GUed89mt.js";
+import "./aggregator-DMvP8cai.js";
+import { s as Ae } from "./hooks-BQJQyGWV.js";
+const Q = ({
+  className: e,
+  enabledLoc: t,
+  disabledLoc: n,
+  enabled: r,
+  ...s
+}) => /* @__PURE__ */ C.jsx(
+  J.Caret.Up,
+  {
+    className: f(
+      f.B("caret-animated"),
+      f.loc(r ? t : n),
+      e
+    ),
+    ...s
+  }
+), lt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Animated: Q
+}, Symbol.toStringTag, { value: "Module" })), Z = (e, t) => t.includes(e.key), D = (e, t) => he.stringsWithNumbers(e.name, t.name), U = (e, t = D) => {
+  typeof t == "function" && e.sort(t);
+  let n = !1;
+  for (let r = 0; r < e.length; r++) {
+    const s = e[r];
+    s.forcePosition != null && r !== s.forcePosition && (n = !0, e.splice(r, 1), e.splice(s.forcePosition, 0, s));
+  }
+  return n ? U(e, !1) : e;
+}, G = ({
+  nodes: e,
+  expanded: t,
+  depth: n = 0,
+  sort: r,
+  path: s = ""
+}) => {
+  n === 0 && r != !1 && (e = e.sort((l, i) => l.name.localeCompare(i.name)));
+  const a = [];
+  return e.forEach((l, i) => {
+    const d = `${s}${l.key}/`, h = Z(l, t);
+    a.push({ ...l, depth: n, expanded: h, index: i, path: d }), h && l.children != null && (l.children = U(l.children, r), a.push(
+      ...G({
+        nodes: l.children,
+        expanded: t,
+        depth: n + 1,
+        sort: r,
+        path: d
+      })
+    ));
+  }), a;
+}, Pe = ({ tree: e, destination: t, keys: n }) => (n = K(n), t == null ? [...ne({ tree: e, keys: n }), ...e.filter((s) => !n.includes(s.key))] : (n.forEach((r) => {
+  const s = v({ tree: e, key: r });
+  s != null && (ee({ tree: e, keys: r }), te({ tree: e, destination: t, additions: s }));
+}), e)), ee = ({ tree: e, keys: t }) => {
+  t = K(t);
+  const n = e.map((r) => r.key);
+  return t.forEach((r) => {
+    var a;
+    const s = n.indexOf(r);
+    if (s !== -1) e.splice(s, 1);
+    else {
+      const l = _({ tree: e, key: r });
+      l != null && (l.children = (a = l.children) == null ? void 0 : a.filter((i) => i.key !== r));
+    }
+  }), e;
+}, te = ({ tree: e, destination: t, additions: n }) => {
+  n = K(n);
+  const r = V.by(n, (l) => l.key, !1), s = r.map((l) => l.key);
+  if (t == null)
+    return [
+      ...r,
+      ...e.filter((l) => !s.includes(l.key))
+    ];
+  const a = v({ tree: e, key: t });
+  if (a == null) throw new Error(`Could not find node with key ${t}`);
+  return a.children ?? (a.children = []), a.children = [
+    ...r,
+    ...a.children.filter((l) => !s.includes(l.key))
+  ], e;
+}, Me = ({
+  tree: e,
+  key: t,
+  updater: n,
+  throwOnMissing: r = !0
+}) => {
+  var l, i;
+  const s = v({ tree: e, key: t });
+  if (s == null) {
+    if (r) throw new Error(`Could not find node with key ${t}`);
+    return e;
+  }
+  const a = _({ tree: e, key: t });
+  if (a != null) {
+    const d = (l = a.children) == null ? void 0 : l.findIndex((h) => h.key === t);
+    d != null && d !== -1 && ((i = a.children) == null || i.splice(d, 1, n(s)));
+  } else
+    e.splice(
+      e.findIndex((d) => d.key === t),
+      1,
+      n(s)
+    );
+  return e;
+}, Be = ({
+  tree: e,
+  parent: t,
+  updater: n,
+  throwOnMissing: r = !0
+}) => {
+  const s = v({ tree: e, key: t });
+  if (s == null) {
+    if (r) throw new Error(`Could not find node with key ${t}`);
+    return e;
+  }
+  return s.children = n(s.children ?? []), e;
+}, v = ({
+  tree: e,
+  key: t,
+  depth: n = 0
+}) => {
+  for (let r = 0; r < e.length; r++) {
+    const s = e[r];
+    if (s.key === t) {
+      const a = s;
+      return a.depth = n, a.position = r, a;
+    }
+    if (s.children != null) {
+      const a = v({ tree: s.children, key: t, depth: n + 1 });
+      if (a != null) return a;
+    }
+  }
+  return null;
+}, ne = ({ tree: e, keys: t }) => {
+  const n = [];
+  for (const r of t) {
+    const s = v({ tree: e, key: r });
+    s != null && n.push(s);
+  }
+  return n;
+}, _ = ({ tree: e, key: t }) => {
+  for (const n of e)
+    if (n.children != null) {
+      if (n.children.some((s) => s.key === t)) return n;
+      const r = _({ tree: n.children, key: t });
+      if (r != null) return r;
+    }
+  return null;
+}, re = (e) => e.map((t) => ({ ...t, children: re(t.children ?? []) })), se = (...e) => {
+  const t = [];
+  return e.forEach((n) => {
+    t.push(n), n.children != null && t.push(...se(...n.children));
+  }), t;
+}, Re = (e) => {
+  if (e.length === 0) return [];
+  let t = 1 / 0;
+  for (const { depth: n } of e) n < t && (t = n);
+  return e.filter(({ depth: n }) => n === t);
+}, H = "tree-item", ke = [["Shift"]], He = ({
+  onExpand: e,
+  nodes: t,
+  initialExpanded: n = [],
+  sort: r,
+  selected: s,
+  onSelectedChange: a
+}) => {
+  const [l, i, d] = ye(n), [h, b] = Oe({
+    initial: [],
+    value: s,
+    onChange: a
+  }), j = be(
+    () => G({ nodes: t, expanded: l, sort: r }),
+    [t, l, r]
+  ), I = xe(j), O = Ae({ triggers: ke }), S = N(
+    (u, { clicked: c }) => {
+      b(u);
+      const y = I.current.find((x) => x.key === c);
+      if ((y == null ? void 0 : y.hasChildren) === !1 || c == null || O.current.held) return;
+      const m = d.current, $ = m.some((x) => x === c) ? "contract" : "expand";
+      let T;
+      $ === "contract" ? T = m.filter((x) => x !== c) : T = [...m, c], i(T), e == null || e({ current: T, action: $, clicked: c });
+    },
+    [e, I, i, b]
+  ), o = N(
+    (u) => {
+      i((c) => V.unique([...c, u])), e == null || e({ current: l, action: "expand", clicked: u });
+    },
+    [i]
+  ), w = N(
+    (...u) => {
+      i((c) => c.filter((y) => !u.includes(y))), u.forEach((c) => {
+        e == null || e({ current: l, action: "contract", clicked: c });
+      });
+    },
+    [i]
+  ), E = N(() => i([]), [i]);
+  return {
+    onSelect: S,
+    selected: h,
+    expanded: l,
+    contract: w,
+    expand: o,
+    nodes: j,
+    clearExpanded: E
+  };
+}, q = Ce(
+  ({
+    entry: e,
+    selected: t,
+    onSelect: n,
+    onDrop: r,
+    onRename: s,
+    onSuccessfulDrop: a,
+    onDoubleClick: l,
+    loading: i = !1,
+    useMargin: d = !0,
+    translate: h,
+    children: b,
+    index: j,
+    sourceIndex: I,
+    hovered: O,
+    ...S
+  }) => {
+    const {
+      key: o,
+      hasChildren: w = !1,
+      allowRename: E = !1,
+      children: u,
+      icon: c,
+      name: y,
+      depth: m,
+      expanded: $,
+      href: T,
+      haulItems: x = []
+    } = e, { getSelected: le } = Ee(), { getSourceData: ae } = $e(), A = w || u != null && u.length > 0, P = [];
+    A && P.push(
+      /* @__PURE__ */ C.jsx(
+        Q,
+        {
+          enabled: $,
+          enabledLoc: "bottom",
+          disabledLoc: "right"
+        },
+        "caret"
+      )
+    ), c != null && P.push(c);
+    const z = [];
+    i && z.push(
+      /* @__PURE__ */ C.jsx(J.Loading, { className: f.B("loading-indicator") }, "loading-indicator")
+    );
+    const [ie, M] = Ne(!1), { startDrag: F, ...oe } = Ie({
+      type: "Tree.Item",
+      key: o,
+      canDrop: N(({ items: p, source: R }) => {
+        const g = p.map((L) => L.key);
+        return M(!1), R.type === "Tree.Item" && !g.includes(o);
+      }, []),
+      onDrop: N((p) => (r == null ? void 0 : r(o, p)) ?? [], [o, r]),
+      onDragOver: N(() => M(!0), [])
+    }), ce = () => {
+      const p = le(), R = ae().filter(
+        (g) => p.includes(g.key)
+      );
+      if (p.includes(o)) {
+        const g = R.map(({ key: L, haulItems: k, depth: W }) => [
+          { type: H, key: L, data: { depth: W } },
+          ...(k == null ? void 0 : k.map((X) => ({
+            ...X,
+            data: { ...X.data, depth: W }
+          }))) ?? []
+        ]).flat();
+        return F(g, (L) => a == null ? void 0 : a(o, L));
+      }
+      F(
+        [
+          { type: H, key: o, data: { depth: m } },
+          ...x.map((g) => ({ ...g, data: { ...g.data, depth: m } }))
+        ],
+        (g) => a == null ? void 0 : a(o, g)
+      );
+    }, de = d ? "marginLeft" : "paddingLeft";
+    let B = m * 2.5 + 1.5;
+    A && (B -= 0.5);
+    const fe = {
+      id: o,
+      variant: "text",
+      draggable: x.length > 0,
+      className: f(
+        f.BE("list", "item"),
+        Se,
+        ie && f.M("dragging-over"),
+        t && _e,
+        f.selected(t),
+        A && f.M("has-children"),
+        f.BM("depth", m.toString())
+      ),
+      onDragLeave: () => M(!1),
+      onDragStart: ce,
+      onClick: () => n == null ? void 0 : n(o),
+      style: {
+        border: "none",
+        position: h != null ? "absolute" : "relative",
+        transform: `translateY(${h}px)`,
+        [de]: `${B}rem`,
+        // @ts-expect-error - CSS variable
+        "--pluto-tree-indicator-offset": `${B - 1.5}rem`
+      },
+      startIcon: P,
+      iconSpacing: "small",
+      noWrap: !0,
+      endIcon: z,
+      onDoubleClick: (p) => l == null ? void 0 : l(o, p),
+      href: T,
+      ...oe
+    }, ue = T != null ? je : Te;
+    return /* @__PURE__ */ C.jsx(ue, { className: f.BE("list", "item"), ...fe, align: "center", ...S, children: b != null ? b({
+      key: o,
+      loading: i,
+      useMargin: d,
+      onDrop: r,
+      onRename: s,
+      onSuccessfulDrop: a,
+      onDoubleClick: l,
+      entry: e,
+      selected: t,
+      onSelect: n,
+      index: j,
+      sourceIndex: I,
+      hovered: O
+    }) : /* @__PURE__ */ C.jsx(
+      me,
+      {
+        id: `text-${o}`,
+        level: "p",
+        allowDoubleClick: !1,
+        value: y,
+        disabled: !E,
+        onChange: (p) => s == null ? void 0 : s(o, p)
+      }
+    ) });
+  }
+);
+q.displayName = "Tree.Item";
+const Ke = ve(q), Ue = ({
+  nodes: e,
+  selected: t = [],
+  onSelect: n,
+  onDrop: r,
+  onRename: s,
+  onSuccessfulDrop: a,
+  onDoubleClick: l,
+  className: i,
+  children: d = Ke,
+  itemHeight: h = 27,
+  useMargin: b = !1,
+  showRules: j = !1,
+  virtual: I = !0,
+  clearExpanded: O,
+  expand: S,
+  contract: o,
+  emptyContent: w,
+  loading: E,
+  ...u
+}) => {
+  const c = I ? Y.Virtual : Y, y = N(
+    ({ key: m, ...$ }) => d({
+      ...$,
+      key: m,
+      loading: E === m,
+      useMargin: b,
+      onDrop: r,
+      onRename: s,
+      onSuccessfulDrop: a,
+      onDoubleClick: l
+    }),
+    [d, E, r, l, s, a]
+  );
+  return /* @__PURE__ */ C.jsx(we, { data: e, emptyContent: w, children: /* @__PURE__ */ C.jsx(
+    Le,
+    {
+      value: t,
+      onChange: n,
+      allowMultiple: !0,
+      replaceOnSingle: !0,
+      children: /* @__PURE__ */ C.jsx(
+        c,
+        {
+          itemHeight: h,
+          className: f(i, f.B("tree"), j && f.M("rules")),
+          ...u,
+          children: y
+        }
+      )
+    }
+  ) });
+}, Ge = (e, t) => pe(`text-${e}`, t), qe = (e) => ge(`text-${e}`), at = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  DefaultItem: q,
+  HAUL_TYPE: H,
+  Tree: Ue,
+  asyncRename: qe,
+  deepCopy: re,
+  defaultSort: D,
+  findNode: v,
+  findNodeParent: _,
+  findNodes: ne,
+  flatten: G,
+  getAllNodesOfMinDepth: Re,
+  getDescendants: se,
+  moveNode: Pe,
+  removeNode: ee,
+  setNode: te,
+  shouldExpand: Z,
+  sortAndSplice: U,
+  startRenaming: Ge,
+  updateNode: Me,
+  updateNodeChildren: Be,
+  use: He
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  Q as A,
+  lt as a,
+  at as e
+};