ep-craft 0.1.34 → 0.1.36

package/dist/components/transfer/transfer.d.ts

@@ -0,0 +1,136 @@
+import type { ComponentInstance, ExtractPublicPropTypes, h as H, VNode } from 'vue';
+import type { ComponentExposed } from 'vue-component-type-helpers';
+import type Transfer from './EpTransfer.vue';
+export type TransferKey = string | number;
+export type TransferDirection = 'left' | 'right';
+export type TransferDataItem = Record<string, any>;
+export type renderContent<T extends TransferDataItem = TransferDataItem> = (h: typeof H, option: T) => VNode | VNode[];
+export interface TransferFormat {
+    noChecked?: string;
+    hasChecked?: string;
+}
+export interface TransferPropsAlias {
+    label?: string;
+    key?: string;
+    disabled?: string;
+}
+export interface TransferCheckedState {
+    leftChecked: TransferKey[];
+    rightChecked: TransferKey[];
+}
+export declare const LEFT_CHECK_CHANGE_EVENT = "left-check-change";
+export declare const RIGHT_CHECK_CHANGE_EVENT = "right-check-change";
+export interface TransferProps<T extends TransferDataItem = TransferDataItem> {
+    /**
+     * @description data source
+     */
+    data?: T[];
+    /**
+     * @description custom list titles
+     */
+    titles?: [string, string];
+    /**
+     * @description custom button texts
+     */
+    buttonTexts?: [string, string];
+    /**
+     * @description placeholder for the filter input
+     */
+    filterPlaceholder?: string;
+    /**
+     * @description custom filter method
+     */
+    filterMethod?: (query: string, item: T) => boolean;
+    /**
+     * @description key array of initially checked data items of the left list
+     */
+    leftDefaultChecked?: TransferKey[];
+    /**
+     * @description key array of initially checked data items of the right list
+     */
+    rightDefaultChecked?: TransferKey[];
+    /**
+     * @description custom render function for data items
+     */
+    renderContent?: renderContent<T>;
+    /**
+     * @description binding value
+     */
+    modelValue?: TransferKey[];
+    /**
+     * @description texts for checking status in list header
+     */
+    format?: TransferFormat;
+    /**
+     * @description whether Transfer is filterable
+     */
+    filterable?: boolean;
+    /**
+     * @description prop aliases for data source
+     */
+    props?: TransferPropsAlias;
+    /**
+     * @description order strategy for elements in the target list. If set to `original`, the elements will keep the same order as the data source. If set to `push`, the newly added elements will be pushed to the bottom. If set to `unshift`, the newly added elements will be inserted on the top
+     */
+    targetOrder?: 'original' | 'push' | 'unshift';
+    /**
+     * @description whether to trigger form validation
+     */
+    validateEvent?: boolean;
+    /**
+     * @description whether to enable virtual scrolling
+     */
+    virtualScroll?: boolean;
+    /**
+     * @description line height for virtual scrolling
+     */
+    itemSize?: number;
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `TransferProps` instead.
+ */
+export declare const transferProps: {
+    readonly data: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => TransferDataItem[]) | (() => TransferDataItem[]) | (((new (...args: any[]) => TransferDataItem[]) | (() => TransferDataItem[])) | null)[], unknown, unknown, () => never[], boolean>;
+    readonly titles: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => [string, string]) | (() => [string, string]) | (((new (...args: any[]) => [string, string]) | (() => [string, string])) | null)[], unknown, unknown, () => never[], boolean>;
+    readonly buttonTexts: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => [string, string]) | (() => [string, string]) | (((new (...args: any[]) => [string, string]) | (() => [string, string])) | null)[], unknown, unknown, () => never[], boolean>;
+    readonly filterPlaceholder: StringConstructor;
+    readonly filterMethod: {
+        readonly type: import("vue").PropType<(query: string, item: TransferDataItem) => boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly leftDefaultChecked: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => TransferKey[]) | (() => TransferKey[]) | (((new (...args: any[]) => TransferKey[]) | (() => TransferKey[])) | null)[], unknown, unknown, () => never[], boolean>;
+    readonly rightDefaultChecked: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => TransferKey[]) | (() => TransferKey[]) | (((new (...args: any[]) => TransferKey[]) | (() => TransferKey[])) | null)[], unknown, unknown, () => never[], boolean>;
+    readonly renderContent: {
+        readonly type: import("vue").PropType<renderContent<TransferDataItem>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly modelValue: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => TransferKey[]) | (() => TransferKey[]) | (((new (...args: any[]) => TransferKey[]) | (() => TransferKey[])) | null)[], unknown, unknown, () => never[], boolean>;
+    readonly format: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => TransferFormat) | (() => TransferFormat) | (((new (...args: any[]) => TransferFormat) | (() => TransferFormat)) | null)[], unknown, unknown, () => {}, boolean>;
+    readonly filterable: BooleanConstructor;
+    readonly props: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => TransferPropsAlias) | (() => TransferPropsAlias) | (((new (...args: any[]) => TransferPropsAlias) | (() => TransferPropsAlias)) | null)[], unknown, unknown, () => import("@element-plus/utils").Mutable<{
+        readonly label: "label";
+        readonly key: "key";
+        readonly disabled: "disabled";
+    }>, boolean>;
+    readonly targetOrder: import("@element-plus/utils").EpPropFinalized<StringConstructor, "push" | "unshift" | "original", unknown, "original", boolean>;
+    readonly validateEvent: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly virtualScroll: BooleanConstructor;
+    readonly itemSize: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 30, boolean>;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `TransferProps` instead.
+ */
+export type TransferPropsPublic = ExtractPublicPropTypes<typeof transferProps>;
+export declare const transferCheckedChangeFn: (value: TransferKey[], movedKeys?: TransferKey[]) => boolean;
+export declare const transferEmits: {
+    change: (value: TransferKey[], direction: TransferDirection, movedKeys: TransferKey[]) => boolean;
+    "update:modelValue": (value: TransferKey[]) => boolean;
+    "left-check-change": (value: TransferKey[], movedKeys?: TransferKey[]) => boolean;
+    "right-check-change": (value: TransferKey[], movedKeys?: TransferKey[]) => boolean;
+};
+export type TransferEmits = typeof transferEmits;
+export type TransferInstance = ComponentInstance<typeof Transfer> & ComponentExposed<typeof Transfer>;

