鍒濆鎻愪氦锛氱墰鍙暟鎹鐞嗙郴缁?- 鍖呭惈鍚庣Spring Boot鍜屽墠绔疺ue3椤圭洰

admin-system/node_modules/element-plus/lib/components/tree-v2/src/composables/useCheck.d.ts

@@ -0,0 +1,15 @@
+import type { CheckboxValueType } from 'element-plus/es/components/checkbox';
+import type { Ref } from 'vue';
+import type { Tree, TreeKey, TreeNode, TreeNodeData, TreeProps } from '../types';
+export declare function useCheck(props: TreeProps, tree: Ref<Tree | undefined>): {
+    updateCheckedKeys: () => void;
+    toggleCheckbox: (node: TreeNode, isChecked: CheckboxValueType, nodeClick?: boolean, immediateUpdate?: boolean) => void;
+    isChecked: (node: TreeNode) => boolean;
+    isIndeterminate: (node: TreeNode) => boolean;
+    getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+    getCheckedNodes: (leafOnly?: boolean) => TreeNodeData[];
+    getHalfCheckedKeys: () => TreeKey[];
+    getHalfCheckedNodes: () => TreeNodeData[];
+    setChecked: (key: TreeKey, isChecked: boolean) => void;
+    setCheckedKeys: (keys: TreeKey[]) => void;
+};

admin-system/node_modules/element-plus/lib/components/tree-v2/src/composables/useCheck.js

