ep-craft 0.1.34 → 0.1.35

package/dist/components/tree/src/tree-node.vue.js

@@ -0,0 +1,108 @@
+import D from "./tree-node2.vue.js";
+import { resolveComponent as a, withDirectives as k, openBlock as d, createElementBlock as p, withModifiers as r, normalizeClass as s, createElementVNode as y, normalizeStyle as N, createBlock as l, withCtx as t, resolveDynamicComponent as E, createCommentVNode as i, createVNode as h, Fragment as w, renderList as $, vShow as m } from "vue";
+import L from "../../../_virtual/_plugin-vue_export-helper.js";
+const S = ["aria-expanded", "aria-disabled", "aria-checked", "draggable", "data-key"], B = ["aria-expanded"];
+function M(e, n, R, V, z, A) {
+  const g = a("el-icon"), C = a("el-checkbox"), u = a("loading"), b = a("node-content"), f = a("ep-tree-node"), v = a("el-collapse-transition");
+  return k((d(), p("div", {
+    ref: "node$",
+    class: s([
+      e.ns.b("node"),
+      e.ns.is("expanded", e.expanded),
+      e.ns.is("current", e.node.isCurrent),
+      e.ns.is("hidden", !e.node.visible),
+      e.ns.is("focusable", !e.node.disabled),
+      e.ns.is("checked", !e.node.disabled && e.node.checked),
+      e.getNodeClass(e.node)
+    ]),
+    role: "treeitem",
+    tabindex: "-1",
+    "aria-expanded": e.expanded,
+    "aria-disabled": e.node.disabled,
+    "aria-checked": e.node.checked,
+    draggable: e.tree.props.draggable,
+    "data-key": e.getNodeKey(e.node),
+    onClick: n[2] || (n[2] = r((...o) => e.handleClick && e.handleClick(...o), ["stop"])),
+    onContextmenu: n[3] || (n[3] = (...o) => e.handleContextMenu && e.handleContextMenu(...o)),
+    onDragstart: n[4] || (n[4] = r((...o) => e.handleDragStart && e.handleDragStart(...o), ["stop"])),
+    onDragover: n[5] || (n[5] = r((...o) => e.handleDragOver && e.handleDragOver(...o), ["stop"])),
+    onDragend: n[6] || (n[6] = r((...o) => e.handleDragEnd && e.handleDragEnd(...o), ["stop"])),
+    onDrop: n[7] || (n[7] = r((...o) => e.handleDrop && e.handleDrop(...o), ["stop"]))
+  }, [
+    y("div", {
+      class: s(e.ns.be("node", "content")),
+      style: N({ paddingLeft: (e.node.level - 1) * e.tree.props.indent + "px" })
+    }, [
+      e.tree.props.icon || e.CaretRight ? (d(), l(g, {
+        key: 0,
+        class: s([
+          e.ns.be("node", "expand-icon"),
+          e.ns.is("leaf", e.node.isLeaf),
+          {
+            expanded: !e.node.isLeaf && e.expanded
+          }
+        ]),
+        onClick: r(e.handleExpandIconClick, ["stop"])
+      }, {
+        default: t(() => [
+          (d(), l(E(e.tree.props.icon || e.CaretRight)))
+        ]),
+        _: 1
+      }, 8, ["class", "onClick"])) : i("", !0),
+      e.showCheckbox ? (d(), l(C, {
+        key: 1,
+        "model-value": e.node.checked,
+        indeterminate: e.node.indeterminate,
+        disabled: !!e.node.disabled,
+        onClick: n[0] || (n[0] = r(() => {
+        }, ["stop"])),
+        onChange: e.handleCheckChange
+      }, null, 8, ["model-value", "indeterminate", "disabled", "onChange"])) : i("", !0),
+      e.node.loading ? (d(), l(g, {
+        key: 2,
+        class: s([e.ns.be("node", "loading-icon"), e.ns.is("loading")])
+      }, {
+        default: t(() => [
+          h(u)
+        ]),
+        _: 1
+      }, 8, ["class"])) : i("", !0),
+      h(b, {
+        node: e.node,
+        "render-content": e.renderContent
+      }, null, 8, ["node", "render-content"])
+    ], 6),
+    h(v, null, {
+      default: t(() => [
+        !e.renderAfterExpand || e.childNodeRendered ? k((d(), p("div", {
+          key: 0,
+          class: s(e.ns.be("node", "children")),
+          role: "group",
+          "aria-expanded": e.expanded,
+          onClick: n[1] || (n[1] = r(() => {
+          }, ["stop"]))
+        }, [
+          (d(!0), p(w, null, $(e.node.childNodes, (o) => (d(), l(f, {
+            key: e.getNodeKey(o),
+            "render-content": e.renderContent,
+            "render-after-expand": e.renderAfterExpand,
+            "show-checkbox": e.showCheckbox,
+            node: o,
+            accordion: e.accordion,
+            props: e.props,
+            onNodeExpand: e.handleChildNodeExpand
+          }, null, 8, ["render-content", "render-after-expand", "show-checkbox", "node", "accordion", "props", "onNodeExpand"]))), 128))
+        ], 10, B)), [
+          [m, e.expanded]
+        ]) : i("", !0)
+      ]),
+      _: 1
+    })
+  ], 42, S)), [
+    [m, e.node.visible]
+  ]);
+}
+const I = /* @__PURE__ */ L(D, [["render", M]]);
+export {
+  I as default
+};