package/dist/components/transfer/transfer.js

@@ -0,0 +1,130 @@
+import { isNil as i } from "lodash-unified";
+import { isArray as a } from "@vue/shared";
+import "@vueuse/core";
+import { mutable as n } from "../../utils/typescript.js";
+import { UPDATE_MODEL_EVENT as f, CHANGE_EVENT as p } from "../../constants/event.js";
+import "@element-plus/icons-vue";
+import { buildProps as d, definePropType as e } from "../../utils/vue/props/runtime.js";
+import "vue";
+const u = "left-check-change", y = "right-check-change", A = d({
+  /**
+   * @description data source
+   */
+  data: {
+    type: e(Array),
+    default: () => []
+  },
+  /**
+   * @description custom list titles
+   */
+  titles: {
+    type: e(Array),
+    default: () => []
+  },
+  /**
+   * @description custom button texts
+   */
+  buttonTexts: {
+    type: e(Array),
+    default: () => []
+  },
+  /**
+   * @description placeholder for the filter input
+   */
+  filterPlaceholder: String,
+  /**
+   * @description custom filter method
+   */
+  filterMethod: {
+    type: e(
+      Function
+    )
+  },
+  /**
+   * @description key array of initially checked data items of the left list
+   */
+  leftDefaultChecked: {
+    type: e(Array),
+    default: () => []
+  },
+  /**
+   * @description key array of initially checked data items of the right list
+   */
+  rightDefaultChecked: {
+    type: e(Array),
+    default: () => []
+  },
+  /**
+   * @description custom render function for data items
+   */
+  renderContent: {
+    type: e(Function)
+  },
+  /**
+   * @description binding value
+   */
+  modelValue: {
+    type: e(Array),
+    default: () => []
+  },
+  /**
+   * @description texts for checking status in list header
+   */
+  format: {
+    type: e(Object),
+    default: () => ({})
+  },
+  /**
+   * @description whether Transfer is filterable
+   */
+  filterable: Boolean,
+  /**
+   * @description prop aliases for data source
+   */
+  props: {
+    type: e(Object),
+    default: () => n({
+      label: "label",
+      key: "key",
+      disabled: "disabled"
+    })
+  },
+  /**
+   * @description order strategy for elements in the target list. If set to `original`, the elements will keep the same order as the data source. If set to `push`, the newly added elements will be pushed to the bottom. If set to `unshift`, the newly added elements will be inserted on the top
+   */
+  targetOrder: {
+    type: String,
+    values: ["original", "push", "unshift"],
+    default: "original"
+  },
+  /**
+   * @description whether to trigger form validation
+   */
+  validateEvent: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description whether to enable virtual scrolling
+   */
+  virtualScroll: Boolean,
+  /**
+   * @description line height for virtual scrolling
+   */
+  itemSize: {
+    type: Number,
+    default: 30
+  }
+}), l = (t, r) => [t, r].every(a) || a(t) && i(r), N = {
+  [p]: (t, r, o) => [t, o].every(a) && ["left", "right"].includes(r),
+  [f]: (t) => a(t),
+  [u]: l,
+  [y]: l
+};
+export {
+  u as LEFT_CHECK_CHANGE_EVENT,
+  y as RIGHT_CHECK_CHANGE_EVENT,
+  l as transferCheckedChangeFn,
+  N as transferEmits,
+  A as transferProps
+};

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