@@ -0,0 +1,196 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var virtualTree = require('../virtual-tree.js');
+
+function useCheck(props, tree) {
+  const checkedKeys = vue.ref(/* @__PURE__ */ new Set());
+  const indeterminateKeys = vue.ref(/* @__PURE__ */ new Set());
+  const { emit } = vue.getCurrentInstance();
+  vue.watch([() => tree.value, () => props.defaultCheckedKeys], () => {
+    return vue.nextTick(() => {
+      _setCheckedKeys(props.defaultCheckedKeys);
+    });
+  }, {
+    immediate: true
+  });
+  const updateCheckedKeys = () => {
+    if (!tree.value || !props.showCheckbox || props.checkStrictly) {
+      return;
+    }
+    const { levelTreeNodeMap, maxLevel } = tree.value;
+    const checkedKeySet = checkedKeys.value;
+    const indeterminateKeySet = /* @__PURE__ */ new Set();
+    for (let level = maxLevel; level >= 1; --level) {
+      const nodes = levelTreeNodeMap.get(level);
+      if (!nodes)
+        continue;
+      nodes.forEach((node) => {
+        const children = node.children;
+        let isEffectivelyChecked = !node.isLeaf || node.disabled || checkedKeySet.has(node.key);
+        if (children) {
+          let allChecked = true;
+          let hasChecked = false;
+          for (const childNode of children) {
+            const key = childNode.key;
+            if (!childNode.isEffectivelyChecked) {
+              isEffectivelyChecked = false;
+            }
+            if (checkedKeySet.has(key)) {
+              hasChecked = true;
+            } else if (indeterminateKeySet.has(key)) {
+              allChecked = false;
+              hasChecked = true;
+              break;
+            } else {
+              allChecked = false;
+            }
+          }
+          if (allChecked) {
+            checkedKeySet.add(node.key);
+          } else if (hasChecked) {
+            indeterminateKeySet.add(node.key);
+            checkedKeySet.delete(node.key);
+          } else {
+            checkedKeySet.delete(node.key);
+            indeterminateKeySet.delete(node.key);
+          }
+        }
+        node.isEffectivelyChecked = isEffectivelyChecked;
+      });
+    }
+    indeterminateKeys.value = indeterminateKeySet;
+  };
+  const isChecked = (node) => checkedKeys.value.has(node.key);
+  const isIndeterminate = (node) => indeterminateKeys.value.has(node.key);
+  const toggleCheckbox = (node, isChecked2, nodeClick = true, immediateUpdate = true) => {
+    const checkedKeySet = checkedKeys.value;
+    const children = node.children;
+    if (!props.checkStrictly && nodeClick && (children == null ? void 0 : children.length)) {
+      isChecked2 = children.some((node2) => !node2.isEffectivelyChecked);
+    }
+    const toggle = (node2, checked) => {
+      checkedKeySet[checked ? virtualTree.SetOperationEnum.ADD : virtualTree.SetOperationEnum.DELETE](node2.key);
+      const children2 = node2.children;
+      if (!props.checkStrictly && children2) {
+        children2.forEach((childNode) => {
+          if (!childNode.disabled || childNode.children) {
+            toggle(childNode, checked);
+          }
+        });
+      }
+    };
+    toggle(node, isChecked2);
+    if (immediateUpdate) {
+      updateCheckedKeys();
+    }
+    if (nodeClick) {
+      afterNodeCheck(node, isChecked2);
+    }
+  };
+  const afterNodeCheck = (node, checked) => {
+    const { checkedNodes, checkedKeys: checkedKeys2 } = getChecked();
+    const { halfCheckedNodes, halfCheckedKeys } = getHalfChecked();
+    emit(virtualTree.NODE_CHECK, node.data, {
+      checkedKeys: checkedKeys2,
+      checkedNodes,
+      halfCheckedKeys,
+      halfCheckedNodes
+    });
+    emit(virtualTree.NODE_CHECK_CHANGE, node.data, checked);
+  };
+  function getCheckedKeys(leafOnly = false) {
+    return getChecked(leafOnly).checkedKeys;
+  }
+  function getCheckedNodes(leafOnly = false) {
+    return getChecked(leafOnly).checkedNodes;
+  }
+  function getHalfCheckedKeys() {
+    return getHalfChecked().halfCheckedKeys;
+  }
+  function getHalfCheckedNodes() {
+    return getHalfChecked().halfCheckedNodes;
+  }
+  function getChecked(leafOnly = false) {
+    const checkedNodes = [];
+    const keys = [];
+    if ((tree == null ? void 0 : tree.value) && props.showCheckbox) {
+      const { treeNodeMap } = tree.value;
+      checkedKeys.value.forEach((key) => {
+        const node = treeNodeMap.get(key);
+        if (node && (!leafOnly || leafOnly && node.isLeaf)) {
+          keys.push(key);
+          checkedNodes.push(node.data);
+        }
+      });
+    }
+    return {
+      checkedKeys: keys,
+      checkedNodes
+    };
+  }
+  function getHalfChecked() {
+    const halfCheckedNodes = [];
+    const halfCheckedKeys = [];
+    if ((tree == null ? void 0 : tree.value) && props.showCheckbox) {
+      const { treeNodeMap } = tree.value;
+      indeterminateKeys.value.forEach((key) => {
+        const node = treeNodeMap.get(key);
+        if (node) {
+          halfCheckedKeys.push(key);
+          halfCheckedNodes.push(node.data);
+        }
+      });
+    }
+    return {
+      halfCheckedNodes,
+      halfCheckedKeys
+    };
+  }
+  function setCheckedKeys(keys) {
+    checkedKeys.value.clear();
+    indeterminateKeys.value.clear();
+    vue.nextTick(() => {
+      _setCheckedKeys(keys);
+    });
+  }
+  function setChecked(key, isChecked2) {
+    if ((tree == null ? void 0 : tree.value) && props.showCheckbox) {
+      const node = tree.value.treeNodeMap.get(key);
+      if (node) {
+        toggleCheckbox(node, isChecked2, false);
+      }
+    }
+  }
+  function _setCheckedKeys(keys) {
+    if (tree == null ? void 0 : tree.value) {
+      const { treeNodeMap } = tree.value;
+      if (props.showCheckbox && treeNodeMap && (keys == null ? void 0 : keys.length) > 0) {
+        for (const key of keys) {
+          const node = treeNodeMap.get(key);
+          if (node && !isChecked(node)) {
+            toggleCheckbox(node, true, false, false);
+          }
+        }
+        updateCheckedKeys();
+      }
+    }
+  }
+  return {
+    updateCheckedKeys,
+    toggleCheckbox,
+    isChecked,
+    isIndeterminate,
+    getCheckedKeys,
+    getCheckedNodes,
+    getHalfCheckedKeys,
+    getHalfCheckedNodes,
+    setChecked,
+    setCheckedKeys
+  };
+}
+
+exports.useCheck = useCheck;
+//# sourceMappingURL=useCheck.js.map

admin-system/node_modules/element-plus/lib/components/tree-v2/src/composables/useFilter.d.ts

