@pantograph/vue 0.25.8 → 0.27.0

package/dist/Tree.vue_vue_type_script_setup_true_lang-Drf23Cl_.js

@@ -0,0 +1,726 @@
+import { defineComponent as Be, useSlots as De, computed as y, createElementBlock as Se, openBlock as te, normalizeClass as Z, unref as i, createCommentVNode as _e, createVNode as Fe, createBlock as Ie, renderSlot as Re, withModifiers as Ve, withCtx as et, normalizeProps as Le, guardReactiveProps as Ee, createElementVNode as Me, toDisplayString as tt, Fragment as at, ref as Y, watch as ue, nextTick as rt, onMounted as lt, onBeforeUnmount as nt, h as ge, render as ot } from "vue";
+import { generateVariantClassList as G, normCls as je, getBemElement as F, getBemBlock as st, createOptionGetterFunc as D, getBemModifier as it, usePCId as ct } from "@pantograph/utils";
+import { cva as Ge } from "class-variance-authority";
+import { isString as dt, uniq as xe, flattenDeep as ut, last as pe, cloneDeep as Ue, isEqual as Ae, omit as gt, isFunction as Oe } from "es-toolkit";
+import pt from "@pantograph/sortable";
+import { createContext as ft } from "reka-ui";
+import { a as qe } from "./options-J8HfRMSU.js";
+import "@pantograph/tokens";
+import { e as ht, y as mt, t as yt, u as vt, q as bt, g as kt } from "./Icon.vue_vue_type_script_setup_true_lang-X8iOewkh.js";
+import "@vueuse/core";
+import "@tanstack/vue-virtual";
+import { _ as We } from "./IndentLevel.vue_vue_type_script_setup_true_lang-DVDr7sdq.js";
+import { _ as _t } from "./Checkbox.vue_vue_type_script_setup_true_lang-CgvdLwu5.js";
+import { u as St } from "./ConfigProvider.vue_vue_type_script_setup_true_lang-DiuPi_DT.js";
+import { _ as It } from "./ScrollContainer.vue_vue_type_script_setup_true_lang-BmQrQlax.js";
+import { u as xt } from "./useInputDataStates-Db6zJZ1T.js";
+import { u as Ct } from "./useVirtualScroll-CXkmR_v2.js";
+import Bt from "@pantograph/style/tree.css?raw";
+const wt = ["sm", "md", "lg"], $e = { none: "gap-none", sm: "gap-sm", md: "gap-md", lg: "gap-lg" }, [Kt, zt] = ft("Tree"), Tt = ["data-key", "data-level", "data-draggable", "tabindex"], Nt = /* @__PURE__ */ Be({
+  ...qe("TreeNode"),
+  __name: "TreeNode",
+  props: {
+    node: {}
+  },
+  setup(P) {
+    const d = P;
+    De();
+    const l = Kt(), e = Ge(l.prefixes.node, {
+      variants: {
+        disabled: G("disabled", l.prefixes.node),
+        active: G("active", l.prefixes.node)
+      }
+    }), p = (v) => l.getNodeChildren(v, !0, !1), T = y(() => p(d.node)), b = y(() => l.props.draggable ? d.node._draggable ?? !0 : !1), k = y(() => !!(l.disabled.value || d.node._disabled)), L = y(() => d.node._dragging ?? !1), _ = y(
+      () => !L.value && l.expandedKeys.value.includes(d.node._key)
+    ), w = y(() => !L.value && !l.dragging.value && l.props.showLine ? C.value ? "all" : "before" : !1), S = y(() => l.getIsSelected(d.node)), x = y(() => l.getIsChecked(d.node)), ae = (v) => l.onCheck(d.node, !!v), E = y(() => l.getLevel(d.node)), C = y(
+      () => {
+        var v, a;
+        return !!((v = T.value) != null && v.length || (a = l.props) != null && a.lazyLoad && !d.node._leaf);
+      }
+    ), B = y(() => ({
+      ...d.node,
+      selected: S.value,
+      checked: x.value,
+      disabled: k.value,
+      expanded: _.value,
+      unFocusable: !0
+    })), U = () => {
+      k.value || l.onSelect(d.node, !S.value);
+    };
+    return (v, a) => {
+      var s, c, f, h, K, m, q;
+      return te(), Se("div", {
+        "data-key": (s = i(l).props) != null && s.draggable ? v.node._key : void 0,
+        "data-level": (c = i(l).props) != null && c.draggable ? E.value : void 0,
+        "data-draggable": (f = i(l).props) != null && f.draggable ? !k.value && b.value : void 0,
+        class: Z(
+          i(je)(
+            i(e)({
+              disabled: k.value,
+              active: S.value
+            }),
+            d.node.class ?? ""
+          )
+        ),
+        tabindex: i(l).props.focusable ? 0 : void 0,
+        onClick: U
+      }, [
+        (h = i(l).props) != null && h.draggable ? (te(), Se("span", {
+          key: 0,
+          class: Z(i(l).prefixes.draggable)
+        }, [
+          i(l).dragging.value ? _e("", !0) : (te(), Ie(ht, {
+            key: 0,
+            icon: "tabler:grip-vertical",
+            size: i(l).iconSize.value,
+            class: Z(i(l).prefixes.draggableIcon)
+          }, null, 8, ["size", "class"]))
+        ], 2)) : _e("", !0),
+        Fe(We, {
+          level: E.value,
+          children: C.value,
+          size: i(l).indentSize.value,
+          expanded: _.value,
+          showLine: w.value,
+          dir: i(l).props.dir,
+          class: Z(i(F)(i(l).prefixes.node, "indent")),
+          loading: v.node._loading,
+          "branch-icon": v.node._switcherIcon ?? ((K = i(l).props) == null ? void 0 : K.switcherIcon),
+          "no-rotate-branch": v.node._noRotateSwitcherIcon ?? ((m = i(l).props) == null ? void 0 : m.noRotateSwitcherIcon),
+          onToggleExpand: a[0] || (a[0] = Ve((M) => i(l).onExpandKey(d.node), ["stop"]))
+        }, {
+          default: et(() => [
+            Re(v.$slots, "switcherIcon", Le(Ee(B.value)))
+          ]),
+          _: 3
+        }, 8, ["level", "children", "size", "expanded", "showLine", "dir", "class", "loading", "branch-icon", "no-rotate-branch"]),
+        (q = i(l).props) != null && q.checkable ? (te(), Ie(_t, {
+          key: 1,
+          size: i(l).iconSize.value,
+          onClick: a[1] || (a[1] = Ve(() => {
+          }, ["stop"])),
+          modelValue: x.value,
+          "onUpdate:modelValue": ae,
+          disabled: k.value
+        }, null, 8, ["size", "modelValue", "disabled"])) : _e("", !0),
+        Re(v.$slots, "default", Le(Ee(B.value)), () => [
+          Me("div", {
+            class: Z(i(F)(i(l).prefixes.node, "title"))
+          }, tt(v.node._title), 3)
+        ])
+      ], 10, Tt);
+    };
+  }
+}), ee = (P) => dt(P);
+function Pt({
+  getValue: P,
+  getDisabled: d,
+  arr: l,
+  getChildren: e,
+  getExtra: p,
+  allowNoValidKey: T
+}) {
+  const b = [], k = (L, _) => {
+    L.forEach((w) => {
+      const S = e(w, _), x = P(w, _, S);
+      if (ee(x) || T != null && T(w, _, S))
+        b.push({
+          ...typeof w == "object" ? w : { _item: w },
+          _parentKeys: _,
+          _key: x,
+          _disabled: !!d(w),
+          _hasChildren: !!(S != null && S.length),
+          ...(p == null ? void 0 : p(w)) ?? {}
+        }), S != null && S.length && k(S, [..._ ?? [], x]);
+      else
+        throw "every node must provide a valid key";
+    });
+  };
+  return k(l), b;
+}
+const Rt = ({
+  getData: P,
+  getExpandedKeys: d,
+  getValue: l,
+  getDisabled: e,
+  getChildren: p,
+  isFlatten: T,
+  getExtra: b
+}) => {
+  const k = y(
+    () => T ? i(P()) : Pt({
+      arr: i(P()),
+      getChildren: p,
+      getValue: l,
+      getDisabled: e,
+      getExtra: b
+    })
+  ), L = y(() => {
+    const a = i(d());
+    return k.value.filter(
+      (s) => {
+        var c, f;
+        return !s._parentKeys || ((f = (c = s._parentKeys) == null ? void 0 : c.every) == null ? void 0 : f.call(c, (h) => a.includes(h)));
+      }
+    );
+  }), _ = (a, s = !1, c = !0) => {
+    const f = a == null ? void 0 : a._key;
+    return !ee(f) || !a ? [] : k.value.filter((h) => {
+      var K;
+      if (s) {
+        const m = pe(h._parentKeys ?? []);
+        return m && m === f;
+      }
+      return (K = h._parentKeys) == null ? void 0 : K.includes(f);
+    }).filter((h) => h && (!c || !(h != null && h._disabled)));
+  }, w = () => k.value.filter((a) => !a._parentKeys), S = (a) => a ? _(a, !0, !1) : w(), x = (a) => ee(a) ? k.value.find((s) => s._key === a) : void 0, ae = (a) => {
+    const s = x(pe(a._parentKeys ?? []));
+    return S(s).findIndex((c) => c._key === a._key);
+  }, E = (a) => {
+    const s = i(a);
+    return s && mt(s) ? Ue(s) : [];
+  }, C = (a, s) => {
+    const c = _(a);
+    if (c != null && c.length)
+      return c.some((f) => U(f, s, !1) === !0);
+  }, B = (a, s) => {
+    const c = _(a);
+    return c != null && c.length ? c.every((f) => U(f, s, !1) === !0) : !1;
+  }, U = (a, s, c = !1) => {
+    const f = E(s), h = a == null ? void 0 : a._key;
+    if (!c && !a._disabled && !f.includes(h)) {
+      const K = _(a);
+      if (K != null && K.length)
+        return B(a, s) ? !0 : C(a, s) ? "indeterminate" : !1;
+    }
+    return f.includes(h);
+  };
+  return {
+    flattenData: k,
+    visibleFlattenData: L,
+    getNodeChildren: _,
+    getNodeByValue: x,
+    getNodeIndexInScope: ae,
+    getChildrenOrRootNodes: S,
+    isSomeChildrenSelected: C,
+    isAllChildrenSelected: B,
+    isSelected: U,
+    getRootNodes: w,
+    selectValue: (a, s, c, f, h, K) => {
+      let m = E(c);
+      if (ee(a._key) && !a._disabled)
+        if (h) {
+          if (s ? m.push(a._key) : m = m.filter((q) => a._key !== q), !f) {
+            const M = _(a).map((g) => g._key), X = m.map(x).filter((g) => g && g._parentKeys);
+            s || X.push(a);
+            const re = xe(
+              ut(X.map((g) => g._parentKeys))
+            ).filter((g) => ee(g) && g !== a._key).filter(ee).map(x).filter(Boolean), z = [], j = [];
+            re.forEach((g) => {
+              const se = g == null ? void 0 : g._key;
+              B(g, m) ? z.push(se) : j.push(se);
+            }), s ? z.push(...M) : j.push(...M), m.push(...z), m = m.filter((g) => !j.includes(g));
+          }
+        } else
+          K === "replace" ? s && (m = [a._key]) : s ? m = [a._key] : m = [];
+      return xe(m);
+    }
+  };
+}, Vt = /* @__PURE__ */ Be({
+  __name: "TreePlaceholder",
+  props: {
+    level: {},
+    size: {},
+    indentSize: {},
+    branchIcon: {},
+    children: { type: Boolean }
+  },
+  setup(P) {
+    return (d, l) => (te(), Se(at, null, [
+      Fe(i(We), {
+        level: d.level,
+        expanded: !1,
+        branchIcon: d.branchIcon,
+        children: d.children,
+        size: d.indentSize
+      }, null, 8, ["level", "branchIcon", "children", "size"]),
+      Me("div", {
+        class: Z(i(yt)({ size: d.size }))
+      }, null, 2)
+    ], 64));
+  }
+}), Ce = {
+  "3xsm": 14,
+  // 700 x 2px = 14px
+  "2xsm": 16,
+  // 800 x 2px = 16px
+  xsm: 20,
+  // 1000 x 2px = 20px
+  sm: 24,
+  // 1200 x 2px = 24px
+  md: 32,
+  // 1600 x 2px = 32px
+  lg: 40,
+  // 20000 x 2px = 40px
+  xlg: 48,
+  // 2400 x 2px = 48px
+  "2xlg": 56
+  // 2800 x 2px = 56px
+}, Zt = Object.keys(Ce), ea = /* @__PURE__ */ Be({
+  ...qe("Tree"),
+  __name: "Tree",
+  props: {
+    selectionBehavior: { default: "toggle" },
+    class: {},
+    size: { default: "md" },
+    gap: {},
+    dir: {},
+    data: {},
+    flattenData: { type: Boolean },
+    modelValue: {},
+    checkedKeys: {},
+    expandedKeys: {},
+    multiple: { type: Boolean },
+    checkable: { type: Boolean },
+    selectable: { type: Boolean },
+    defaultExpandAll: { type: Boolean },
+    showLine: { type: Boolean },
+    inlineNode: { type: Boolean },
+    lazyLoad: { type: Boolean },
+    getLoading: {},
+    getNoRotateSwitcherIcon: {},
+    getTitle: {},
+    getLeaf: {},
+    getDraggable: {},
+    getKey: {},
+    getSwitcherIcon: {},
+    getDisabled: {},
+    getChildren: {},
+    groupName: {},
+    sortableProps: {},
+    focusable: { type: Boolean, default: !0 },
+    checkStrictly: { type: Boolean, default: void 0 },
+    syncCheckboxAndSelect: { type: Boolean },
+    virtual: { type: [Boolean, Object] },
+    scrollContainerProps: {},
+    outerVirtualScroll: { type: Boolean },
+    switcherIcon: {},
+    noRotateSwitcherIcon: { type: Boolean },
+    draggable: { type: Boolean },
+    disabled: { type: Boolean, default: void 0 }
+  },
+  emits: ["update:modelValue", "update:expandedKeys", "update:checkedKeys", "change", "expand", "select", "check", "dragStart", "dragEnd", "choose", "unchoose"],
+  setup(P, { expose: d, emit: l }) {
+    vt("tree", Bt);
+    const e = P, p = l, T = De(), b = st("tree"), k = F(b, "node"), L = F(k, "group"), _ = F(k, "draggable"), w = F(_, "icon"), S = F(L, "list"), x = {
+      node: k,
+      group: L,
+      draggable: _,
+      draggableIcon: w,
+      groupList: S
+    }, ae = Ge(b, {
+      variants: {
+        size: G(wt, b),
+        gap: G($e, b),
+        selectable: G("selectable", b),
+        disabled: G("disabled", b),
+        inlineNode: G("inline-node", b),
+        dragging: G("dragging", b)
+      }
+    }), E = {
+      getLoading: D({
+        key: "loading",
+        getter: e.getLoading,
+        noReturnOption: !0
+      }),
+      getNoRotateSwitcherIcon: D({
+        key: "noRotateSwitcherIcon",
+        getter: e.getNoRotateSwitcherIcon,
+        noReturnOption: !0
+      }),
+      getTitle: D({
+        key: "title",
+        getter: e.getTitle,
+        noReturnOption: !0
+      }),
+      getLeaf: D({
+        key: "leaf",
+        getter: e.getLeaf,
+        noReturnOption: !0
+      }),
+      getDraggable: D({
+        key: "draggable",
+        getter: e.getDraggable,
+        noReturnOption: !0
+      }),
+      getKey: D({
+        key: "key",
+        getter: e.getKey,
+        noReturnOption: !0
+      }),
+      getSwitcherIcon: D({
+        key: "switcherIcon",
+        getter: e.getSwitcherIcon,
+        noReturnOption: !0
+      }),
+      getDisabled: D({
+        key: "disabled",
+        getter: e.getDisabled,
+        noReturnOption: !0
+      }),
+      getChildren: D({
+        key: "children",
+        getter: e.getChildren,
+        noReturnOption: !0
+      })
+    }, C = (t, n) => {
+      var A;
+      const o = `get${n[0].toUpperCase() + n.slice(1)}`;
+      return (A = E[o]) == null ? void 0 : A.call(E, t);
+    }, B = Y(e.expandedKeys ?? []), {
+      flattenData: U,
+      visibleFlattenData: v,
+      getNodeByValue: a,
+      getChildrenOrRootNodes: s,
+      getNodeIndexInScope: c,
+      isSelected: f,
+      getNodeChildren: h,
+      selectValue: K,
+      getRootNodes: m
+    } = Rt({
+      isFlatten: e.flattenData,
+      getData: () => e.data,
+      getExpandedKeys: () => B,
+      getValue: (t) => C(t, "key"),
+      getDisabled: (t) => C(t, "disabled"),
+      getChildren: (t) => C(t, "children"),
+      getExtra: (t) => ({
+        _switcherIcon: C(t, "switcherIcon"),
+        _title: C(t, "title"),
+        _draggable: C(t, "draggable"),
+        _leaf: C(t, "leaf"),
+        _loading: C(t, "loading"),
+        _noRotateSwitcherIcon: C(t, "noRotateSwitcherIcon")
+      })
+    }), q = () => U.value.filter((t) => t == null ? void 0 : t._hasChildren).map((t) => t._key);
+    let M = !1;
+    ue(
+      () => [e.defaultExpandAll, e.expandedKeys],
+      ([t, n], o) => {
+        M || (M = !0, n !== (o == null ? void 0 : o[1]) ? B.value = e.expandedKeys ?? [] : t && !(o != null && o[0]) && (B.value = q()), rt(() => M = !1));
+      },
+      { deep: !0, immediate: !0 }
+    ), ue(
+      B,
+      (t) => {
+        !M && t !== e.expandedKeys && p("update:expandedKeys", t);
+      },
+      { deep: !0 }
+    );
+    const X = Y(e.modelValue ?? []);
+    ue(
+      () => e.modelValue,
+      () => {
+        X.value = e.modelValue ?? [], e.syncCheckboxAndSelect && (z.value = e.modelValue ?? []);
+      },
+      { deep: !0 }
+    );
+    const R = y({
+      get() {
+        return X.value;
+      },
+      set(t) {
+        t && (e.modelValue || (X.value = t), p("update:modelValue", t));
+      }
+    }), re = Y(e.checkedKeys ?? []);
+    ue(
+      () => e.checkedKeys,
+      () => {
+        re.value = e.checkedKeys ?? [], e.syncCheckboxAndSelect && (R.value = e.checkedKeys ?? []);
+      },
+      { deep: !0 }
+    );
+    const z = y({
+      get() {
+        return re.value;
+      },
+      set(t) {
+        e.checkedKeys || (re.value = t), p("update:checkedKeys", t);
+      }
+    }), { getDisabled: j, getSize: g } = xt(), se = (t) => !!f(t, R, !0), He = (t) => f(t, z, e.checkStrictly), we = (t, n) => {
+      if (e.selectable && !j.value) {
+        const o = K(
+          t,
+          n,
+          R,
+          !!(e.syncCheckboxAndSelect ? e.checkStrictly : e.checkStrictly !== !1),
+          e.multiple,
+          e.selectionBehavior
+        );
+        Ae(o, R.value) || (R.value = o, p("select", t, n, o), p("change", { modelValue: R.value, checkedKeys: z.value }), e.syncCheckboxAndSelect && (z.value = o, p("check", t, n, o)));
+      }
+    }, Ke = (t, n) => {
+      if (e.checkable && !j.value) {
+        const o = K(t, n, z, !!e.checkStrictly, !0);
+        Ae(o, z.value) || (z.value = o, p("check", t, n, z.value), p("change", { modelValue: R.value, checkedKeys: z.value }), e.syncCheckboxAndSelect && (R.value = o, p("select", t, n, o)));
+      }
+    }, ie = (t) => {
+      let n = !0, o = Ue(B.value);
+      o.includes(t._key) ? (o = o.filter((A) => A !== t._key), n = !1) : (o = xe([...o, t._key]), n = !0), B.value = o, p("expand", t, n);
+    }, fe = y(() => {
+      if (e.gap) {
+        if (typeof e.gap == "number") return `${e.gap}px`;
+        if (!Object.keys($e).includes(e.gap)) return e.gap;
+      }
+    }), ce = Y(!1), { getDir: Je } = St(), he = Je(), ze = y(() => {
+      switch (g.value) {
+        case "sm":
+          return "2xsm";
+        case "lg":
+          return "sm";
+        default:
+          return "xsm";
+      }
+    }), Qe = y(() => g.value === "sm" ? "2xsm" : "xsm"), Te = (t) => {
+      var n;
+      return (((n = t == null ? void 0 : t._parentKeys) == null ? void 0 : n.length) ?? 0) + 1;
+    };
+    zt({
+      iconSize: Qe,
+      disabled: j,
+      props: e,
+      expandedKeys: B,
+      model: R,
+      dir: he,
+      checked: z,
+      onExpandKey: ie,
+      onSelect: we,
+      onCheck: Ke,
+      getNodeChildren: h,
+      getNodeField: C,
+      getIsSelected: se,
+      getIsChecked: He,
+      getLevel: Te,
+      dragging: ce,
+      indentSize: ze,
+      prefixes: x
+    });
+    const me = Y();
+    if (e.draggable) {
+      let t, n;
+      const o = (V) => {
+        const u = V.getAttribute("data-key");
+        if (u) return a(u);
+      }, A = it(F(b, "dragging_item"), g.value), le = () => {
+        var V;
+        (V = t == null ? void 0 : t.destroy) == null || V.call(t), t = void 0;
+      };
+      lt(async () => {
+        let V, u, H, ne, O;
+        const ke = (r) => ({
+          ...r,
+          node: u,
+          oldParents: H,
+          newParents: ne,
+          oldIndex: V,
+          oldDraggableIndex: V,
+          newIndex: O,
+          newDraggableIndex: O
+        }), Pe = (r, J) => {
+          if (r) {
+            const N = () => {
+              const de = Te(u), I = !!(u != null && u._hasChildren);
+              return {
+                size: g.value,
+                level: de,
+                children: I,
+                indentSize: ze.value,
+                branchIcon: (u ? u._switcherIcon ?? (e == null ? void 0 : e.switcherIcon) : e == null ? void 0 : e.switcherIcon) ?? "tabler:chevron-left"
+              };
+            }, $ = document.createElement("div"), Q = r.getBoundingClientRect();
+            $.style.width = Q.width ? `${Q.width}px` : "100%", $.style.height = Q.height ? `${Q.height}px` : "100%", $.classList.add(F(b, bt));
+            const oe = N();
+            return J && (oe.level = J), ot(ge(Vt, oe), $), $;
+          }
+        };
+        t ? le() : me.value && (t = new pt(me.value, {
+          ...gt(e.sortableProps || {}, ["onMove"]),
+          group: Oe(e.groupName) ? e.groupName() : e.groupName ?? ct(b),
+          filter: "[data-draggable=false]",
+          tree: !0,
+          draggable: `.${x.node}`,
+          handle: `.${x.node} .${x.draggable} .${x.draggableIcon}`,
+          dataIdAttr: "data-key",
+          dragClass: A,
+          onChoose(r) {
+            var J;
+            if (u = o(r == null ? void 0 : r.item), H = (J = u == null ? void 0 : u._parentKeys) == null ? void 0 : J.map(a).filter(Boolean), u) {
+              if (H != null && H.length) {
+                const N = pe(H);
+                N && (V = h(N, !0, !1).findIndex(
+                  ($) => $._key === u._key
+                ));
+              } else
+                V = m().findIndex((N) => N._key === u._key);
+              u._dragging = !0;
+            }
+            p("choose", r);
+          },
+          onUnchoose(r) {
+            u && (u._dragging = !1), p("unchoose", r);
+          },
+          onStart(r) {
+            u != null && u._key && B.value.includes(u._key) && (n = u, ie(n)), ce.value = !0, p("dragStart", ke(r));
+          },
+          onEnd(r) {
+            ce.value = !1, n && (ie(n), n = void 0), p("dragEnd", ke(r)), V = H = O = ne = u = void 0;
+          },
+          onMove(r, J) {
+            var Q, oe, de;
+            if (O = ne = void 0, r.draggedTreeItemParent) {
+              const I = o(r == null ? void 0 : r.draggedTreeItemParent);
+              I && (ne = [
+                ...((Q = I == null ? void 0 : I._parentKeys) == null ? void 0 : Q.map(a).filter(Boolean)) ?? [],
+                I
+              ], (oe = h(I, !0, !1)) != null && oe.length && !B.value.includes(I._key) && ie(I));
+            }
+            const N = r.draggedTreeItemLevel ?? 1;
+            if (!r.draggedTreeItemBefore) O = 0;
+            else if (r.draggedTreeItemBefore) {
+              if (r.draggedTreeItemBefore.level === N) {
+                const I = o(r.draggedTreeItemBefore);
+                I && (O = c(I) + 1);
+              } else if (r.draggedTreeItemBefore.level < N)
+                O = 0;
+              else if (r.draggedTreeItemBefore.level > N) {
+                if (!r.draggedTreeItemAfter || r.draggedTreeItemAfter.level < N) {
+                  const I = pe(ne ?? []);
+                  O = s(I).length;
+                } else if (r.draggedTreeItemAfter.level === N) {
+                  const I = o(r.draggedTreeItemAfter);
+                  I && (O = c(I));
+                }
+              }
+            }
+            const $ = ke(r);
+            Oe((de = e.sortableProps) == null ? void 0 : de.onMove) && e.sortableProps.onMove($, J);
+          },
+          getPlaceholder(r) {
+            return Pe(r == null ? void 0 : r.item);
+          },
+          getPlaceholderOnMove(r) {
+            return Pe(r == null ? void 0 : r.dragged, r.draggedTreeItemLevel || 1);
+          }
+        }));
+      }), nt(le);
+    }
+    const ye = Y(), Xe = {
+      none: 0,
+      sm: 4,
+      md: 6,
+      lg: 8
+    }, Ye = y(() => ({
+      get count() {
+        return v.value.length ?? 0;
+      },
+      getScrollElement: () => {
+        var t;
+        return (t = ye.value) == null ? void 0 : t.container.viewportElement;
+      },
+      estimateSize: () => Ce[e.size] ?? Ce.md,
+      overscan: 5,
+      get gap() {
+        return Xe[fe.value ?? g.value] ?? fe.value ?? g.value ?? 0;
+      }
+    }));
+    let ve, W;
+    if (e.virtual)
+      if (typeof e.virtual == "object")
+        ve = e.virtual;
+      else {
+        const { virtualizer: t, ...n } = Ct(Ye);
+        ve = t, W = n;
+      }
+    const Ne = y(
+      () => {
+        var t;
+        return e.virtual ? (((t = i(ve)) == null ? void 0 : t.getVirtualItems()) ?? []).map(
+          (n) => v.value[n.index]
+        ) : v.value;
+      }
+    ), Ze = () => {
+      var n;
+      const t = () => {
+        const o = () => {
+          var le;
+          const A = (le = T.default) == null ? void 0 : le.call(T, {
+            items: Ne.value
+          });
+          return kt(A) ? Ne.value.map(
+            (be) => ge(
+              Nt,
+              { key: be._key, node: be },
+              {
+                default: T.node,
+                switcherIcon: T.switcherIcon
+              }
+            )
+          ) : A;
+        };
+        return ge(
+          "div",
+          {
+            dir: he.value,
+            role: "tree",
+            class: je(
+              ae({
+                size: g.value,
+                gap: e.gap ?? g.value,
+                selectable: e.selectable,
+                disabled: j.value,
+                inlineNode: e.inlineNode,
+                dragging: ce.value
+              }),
+              e.class
+            ),
+            style: {
+              "--ptc-tree-gap": fe.value,
+              ...e.virtual ? (W == null ? void 0 : W.containerStyles.value) ?? {} : {}
+            },
+            ref: me
+          },
+          o()
+        );
+      };
+      return e.virtual && !e.outerVirtualScroll ? ge(
+        It,
+        {
+          ...e.scrollContainerProps,
+          ref: ye,
+          dir: he.value,
+          wrapProps: {
+            ...((n = e.scrollContainerProps) == null ? void 0 : n.wrapProps) ?? {},
+            style: (W == null ? void 0 : W.scrollWrapperStyles.value) ?? {}
+          }
+        },
+        t
+      ) : t();
+    };
+    return d({
+      scrollContainerRef: ye,
+      onSelect: we,
+      onCheck: Ke
+    }), (t, n) => (te(), Ie(Ze));
+  }
+});
+export {
+  wt as T,
+  ea as _,
+  Nt as a,
+  $e as b,
+  Zt as c,
+  Pt as f,
+  Kt as i,
+  zt as p,
+  Ce as s
+};