@@ -1,4 +1,9 @@
 import type { Plugin } from 'vue';
-import { ElTree } from 'element-plus';
-export declare const EpTree: typeof ElTree & Plugin;
+import _EpTree from './src/tree.vue';
+export declare const EpTree: typeof _EpTree & Plugin;
 export default EpTree;
+export { treeEmits, treeProps } from './src/tree';
+export { NODE_INSTANCE_INJECTION_KEY, ROOT_TREE_INJECTION_KEY, TREE_NODE_MAP_INJECTION_KEY, } from './src/tokens';
+export type { TreeEmits } from './src/tree';
+export type { TreeInstance } from './src/instance';
+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, } from './src/tree.type';

package/dist/components/tree/index.js

@@ -1,6 +1,10 @@
-import { ElTree as e } from "element-plus";
-import { withInstall as r } from "../../utils/with-install.js";
-const t = Object.assign({}, e, { name: "EpTree" }), m = r(t, "ep-tree");
+import { withInstall as e } from "../../utils/with-install.js";
+import r from "./src/tree.vue.js";
+import { treeEmits as f, treeProps as i } from "./src/tree.js";
+const p = e(r, "ep-tree");
 export {
-  m as EpTree
+  p as EpTree,
+  p as default,
+  f as treeEmits,
+  i as treeProps
 };

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

@@ -0,0 +1,2 @@
+import type Tree from './tree.vue';
+export type TreeInstance = InstanceType<typeof Tree> & unknown;

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