@@ -0,0 +1,8 @@
+import type { Ref } from 'vue';
+import type { Tree, TreeKey, TreeNode, TreeProps } from '../types';
+export declare function useFilter(props: TreeProps, tree: Ref<Tree | undefined>): {
+    hiddenExpandIconKeySet: Ref<Set<TreeKey>>;
+    hiddenNodeKeySet: Ref<Set<TreeKey>>;
+    doFilter: (query: string) => Set<TreeKey> | undefined;
+    isForceHiddenExpandIcon: (node: TreeNode) => boolean;
+};

admin-system/node_modules/element-plus/lib/components/tree-v2/src/composables/useFilter.js

@@ -0,0 +1,80 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var shared = require('@vue/shared');
+
+function useFilter(props, tree) {
+  const hiddenNodeKeySet = vue.ref(/* @__PURE__ */ new Set([]));
+  const hiddenExpandIconKeySet = vue.ref(/* @__PURE__ */ new Set([]));
+  const filterable = vue.computed(() => {
+    return shared.isFunction(props.filterMethod);
+  });
+  function doFilter(query) {
+    var _a;
+    if (!filterable.value) {
+      return;
+    }
+    const expandKeySet = /* @__PURE__ */ new Set();
+    const hiddenExpandIconKeys = hiddenExpandIconKeySet.value;
+    const hiddenKeys = hiddenNodeKeySet.value;
+    const family = [];
+    const nodes = ((_a = tree.value) == null ? void 0 : _a.treeNodes) || [];
+    const filter = props.filterMethod;
+    hiddenKeys.clear();
+    function traverse(nodes2) {
+      nodes2.forEach((node) => {
+        family.push(node);
+        if (filter == null ? void 0 : filter(query, node.data, node)) {
+          family.forEach((member) => {
+            expandKeySet.add(member.key);
+            member.expanded = true;
+          });
+        } else {
+          node.expanded = false;
+          if (node.isLeaf) {
+            hiddenKeys.add(node.key);
+          }
+        }
+        const children = node.children;
+        if (children) {
+          traverse(children);
+        }
+        if (!node.isLeaf) {
+          if (!expandKeySet.has(node.key)) {
+            hiddenKeys.add(node.key);
+          } else if (children) {
+            let allHidden = true;
+            for (const childNode of children) {
+              if (!hiddenKeys.has(childNode.key)) {
+                allHidden = false;
+                break;
+              }
+            }
+            if (allHidden) {
+              hiddenExpandIconKeys.add(node.key);
+            } else {
+              hiddenExpandIconKeys.delete(node.key);
+            }
+          }
+        }
+        family.pop();
+      });
+    }
+    traverse(nodes);
+    return expandKeySet;
+  }
+  function isForceHiddenExpandIcon(node) {
+    return hiddenExpandIconKeySet.value.has(node.key);
+  }
+  return {
+    hiddenExpandIconKeySet,
+    hiddenNodeKeySet,
+    doFilter,
+    isForceHiddenExpandIcon
+  };
+}
+
+exports.useFilter = useFilter;
+//# sourceMappingURL=useFilter.js.map

admin-system/node_modules/element-plus/lib/components/tree-v2/src/composables/useTree.d.ts