package/dist/components/tree/src/tree-node2.vue.js

@@ -0,0 +1,166 @@
+import { defineComponent as I, inject as x, ref as r, getCurrentInstance as T, provide as _, watch as i, nextTick as E } from "vue";
+import { isFunction as S, isString as B } from "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { debugWarn as L } from "../../../utils/error.js";
+import { Loading as R, CaretRight as $ } from "@element-plus/icons-vue";
+import { EpCollapseTransition as w } from "../../collapse-transition/index.js";
+import { EpCheckbox as F } from "../../checkbox/index.js";
+import { ElIcon as P } from "../../icon/index.js";
+import { useNamespace as j } from "../../../hooks/use-namespace/index.js";
+import "../../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../../hooks/use-z-index/index.js";
+import "../../../hooks/use-delayed-toggle/index.js";
+import "../../../hooks/use-aria/index.js";
+import "../../../hooks/use-model-toggle/index.js";
+import "../../../hooks/use-empty-values/index.js";
+import A from "./tree-node-content.vue.js";
+import { handleCurrentChange as H, getNodeKey as J } from "./model/util.js";
+import { useNodeExpandEventBroadcast as Y } from "./model/useNodeExpandEventBroadcast.js";
+import { dragEventsKey as M } from "./model/useDragNode.js";
+import W from "./model/node.js";
+import { ROOT_TREE_INJECTION_KEY as q, NODE_INSTANCE_INJECTION_KEY as z } from "./tokens.js";
+const ve = I({
+  name: "EpTreeNode",
+  components: {
+    ElCollapseTransition: w,
+    ElCheckbox: F,
+    NodeContent: A,
+    ElIcon: P,
+    Loading: R
+  },
+  props: {
+    node: {
+      type: W,
+      default: () => ({})
+    },
+    props: {
+      type: Object,
+      default: () => ({})
+    },
+    accordion: Boolean,
+    renderContent: Function,
+    renderAfterExpand: Boolean,
+    showCheckbox: Boolean
+  },
+  emits: ["node-expand"],
+  setup(n, p) {
+    const v = j("tree"), { broadcastExpanded: y } = Y(n), t = x(q), l = r(!1), s = r(!1), h = r(), m = r(), C = r(), f = x(M), c = T();
+    _(z, c), t || L("Tree", "Can not find node's tree."), n.node.expanded && (l.value = !0, s.value = !0);
+    const K = t.props.props.children || "children";
+    i(
+      () => {
+        var o;
+        const e = (o = n.node.data) == null ? void 0 : o[K];
+        return e && [...e];
+      },
+      () => {
+        n.node.updateChildren();
+      }
+    ), i(
+      () => n.node.indeterminate,
+      (e) => {
+        u(n.node.checked, e);
+      }
+    ), i(
+      () => n.node.checked,
+      (e) => {
+        u(e, n.node.indeterminate);
+      }
+    ), i(
+      () => n.node.childNodes.length,
+      () => n.node.reInitChecked()
+    ), i(
+      () => n.node.expanded,
+      (e) => {
+        E(() => l.value = e), e && (s.value = !0);
+      }
+    );
+    const N = (e) => t.props.nodeKey ? J(t.props.nodeKey, e.data) : e.id, D = (e) => {
+      const o = n.props.class;
+      if (!o)
+        return {};
+      let d;
+      if (S(o)) {
+        const { data: a } = e;
+        d = o(a, e);
+      } else
+        d = o;
+      return B(d) ? { [d]: !0 } : d;
+    }, u = (e, o) => {
+      (h.value !== e || m.value !== o) && t.ctx.emit("check-change", n.node.data, e, o), h.value = e, m.value = o;
+    }, O = (e) => {
+      H(t.store, t.ctx.emit, () => {
+        var d;
+        if ((d = t == null ? void 0 : t.props) == null ? void 0 : d.nodeKey) {
+          const a = N(n.node);
+          t.store.value.setCurrentNodeKey(a);
+        } else
+          t.store.value.setCurrentNode(n.node);
+      }), t.currentNode.value = n.node, t.props.expandOnClickNode && g(), (t.props.checkOnClickNode || n.node.isLeaf && t.props.checkOnClickLeaf && n.showCheckbox) && !n.node.disabled && k(!n.node.checked), t.ctx.emit("node-click", n.node.data, n.node, c, e);
+    }, b = (e) => {
+      var o;
+      (o = t.instance.vnode.props) != null && o.onNodeContextmenu && (e.stopPropagation(), e.preventDefault()), t.ctx.emit(
+        "node-contextmenu",
+        e,
+        n.node.data,
+        n.node,
+        c
+      );
+    }, g = () => {
+      n.node.isLeaf || (l.value ? (t.ctx.emit("node-collapse", n.node.data, n.node, c), n.node.collapse()) : n.node.expand(() => {
+        p.emit("node-expand", n.node.data, n.node, c);
+      }));
+    }, k = (e) => {
+      const o = t == null ? void 0 : t.props.checkStrictly, d = n.node.childNodes;
+      !o && d.length && (e = d.some((a) => !a.isEffectivelyChecked)), n.node.setChecked(e, !o), E(() => {
+        const a = t.store.value;
+        t.ctx.emit("check", n.node.data, {
+          checkedNodes: a.getCheckedNodes(),
+          checkedKeys: a.getCheckedKeys(),
+          halfCheckedNodes: a.getHalfCheckedNodes(),
+          halfCheckedKeys: a.getHalfCheckedKeys()
+        });
+      });
+    };
+    return {
+      ns: v,
+      node$: C,
+      tree: t,
+      expanded: l,
+      childNodeRendered: s,
+      oldChecked: h,
+      oldIndeterminate: m,
+      getNodeKey: N,
+      getNodeClass: D,
+      handleSelectChange: u,
+      handleClick: O,
+      handleContextMenu: b,
+      handleExpandIconClick: g,
+      handleCheckChange: k,
+      handleChildNodeExpand: (e, o, d) => {
+        y(o), t.ctx.emit("node-expand", e, o, d);
+      },
+      handleDragStart: (e) => {
+        t.props.draggable && f.treeNodeDragStart({ event: e, treeNode: n });
+      },
+      handleDragOver: (e) => {
+        e.preventDefault(), t.props.draggable && f.treeNodeDragOver({
+          event: e,
+          treeNode: { $el: C.value, node: n.node }
+        });
+      },
+      handleDrop: (e) => {
+        e.preventDefault();
+      },
+      handleDragEnd: (e) => {
+        t.props.draggable && f.treeNodeDragEnd(e);
+      },
+      CaretRight: $
+    };
+  }
+});
+export {
+  ve as default
+};

