@pantograph/vue 0.30.7 → 0.30.9

package/dist/index-_lrD3ofV.js

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