@@ -0,0 +1,205 @@
+import type { Alignment as ScrollStrategy } from 'element-plus/es/components/virtual-list';
+import type { SetupContext } from 'vue';
+import type { treeEmits } from '../virtual-tree';
+import type { CheckboxValueType } from 'element-plus/es/components/checkbox';
+import type { Tree, TreeData, TreeKey, TreeNode, TreeNodeData, TreeProps } from '../types';
+export declare function useTree(props: TreeProps, emit: SetupContext<typeof treeEmits>['emit']): {
+    tree: import("vue").ShallowRef<Tree | undefined>;
+    flattenTree: import("vue").ComputedRef<TreeNode[]>;
+    isNotEmpty: import("vue").ComputedRef<boolean>;
+    listRef: import("vue").Ref<import("vue").DefineComponent<{
+        readonly className: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly containerElement: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | Element) | (() => string | Element) | ((new (...args: any[]) => string | Element) | (() => string | Element))[], unknown, unknown, "div", boolean>;
+        readonly data: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => any[]) | (() => any[]) | ((new (...args: any[]) => any[]) | (() => any[]))[], unknown, unknown, () => [], boolean>;
+        readonly direction: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "ltr" | "rtl", never, "ltr", false>;
+        readonly height: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+            readonly required: true;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly innerElement: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, ObjectConstructor], unknown, unknown, "div", boolean>;
+        readonly innerProps: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => Record<string, unknown>) | (() => Record<string, unknown>) | ((new (...args: any[]) => Record<string, unknown>) | (() => Record<string, unknown>))[], unknown, unknown, () => {}, boolean>;
+        readonly style: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | ((new (...args: any[]) => string | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue))[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly useIsScrolling: BooleanConstructor;
+        readonly width: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly perfMode: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly scrollbarAlwaysOn: BooleanConstructor;
+        readonly cache: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, never, never, 2, false>;
+        readonly estimatedItemSize: {
+            readonly type: import("vue").PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly layout: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "horizontal" | "vertical", never, "vertical", false>;
+        readonly initScrollOffset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, never, never, 0, false>;
+        readonly total: {
+            readonly type: import("vue").PropType<number>;
+            readonly required: true;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly itemSize: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => number | import("element-plus/es/components/virtual-list").ItemSize) | (() => number | import("element-plus/es/components/virtual-list").ItemSize) | ((new (...args: any[]) => number | import("element-plus/es/components/virtual-list").ItemSize) | (() => number | import("element-plus/es/components/virtual-list").ItemSize))[], never, never>>;
+            readonly required: true;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }, {
+        ns: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string) => string;
+            e: (element?: string) => string;
+            m: (modifier?: string) => string;
+            be: (blockSuffix?: string, element?: string) => string;
+            em: (element?: string, modifier?: string) => string;
+            bm: (blockSuffix?: string, modifier?: string) => string;
+            bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+            is: {
+                (name: string, state: boolean | undefined): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        clientSize: import("vue").ComputedRef<string | number | undefined>;
+        estimatedTotalSize: import("vue").ComputedRef<number>;
+        windowStyle: import("vue").ComputedRef<(string | import("vue").CSSProperties | import("vue").StyleValue[] | {
+            [x: string]: string;
+            position: string;
+            WebkitOverflowScrolling: string;
+            willChange: string;
+        } | undefined)[]>;
+        windowRef: import("vue").Ref<HTMLElement | undefined>;
+        innerRef: import("vue").Ref<HTMLElement | undefined>;
+        innerStyle: import("vue").ComputedRef<{
+            height: string;
+            pointerEvents: string | undefined;
+            width: string;
+        }>;
+        itemsToRender: import("vue").ComputedRef<number[]>;
+        scrollbarRef: import("vue").Ref<any>;
+        states: import("vue").Ref<{
+            isScrolling: boolean;
+            scrollDir: string;
+            scrollOffset: number;
+            updateRequested: boolean;
+            isScrollbarDragging: boolean;
+            scrollbarAlwaysOn: boolean;
+        }>;
+        getItemStyle: (idx: number) => import("vue").CSSProperties;
+        onScroll: (e: Event) => void;
+        onScrollbarScroll: (distanceToGo: number, totalSteps: number) => void;
+        onWheel: (e: WheelEvent) => void;
+        scrollTo: (offset: number) => void;
+        scrollToItem: (idx: number, alignment?: ScrollStrategy) => void;
+        resetScrollTop: () => void;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("scroll" | "itemRendered")[], "scroll" | "itemRendered", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        readonly className: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly containerElement: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | Element) | (() => string | Element) | ((new (...args: any[]) => string | Element) | (() => string | Element))[], unknown, unknown, "div", boolean>;
+        readonly data: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => any[]) | (() => any[]) | ((new (...args: any[]) => any[]) | (() => any[]))[], unknown, unknown, () => [], boolean>;
+        readonly direction: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "ltr" | "rtl", never, "ltr", false>;
+        readonly height: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+            readonly required: true;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly innerElement: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, ObjectConstructor], unknown, unknown, "div", boolean>;
+        readonly innerProps: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => Record<string, unknown>) | (() => Record<string, unknown>) | ((new (...args: any[]) => Record<string, unknown>) | (() => Record<string, unknown>))[], unknown, unknown, () => {}, boolean>;
+        readonly style: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | ((new (...args: any[]) => string | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue))[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly useIsScrolling: BooleanConstructor;
+        readonly width: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly perfMode: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly scrollbarAlwaysOn: BooleanConstructor;
+        readonly cache: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, never, never, 2, false>;
+        readonly estimatedItemSize: {
+            readonly type: import("vue").PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly layout: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "horizontal" | "vertical", never, "vertical", false>;
+        readonly initScrollOffset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, never, never, 0, false>;
+        readonly total: {
+            readonly type: import("vue").PropType<number>;
+            readonly required: true;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly itemSize: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => number | import("element-plus/es/components/virtual-list").ItemSize) | (() => number | import("element-plus/es/components/virtual-list").ItemSize) | ((new (...args: any[]) => number | import("element-plus/es/components/virtual-list").ItemSize) | (() => number | import("element-plus/es/components/virtual-list").ItemSize))[], never, never>>;
+            readonly required: true;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>> & {
+        onScroll?: ((...args: any[]) => any) | undefined;
+        onItemRendered?: ((...args: any[]) => any) | undefined;
+    }, {
+        readonly data: any[];
+        readonly direction: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "ltr" | "rtl", never>;
+        readonly layout: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "horizontal" | "vertical", never>;
+        readonly className: string;
+        readonly containerElement: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | Element) | (() => string | Element) | ((new (...args: any[]) => string | Element) | (() => string | Element))[], unknown, unknown>;
+        readonly innerElement: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, ObjectConstructor], unknown, unknown>;
+        readonly innerProps: Record<string, unknown>;
+        readonly perfMode: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly useIsScrolling: boolean;
+        readonly scrollbarAlwaysOn: boolean;
+        readonly cache: number;
+        readonly initScrollOffset: number;
+    }> | undefined>;
+    getKey: (node: TreeNodeData) => TreeKey;
+    getChildren: (node: TreeNodeData) => TreeNodeData[];
+    toggleExpand: (node: TreeNode) => void;
+    toggleCheckbox: (node: TreeNode, isChecked: CheckboxValueType, nodeClick?: boolean, immediateUpdate?: boolean) => void;
+    isChecked: (node: TreeNode) => boolean;
+    isIndeterminate: (node: TreeNode) => boolean;
+    isDisabled: (node: TreeNode) => boolean;
+    isCurrent: (node: TreeNode) => boolean;
+    isForceHiddenExpandIcon: (node: TreeNode) => boolean;
+    handleNodeClick: (node: TreeNode, e: MouseEvent) => void;
+    handleNodeDrop: (node: TreeNode, e: DragEvent) => void;
+    handleNodeCheck: (node: TreeNode, checked: CheckboxValueType) => void;
+    getCurrentNode: () => TreeNodeData | undefined;
+    getCurrentKey: () => TreeKey | undefined;
+    setCurrentKey: (key: TreeKey) => void;
+    getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+    getCheckedNodes: (leafOnly?: boolean) => TreeNodeData[];
+    getHalfCheckedKeys: () => TreeKey[];
+    getHalfCheckedNodes: () => TreeNodeData[];
+    setChecked: (key: TreeKey, isChecked: boolean) => void;
+    setCheckedKeys: (keys: TreeKey[]) => void;
+    filter: (query: string) => void;
+    setData: (data: TreeData) => void;
+    getNode: (data: TreeKey | TreeNodeData) => TreeNode | undefined;
+    expandNode: (node: TreeNode) => void;
+    collapseNode: (node: TreeNode) => void;
+    setExpandedKeys: (keys: TreeKey[]) => void;
+    scrollToNode: (key: TreeKey, strategy?: ScrollStrategy) => void;
+    scrollTo: (offset: number) => void;
+};