@@ -0,0 +1,63 @@
+import type TreeStore from './tree-store';
+import type { Nullable } from '@element-plus/utils';
+import type { FakeNode, TreeKey, TreeNodeChildState, TreeNodeData, TreeNodeLoadedDefaultProps, TreeNodeOptions } from '../tree.type';
+export declare const getChildState: (node: Node[]) => TreeNodeChildState;
+declare class Node {
+    id: number;
+    text: string | null;
+    checked: boolean;
+    indeterminate: boolean;
+    data: TreeNodeData;
+    expanded: boolean;
+    parent: Node | null;
+    visible: boolean;
+    isCurrent: boolean;
+    store: TreeStore;
+    isLeafByUser: boolean | undefined;
+    isLeaf: boolean | undefined;
+    canFocus: boolean;
+    level: number;
+    loaded: boolean;
+    childNodes: Node[];
+    loading: boolean;
+    /**
+     * Determines whether the current tree node is effectively checked.
+     *
+     * Rules:
+     * 1. A disabled leaf node is always considered checked.
+     * 2. A non-disabled leaf node reflects its actual checked state.
+     * 3. A non-leaf node is considered checked only when:
+     *    - All of its child nodes are effectively checked, and
+     *    - Each child follows the same evaluation rules:
+     *      - Disabled leaf nodes follow rule #1.
+     *      - Non-leaf child nodes are recursively evaluated under this rule (#3).
+     */
+    isEffectivelyChecked: boolean;
+    constructor(options: TreeNodeOptions);
+    initialize(): void;
+    setData(data: TreeNodeData): void;
+    get label(): string;
+    get key(): TreeKey | null | undefined;
+    get disabled(): boolean;
+    get nextSibling(): Nullable<Node>;
+    get previousSibling(): Nullable<Node>;
+    contains(target: Node, deep?: boolean): boolean;
+    remove(): void;
+    insertChild(child?: FakeNode | Node, index?: number, batch?: boolean): void;
+    insertBefore(child: FakeNode | Node, ref: Node): void;
+    insertAfter(child: FakeNode | Node, ref: Node): void;
+    removeChild(child: Node): void;
+    removeChildByData(data: TreeNodeData | null): void;
+    expand(callback?: (() => void) | null, expandParent?: boolean): void;
+    doCreateChildren(array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps): void;
+    collapse(): void;
+    shouldLoadData(): boolean;
+    updateLeafState(): void;
+    setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void;
+    getChildren(forceInit?: boolean): TreeNodeData | TreeNodeData[] | null;
+    updateChildren(): void;
+    loadData(callback: (data?: TreeNodeData[]) => void, defaultProps?: TreeNodeLoadedDefaultProps): void;
+    eachNode(callback: (node: Node) => void): void;
+    reInitChecked(): void;
+}
+export default Node;

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