package/dist/components/tree/src/tree.d.ts

@@ -0,0 +1,103 @@
+import type { ComponentInternalInstance, PropType } from 'vue';
+import type { EmitFn } from '@element-plus/utils';
+import type Node from './model/node';
+import type { AllowDragFunction, AllowDropFunction, CheckedInfo, NodeDropType, RenderContentFunction, TreeData } from './tree.type';
+export declare const treeProps: {
+    readonly data: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => TreeData) | (() => TreeData) | (((new (...args: any[]) => TreeData) | (() => TreeData)) | null)[], unknown, unknown, () => never[], boolean>;
+    readonly emptyText: {
+        readonly type: PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly renderAfterExpand: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly nodeKey: StringConstructor;
+    readonly checkStrictly: BooleanConstructor;
+    readonly defaultExpandAll: BooleanConstructor;
+    readonly expandOnClickNode: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly checkOnClickNode: BooleanConstructor;
+    readonly checkOnClickLeaf: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly checkDescendants: BooleanConstructor;
+    readonly autoExpandParent: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly defaultCheckedKeys: {
+        readonly type: PropType<import("./tree.type").TreeKey[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly defaultExpandedKeys: {
+        readonly type: PropType<import("./tree.type").TreeKey[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly currentNodeKey: {
+        readonly type: PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly renderContent: {
+        readonly type: PropType<RenderContentFunction>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly showCheckbox: BooleanConstructor;
+    readonly draggable: BooleanConstructor;
+    readonly allowDrag: {
+        readonly type: PropType<AllowDragFunction>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly allowDrop: {
+        readonly type: PropType<AllowDropFunction>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly props: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => import("./tree.type").TreeOptionProps) | (() => import("./tree.type").TreeOptionProps) | (((new (...args: any[]) => import("./tree.type").TreeOptionProps) | (() => import("./tree.type").TreeOptionProps)) | null)[], unknown, unknown, () => {
+        children: string;
+        label: string;
+        disabled: string;
+    }, boolean>;
+    readonly lazy: BooleanConstructor;
+    readonly highlightCurrent: BooleanConstructor;
+    readonly load: {
+        readonly type: PropType<import("./tree.type").LoadFunction>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly filterNodeMethod: {
+        readonly type: PropType<import("./tree.type").FilterNodeMethodFunction>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly accordion: BooleanConstructor;
+    readonly indent: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 18, boolean>;
+    readonly icon: {
+        readonly type: PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export declare const treeEmits: {
+    'check-change': (data: any, checked: boolean, indeterminate: boolean) => any;
+    'current-change': (data: any | null, node: Node | null) => boolean;
+    'node-click': (data: any, node: Node, nodeInstance: ComponentInternalInstance | null, evt: MouseEvent) => any;
+    'node-contextmenu': (evt: Event, data: any, node: Node, nodeInstance: ComponentInternalInstance | null) => any;
+    'node-collapse': (data: any, node: Node, nodeInstance: ComponentInternalInstance | null) => any;
+    'node-expand': (data: any, node: Node, nodeInstance: ComponentInternalInstance | null) => any;
+    check: (data: any, checkedInfo: CheckedInfo) => any;
+    'node-drag-start': (node: Node, evt: DragEvent) => DragEvent;
+    'node-drag-end': (draggingNode: Node, dropNode: Node | null, dropType: NodeDropType, evt: DragEvent) => DragEvent;
+    'node-drop': (draggingNode: Node, dropNode: Node, dropType: Exclude<NodeDropType, "none">, evt: DragEvent) => DragEvent;
+    'node-drag-leave': (draggingNode: Node, oldDropNode: Node, evt: DragEvent) => DragEvent;
+    'node-drag-enter': (draggingNode: Node, dropNode: Node, evt: DragEvent) => DragEvent;
+    'node-drag-over': (draggingNode: Node, dropNode: Node, evt: DragEvent) => DragEvent;
+};
+export type TreeEmits = EmitFn<typeof treeEmits>;

package/dist/components/tree/src/tree.js

@@ -0,0 +1,99 @@
+import { isBoolean as d } from "../../../utils/types.js";
+import "lodash-unified";
+import "@vueuse/core";
+import "@vue/shared";
+import { iconPropType as r } from "../../../utils/vue/icon.js";
+import "vue";
+import { buildProps as l, definePropType as a } from "../../../utils/vue/props/runtime.js";
+const h = l({
+  data: {
+    type: a(Array),
+    default: () => []
+  },
+  emptyText: {
+    type: String
+  },
+  renderAfterExpand: {
+    type: Boolean,
+    default: !0
+  },
+  nodeKey: String,
+  checkStrictly: Boolean,
+  defaultExpandAll: Boolean,
+  expandOnClickNode: {
+    type: Boolean,
+    default: !0
+  },
+  checkOnClickNode: Boolean,
+  checkOnClickLeaf: {
+    type: Boolean,
+    default: !0
+  },
+  checkDescendants: Boolean,
+  autoExpandParent: {
+    type: Boolean,
+    default: !0
+  },
+  defaultCheckedKeys: {
+    type: Array
+  },
+  defaultExpandedKeys: {
+    type: Array
+  },
+  currentNodeKey: {
+    type: [String, Number]
+  },
+  renderContent: {
+    type: a(Function)
+  },
+  showCheckbox: Boolean,
+  draggable: Boolean,
+  allowDrag: {
+    type: a(Function)
+  },
+  allowDrop: {
+    type: a(Function)
+  },
+  props: {
+    type: Object,
+    default: () => ({
+      children: "children",
+      label: "label",
+      disabled: "disabled"
+    })
+  },
+  lazy: Boolean,
+  highlightCurrent: Boolean,
+  load: {
+    type: Function
+  },
+  filterNodeMethod: {
+    type: Function
+  },
+  accordion: Boolean,
+  indent: {
+    type: Number,
+    default: 18
+  },
+  icon: {
+    type: r
+  }
+}), g = {
+  "check-change": (e, o, n) => e && d(o) && d(n),
+  "current-change": (e, o) => !0,
+  "node-click": (e, o, n, t) => e && o && t instanceof Event,
+  "node-contextmenu": (e, o, n, t) => e instanceof Event && o && n,
+  "node-collapse": (e, o, n) => e && o,
+  "node-expand": (e, o, n) => e && o,
+  check: (e, o) => e && o,
+  "node-drag-start": (e, o) => e && o,
+  "node-drag-end": (e, o, n, t) => e && t,
+  "node-drop": (e, o, n, t) => e && o && t,
+  "node-drag-leave": (e, o, n) => e && o && n,
+  "node-drag-enter": (e, o, n) => e && o && n,
+  "node-drag-over": (e, o, n) => e && o && n
+};
+export {
+  g as treeEmits,
+  h as treeProps
+};

package/dist/components/tree/src/tree.type.d.ts

@@ -0,0 +1,112 @@
+import type TreeStore from './model/tree-store';
+import type Node from './model/node';
+import type { treeEmits } from './tree';
+import type { DragEvents } from './model/useDragNode';
+import type { Component, ComponentInternalInstance, Ref, SetupContext, VNode, h } from 'vue';
+interface RootTreeType {
+    ctx: SetupContext<typeof treeEmits>;
+    props: TreeComponentProps;
+    store: Ref<TreeStore>;
+    root: Ref<Node>;
+    currentNode: Ref<Node>;
+    instance: ComponentInternalInstance;
+}
+type hType = typeof h;
+type TreeData = TreeNodeData[];
+type TreeKey = string | number;
+interface FakeNode {
+    data: TreeNodeData;
+}
+type TreeNodeData = Record<string, any>;
+interface TreeNodeLoadedDefaultProps {
+    checked?: boolean;
+}
+interface TreeNodeChildState {
+    all: boolean;
+    none: boolean;
+    allWithoutDisable: boolean;
+    half: boolean;
+    isEffectivelyChecked: boolean;
+}
+interface TreeNodeOptions {
+    data: TreeNodeData;
+    store: TreeStore;
+    parent?: Node;
+}
+interface TreeStoreNodesMap {
+    [key: string]: Node;
+}
+interface TreeStoreOptions {
+    key?: TreeKey;
+    data: TreeData;
+    lazy: boolean;
+    props: TreeOptionProps;
+    load?: LoadFunction;
+    currentNodeKey?: TreeKey;
+    checkStrictly: boolean;
+    checkDescendants: boolean;
+    defaultCheckedKeys?: TreeKey[];
+    defaultExpandedKeys?: TreeKey[];
+    autoExpandParent: boolean;
+    defaultExpandAll: boolean;
+    filterNodeMethod?: FilterNodeMethodFunction;
+}
+interface TreeOptionProps {
+    children?: string;
+    label?: string | ((data: TreeNodeData, node: Node) => string);
+    disabled?: string | ((data: TreeNodeData, node: Node) => boolean);
+    isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean);
+    class?: (data: TreeNodeData, node: Node) => string | {
+        [key: string]: boolean;
+    };
+}
+type RenderContentFunction = (h: hType, context: RenderContentContext) => VNode | VNode[];
+interface RenderContentContext {
+    _self: ComponentInternalInstance;
+    node: Node;
+    data: TreeNodeData;
+    store: TreeStore;
+}
+type AllowDragFunction = (node: Node) => boolean;
+type AllowDropType = 'inner' | 'prev' | 'next';
+type AllowDropFunction = (draggingNode: Node, dropNode: Node, type: AllowDropType) => boolean;
+type LoadFunction = (rootNode: Node, loadedCallback: (data: TreeData) => void, stopLoading: () => void) => void;
+type FilterValue = any;
+type FilterNodeMethodFunction = (value: FilterValue, data: TreeNodeData, child: Node) => boolean;
+interface TreeComponentProps {
+    data: TreeData;
+    emptyText: string;
+    renderAfterExpand: boolean;
+    nodeKey: string;
+    checkStrictly: boolean;
+    expandOnClickNode: boolean;
+    defaultExpandAll: boolean;
+    checkOnClickNode: boolean;
+    checkOnClickLeaf: boolean;
+    checkDescendants: boolean;
+    autoExpandParent: boolean;
+    defaultCheckedKeys: TreeKey[];
+    defaultExpandedKeys: TreeKey[];
+    currentNodeKey: TreeKey;
+    renderContent: RenderContentFunction;
+    showCheckbox: boolean;
+    draggable: boolean;
+    allowDrag: AllowDragFunction;
+    allowDrop: AllowDropFunction;
+    props: TreeOptionProps;
+    lazy: boolean;
+    highlightCurrent: boolean;
+    load: LoadFunction;
+    filterNodeMethod: FilterNodeMethodFunction;
+    accordion: boolean;
+    indent: number;
+    icon: string | Component;
+}
+type NodeDropType = 'before' | 'after' | 'inner' | 'none';
+interface CheckedInfo {
+    checkedKeys: TreeKey[];
+    checkedNodes: TreeData;
+    halfCheckedKeys: TreeKey[];
+    halfCheckedNodes: TreeData;
+}
+export type { AllowDragFunction, AllowDropFunction, AllowDropType, CheckedInfo, DragEvents, FakeNode, FilterNodeMethodFunction, FilterValue, LoadFunction, NodeDropType, RenderContentContext, RenderContentFunction, RootTreeType, TreeComponentProps, TreeData, TreeKey, TreeNodeChildState, TreeNodeData, TreeNodeLoadedDefaultProps, TreeNodeOptions, TreeOptionProps, TreeStoreNodesMap, TreeStoreOptions, hType, };