admin-system/node_modules/element-plus/lib/components/tree-v2/src/composables/useTree.js

@@ -0,0 +1,299 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var virtualTree = require('../virtual-tree.js');
+var useCheck = require('./useCheck.js');
+var useFilter = require('./useFilter.js');
+var shared = require('@vue/shared');
+
+function useTree(props, emit) {
+  const expandedKeySet = vue.ref(/* @__PURE__ */ new Set());
+  const currentKey = vue.ref();
+  const tree = vue.shallowRef();
+  const listRef = vue.ref();
+  const {
+    isIndeterminate,
+    isChecked,
+    toggleCheckbox,
+    getCheckedKeys,
+    getCheckedNodes,
+    getHalfCheckedKeys,
+    getHalfCheckedNodes,
+    setChecked,
+    setCheckedKeys
+  } = useCheck.useCheck(props, tree);
+  const { doFilter, hiddenNodeKeySet, isForceHiddenExpandIcon } = useFilter.useFilter(props, tree);
+  const valueKey = vue.computed(() => {
+    var _a;
+    return ((_a = props.props) == null ? void 0 : _a.value) || virtualTree.TreeOptionsEnum.KEY;
+  });
+  const childrenKey = vue.computed(() => {
+    var _a;
+    return ((_a = props.props) == null ? void 0 : _a.children) || virtualTree.TreeOptionsEnum.CHILDREN;
+  });
+  const disabledKey = vue.computed(() => {
+    var _a;
+    return ((_a = props.props) == null ? void 0 : _a.disabled) || virtualTree.TreeOptionsEnum.DISABLED;
+  });
+  const labelKey = vue.computed(() => {
+    var _a;
+    return ((_a = props.props) == null ? void 0 : _a.label) || virtualTree.TreeOptionsEnum.LABEL;
+  });
+  const flattenTree = vue.computed(() => {
+    var _a;
+    const expandedKeys = expandedKeySet.value;
+    const hiddenKeys = hiddenNodeKeySet.value;
+    const flattenNodes = [];
+    const nodes = ((_a = tree.value) == null ? void 0 : _a.treeNodes) || [];
+    const stack = [];
+    for (let i = nodes.length - 1; i >= 0; --i) {
+      stack.push(nodes[i]);
+    }
+    while (stack.length) {
+      const node = stack.pop();
+      if (hiddenKeys.has(node.key))
+        continue;
+      flattenNodes.push(node);
+      if (node.children && expandedKeys.has(node.key)) {
+        for (let i = node.children.length - 1; i >= 0; --i) {
+          stack.push(node.children[i]);
+        }
+      }
+    }
+    return flattenNodes;
+  });
+  const isNotEmpty = vue.computed(() => {
+    return flattenTree.value.length > 0;
+  });
+  function createTree(data) {
+    const treeNodeMap = /* @__PURE__ */ new Map();
+    const levelTreeNodeMap = /* @__PURE__ */ new Map();
+    let maxLevel = 1;
+    function traverse(nodes, level = 1, parent = void 0) {
+      var _a;
+      const siblings = [];
+      for (const rawNode of nodes) {
+        const value = getKey(rawNode);
+        const node = {
+          level,
+          key: value,
+          data: rawNode
+        };
+        node.label = getLabel(rawNode);
+        node.parent = parent;
+        const children = getChildren(rawNode);
+        node.disabled = getDisabled(rawNode);
+        node.isLeaf = !children || children.length === 0;
+        node.expanded = expandedKeySet.value.has(value);
+        if (children && children.length) {
+          node.children = traverse(children, level + 1, node);
+        }
+        siblings.push(node);
+        treeNodeMap.set(value, node);
+        if (!levelTreeNodeMap.has(level)) {
+          levelTreeNodeMap.set(level, []);
+        }
+        (_a = levelTreeNodeMap.get(level)) == null ? void 0 : _a.push(node);
+      }
+      if (level > maxLevel) {
+        maxLevel = level;
+      }
+      return siblings;
+    }
+    const treeNodes = traverse(data);
+    return {
+      treeNodeMap,
+      levelTreeNodeMap,
+      maxLevel,
+      treeNodes
+    };
+  }
+  function filter(query) {
+    const keys = doFilter(query);
+    if (keys) {
+      expandedKeySet.value = keys;
+    }
+  }
+  function getChildren(node) {
+    return node[childrenKey.value];
+  }
+  function getKey(node) {
+    if (!node) {
+      return "";
+    }
+    return node[valueKey.value];
+  }
+  function getDisabled(node) {
+    return node[disabledKey.value];
+  }
+  function getLabel(node) {
+    return node[labelKey.value];
+  }
+  function toggleExpand(node) {
+    const expandedKeys = expandedKeySet.value;
+    if (expandedKeys.has(node.key)) {
+      collapseNode(node);
+    } else {
+      expandNode(node);
+    }
+  }
+  function setExpandedKeys(keys) {
+    const expandedKeys = /* @__PURE__ */ new Set();
+    const nodeMap = tree.value.treeNodeMap;
+    expandedKeySet.value.forEach((key) => {
+      const node = nodeMap.get(key);
+      expandedKeySet.value.delete(node.key);
+      node.expanded = false;
+    });
+    keys.forEach((k) => {
+      let node = nodeMap.get(k);
+      while (node && !expandedKeys.has(node.key)) {
+        expandedKeys.add(node.key);
+        node.expanded = true;
+        node = node.parent;
+      }
+    });
+    expandedKeySet.value = expandedKeys;
+  }
+  function handleNodeClick(node, e) {
+    emit(virtualTree.NODE_CLICK, node.data, node, e);
+    handleCurrentChange(node);
+    if (props.expandOnClickNode) {
+      toggleExpand(node);
+    }
+    if (props.showCheckbox && (props.checkOnClickNode || node.isLeaf && props.checkOnClickLeaf) && !node.disabled) {
+      toggleCheckbox(node, !isChecked(node), true);
+    }
+  }
+  function handleNodeDrop(node, e) {
+    emit(virtualTree.NODE_DROP, node.data, node, e);
+  }
+  function handleCurrentChange(node) {
+    if (!isCurrent(node)) {
+      currentKey.value = node.key;
+      emit(virtualTree.CURRENT_CHANGE, node.data, node);
+    }
+  }
+  function handleNodeCheck(node, checked) {
+    toggleCheckbox(node, checked);
+  }
+  function expandNode(node) {
+    const keySet = expandedKeySet.value;
+    if (tree.value && props.accordion) {
+      const { treeNodeMap } = tree.value;
+      keySet.forEach((key) => {
+        const treeNode = treeNodeMap.get(key);
+        if (node && node.level === (treeNode == null ? void 0 : treeNode.level)) {
+          keySet.delete(key);
+          treeNode.expanded = false;
+        }
+      });
+    }
+    keySet.add(node.key);
+    const _node = getNode(node.key);
+    if (_node) {
+      _node.expanded = true;
+      emit(virtualTree.NODE_EXPAND, _node.data, _node);
+    }
+  }
+  function collapseNode(node) {
+    expandedKeySet.value.delete(node.key);
+    const _node = getNode(node.key);
+    if (_node) {
+      _node.expanded = false;
+      emit(virtualTree.NODE_COLLAPSE, _node.data, _node);
+    }
+  }
+  function isDisabled(node) {
+    return !!node.disabled;
+  }
+  function isCurrent(node) {
+    const current = currentKey.value;
+    return current !== void 0 && current === node.key;
+  }
+  function getCurrentNode() {
+    var _a, _b;
+    if (!currentKey.value)
+      return void 0;
+    return (_b = (_a = tree.value) == null ? void 0 : _a.treeNodeMap.get(currentKey.value)) == null ? void 0 : _b.data;
+  }
+  function getCurrentKey() {
+    return currentKey.value;
+  }
+  function setCurrentKey(key) {
+    currentKey.value = key;
+  }
+  function setData(data) {
+    tree.value = createTree(data);
+  }
+  function getNode(data) {
+    var _a;
+    const key = shared.isObject(data) ? getKey(data) : data;
+    return (_a = tree.value) == null ? void 0 : _a.treeNodeMap.get(key);
+  }
+  function scrollToNode(key, strategy = "auto") {
+    const node = getNode(key);
+    if (node && listRef.value) {
+      listRef.value.scrollToItem(flattenTree.value.indexOf(node), strategy);
+    }
+  }
+  function scrollTo(offset) {
+    var _a;
+    (_a = listRef.value) == null ? void 0 : _a.scrollTo(offset);
+  }
+  vue.watch(() => props.currentNodeKey, (key) => {
+    currentKey.value = key;
+  }, {
+    immediate: true
+  });
+  vue.watch(() => props.defaultExpandedKeys, (key) => {
+    expandedKeySet.value = new Set(key);
+  }, {
+    immediate: true
+  });
+  vue.watch(() => props.data, (data) => {
+    setData(data);
+  }, {
+    immediate: true
+  });
+  return {
+    tree,
+    flattenTree,
+    isNotEmpty,
+    listRef,
+    getKey,
+    getChildren,
+    toggleExpand,
+    toggleCheckbox,
+    isChecked,
+    isIndeterminate,
+    isDisabled,
+    isCurrent,
+    isForceHiddenExpandIcon,
+    handleNodeClick,
+    handleNodeDrop,
+    handleNodeCheck,
+    getCurrentNode,
+    getCurrentKey,
+    setCurrentKey,
+    getCheckedKeys,
+    getCheckedNodes,
+    getHalfCheckedKeys,
+    getHalfCheckedNodes,
+    setChecked,
+    setCheckedKeys,
+    filter,
+    setData,
+    getNode,
+    expandNode,
+    collapseNode,
+    setExpandedKeys,
+    scrollToNode,
+    scrollTo
+  };
+}
+
+exports.useTree = useTree;
+//# sourceMappingURL=useTree.js.map