@@ -0,0 +1,263 @@
+import { reactive as m } from "vue";
+import { isNil as D } from "lodash-unified";
+import { isBoolean as S, isUndefined as o } from "../../../../utils/types.js";
+import "@vueuse/core";
+import { hasOwn as b, isArray as c, isFunction as w, isString as z } from "@vue/shared";
+import "@element-plus/icons-vue";
+import { markNodeData as g, NODE_KEY as k } from "./util.js";
+const v = (a) => {
+  let e = !0, t = !0, s = !0, i = !0;
+  for (let h = 0, d = a.length; h < d; h++) {
+    const r = a[h];
+    (r.checked !== !0 || r.indeterminate) && (e = !1, r.disabled || (s = !1)), (r.checked !== !1 || r.indeterminate) && (t = !1), r.isEffectivelyChecked || (i = !1);
+  }
+  return {
+    all: e,
+    none: t,
+    allWithoutDisable: s,
+    half: !e && !t,
+    isEffectivelyChecked: i
+  };
+}, n = function(a) {
+  if (a.childNodes.length === 0 || a.loading) {
+    a.isEffectivelyChecked = a.disabled || a.checked;
+    return;
+  }
+  const { all: e, none: t, half: s, isEffectivelyChecked: i } = v(
+    a.childNodes
+  );
+  a.isEffectivelyChecked = i, e ? (a.checked = !0, a.indeterminate = !1) : s ? (a.checked = !1, a.indeterminate = !0) : t && (a.checked = !1, a.indeterminate = !1);
+  const h = a.parent;
+  !h || h.level === 0 || a.store.checkStrictly || n(h);
+}, u = function(a, e) {
+  const t = a.store.props, s = a.data || {}, i = t[e];
+  if (w(i))
+    return i(s, a);
+  if (z(i))
+    return s[i];
+  if (o(i)) {
+    const h = s[e];
+    return o(h) ? "" : h;
+  }
+}, C = function(a, e) {
+  a.forEach((t) => {
+    t.canFocus = e, C(t.childNodes, e);
+  });
+};
+let O = 0;
+class p {
+  constructor(e) {
+    this.isLeafByUser = void 0, this.isLeaf = void 0, this.isEffectivelyChecked = !1, this.id = O++, this.text = null, this.checked = !1, this.indeterminate = !1, this.data = null, this.expanded = !1, this.parent = null, this.visible = !0, this.isCurrent = !1, this.canFocus = !1;
+    for (const t in e)
+      b(e, t) && (this[t] = e[t]);
+    this.level = 0, this.loaded = !1, this.childNodes = [], this.loading = !1, this.parent && (this.level = this.parent.level + 1);
+  }
+  initialize() {
+    var h;
+    const e = this.store;
+    if (!e)
+      throw new Error("[Node]store is required!");
+    e.registerNode(this);
+    const t = e.props;
+    if (t && typeof t.isLeaf < "u") {
+      const d = u(this, "isLeaf");
+      S(d) && (this.isLeafByUser = d);
+    }
+    if (e.lazy !== !0 && this.data ? (this.setData(this.data), e.defaultExpandAll && (this.expanded = !0, this.canFocus = !0)) : this.level > 0 && e.lazy && e.defaultExpandAll && !this.isLeafByUser && this.expand(), c(this.data) || g(this, this.data), !this.data) return;
+    const s = e.defaultExpandedKeys, i = e.key;
+    i && !D(this.key) && s && s.includes(this.key) && this.expand(null, e.autoExpandParent), i && e.currentNodeKey !== void 0 && this.key === e.currentNodeKey && (e.currentNode && (e.currentNode.isCurrent = !1), e.currentNode = this, e.currentNode.isCurrent = !0), e.lazy && e._initDefaultCheckedNode(this), this.updateLeafState(), (this.level === 1 || ((h = this.parent) == null ? void 0 : h.expanded) === !0) && (this.canFocus = !0);
+  }
+  setData(e) {
+    c(e) || g(this, e), this.data = e, this.childNodes = [];
+    let t;
+    this.level === 0 && c(this.data) ? t = this.data : t = u(this, "children") || [];
+    for (let s = 0, i = t.length; s < i; s++)
+      this.insertChild({ data: t[s] });
+  }
+  get label() {
+    return u(this, "label");
+  }
+  get key() {
+    const e = this.store.key;
+    return this.data ? this.data[e] : null;
+  }
+  get disabled() {
+    return u(this, "disabled");
+  }
+  get nextSibling() {
+    const e = this.parent;
+    if (e) {
+      const t = e.childNodes.indexOf(this);
+      if (t > -1)
+        return e.childNodes[t + 1];
+    }
+    return null;
+  }
+  get previousSibling() {
+    const e = this.parent;
+    if (e) {
+      const t = e.childNodes.indexOf(this);
+      if (t > -1)
+        return t > 0 ? e.childNodes[t - 1] : null;
+    }
+    return null;
+  }
+  contains(e, t = !0) {
+    return (this.childNodes || []).some(
+      (s) => s === e || t && s.contains(e)
+    );
+  }
+  remove() {
+    const e = this.parent;
+    e && e.removeChild(this);
+  }
+  insertChild(e, t, s) {
+    if (!e) throw new Error("InsertChild error: child is required.");
+    if (!(e instanceof p)) {
+      if (!s) {
+        const i = this.getChildren(!0);
+        i != null && i.includes(e.data) || (o(t) || t < 0 ? i == null || i.push(e.data) : i == null || i.splice(t, 0, e.data));
+      }
+      Object.assign(e, {
+        parent: this,
+        store: this.store
+      }), e = m(new p(e)), e instanceof p && e.initialize();
+    }
+    e.level = this.level + 1, o(t) || t < 0 ? this.childNodes.push(e) : this.childNodes.splice(t, 0, e), this.updateLeafState();
+  }
+  insertBefore(e, t) {
+    let s;
+    t && (s = this.childNodes.indexOf(t)), this.insertChild(e, s);
+  }
+  insertAfter(e, t) {
+    let s;
+    t && (s = this.childNodes.indexOf(t), s !== -1 && (s += 1)), this.insertChild(e, s);
+  }
+  removeChild(e) {
+    const t = this.getChildren() || [], s = t.indexOf(e.data);
+    s > -1 && t.splice(s, 1);
+    const i = this.childNodes.indexOf(e);
+    i > -1 && (this.store && this.store.deregisterNode(e), e.parent = null, this.childNodes.splice(i, 1)), this.updateLeafState();
+  }
+  removeChildByData(e) {
+    const t = this.childNodes.find((s) => s.data === e);
+    t && this.removeChild(t);
+  }
+  expand(e, t) {
+    const s = () => {
+      if (t) {
+        let i = this.parent;
+        for (; i && i.level > 0; )
+          i.expanded = !0, i = i.parent;
+      }
+      this.expanded = !0, e && e(), C(this.childNodes, !0);
+    };
+    this.shouldLoadData() ? this.loadData((i) => {
+      c(i) && (this.store.checkStrictly || (this.checked ? this.setChecked(!0, !0) : n(this)), s());
+    }) : s();
+  }
+  doCreateChildren(e, t = {}) {
+    e.forEach((s) => {
+      this.insertChild(
+        Object.assign({ data: s }, t),
+        void 0,
+        !0
+      );
+    });
+  }
+  collapse() {
+    this.expanded = !1, C(this.childNodes, !1);
+  }
+  shouldLoadData() {
+    return !!(this.store.lazy === !0 && this.store.load && !this.loaded);
+  }
+  updateLeafState() {
+    if (this.store.lazy === !0 && this.loaded !== !0 && typeof this.isLeafByUser < "u") {
+      this.isLeaf = this.isLeafByUser, this.isEffectivelyChecked = this.isLeaf && this.disabled;
+      return;
+    }
+    const e = this.childNodes;
+    if (!this.store.lazy || this.store.lazy === !0 && this.loaded === !0) {
+      this.isLeaf = !e || e.length === 0, this.isEffectivelyChecked = this.isLeaf && this.disabled;
+      return;
+    }
+    this.isLeaf = !1;
+  }
+  setChecked(e, t, s, i) {
+    if (this.indeterminate = e === "half", this.checked = e === !0, this.isEffectivelyChecked = !this.childNodes.length && (this.disabled || this.checked), this.store.checkStrictly && !t) return;
+    if (!(this.shouldLoadData() && !this.store.checkDescendants)) {
+      const d = () => {
+        if (t) {
+          const r = this.childNodes;
+          for (let y = 0, x = r.length; y < x; y++) {
+            const f = r[y];
+            i = i || e !== !1;
+            const L = f.disabled && f.isLeaf ? f.checked : i;
+            f.setChecked(L, t, !0, i);
+          }
+          const { half: N, all: l, isEffectivelyChecked: E } = v(r);
+          l || (this.checked = l, this.indeterminate = N), this.isEffectivelyChecked = this.childNodes.length ? E : this.disabled || this.checked;
+        }
+      };
+      if (this.shouldLoadData()) {
+        this.loadData(
+          () => {
+            d(), n(this);
+          },
+          {
+            checked: e !== !1
+          }
+        );
+        return;
+      } else
+        d();
+    }
+    const h = this.parent;
+    !h || h.level === 0 || !s && !this.store.checkStrictly && n(h);
+  }
+  getChildren(e = !1) {
+    if (this.level === 0) return this.data;
+    const t = this.data;
+    if (!t) return null;
+    const s = this.store.props;
+    let i = "children";
+    return s && (i = s.children || "children"), o(t[i]) && (t[i] = null), e && !t[i] && (t[i] = []), t[i];
+  }
+  updateChildren() {
+    const e = this.getChildren() || [], t = this.childNodes.map((h) => h.data), s = {}, i = [];
+    e.forEach((h, d) => {
+      const r = h[k];
+      !!r && t.some((l) => (l == null ? void 0 : l[k]) === r) ? s[r] = { index: d, data: h } : i.push({ index: d, data: h });
+    }), this.store.lazy || t.forEach((h) => {
+      s[h == null ? void 0 : h[k]] || this.removeChildByData(h);
+    }), i.forEach(({ index: h, data: d }) => {
+      this.insertChild({ data: d }, h);
+    }), this.updateLeafState();
+  }
+  loadData(e, t = {}) {
+    if (this.store.lazy === !0 && this.store.load && !this.loaded && (!this.loading || Object.keys(t).length)) {
+      this.loading = !0;
+      const s = (h) => {
+        this.childNodes = [], this.doCreateChildren(h, t), this.loaded = !0, this.loading = !1, this.updateLeafState(), e && e.call(this, h);
+      }, i = () => {
+        this.loading = !1;
+      };
+      this.store.load(this, s, i);
+    } else
+      e && e.call(this);
+  }
+  eachNode(e) {
+    const t = [this];
+    for (; t.length; ) {
+      const s = t.shift();
+      t.unshift(...s.childNodes), e(s);
+    }
+  }
+  reInitChecked() {
+    this.store.checkStrictly || n(this);
+  }
+}
+export {
+  p as default,
+  v as getChildState
+};

package/dist/components/tree/src/model/tree-store.d.ts

@@ -0,0 +1,51 @@
+import Node from './node';
+import type { FilterNodeMethodFunction, FilterValue, LoadFunction, TreeData, TreeKey, TreeNodeData, TreeOptionProps, TreeStoreNodesMap, TreeStoreOptions } from '../tree.type';
+export default class TreeStore {
+    currentNode: Node | null;
+    currentNodeKey: TreeKey | null;
+    nodesMap: TreeStoreNodesMap;
+    root: Node;
+    data: TreeData;
+    lazy: boolean;
+    load?: LoadFunction;
+    filterNodeMethod?: FilterNodeMethodFunction;
+    key: TreeKey;
+    defaultCheckedKeys?: TreeKey[];
+    checkStrictly: boolean;
+    defaultExpandedKeys?: TreeKey[];
+    autoExpandParent: boolean;
+    defaultExpandAll: boolean;
+    checkDescendants: boolean;
+    props: TreeOptionProps;
+    constructor(options: TreeStoreOptions);
+    initialize(): void;
+    filter(value: FilterValue): void;
+    setData(newVal: TreeData): void;
+    getNode(data: TreeKey | TreeNodeData | Node): Node;
+    insertBefore(data: TreeNodeData, refData: TreeKey | TreeNodeData | Node): void;
+    insertAfter(data: TreeNodeData, refData: TreeKey | TreeNodeData | Node): void;
+    remove(data: TreeNodeData | Node): void;
+    append(data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node): void;
+    _initDefaultCheckedNodes(): void;
+    _initDefaultCheckedNode(node: Node): void;
+    setDefaultCheckedKey(newVal: TreeKey[]): void;
+    registerNode(node: Node): void;
+    deregisterNode(node: Node): void;
+    getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): TreeNodeData[];
+    getCheckedKeys(leafOnly?: boolean): TreeKey[];
+    getHalfCheckedNodes(): TreeNodeData[];
+    getHalfCheckedKeys(): TreeKey[];
+    _getAllNodes(): Node[];
+    updateChildren(key: TreeKey, data: TreeData): void;
+    _setCheckedKeys(key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
+        [key: string]: boolean;
+    }): void;
+    setCheckedNodes(array: Node[], leafOnly?: boolean): void;
+    setCheckedKeys(keys: TreeKey[], leafOnly?: boolean): void;
+    setDefaultExpandedKeys(keys: TreeKey[]): void;
+    setChecked(data: TreeKey | TreeNodeData, checked: boolean, deep: boolean): void;
+    getCurrentNode(): Node | null;
+    setCurrentNode(currentNode: Node): void;
+    setUserCurrentNode(node: Node, shouldAutoExpandParent?: boolean): void;
+    setCurrentNodeKey(key: TreeKey | null, shouldAutoExpandParent?: boolean): void;
+}