完全跑通1.0版本

frontend/node_modules/element-plus/es/components/tree/index.d.ts

@@ -0,0 +1,12 @@
+import { SFCWithInstall } from "../../utils/vue/typescript.js";
+import { TreeEmits, treeEmits, treeProps } from "./src/tree.js";
+import { AllowDragFunction, AllowDropFunction, AllowDropType, CheckedInfo, FakeNode, FilterNodeMethodFunction, FilterValue, LoadFunction, NodeDropType, RenderContentContext, RenderContentFunction, RootTreeType, TreeComponentProps, TreeData, TreeKey, TreeNodeChildState, TreeNodeData, TreeNodeLoadedDefaultProps, TreeNodeOptions, TreeOptionProps, TreeStoreNodesMap, TreeStoreOptions, hType } from "./src/tree.type.js";
+import { DragEvents } from "./src/model/useDragNode.js";
+import _default from "./src/tree.vue.js";
+import { TreeInstance } from "./src/instance.js";
+import { NODE_INSTANCE_INJECTION_KEY, ROOT_TREE_INJECTION_KEY, TREE_NODE_MAP_INJECTION_KEY } from "./src/tokens.js";
+
+//#region ../../packages/components/tree/index.d.ts
+declare const ElTree: SFCWithInstall<typeof _default>;
+//#endregion
+export { AllowDragFunction, AllowDropFunction, AllowDropType, CheckedInfo, DragEvents, ElTree, ElTree as default, FakeNode, FilterNodeMethodFunction, FilterValue, LoadFunction, NODE_INSTANCE_INJECTION_KEY, NodeDropType, ROOT_TREE_INJECTION_KEY, RenderContentContext, RenderContentFunction, RootTreeType, TREE_NODE_MAP_INJECTION_KEY, TreeComponentProps, TreeData, TreeEmits, TreeInstance, TreeKey, TreeNodeChildState, TreeNodeData, TreeNodeLoadedDefaultProps, TreeNodeOptions, TreeOptionProps, TreeStoreNodesMap, TreeStoreOptions, hType, treeEmits, treeProps };

frontend/node_modules/element-plus/es/components/tree/index.mjs

@@ -0,0 +1,10 @@
+import { withInstall } from "../../utils/vue/install.mjs";
+import { NODE_INSTANCE_INJECTION_KEY, ROOT_TREE_INJECTION_KEY, TREE_NODE_MAP_INJECTION_KEY } from "./src/tokens.mjs";
+import { treeEmits, treeProps } from "./src/tree.mjs";
+import tree_default from "./src/tree2.mjs";
+//#region ../../packages/components/tree/index.ts
+const ElTree = withInstall(tree_default);
+//#endregion
+export { ElTree, ElTree as default, NODE_INSTANCE_INJECTION_KEY, ROOT_TREE_INJECTION_KEY, TREE_NODE_MAP_INJECTION_KEY, treeEmits, treeProps };
+
+//# sourceMappingURL=index.mjs.map

frontend/node_modules/element-plus/es/components/tree/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["Tree"],"sources":["../../../../../packages/components/tree/index.ts"],"sourcesContent":["import { withInstall } from '@element-plus/utils'\nimport Tree from './src/tree.vue'\n\nimport type { SFCWithInstall } from '@element-plus/utils'\n\nexport const ElTree: SFCWithInstall<typeof Tree> = withInstall(Tree)\n\nexport default ElTree\n\nexport * from './src/tree.type'\nexport * from './src/instance'\nexport * from './src/tokens'\nexport * from './src/tree'\n"],"mappings":";;;;;AAKA,MAAa,SAAsC,YAAYA,aAAK"}

frontend/node_modules/element-plus/es/components/tree/src/instance.d.ts

@@ -0,0 +1,6 @@
+import _default from "./tree.vue.js";
+
+//#region ../../packages/components/tree/src/instance.d.ts
+type TreeInstance = InstanceType<typeof _default> & unknown;
+//#endregion
+export { TreeInstance };

frontend/node_modules/element-plus/es/components/tree/src/model/node.d.ts

@@ -0,0 +1,66 @@
+import { Nullable } from "../../../../utils/typescript.js";
+import TreeStore from "./tree-store.js";
+import { FakeNode, TreeKey, TreeNodeChildState, TreeNodeData, TreeNodeLoadedDefaultProps, TreeNodeOptions } from "../tree.type.js";
+
+//#region ../../packages/components/tree/src/model/node.d.ts
+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;
+}
+//#endregion
+export { Node as default, getChildState };

frontend/node_modules/element-plus/es/components/tree/src/model/node.mjs

@@ -0,0 +1,363 @@
+import { isArray, isBoolean, isFunction, isString, isUndefined as isUndefined$1 } from "../../../../utils/types.mjs";
+import { hasOwn } from "../../../../utils/objects.mjs";
+import { NODE_KEY, markNodeData } from "./util.mjs";
+import { isNil } from "lodash-unified";
+import { reactive } from "vue";
+//#region ../../packages/components/tree/src/model/node.ts
+const getChildState = (node) => {
+	let all = true;
+	let none = true;
+	let allWithoutDisable = true;
+	let isEffectivelyChecked = true;
+	for (let i = 0, j = node.length; i < j; i++) {
+		const n = node[i];
+		if (n.checked !== true || n.indeterminate) {
+			all = false;
+			if (!n.disabled) allWithoutDisable = false;
+		}
+		if (n.checked !== false || n.indeterminate) none = false;
+		if (!n.isEffectivelyChecked) isEffectivelyChecked = false;
+	}
+	return {
+		all,
+		none,
+		allWithoutDisable,
+		half: !all && !none,
+		isEffectivelyChecked
+	};
+};
+const reInitChecked = function(node) {
+	if (node.childNodes.length === 0 || node.loading) {
+		node.isEffectivelyChecked = node.disabled || node.checked;
+		return;
+	}
+	const { all, none, half, isEffectivelyChecked } = getChildState(node.childNodes);
+	node.isEffectivelyChecked = isEffectivelyChecked;
+	if (all) {
+		node.checked = true;
+		node.indeterminate = false;
+	} else if (half) {
+		node.checked = false;
+		node.indeterminate = true;
+	} else if (none) {
+		node.checked = false;
+		node.indeterminate = false;
+	}
+	const parent = node.parent;
+	if (!parent || parent.level === 0) return;
+	if (!node.store.checkStrictly) reInitChecked(parent);
+};
+const getPropertyFromData = function(node, prop) {
+	const props = node.store.props;
+	const data = node.data || {};
+	const config = props[prop];
+	if (isFunction(config)) return config(data, node);
+	else if (isString(config)) return data[config];
+	else if (isUndefined$1(config)) {
+		const dataProp = data[prop];
+		return isUndefined$1(dataProp) ? "" : dataProp;
+	}
+};
+const setCanFocus = function(childNodes, focus) {
+	childNodes.forEach((item) => {
+		item.canFocus = focus;
+		setCanFocus(item.childNodes, focus);
+	});
+};
+let nodeIdSeed = 0;
+var Node = class Node {
+	constructor(options) {
+		this.isLeafByUser = void 0;
+		this.isLeaf = void 0;
+		this.isEffectivelyChecked = false;
+		this.id = nodeIdSeed++;
+		this.text = null;
+		this.checked = false;
+		this.indeterminate = false;
+		this.data = null;
+		this.expanded = false;
+		this.parent = null;
+		this.visible = true;
+		this.isCurrent = false;
+		this.canFocus = false;
+		for (const name in options) if (hasOwn(options, name)) this[name] = options[name];
+		this.level = 0;
+		this.loaded = false;
+		this.childNodes = [];
+		this.loading = false;
+		if (this.parent) this.level = this.parent.level + 1;
+	}
+	initialize() {
+		const store = this.store;
+		if (!store) throw new Error("[Node]store is required!");
+		store.registerNode(this);
+		const props = store.props;
+		if (props && typeof props.isLeaf !== "undefined") {
+			const isLeaf = getPropertyFromData(this, "isLeaf");
+			if (isBoolean(isLeaf)) this.isLeafByUser = isLeaf;
+		}
+		if (store.lazy !== true && this.data) {
+			this.setData(this.data);
+			if (store.defaultExpandAll) {
+				this.expanded = true;
+				this.canFocus = true;
+			}
+		} else if (this.level > 0 && store.lazy && store.defaultExpandAll && !this.isLeafByUser) this.expand();
+		if (!isArray(this.data)) markNodeData(this, this.data);
+		if (!this.data) return;
+		const defaultExpandedKeys = store.defaultExpandedKeys;
+		const key = store.key;
+		if (key && !isNil(this.key) && defaultExpandedKeys && defaultExpandedKeys.includes(this.key)) this.expand(null, store.autoExpandParent);
+		if (key && store.currentNodeKey !== void 0 && this.key === store.currentNodeKey) {
+			store.currentNode && (store.currentNode.isCurrent = false);
+			store.currentNode = this;
+			store.currentNode.isCurrent = true;
+		}
+		if (store.lazy) store._initDefaultCheckedNode(this);
+		this.updateLeafState();
+		if (this.level === 1 || this.parent?.expanded === true) this.canFocus = true;
+	}
+	setData(data) {
+		if (!isArray(data)) markNodeData(this, data);
+		this.data = data;
+		this.childNodes = [];
+		let children;
+		if (this.level === 0 && isArray(this.data)) children = this.data;
+		else children = getPropertyFromData(this, "children") || [];
+		for (let i = 0, j = children.length; i < j; i++) this.insertChild({ data: children[i] });
+	}
+	get label() {
+		return getPropertyFromData(this, "label");
+	}
+	get key() {
+		const nodeKey = this.store.key;
+		if (this.data) return this.data[nodeKey];
+		return null;
+	}
+	get disabled() {
+		return getPropertyFromData(this, "disabled");
+	}
+	get nextSibling() {
+		const parent = this.parent;
+		if (parent) {
+			const index = parent.childNodes.indexOf(this);
+			if (index > -1) return parent.childNodes[index + 1];
+		}
+		return null;
+	}
+	get previousSibling() {
+		const parent = this.parent;
+		if (parent) {
+			const index = parent.childNodes.indexOf(this);
+			if (index > -1) return index > 0 ? parent.childNodes[index - 1] : null;
+		}
+		return null;
+	}
+	contains(target, deep = true) {
+		return (this.childNodes || []).some((child) => child === target || deep && child.contains(target));
+	}
+	remove() {
+		const parent = this.parent;
+		if (parent) parent.removeChild(this);
+	}
+	insertChild(child, index, batch) {
+		if (!child) throw new Error("InsertChild error: child is required.");
+		if (!(child instanceof Node)) {
+			if (!batch) {
+				const children = this.getChildren(true);
+				if (!children?.includes(child.data)) if (isUndefined$1(index) || index < 0) children?.push(child.data);
+				else children?.splice(index, 0, child.data);
+			}
+			Object.assign(child, {
+				parent: this,
+				store: this.store
+			});
+			child = reactive(new Node(child));
+			if (child instanceof Node) child.initialize();
+		}
+		child.level = this.level + 1;
+		if (isUndefined$1(index) || index < 0) this.childNodes.push(child);
+		else this.childNodes.splice(index, 0, child);
+		this.updateLeafState();
+	}
+	insertBefore(child, ref) {
+		let index;
+		if (ref) index = this.childNodes.indexOf(ref);
+		this.insertChild(child, index);
+	}
+	insertAfter(child, ref) {
+		let index;
+		if (ref) {
+			index = this.childNodes.indexOf(ref);
+			if (index !== -1) index += 1;
+		}
+		this.insertChild(child, index);
+	}
+	removeChild(child) {
+		const children = this.getChildren() || [];
+		const dataIndex = children.indexOf(child.data);
+		if (dataIndex > -1) children.splice(dataIndex, 1);
+		const index = this.childNodes.indexOf(child);
+		if (index > -1) {
+			this.store && this.store.deregisterNode(child);
+			child.parent = null;
+			this.childNodes.splice(index, 1);
+		}
+		this.updateLeafState();
+	}
+	removeChildByData(data) {
+		const targetNode = this.childNodes.find((child) => child.data === data);
+		if (targetNode) this.removeChild(targetNode);
+	}
+	expand(callback, expandParent) {
+		const done = () => {
+			if (expandParent) {
+				let parent = this.parent;
+				while (parent && parent.level > 0) {
+					parent.expanded = true;
+					parent = parent.parent;
+				}
+			}
+			this.expanded = true;
+			if (callback) callback();
+			setCanFocus(this.childNodes, true);
+		};
+		if (this.shouldLoadData()) this.loadData((data) => {
+			if (isArray(data)) {
+				if (this.checked) this.setChecked(true, true);
+				else if (!this.store.checkStrictly) reInitChecked(this);
+				done();
+			}
+		});
+		else done();
+	}
+	doCreateChildren(array, defaultProps = {}) {
+		array.forEach((item) => {
+			this.insertChild(Object.assign({ data: item }, defaultProps), void 0, true);
+		});
+	}
+	collapse() {
+		this.expanded = false;
+		setCanFocus(this.childNodes, false);
+	}
+	shouldLoadData() {
+		return Boolean(this.store.lazy === true && this.store.load && !this.loaded);
+	}
+	updateLeafState() {
+		if (this.store.lazy === true && this.loaded !== true && typeof this.isLeafByUser !== "undefined") {
+			this.isLeaf = this.isLeafByUser;
+			this.isEffectivelyChecked = this.isLeaf && this.disabled;
+			return;
+		}
+		const childNodes = this.childNodes;
+		if (!this.store.lazy || this.store.lazy === true && this.loaded === true) {
+			this.isLeaf = !childNodes || childNodes.length === 0;
+			this.isEffectivelyChecked = this.isLeaf && this.disabled;
+			return;
+		}
+		this.isLeaf = false;
+	}
+	setChecked(value, deep, recursion, passValue) {
+		this.indeterminate = value === "half";
+		this.checked = value === true;
+		this.isEffectivelyChecked = !this.childNodes.length && (this.disabled || this.checked);
+		if (this.store.checkStrictly && !deep) return;
+		if (!(this.shouldLoadData() && !this.store.checkDescendants)) {
+			const handleDescendants = () => {
+				if (deep) {
+					const childNodes = this.childNodes;
+					for (let i = 0, j = childNodes.length; i < j; i++) {
+						const child = childNodes[i];
+						passValue = passValue || value !== false;
+						const isCheck = child.disabled && child.isLeaf ? child.checked : passValue;
+						child.setChecked(isCheck, deep, true, passValue);
+					}
+					const { half, all, isEffectivelyChecked } = getChildState(childNodes);
+					if (!all) {
+						this.checked = all;
+						this.indeterminate = half;
+					}
+					this.isEffectivelyChecked = !this.childNodes.length ? this.disabled || this.checked : isEffectivelyChecked;
+				}
+			};
+			if (this.shouldLoadData()) {
+				this.loadData(() => {
+					handleDescendants();
+					reInitChecked(this);
+				}, { checked: value !== false });
+				return;
+			} else handleDescendants();
+		}
+		const parent = this.parent;
+		if (!parent || parent.level === 0) return;
+		if (!recursion && !this.store.checkStrictly) reInitChecked(parent);
+	}
+	getChildren(forceInit = false) {
+		if (this.level === 0) return this.data;
+		const data = this.data;
+		if (!data) return null;
+		const props = this.store.props;
+		let children = "children";
+		if (props) children = props.children || "children";
+		if (isUndefined$1(data[children])) data[children] = null;
+		if (forceInit && !data[children]) data[children] = [];
+		return data[children];
+	}
+	updateChildren() {
+		const newData = this.getChildren() || [];
+		const oldData = this.childNodes.map((node) => node.data);
+		const newDataMap = {};
+		const newNodes = [];
+		newData.forEach((item, index) => {
+			const key = item[NODE_KEY];
+			if (!!key && oldData.some((data) => data?.["$treeNodeId"] === key)) newDataMap[key] = {
+				index,
+				data: item
+			};
+			else newNodes.push({
+				index,
+				data: item
+			});
+		});
+		if (!this.store.lazy) oldData.forEach((item) => {
+			if (!newDataMap[item?.["$treeNodeId"]]) this.removeChildByData(item);
+		});
+		newNodes.forEach(({ index, data }) => {
+			this.insertChild({ data }, index);
+		});
+		this.updateLeafState();
+	}
+	loadData(callback, defaultProps = {}) {
+		if (this.store.lazy === true && this.store.load && !this.loaded && (!this.loading || Object.keys(defaultProps).length)) {
+			this.loading = true;
+			const resolve = (children) => {
+				this.childNodes = [];
+				this.doCreateChildren(children, defaultProps);
+				this.loaded = true;
+				this.loading = false;
+				this.updateLeafState();
+				if (callback) callback.call(this, children);
+			};
+			const reject = () => {
+				this.loading = false;
+			};
+			this.store.load(this, resolve, reject);
+		} else if (callback) callback.call(this);
+	}
+	eachNode(callback) {
+		const arr = [this];
+		while (arr.length) {
+			const node = arr.shift();
+			arr.unshift(...node.childNodes);
+			callback(node);
+		}
+	}
+	reInitChecked() {
+		if (this.store.checkStrictly) return;
+		reInitChecked(this);
+	}
+};
+//#endregion
+export { Node as default, getChildState };
+
+//# sourceMappingURL=node.mjs.map

frontend/node_modules/element-plus/es/components/tree/src/model/tree-store.d.ts

@@ -0,0 +1,55 @@
+import Node from "./node.js";
+import { FilterNodeMethodFunction, FilterValue, LoadFunction, TreeData, TreeKey, TreeNodeData, TreeOptionProps, TreeStoreNodesMap, TreeStoreOptions } from "../tree.type.js";
+
+//#region ../../packages/components/tree/src/model/tree-store.d.ts
+declare 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;
+}
+//#endregion
+export { TreeStore as default };

frontend/node_modules/element-plus/es/components/tree/src/model/tree-store.mjs

@@ -0,0 +1,269 @@
+import { isObject, isPropAbsent } from "../../../../utils/types.mjs";
+import { hasOwn } from "../../../../utils/objects.mjs";
+import { NOOP } from "../../../../utils/functions.mjs";
+import { getNodeKey } from "./util.mjs";
+import Node from "./node.mjs";
+import { isNil } from "lodash-unified";
+import { nextTick } from "vue";
+//#region ../../packages/components/tree/src/model/tree-store.ts
+var TreeStore = class {
+	constructor(options) {
+		this.lazy = false;
+		this.checkStrictly = false;
+		this.autoExpandParent = false;
+		this.defaultExpandAll = false;
+		this.checkDescendants = false;
+		this.currentNode = null;
+		this.currentNodeKey = null;
+		for (const option in options) if (hasOwn(options, option)) this[option] = options[option];
+		this.nodesMap = {};
+	}
+	initialize() {
+		this.root = new Node({
+			data: this.data,
+			store: this
+		});
+		this.root.initialize();
+		if (this.lazy && this.load) {
+			const loadFn = this.load;
+			loadFn(this.root, (data) => {
+				this.root.doCreateChildren(data);
+				this._initDefaultCheckedNodes();
+			}, NOOP);
+		} else this._initDefaultCheckedNodes();
+	}
+	filter(value) {
+		const filterNodeMethod = this.filterNodeMethod;
+		const lazy = this.lazy;
+		const traverse = async function(node) {
+			const childNodes = node.root ? node.root.childNodes : node.childNodes;
+			for (const [index, child] of childNodes.entries()) {
+				child.visible = !!filterNodeMethod?.call(child, value, child.data, child);
+				if (index % 80 === 0 && index > 0) await nextTick();
+				await traverse(child);
+			}
+			if (!node.visible && childNodes.length) {
+				let allHidden = true;
+				allHidden = !childNodes.some((child) => child.visible);
+				if (node.root) node.root.visible = allHidden === false;
+				else node.visible = allHidden === false;
+			}
+			if (!value) return;
+			if (node.visible && !node.isLeaf) {
+				if (!lazy || node.loaded) node.expand();
+			}
+		};
+		traverse(this);
+	}
+	setData(newVal) {
+		if (newVal !== this.root.data) {
+			this.nodesMap = {};
+			this.root.setData(newVal);
+			this._initDefaultCheckedNodes();
+			this.setCurrentNodeKey(this.currentNodeKey);
+		} else this.root.updateChildren();
+	}
+	getNode(data) {
+		if (data instanceof Node) return data;
+		const key = isObject(data) ? getNodeKey(this.key, data) : data;
+		return this.nodesMap[key] || null;
+	}
+	insertBefore(data, refData) {
+		const refNode = this.getNode(refData);
+		refNode.parent?.insertBefore({ data }, refNode);
+	}
+	insertAfter(data, refData) {
+		const refNode = this.getNode(refData);
+		refNode.parent?.insertAfter({ data }, refNode);
+	}
+	remove(data) {
+		const node = this.getNode(data);
+		if (node && node.parent) {
+			if (node === this.currentNode) this.currentNode = null;
+			node.parent.removeChild(node);
+		}
+	}
+	append(data, parentData) {
+		const parentNode = !isPropAbsent(parentData) ? this.getNode(parentData) : this.root;
+		if (parentNode) parentNode.insertChild({ data });
+	}
+	_initDefaultCheckedNodes() {
+		const defaultCheckedKeys = this.defaultCheckedKeys || [];
+		const nodesMap = this.nodesMap;
+		defaultCheckedKeys.forEach((checkedKey) => {
+			const node = nodesMap[checkedKey];
+			if (node) node.setChecked(true, !this.checkStrictly);
+		});
+	}
+	_initDefaultCheckedNode(node) {
+		const defaultCheckedKeys = this.defaultCheckedKeys || [];
+		if (!isNil(node.key) && defaultCheckedKeys.includes(node.key)) node.setChecked(true, !this.checkStrictly);
+	}
+	setDefaultCheckedKey(newVal) {
+		if (newVal !== this.defaultCheckedKeys) {
+			this.defaultCheckedKeys = newVal;
+			this._initDefaultCheckedNodes();
+		}
+	}
+	registerNode(node) {
+		const key = this.key;
+		if (!node || !node.data) return;
+		if (!key) this.nodesMap[node.id] = node;
+		else {
+			const nodeKey = node.key;
+			if (!isNil(nodeKey)) this.nodesMap[nodeKey] = node;
+		}
+	}
+	deregisterNode(node) {
+		if (!this.key || !node || !node.data) return;
+		node.childNodes.forEach((child) => {
+			this.deregisterNode(child);
+		});
+		delete this.nodesMap[node.key];
+	}
+	getCheckedNodes(leafOnly = false, includeHalfChecked = false) {
+		const checkedNodes = [];
+		const traverse = function(node) {
+			(node.root ? node.root.childNodes : node.childNodes).forEach((child) => {
+				if ((child.checked || includeHalfChecked && child.indeterminate) && (!leafOnly || leafOnly && child.isLeaf)) checkedNodes.push(child.data);
+				traverse(child);
+			});
+		};
+		traverse(this);
+		return checkedNodes;
+	}
+	getCheckedKeys(leafOnly = false) {
+		return this.getCheckedNodes(leafOnly).map((data) => (data || {})[this.key]);
+	}
+	getHalfCheckedNodes() {
+		const nodes = [];
+		const traverse = function(node) {
+			(node.root ? node.root.childNodes : node.childNodes).forEach((child) => {
+				if (child.indeterminate) nodes.push(child.data);
+				traverse(child);
+			});
+		};
+		traverse(this);
+		return nodes;
+	}
+	getHalfCheckedKeys() {
+		return this.getHalfCheckedNodes().map((data) => (data || {})[this.key]);
+	}
+	_getAllNodes() {
+		const allNodes = [];
+		const nodesMap = this.nodesMap;
+		for (const nodeKey in nodesMap) if (hasOwn(nodesMap, nodeKey)) allNodes.push(nodesMap[nodeKey]);
+		return allNodes;
+	}
+	updateChildren(key, data) {
+		const node = this.nodesMap[key];
+		if (!node) return;
+		const childNodes = node.childNodes;
+		for (let i = childNodes.length - 1; i >= 0; i--) {
+			const child = childNodes[i];
+			this.remove(child.data);
+		}
+		for (let i = 0, j = data.length; i < j; i++) {
+			const child = data[i];
+			this.append(child, node.data);
+		}
+	}
+	_setCheckedKeys(key, leafOnly = false, checkedKeys) {
+		const allNodes = this._getAllNodes().sort((a, b) => a.level - b.level);
+		const cache = Object.create(null);
+		const keys = Object.keys(checkedKeys);
+		allNodes.forEach((node) => node.setChecked(false, false));
+		const cacheCheckedChild = (node) => {
+			node.childNodes.forEach((child) => {
+				cache[child.data[key]] = true;
+				if (child.childNodes?.length) cacheCheckedChild(child);
+			});
+		};
+		for (let i = 0, j = allNodes.length; i < j; i++) {
+			const node = allNodes[i];
+			const nodeKey = node.data[key].toString();
+			if (!keys.includes(nodeKey)) {
+				if (node.checked && !cache[nodeKey]) node.setChecked(false, false);
+				continue;
+			}
+			if (node.childNodes.length) cacheCheckedChild(node);
+			if (node.isLeaf || this.checkStrictly) {
+				node.setChecked(true, false);
+				continue;
+			}
+			node.setChecked(true, true);
+			if (leafOnly) {
+				node.setChecked(false, false, true);
+				const traverse = function(node) {
+					node.childNodes.forEach((child) => {
+						if (!child.isLeaf) child.setChecked(false, false, true);
+						traverse(child);
+					});
+					node.reInitChecked();
+				};
+				traverse(node);
+			}
+		}
+	}
+	setCheckedNodes(array, leafOnly = false) {
+		const key = this.key;
+		const checkedKeys = {};
+		array.forEach((item) => {
+			checkedKeys[(item || {})[key]] = true;
+		});
+		this._setCheckedKeys(key, leafOnly, checkedKeys);
+	}
+	setCheckedKeys(keys, leafOnly = false) {
+		this.defaultCheckedKeys = keys;
+		const key = this.key;
+		const checkedKeys = {};
+		keys.forEach((key) => {
+			checkedKeys[key] = true;
+		});
+		this._setCheckedKeys(key, leafOnly, checkedKeys);
+	}
+	setDefaultExpandedKeys(keys) {
+		keys = keys || [];
+		this.defaultExpandedKeys = keys;
+		keys.forEach((key) => {
+			const node = this.getNode(key);
+			if (node) node.expand(null, this.autoExpandParent);
+		});
+	}
+	setChecked(data, checked, deep) {
+		const node = this.getNode(data);
+		if (node) node.setChecked(!!checked, deep);
+	}
+	getCurrentNode() {
+		return this.currentNode;
+	}
+	setCurrentNode(currentNode) {
+		const prevCurrentNode = this.currentNode;
+		if (prevCurrentNode) prevCurrentNode.isCurrent = false;
+		this.currentNode = currentNode;
+		this.currentNode.isCurrent = true;
+	}
+	setUserCurrentNode(node, shouldAutoExpandParent = true) {
+		const key = node[this.key];
+		const currNode = this.nodesMap[key];
+		this.setCurrentNode(currNode);
+		if (shouldAutoExpandParent && this.currentNode && this.currentNode.level > 1) this.currentNode.parent?.expand(null, true);
+	}
+	setCurrentNodeKey(key, shouldAutoExpandParent = true) {
+		this.currentNodeKey = key;
+		if (isPropAbsent(key)) {
+			this.currentNode && (this.currentNode.isCurrent = false);
+			this.currentNode = null;
+			return;
+		}
+		const node = this.getNode(key);
+		if (node) {
+			this.setCurrentNode(node);
+			if (shouldAutoExpandParent && this.currentNode && this.currentNode.level > 1) this.currentNode.parent?.expand(null, true);
+		}
+	}
+};
+//#endregion
+export { TreeStore as default };
+
+//# sourceMappingURL=tree-store.mjs.map

frontend/node_modules/element-plus/es/components/tree/src/model/useDragNode.d.ts

@@ -0,0 +1,468 @@
+import TreeStore from "./tree-store.js";
+import Node from "./node.js";
+import { treeEmits } from "../tree.js";
+import { AllowDragFunction, AllowDropFunction, FakeNode, FilterNodeMethodFunction, FilterValue, LoadFunction, NodeDropType, TreeData, TreeKey, TreeNodeData, TreeNodeLoadedDefaultProps, TreeStoreNodesMap } from "../tree.type.js";
+import { InjectionKey, Ref, SetupContext } from "vue";
+
+//#region ../../packages/components/tree/src/model/useDragNode.d.ts
+interface TreeNode {
+  node: Node;
+  $el?: HTMLElement;
+}
+interface DragOptions {
+  event: DragEvent;
+  treeNode: TreeNode;
+}
+interface Props {
+  props: {
+    allowDrag?: AllowDragFunction;
+    allowDrop?: AllowDropFunction;
+  };
+  ctx: SetupContext<typeof treeEmits>;
+  el$: Ref<HTMLElement | null>;
+  dropIndicator$: Ref<HTMLElement | null>;
+  store: Ref<TreeStore>;
+}
+interface DragEvents {
+  treeNodeDragStart: (options: DragOptions) => void;
+  treeNodeDragOver: (options: DragOptions) => void;
+  treeNodeDragEnd: (event: DragEvent) => void;
+}
+declare const dragEventsKey: InjectionKey<DragEvents>;
+declare function useDragNodeHandler({
+  props,
+  ctx,
+  el$,
+  dropIndicator$,
+  store
+}: Props): {
+  dragState: Ref<{
+    allowDrop: boolean;
+    dropType: NodeDropType | null;
+    draggingNode: {
+      node: {
+        id: number;
+        text: string | null;
+        checked: boolean;
+        indeterminate: boolean;
+        data: TreeNodeData;
+        expanded: boolean;
+        parent: /*elided*/any | null;
+        visible: boolean;
+        isCurrent: boolean;
+        store: {
+          currentNode: /*elided*/any | null;
+          currentNodeKey: TreeKey | null;
+          nodesMap: TreeStoreNodesMap;
+          root: /*elided*/any;
+          data: TreeNodeData[];
+          lazy: boolean;
+          load?: LoadFunction | undefined;
+          filterNodeMethod?: FilterNodeMethodFunction | undefined;
+          key: TreeKey;
+          defaultCheckedKeys?: TreeKey[] | undefined;
+          checkStrictly: boolean;
+          defaultExpandedKeys?: TreeKey[] | undefined;
+          autoExpandParent: boolean;
+          defaultExpandAll: boolean;
+          checkDescendants: boolean;
+          props: {
+            children?: string | undefined;
+            label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
+            disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+            isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+            class?: ((data: TreeNodeData, node: Node) => string | {
+              [key: string]: boolean;
+            }) | undefined;
+          };
+          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;
+        };
+        isLeafByUser: boolean | undefined;
+        isLeaf: boolean | undefined;
+        canFocus: boolean;
+        level: number;
+        loaded: boolean;
+        childNodes: /*elided*/any[];
+        loading: boolean;
+        isEffectivelyChecked: boolean;
+        initialize: () => void;
+        setData: (data: TreeNodeData) => void;
+        readonly label: string;
+        readonly key: TreeKey | null | undefined;
+        readonly disabled: boolean;
+        readonly nextSibling: /*elided*/any | null;
+        readonly previousSibling: /*elided*/any | null;
+        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;
+      };
+      $el?: HTMLElement | undefined;
+    } | null;
+    showDropIndicator: boolean;
+    dropNode: {
+      node: {
+        id: number;
+        text: string | null;
+        checked: boolean;
+        indeterminate: boolean;
+        data: TreeNodeData;
+        expanded: boolean;
+        parent: /*elided*/any | null;
+        visible: boolean;
+        isCurrent: boolean;
+        store: {
+          currentNode: /*elided*/any | null;
+          currentNodeKey: TreeKey | null;
+          nodesMap: TreeStoreNodesMap;
+          root: /*elided*/any;
+          data: TreeNodeData[];
+          lazy: boolean;
+          load?: LoadFunction | undefined;
+          filterNodeMethod?: FilterNodeMethodFunction | undefined;
+          key: TreeKey;
+          defaultCheckedKeys?: TreeKey[] | undefined;
+          checkStrictly: boolean;
+          defaultExpandedKeys?: TreeKey[] | undefined;
+          autoExpandParent: boolean;
+          defaultExpandAll: boolean;
+          checkDescendants: boolean;
+          props: {
+            children?: string | undefined;
+            label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
+            disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+            isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+            class?: ((data: TreeNodeData, node: Node) => string | {
+              [key: string]: boolean;
+            }) | undefined;
+          };
+          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;
+        };
+        isLeafByUser: boolean | undefined;
+        isLeaf: boolean | undefined;
+        canFocus: boolean;
+        level: number;
+        loaded: boolean;
+        childNodes: /*elided*/any[];
+        loading: boolean;
+        isEffectivelyChecked: boolean;
+        initialize: () => void;
+        setData: (data: TreeNodeData) => void;
+        readonly label: string;
+        readonly key: TreeKey | null | undefined;
+        readonly disabled: boolean;
+        readonly nextSibling: /*elided*/any | null;
+        readonly previousSibling: /*elided*/any | null;
+        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;
+      };
+      $el?: HTMLElement | undefined;
+    } | null;
+  }, {
+    allowDrop: boolean;
+    dropType: NodeDropType | null;
+    draggingNode: TreeNode | null;
+    showDropIndicator: boolean;
+    dropNode: TreeNode | null;
+  } | {
+    allowDrop: boolean;
+    dropType: NodeDropType | null;
+    draggingNode: {
+      node: {
+        id: number;
+        text: string | null;
+        checked: boolean;
+        indeterminate: boolean;
+        data: TreeNodeData;
+        expanded: boolean;
+        parent: /*elided*/any | null;
+        visible: boolean;
+        isCurrent: boolean;
+        store: {
+          currentNode: /*elided*/any | null;
+          currentNodeKey: TreeKey | null;
+          nodesMap: TreeStoreNodesMap;
+          root: /*elided*/any;
+          data: TreeNodeData[];
+          lazy: boolean;
+          load?: LoadFunction | undefined;
+          filterNodeMethod?: FilterNodeMethodFunction | undefined;
+          key: TreeKey;
+          defaultCheckedKeys?: TreeKey[] | undefined;
+          checkStrictly: boolean;
+          defaultExpandedKeys?: TreeKey[] | undefined;
+          autoExpandParent: boolean;
+          defaultExpandAll: boolean;
+          checkDescendants: boolean;
+          props: {
+            children?: string | undefined;
+            label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
+            disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+            isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+            class?: ((data: TreeNodeData, node: Node) => string | {
+              [key: string]: boolean;
+            }) | undefined;
+          };
+          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;
+        };
+        isLeafByUser: boolean | undefined;
+        isLeaf: boolean | undefined;
+        canFocus: boolean;
+        level: number;
+        loaded: boolean;
+        childNodes: /*elided*/any[];
+        loading: boolean;
+        isEffectivelyChecked: boolean;
+        initialize: () => void;
+        setData: (data: TreeNodeData) => void;
+        readonly label: string;
+        readonly key: TreeKey | null | undefined;
+        readonly disabled: boolean;
+        readonly nextSibling: /*elided*/any | null;
+        readonly previousSibling: /*elided*/any | null;
+        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;
+      };
+      $el?: HTMLElement | undefined;
+    } | null;
+    showDropIndicator: boolean;
+    dropNode: {
+      node: {
+        id: number;
+        text: string | null;
+        checked: boolean;
+        indeterminate: boolean;
+        data: TreeNodeData;
+        expanded: boolean;
+        parent: /*elided*/any | null;
+        visible: boolean;
+        isCurrent: boolean;
+        store: {
+          currentNode: /*elided*/any | null;
+          currentNodeKey: TreeKey | null;
+          nodesMap: TreeStoreNodesMap;
+          root: /*elided*/any;
+          data: TreeNodeData[];
+          lazy: boolean;
+          load?: LoadFunction | undefined;
+          filterNodeMethod?: FilterNodeMethodFunction | undefined;
+          key: TreeKey;
+          defaultCheckedKeys?: TreeKey[] | undefined;
+          checkStrictly: boolean;
+          defaultExpandedKeys?: TreeKey[] | undefined;
+          autoExpandParent: boolean;
+          defaultExpandAll: boolean;
+          checkDescendants: boolean;
+          props: {
+            children?: string | undefined;
+            label?: string | ((data: TreeNodeData, node: Node) => string) | undefined;
+            disabled?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+            isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean) | undefined;
+            class?: ((data: TreeNodeData, node: Node) => string | {
+              [key: string]: boolean;
+            }) | undefined;
+          };
+          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;
+        };
+        isLeafByUser: boolean | undefined;
+        isLeaf: boolean | undefined;
+        canFocus: boolean;
+        level: number;
+        loaded: boolean;
+        childNodes: /*elided*/any[];
+        loading: boolean;
+        isEffectivelyChecked: boolean;
+        initialize: () => void;
+        setData: (data: TreeNodeData) => void;
+        readonly label: string;
+        readonly key: TreeKey | null | undefined;
+        readonly disabled: boolean;
+        readonly nextSibling: /*elided*/any | null;
+        readonly previousSibling: /*elided*/any | null;
+        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;
+      };
+      $el?: HTMLElement | undefined;
+    } | null;
+  }>;
+};
+//#endregion
+export { DragEvents, TreeNode, dragEventsKey, useDragNodeHandler };

frontend/node_modules/element-plus/es/components/tree/src/model/useDragNode.mjs

@@ -0,0 +1,122 @@
+import { isFunction } from "../../../../utils/types.mjs";
+import { addClass, removeClass } from "../../../../utils/dom/style.mjs";
+import { useNamespace } from "../../../../hooks/use-namespace/index.mjs";
+import { provide, ref } from "vue";
+//#region ../../packages/components/tree/src/model/useDragNode.ts
+const dragEventsKey = Symbol("dragEvents");
+function useDragNodeHandler({ props, ctx, el$, dropIndicator$, store }) {
+	const ns = useNamespace("tree");
+	const dragState = ref({
+		showDropIndicator: false,
+		draggingNode: null,
+		dropNode: null,
+		allowDrop: true,
+		dropType: null
+	});
+	const treeNodeDragStart = ({ event, treeNode }) => {
+		if (!event.dataTransfer) return;
+		if (isFunction(props.allowDrag) && !props.allowDrag(treeNode.node)) {
+			event.preventDefault();
+			return false;
+		}
+		event.dataTransfer.effectAllowed = "move";
+		try {
+			event.dataTransfer.setData("text/plain", "");
+		} catch {}
+		dragState.value.draggingNode = treeNode;
+		ctx.emit("node-drag-start", treeNode.node, event);
+	};
+	const treeNodeDragOver = ({ event, treeNode }) => {
+		if (!event.dataTransfer) return;
+		const dropNode = treeNode;
+		const oldDropNode = dragState.value.dropNode;
+		if (oldDropNode && oldDropNode.node.id !== dropNode.node.id) removeClass(oldDropNode.$el, ns.is("drop-inner"));
+		const draggingNode = dragState.value.draggingNode;
+		if (!draggingNode || !dropNode) return;
+		let dropPrev = true;
+		let dropInner = true;
+		let dropNext = true;
+		let userAllowDropInner = true;
+		if (isFunction(props.allowDrop)) {
+			dropPrev = props.allowDrop(draggingNode.node, dropNode.node, "prev");
+			userAllowDropInner = dropInner = props.allowDrop(draggingNode.node, dropNode.node, "inner");
+			dropNext = props.allowDrop(draggingNode.node, dropNode.node, "next");
+		}
+		event.dataTransfer.dropEffect = dropInner || dropPrev || dropNext ? "move" : "none";
+		if ((dropPrev || dropInner || dropNext) && oldDropNode?.node.id !== dropNode.node.id) {
+			if (oldDropNode) ctx.emit("node-drag-leave", draggingNode.node, oldDropNode.node, event);
+			ctx.emit("node-drag-enter", draggingNode.node, dropNode.node, event);
+		}
+		if (dropPrev || dropInner || dropNext) dragState.value.dropNode = dropNode;
+		else dragState.value.dropNode = null;
+		if (dropNode.node.nextSibling === draggingNode.node) dropNext = false;
+		if (dropNode.node.previousSibling === draggingNode.node) dropPrev = false;
+		if (dropNode.node.contains(draggingNode.node, false)) dropInner = false;
+		if (draggingNode.node === dropNode.node || draggingNode.node.contains(dropNode.node)) {
+			dropPrev = false;
+			dropInner = false;
+			dropNext = false;
+		}
+		const dropEl = dropNode.$el;
+		const targetPosition = dropEl.querySelector(`.${ns.be("node", "content")}`).getBoundingClientRect();
+		const treePosition = el$.value.getBoundingClientRect();
+		const treeScrollTop = el$.value.scrollTop;
+		let dropType;
+		const prevPercent = dropPrev ? dropInner ? .25 : dropNext ? .45 : 1 : Number.NEGATIVE_INFINITY;
+		const nextPercent = dropNext ? dropInner ? .75 : dropPrev ? .55 : 0 : Number.POSITIVE_INFINITY;
+		let indicatorTop = -9999;
+		const distance = event.clientY - targetPosition.top;
+		if (distance < targetPosition.height * prevPercent) dropType = "before";
+		else if (distance > targetPosition.height * nextPercent) dropType = "after";
+		else if (dropInner) dropType = "inner";
+		else dropType = "none";
+		const iconPosition = dropEl.querySelector(`.${ns.be("node", "expand-icon")}`).getBoundingClientRect();
+		const dropIndicator = dropIndicator$.value;
+		if (dropType === "before") indicatorTop = iconPosition.top - treePosition.top + treeScrollTop;
+		else if (dropType === "after") indicatorTop = iconPosition.bottom - treePosition.top + treeScrollTop;
+		dropIndicator.style.top = `${indicatorTop}px`;
+		dropIndicator.style.left = `${iconPosition.right - treePosition.left}px`;
+		if (dropType === "inner") addClass(dropEl, ns.is("drop-inner"));
+		else removeClass(dropEl, ns.is("drop-inner"));
+		dragState.value.showDropIndicator = dropType === "before" || dropType === "after";
+		dragState.value.allowDrop = dragState.value.showDropIndicator || userAllowDropInner;
+		dragState.value.dropType = dropType;
+		ctx.emit("node-drag-over", draggingNode.node, dropNode.node, event);
+	};
+	const treeNodeDragEnd = (event) => {
+		const { draggingNode, dropType, dropNode } = dragState.value;
+		event.preventDefault();
+		if (event.dataTransfer) event.dataTransfer.dropEffect = "move";
+		if (draggingNode?.node.data && dropNode) {
+			const draggingNodeCopy = { data: draggingNode.node.data };
+			if (dropType !== "none") draggingNode.node.remove();
+			if (dropType === "before") dropNode.node.parent?.insertBefore(draggingNodeCopy, dropNode.node);
+			else if (dropType === "after") dropNode.node.parent?.insertAfter(draggingNodeCopy, dropNode.node);
+			else if (dropType === "inner") dropNode.node.insertChild(draggingNodeCopy);
+			if (dropType !== "none") {
+				store.value.registerNode(draggingNodeCopy);
+				if (store.value.key) draggingNode.node.eachNode((node) => {
+					store.value.nodesMap[node.data[store.value.key]]?.setChecked(node.checked, !store.value.checkStrictly);
+				});
+			}
+			removeClass(dropNode.$el, ns.is("drop-inner"));
+			ctx.emit("node-drag-end", draggingNode.node, dropNode.node, dropType, event);
+			if (dropType !== "none") ctx.emit("node-drop", draggingNode.node, dropNode.node, dropType, event);
+		}
+		if (draggingNode && !dropNode) ctx.emit("node-drag-end", draggingNode.node, null, dropType, event);
+		dragState.value.showDropIndicator = false;
+		dragState.value.draggingNode = null;
+		dragState.value.dropNode = null;
+		dragState.value.allowDrop = true;
+	};
+	provide(dragEventsKey, {
+		treeNodeDragStart,
+		treeNodeDragOver,
+		treeNodeDragEnd
+	});
+	return { dragState };
+}
+//#endregion
+export { dragEventsKey, useDragNodeHandler };
+
+//# sourceMappingURL=useDragNode.mjs.map

frontend/node_modules/element-plus/es/components/tree/src/model/useKeydown.d.ts

@@ -0,0 +1,12 @@
+import TreeStore from "./tree-store.js";
+import { Ref } from "vue";
+
+//#region ../../packages/components/tree/src/model/useKeydown.d.ts
+interface UseKeydownOption {
+  el$: Ref<HTMLElement | null>;
+}
+declare function useKeydown({
+  el$
+}: UseKeydownOption, store: Ref<TreeStore>): void;
+//#endregion
+export { useKeydown };

frontend/node_modules/element-plus/es/components/tree/src/model/useKeydown.mjs

@@ -0,0 +1,89 @@
+import { EVENT_CODE } from "../../../../constants/aria.mjs";
+import { getEventCode } from "../../../../utils/dom/event.mjs";
+import { useNamespace } from "../../../../hooks/use-namespace/index.mjs";
+import { useEventListener } from "@vueuse/core";
+import { onMounted, onUpdated } from "vue";
+//#region ../../packages/components/tree/src/model/useKeydown.ts
+function useKeydown({ el$ }, store) {
+	const ns = useNamespace("tree");
+	onMounted(() => {
+		initTabIndex();
+	});
+	onUpdated(() => {
+		el$.value?.querySelectorAll("input[type=checkbox]").forEach((checkbox) => {
+			checkbox.setAttribute("tabindex", "-1");
+		});
+	});
+	function canNodeFocus(treeItems, nextIndex) {
+		const currentNode = store.value.getNode(treeItems[nextIndex].dataset.key);
+		return currentNode.canFocus && currentNode.visible && (currentNode.parent?.expanded || currentNode.parent?.level === 0);
+	}
+	const handleKeydown = (ev) => {
+		const currentItem = ev.target;
+		if (!currentItem.className.includes(ns.b("node"))) return;
+		const code = getEventCode(ev);
+		const treeItems = Array.from(el$.value.querySelectorAll(`.${ns.is("focusable")}[role=treeitem]`));
+		const currentIndex = treeItems.indexOf(currentItem);
+		let nextIndex;
+		if ([EVENT_CODE.up, EVENT_CODE.down].includes(code)) {
+			ev.preventDefault();
+			if (code === EVENT_CODE.up) {
+				nextIndex = currentIndex === -1 ? 0 : currentIndex !== 0 ? currentIndex - 1 : treeItems.length - 1;
+				const startIndex = nextIndex;
+				while (true) {
+					if (canNodeFocus(treeItems, nextIndex)) break;
+					nextIndex--;
+					if (nextIndex === startIndex) {
+						nextIndex = -1;
+						break;
+					}
+					if (nextIndex < 0) nextIndex = treeItems.length - 1;
+				}
+			} else {
+				nextIndex = currentIndex === -1 ? 0 : currentIndex < treeItems.length - 1 ? currentIndex + 1 : 0;
+				const startIndex = nextIndex;
+				while (true) {
+					if (canNodeFocus(treeItems, nextIndex)) break;
+					nextIndex++;
+					if (nextIndex === startIndex) {
+						nextIndex = -1;
+						break;
+					}
+					if (nextIndex >= treeItems.length) nextIndex = 0;
+				}
+			}
+			nextIndex !== -1 && treeItems[nextIndex].focus();
+		}
+		if ([EVENT_CODE.left, EVENT_CODE.right].includes(code)) {
+			ev.preventDefault();
+			currentItem.click();
+		}
+		const hasInput = currentItem.querySelector("[type=\"checkbox\"]");
+		if ([
+			EVENT_CODE.enter,
+			EVENT_CODE.numpadEnter,
+			EVENT_CODE.space
+		].includes(code) && hasInput) {
+			ev.preventDefault();
+			hasInput.click();
+		}
+	};
+	useEventListener(el$, "keydown", handleKeydown);
+	const initTabIndex = () => {
+		if (!el$.value) return;
+		const treeItems = Array.from(el$.value.querySelectorAll(`.${ns.is("focusable")}[role=treeitem]`));
+		Array.from(el$.value.querySelectorAll("input[type=checkbox]")).forEach((checkbox) => {
+			checkbox.setAttribute("tabindex", "-1");
+		});
+		const checkedItem = el$.value.querySelectorAll(`.${ns.is("checked")}[role=treeitem]`);
+		if (checkedItem.length) {
+			checkedItem[0].setAttribute("tabindex", "0");
+			return;
+		}
+		treeItems[0]?.setAttribute("tabindex", "0");
+	};
+}
+//#endregion
+export { useKeydown };
+
+//# sourceMappingURL=useKeydown.mjs.map

frontend/node_modules/element-plus/es/components/tree/src/model/useNodeExpandEventBroadcast.d.ts

@@ -0,0 +1,12 @@
+import Node from "./node.js";
+
+//#region ../../packages/components/tree/src/model/useNodeExpandEventBroadcast.d.ts
+interface Props {
+  node?: Node;
+  accordion: boolean;
+}
+declare function useNodeExpandEventBroadcast(props: Props): {
+  broadcastExpanded: (node?: Node) => void;
+};
+//#endregion
+export { useNodeExpandEventBroadcast };

frontend/node_modules/element-plus/es/components/tree/src/model/useNodeExpandEventBroadcast.mjs

@@ -0,0 +1,26 @@
+import { TREE_NODE_MAP_INJECTION_KEY } from "../tokens.mjs";
+import { inject, onBeforeUnmount, provide } from "vue";
+//#region ../../packages/components/tree/src/model/useNodeExpandEventBroadcast.ts
+function useNodeExpandEventBroadcast(props) {
+	const parentNodeMap = inject(TREE_NODE_MAP_INJECTION_KEY, null);
+	let currentNodeMap = {
+		treeNodeExpand: (node) => {
+			if (props.node !== node) props.node?.collapse();
+		},
+		children: /* @__PURE__ */ new Set()
+	};
+	if (parentNodeMap) parentNodeMap.children.add(currentNodeMap);
+	onBeforeUnmount(() => {
+		if (parentNodeMap) parentNodeMap.children.delete(currentNodeMap);
+		currentNodeMap = null;
+	});
+	provide(TREE_NODE_MAP_INJECTION_KEY, currentNodeMap);
+	return { broadcastExpanded: (node) => {
+		if (!props.accordion) return;
+		for (const childNode of currentNodeMap.children) childNode.treeNodeExpand(node);
+	} };
+}
+//#endregion
+export { useNodeExpandEventBroadcast };
+
+//# sourceMappingURL=useNodeExpandEventBroadcast.mjs.map

frontend/node_modules/element-plus/es/components/tree/src/model/useNodeExpandEventBroadcast.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNodeExpandEventBroadcast.mjs","names":[],"sources":["../../../../../../../packages/components/tree/src/model/useNodeExpandEventBroadcast.ts"],"sourcesContent":["import { inject, onBeforeUnmount, provide } from 'vue'\nimport { TREE_NODE_MAP_INJECTION_KEY } from '../tokens'\n\nimport type Node from '../model/node'\n\ninterface NodeMap {\n  treeNodeExpand(node?: Node): void\n  children: Set<NodeMap>\n}\n\ninterface Props {\n  node?: Node\n  accordion: boolean\n}\n\nexport function useNodeExpandEventBroadcast(props: Props) {\n  const parentNodeMap = inject(\n    TREE_NODE_MAP_INJECTION_KEY,\n    null\n  ) as NodeMap | null\n  let currentNodeMap: NodeMap | null = {\n    treeNodeExpand: (node) => {\n      if (props.node !== node) {\n        props.node?.collapse()\n      }\n    },\n    children: new Set(),\n  }\n\n  if (parentNodeMap) {\n    parentNodeMap.children.add(currentNodeMap)\n  }\n\n  onBeforeUnmount(() => {\n    if (parentNodeMap) {\n      parentNodeMap.children.delete(currentNodeMap!)\n    }\n    currentNodeMap = null\n  })\n\n  provide(TREE_NODE_MAP_INJECTION_KEY, currentNodeMap)\n\n  return {\n    broadcastExpanded: (node?: Node): void => {\n      if (!props.accordion) return\n      for (const childNode of currentNodeMap!.children) {\n        childNode.treeNodeExpand(node)\n      }\n    },\n  }\n}\n"],"mappings":";;;AAeA,SAAgB,4BAA4B,OAAc;CACxD,MAAM,gBAAgB,OACpB,6BACA,KACD;CACD,IAAI,iBAAiC;EACnC,iBAAiB,SAAS;GACxB,IAAI,MAAM,SAAS,MACjB,MAAM,MAAM,UAAU;;EAG1B,0BAAU,IAAI,KAAK;EACpB;CAED,IAAI,eACF,cAAc,SAAS,IAAI,eAAe;CAG5C,sBAAsB;EACpB,IAAI,eACF,cAAc,SAAS,OAAO,eAAgB;EAEhD,iBAAiB;GACjB;CAEF,QAAQ,6BAA6B,eAAe;CAEpD,OAAO,EACL,oBAAoB,SAAsB;EACxC,IAAI,CAAC,MAAM,WAAW;EACtB,KAAK,MAAM,aAAa,eAAgB,UACtC,UAAU,eAAe,KAAK;IAGnC"}

frontend/node_modules/element-plus/es/components/tree/src/model/util.d.ts

@@ -0,0 +1,11 @@
+import Node from "./node.js";
+import { TreeEmits } from "../tree.js";
+import { RootTreeType, TreeKey, TreeNodeData } from "../tree.type.js";
+
+//#region ../../packages/components/tree/src/model/util.d.ts
+declare const NODE_KEY = "$treeNodeId";
+declare const markNodeData: (node: Node, data: TreeNodeData | null) => void;
+declare const getNodeKey: (key: TreeKey | undefined, data: TreeNodeData) => any;
+declare const handleCurrentChange: (store: RootTreeType["store"], emit: TreeEmits, setCurrent: () => void) => void;
+//#endregion
+export { NODE_KEY, getNodeKey, handleCurrentChange, markNodeData };

frontend/node_modules/element-plus/es/components/tree/src/model/util.mjs

@@ -0,0 +1,23 @@
+//#region ../../packages/components/tree/src/model/util.ts
+const NODE_KEY = "$treeNodeId";
+const markNodeData = function(node, data) {
+	if (!data || data["$treeNodeId"]) return;
+	Object.defineProperty(data, NODE_KEY, {
+		value: node.id,
+		enumerable: false,
+		configurable: false,
+		writable: false
+	});
+};
+const getNodeKey = (key, data) => data?.[key || "$treeNodeId"];
+const handleCurrentChange = (store, emit, setCurrent) => {
+	const preCurrentNode = store.value.currentNode;
+	setCurrent();
+	const currentNode = store.value.currentNode;
+	if (preCurrentNode === currentNode) return;
+	emit("current-change", currentNode ? currentNode.data : null, currentNode);
+};
+//#endregion
+export { NODE_KEY, getNodeKey, handleCurrentChange, markNodeData };
+
+//# sourceMappingURL=util.mjs.map

frontend/node_modules/element-plus/es/components/tree/src/model/util.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.mjs","names":[],"sources":["../../../../../../../packages/components/tree/src/model/util.ts"],"sourcesContent":["import type Node from './node'\nimport type { TreeEmits } from '../tree'\nimport type { RootTreeType, TreeKey, TreeNodeData } from '../tree.type'\n\nexport const NODE_KEY = '$treeNodeId'\n\nexport const markNodeData = function (\n  node: Node,\n  data: TreeNodeData | null\n): void {\n  if (!data || data[NODE_KEY]) return\n  Object.defineProperty(data, NODE_KEY, {\n    value: node.id,\n    enumerable: false,\n    configurable: false,\n    writable: false,\n  })\n}\n\nexport const getNodeKey = (key: TreeKey | undefined, data: TreeNodeData) =>\n  data?.[key || NODE_KEY]\n\nexport const handleCurrentChange = (\n  store: RootTreeType['store'],\n  emit: TreeEmits,\n  setCurrent: () => void\n) => {\n  const preCurrentNode = store.value.currentNode\n  setCurrent()\n  const currentNode = store.value.currentNode\n  if (preCurrentNode === currentNode) return\n\n  emit('current-change', currentNode ? currentNode.data : null, currentNode)\n}\n"],"mappings":";AAIA,MAAa,WAAW;AAExB,MAAa,eAAe,SAC1B,MACA,MACM;CACN,IAAI,CAAC,QAAQ,KAAA,gBAAgB;CAC7B,OAAO,eAAe,MAAM,UAAU;EACpC,OAAO,KAAK;EACZ,YAAY;EACZ,cAAc;EACd,UAAU;EACX,CAAC;;AAGJ,MAAa,cAAc,KAA0B,SACnD,OAAO,OAAA;AAET,MAAa,uBACX,OACA,MACA,eACG;CACH,MAAM,iBAAiB,MAAM,MAAM;CACnC,YAAY;CACZ,MAAM,cAAc,MAAM,MAAM;CAChC,IAAI,mBAAmB,aAAa;CAEpC,KAAK,kBAAkB,cAAc,YAAY,OAAO,MAAM,YAAY"}

frontend/node_modules/element-plus/es/components/tree/src/tokens.d.ts

@@ -0,0 +1,6 @@
+//#region ../../packages/components/tree/src/tokens.d.ts
+declare const ROOT_TREE_INJECTION_KEY = "RootTree";
+declare const NODE_INSTANCE_INJECTION_KEY = "NodeInstance";
+declare const TREE_NODE_MAP_INJECTION_KEY = "TreeNodeMap";
+//#endregion
+export { NODE_INSTANCE_INJECTION_KEY, ROOT_TREE_INJECTION_KEY, TREE_NODE_MAP_INJECTION_KEY };

frontend/node_modules/element-plus/es/components/tree/src/tokens.mjs

@@ -0,0 +1,8 @@
+//#region ../../packages/components/tree/src/tokens.ts
+const ROOT_TREE_INJECTION_KEY = "RootTree";
+const NODE_INSTANCE_INJECTION_KEY = "NodeInstance";
+const TREE_NODE_MAP_INJECTION_KEY = "TreeNodeMap";
+//#endregion
+export { NODE_INSTANCE_INJECTION_KEY, ROOT_TREE_INJECTION_KEY, TREE_NODE_MAP_INJECTION_KEY };
+
+//# sourceMappingURL=tokens.mjs.map

frontend/node_modules/element-plus/es/components/tree/src/tokens.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.mjs","names":[],"sources":["../../../../../../packages/components/tree/src/tokens.ts"],"sourcesContent":["export const ROOT_TREE_INJECTION_KEY = 'RootTree'\n\nexport const NODE_INSTANCE_INJECTION_KEY = 'NodeInstance'\n\nexport const TREE_NODE_MAP_INJECTION_KEY = 'TreeNodeMap'\n"],"mappings":";AAAA,MAAa,0BAA0B;AAEvC,MAAa,8BAA8B;AAE3C,MAAa,8BAA8B"}

frontend/node_modules/element-plus/es/components/tree/src/tree-node-content.mjs

@@ -0,0 +1,7 @@
+import tree_node_content_vue_vue_type_script_lang_default from "./tree-node-content.vue_vue_type_script_lang.mjs";
+//#region ../../packages/components/tree/src/tree-node-content.vue
+var tree_node_content_default = tree_node_content_vue_vue_type_script_lang_default;
+//#endregion
+export { tree_node_content_default as default };
+
+//# sourceMappingURL=tree-node-content.mjs.map

frontend/node_modules/element-plus/es/components/tree/src/tree-node-content.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-node-content.mjs","names":[],"sources":["../../../../../../packages/components/tree/src/tree-node-content.vue"],"sourcesContent":["<script lang=\"ts\">\nimport { defineComponent, h, inject, renderSlot } from 'vue'\nimport ElText from '@element-plus/components/text'\nimport { useNamespace } from '@element-plus/hooks'\nimport { NODE_INSTANCE_INJECTION_KEY, ROOT_TREE_INJECTION_KEY } from './tokens'\n\nimport type { ComponentInternalInstance } from 'vue'\nimport type { RootTreeType } from './tree.type'\n\nexport default defineComponent({\n  name: 'ElTreeNodeContent',\n  props: {\n    node: {\n      type: Object,\n      required: true,\n    },\n    renderContent: Function,\n  },\n  setup(props) {\n    const ns = useNamespace('tree')\n    const nodeInstance = inject<ComponentInternalInstance>(\n      NODE_INSTANCE_INJECTION_KEY\n    )\n    const tree = inject<RootTreeType>(ROOT_TREE_INJECTION_KEY)!\n    return () => {\n      const node = props.node\n      const { data, store } = node\n      return props.renderContent\n        ? props.renderContent(h, { _self: nodeInstance, node, data, store })\n        : renderSlot(tree.ctx.slots, 'default', { node, data }, () => [\n            h(\n              ElText,\n              { tag: 'span', truncated: true, class: ns.be('node', 'label') },\n              () => [node.label]\n            ),\n          ])\n    }\n  },\n})\n</script>\n"],"mappings":""}

frontend/node_modules/element-plus/es/components/tree/src/tree-node-content.vue.d.ts

@@ -0,0 +1,19 @@
+import * as _$vue from "vue";
+
+//#region ../../packages/components/tree/src/tree-node-content.vue.d.ts
+declare const _default: typeof __VLS_export;
+declare const __VLS_export: _$vue.DefineComponent<_$vue.ExtractPropTypes<{
+  node: {
+    type: ObjectConstructor;
+    required: true;
+  };
+  renderContent: FunctionConstructor;
+}>, () => any, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {}, string, _$vue.PublicProps, Readonly<_$vue.ExtractPropTypes<{
+  node: {
+    type: ObjectConstructor;
+    required: true;
+  };
+  renderContent: FunctionConstructor;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, _$vue.ComponentProvideOptions, true, {}, any>;
+//#endregion
+export { _default as default };

frontend/node_modules/element-plus/es/components/tree/src/tree-node-content.vue_vue_type_script_lang.mjs

@@ -0,0 +1,41 @@
+import { useNamespace } from "../../../hooks/use-namespace/index.mjs";
+import { ElText } from "../../text/index.mjs";
+import { NODE_INSTANCE_INJECTION_KEY, ROOT_TREE_INJECTION_KEY } from "./tokens.mjs";
+import { defineComponent, h, inject, renderSlot } from "vue";
+//#region ../../packages/components/tree/src/tree-node-content.vue?vue&type=script&lang.ts
+var tree_node_content_vue_vue_type_script_lang_default = defineComponent({
+	name: "ElTreeNodeContent",
+	props: {
+		node: {
+			type: Object,
+			required: true
+		},
+		renderContent: Function
+	},
+	setup(props) {
+		const ns = useNamespace("tree");
+		const nodeInstance = inject(NODE_INSTANCE_INJECTION_KEY);
+		const tree = inject(ROOT_TREE_INJECTION_KEY);
+		return () => {
+			const node = props.node;
+			const { data, store } = node;
+			return props.renderContent ? props.renderContent(h, {
+				_self: nodeInstance,
+				node,
+				data,
+				store
+			}) : renderSlot(tree.ctx.slots, "default", {
+				node,
+				data
+			}, () => [h(ElText, {
+				tag: "span",
+				truncated: true,
+				class: ns.be("node", "label")
+			}, () => [node.label])]);
+		};
+	}
+});
+//#endregion
+export { tree_node_content_vue_vue_type_script_lang_default as default };
+
+//# sourceMappingURL=tree-node-content.vue_vue_type_script_lang.mjs.map

frontend/node_modules/element-plus/es/components/tree/src/tree-node-content.vue_vue_type_script_lang.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-node-content.vue_vue_type_script_lang.mjs","names":[],"sources":["../../../../../../packages/components/tree/src/tree-node-content.vue"],"sourcesContent":["<script lang=\"ts\">\nimport { defineComponent, h, inject, renderSlot } from 'vue'\nimport ElText from '@element-plus/components/text'\nimport { useNamespace } from '@element-plus/hooks'\nimport { NODE_INSTANCE_INJECTION_KEY, ROOT_TREE_INJECTION_KEY } from './tokens'\n\nimport type { ComponentInternalInstance } from 'vue'\nimport type { RootTreeType } from './tree.type'\n\nexport default defineComponent({\n  name: 'ElTreeNodeContent',\n  props: {\n    node: {\n      type: Object,\n      required: true,\n    },\n    renderContent: Function,\n  },\n  setup(props) {\n    const ns = useNamespace('tree')\n    const nodeInstance = inject<ComponentInternalInstance>(\n      NODE_INSTANCE_INJECTION_KEY\n    )\n    const tree = inject<RootTreeType>(ROOT_TREE_INJECTION_KEY)!\n    return () => {\n      const node = props.node\n      const { data, store } = node\n      return props.renderContent\n        ? props.renderContent(h, { _self: nodeInstance, node, data, store })\n        : renderSlot(tree.ctx.slots, 'default', { node, data }, () => [\n            h(\n              ElText,\n              { tag: 'span', truncated: true, class: ns.be('node', 'label') },\n              () => [node.label]\n            ),\n          ])\n    }\n  },\n})\n</script>\n"],"mappings":";;;;;AASA,IAAA,qDAAe,gBAAgB;CAC7B,MAAM;CACN,OAAO;EACL,MAAM;GACJ,MAAM;GACN,UAAU;GACX;EACD,eAAe;EAChB;CACD,MAAM,OAAO;EACX,MAAM,KAAK,aAAa,OAAM;EAC9B,MAAM,eAAe,OACnB,4BACF;EACA,MAAM,OAAO,OAAqB,wBAAwB;EAC1D,aAAa;GACX,MAAM,OAAO,MAAM;GACnB,MAAM,EAAE,MAAM,UAAU;GACxB,OAAO,MAAM,gBACT,MAAM,cAAc,GAAG;IAAE,OAAO;IAAc;IAAM;IAAM;IAAO,CAAA,GACjE,WAAW,KAAK,IAAI,OAAO,WAAW;IAAE;IAAM;IAAM,QAAQ,CAC1D,EACE,QACA;IAAE,KAAK;IAAQ,WAAW;IAAM,OAAO,GAAG,GAAG,QAAQ,QAAO;IAAG,QACzD,CAAC,KAAK,MAAK,CAClB,CACF,CAAA;;;CAGV,CAAA"}

frontend/node_modules/element-plus/es/components/tree/src/tree-node.mjs

@@ -0,0 +1,118 @@
+import _plugin_vue_export_helper_default from "../../../_virtual/_plugin-vue_export-helper.mjs";
+import tree_node_vue_vue_type_script_lang_default from "./tree-node.vue_vue_type_script_lang.mjs";
+import { Fragment, createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, normalizeClass, normalizeStyle, openBlock, renderList, resolveComponent, resolveDynamicComponent, vShow, withCtx, withDirectives, withModifiers } from "vue";
+//#region ../../packages/components/tree/src/tree-node.vue
+const _hoisted_1 = [
+	"aria-expanded",
+	"aria-disabled",
+	"aria-checked",
+	"draggable",
+	"data-key"
+];
+const _hoisted_2 = ["aria-expanded"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+	const _component_el_icon = resolveComponent("el-icon");
+	const _component_el_checkbox = resolveComponent("el-checkbox");
+	const _component_loading = resolveComponent("loading");
+	const _component_node_content = resolveComponent("node-content");
+	const _component_el_tree_node = resolveComponent("el-tree-node");
+	const _component_el_collapse_transition = resolveComponent("el-collapse-transition");
+	return withDirectives((openBlock(), createElementBlock("div", {
+		ref: "node$",
+		class: normalizeClass([
+			_ctx.ns.b("node"),
+			_ctx.ns.is("expanded", _ctx.expanded),
+			_ctx.ns.is("current", _ctx.node.isCurrent),
+			_ctx.ns.is("hidden", !_ctx.node.visible),
+			_ctx.ns.is("focusable", !_ctx.node.disabled),
+			_ctx.ns.is("checked", !_ctx.node.disabled && _ctx.node.checked),
+			_ctx.getNodeClass(_ctx.node)
+		]),
+		role: "treeitem",
+		tabindex: "-1",
+		"aria-expanded": _ctx.expanded,
+		"aria-disabled": _ctx.node.disabled,
+		"aria-checked": _ctx.node.checked,
+		draggable: _ctx.tree.props.draggable,
+		"data-key": _ctx.getNodeKey(_ctx.node),
+		onClick: _cache[2] || (_cache[2] = withModifiers((...args) => _ctx.handleClick && _ctx.handleClick(...args), ["stop"])),
+		onContextmenu: _cache[3] || (_cache[3] = (...args) => _ctx.handleContextMenu && _ctx.handleContextMenu(...args)),
+		onDragstart: _cache[4] || (_cache[4] = withModifiers((...args) => _ctx.handleDragStart && _ctx.handleDragStart(...args), ["stop"])),
+		onDragover: _cache[5] || (_cache[5] = withModifiers((...args) => _ctx.handleDragOver && _ctx.handleDragOver(...args), ["stop"])),
+		onDragend: _cache[6] || (_cache[6] = withModifiers((...args) => _ctx.handleDragEnd && _ctx.handleDragEnd(...args), ["stop"])),
+		onDrop: _cache[7] || (_cache[7] = withModifiers((...args) => _ctx.handleDrop && _ctx.handleDrop(...args), ["stop"]))
+	}, [createElementVNode("div", {
+		class: normalizeClass(_ctx.ns.be("node", "content")),
+		style: normalizeStyle({ paddingLeft: (_ctx.node.level - 1) * _ctx.tree.props.indent + "px" })
+	}, [
+		_ctx.tree.props.icon || _ctx.CaretRight ? (openBlock(), createBlock(_component_el_icon, {
+			key: 0,
+			class: normalizeClass([
+				_ctx.ns.be("node", "expand-icon"),
+				_ctx.ns.is("leaf", _ctx.node.isLeaf),
+				{ expanded: !_ctx.node.isLeaf && _ctx.expanded }
+			]),
+			onClick: withModifiers(_ctx.handleExpandIconClick, ["stop"])
+		}, {
+			default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(_ctx.tree.props.icon || _ctx.CaretRight)))]),
+			_: 1
+		}, 8, ["class", "onClick"])) : createCommentVNode("v-if", true),
+		_ctx.showCheckbox ? (openBlock(), createBlock(_component_el_checkbox, {
+			key: 1,
+			"model-value": _ctx.node.checked,
+			indeterminate: _ctx.node.indeterminate,
+			disabled: !!_ctx.node.disabled,
+			onClick: _cache[0] || (_cache[0] = withModifiers(() => {}, ["stop"])),
+			onChange: _ctx.handleCheckChange
+		}, null, 8, [
+			"model-value",
+			"indeterminate",
+			"disabled",
+			"onChange"
+		])) : createCommentVNode("v-if", true),
+		_ctx.node.loading ? (openBlock(), createBlock(_component_el_icon, {
+			key: 2,
+			class: normalizeClass([_ctx.ns.be("node", "loading-icon"), _ctx.ns.is("loading")])
+		}, {
+			default: withCtx(() => [createVNode(_component_loading)]),
+			_: 1
+		}, 8, ["class"])) : createCommentVNode("v-if", true),
+		createVNode(_component_node_content, {
+			node: _ctx.node,
+			"render-content": _ctx.renderContent
+		}, null, 8, ["node", "render-content"])
+	], 6), createVNode(_component_el_collapse_transition, null, {
+		default: withCtx(() => [!_ctx.renderAfterExpand || _ctx.childNodeRendered ? withDirectives((openBlock(), createElementBlock("div", {
+			key: 0,
+			class: normalizeClass(_ctx.ns.be("node", "children")),
+			role: "group",
+			"aria-expanded": _ctx.expanded,
+			onClick: _cache[1] || (_cache[1] = withModifiers(() => {}, ["stop"]))
+		}, [(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.node.childNodes, (child) => {
+			return openBlock(), createBlock(_component_el_tree_node, {
+				key: _ctx.getNodeKey(child),
+				"render-content": _ctx.renderContent,
+				"render-after-expand": _ctx.renderAfterExpand,
+				"show-checkbox": _ctx.showCheckbox,
+				node: child,
+				accordion: _ctx.accordion,
+				props: _ctx.props,
+				onNodeExpand: _ctx.handleChildNodeExpand
+			}, null, 8, [
+				"render-content",
+				"render-after-expand",
+				"show-checkbox",
+				"node",
+				"accordion",
+				"props",
+				"onNodeExpand"
+			]);
+		}), 128))], 10, _hoisted_2)), [[vShow, _ctx.expanded]]) : createCommentVNode("v-if", true)]),
+		_: 1
+	})], 42, _hoisted_1)), [[vShow, _ctx.node.visible]]);
+}
+var tree_node_default = /* @__PURE__ */ _plugin_vue_export_helper_default(tree_node_vue_vue_type_script_lang_default, [["render", _sfc_render]]);
+//#endregion
+export { tree_node_default as default };
+
+//# sourceMappingURL=tree-node.mjs.map

frontend/node_modules/element-plus/es/components/tree/src/tree-node.vue.d.ts

@@ -0,0 +1,230 @@
+import { SFCWithInstall } from "../../../utils/vue/typescript.js";
+import { CheckboxProps, CheckboxValueType } from "../../checkbox/src/checkbox.js";
+import _default$1 from "../../checkbox/src/checkbox-button.vue.js";
+import _default$2 from "../../checkbox/src/checkbox-group.vue.js";
+import { IconProps } from "../../icon/src/icon.js";
+import Node from "./model/node.js";
+import { RootTreeType, TreeNodeData, TreeOptionProps } from "./tree.type.js";
+import * as _$vue from "vue";
+import { ComponentInternalInstance, PropType } from "vue";
+
+//#region ../../packages/components/tree/src/tree-node.vue.d.ts
+declare const _default: typeof __VLS_export;
+declare const __VLS_export: _$vue.DefineComponent<_$vue.ExtractPropTypes<{
+  node: {
+    type: typeof Node;
+    default: () => {};
+  };
+  props: {
+    type: PropType<TreeOptionProps>;
+    default: () => {};
+  };
+  accordion: BooleanConstructor;
+  renderContent: FunctionConstructor;
+  renderAfterExpand: BooleanConstructor;
+  showCheckbox: BooleanConstructor;
+}>, {
+  ns: {
+    namespace: _$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;
+  };
+  node$: _$vue.Ref<HTMLElement | undefined, HTMLElement | undefined>;
+  tree: RootTreeType;
+  expanded: _$vue.Ref<boolean, boolean>;
+  childNodeRendered: _$vue.Ref<boolean, boolean>;
+  oldChecked: _$vue.Ref<boolean | undefined, boolean | undefined>;
+  oldIndeterminate: _$vue.Ref<boolean | undefined, boolean | undefined>;
+  getNodeKey: (node: Node) => any;
+  getNodeClass: (node: Node) => {
+    [key: string]: boolean;
+  };
+  handleSelectChange: (checked: boolean, indeterminate: boolean) => void;
+  handleClick: (e: MouseEvent) => void;
+  handleContextMenu: (event: Event) => void;
+  handleExpandIconClick: () => void;
+  handleCheckChange: (value: CheckboxValueType) => void;
+  handleChildNodeExpand: (nodeData: TreeNodeData, node: Node, instance: ComponentInternalInstance) => void;
+  handleDragStart: (event: DragEvent) => void;
+  handleDragOver: (event: DragEvent) => void;
+  handleDrop: (event: DragEvent) => void;
+  handleDragEnd: (event: DragEvent) => void;
+  CaretRight: _$vue.DefineComponent<{}, void, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {}, string, _$vue.PublicProps, Readonly<{}>, {}, {}, {}, {}, string, _$vue.ComponentProvideOptions, true, {}, any>;
+}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, "node-expand"[], "node-expand", _$vue.PublicProps, Readonly<_$vue.ExtractPropTypes<{
+  node: {
+    type: typeof Node;
+    default: () => {};
+  };
+  props: {
+    type: PropType<TreeOptionProps>;
+    default: () => {};
+  };
+  accordion: BooleanConstructor;
+  renderContent: FunctionConstructor;
+  renderAfterExpand: BooleanConstructor;
+  showCheckbox: BooleanConstructor;
+}>> & Readonly<{
+  "onNode-expand"?: ((...args: any[]) => any) | undefined;
+}>, {
+  props: TreeOptionProps;
+  accordion: boolean;
+  node: Node;
+  renderAfterExpand: boolean;
+  showCheckbox: boolean;
+}, {}, {
+  ElCollapseTransition: SFCWithInstall<{
+    new (...args: any[]): _$vue.CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {}, _$vue.PublicProps, {}, true, {}, {}, _$vue.GlobalComponents, _$vue.GlobalDirectives, string, {}, any, _$vue.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & _$vue.ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}, _$vue.GlobalComponents, _$vue.GlobalDirectives, string, _$vue.ComponentProvideOptions> & _$vue.VNodeProps & _$vue.AllowedComponentProps & _$vue.ComponentCustomProps & (new () => {
+    $slots: {
+      default?: (props: {}) => any;
+    };
+  })>;
+  ElCheckbox: {
+    new (...args: any[]): _$vue.CreateComponentPublicInstanceWithMixins<Readonly<CheckboxProps> & Readonly<{
+      "onUpdate:modelValue"?: ((val: CheckboxValueType) => any) | undefined;
+      onChange?: ((val: CheckboxValueType) => any) | undefined;
+    }>, {}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {
+      change: (val: CheckboxValueType) => void;
+      "update:modelValue": (val: CheckboxValueType) => void;
+    }, _$vue.PublicProps, {
+      name: string;
+      label: string | boolean | number | object;
+      disabled: boolean;
+      modelValue: number | string | boolean;
+      id: string;
+      validateEvent: boolean;
+      value: string | boolean | number | object;
+      trueValue: string | number;
+      falseValue: string | number;
+      trueLabel: string | number;
+      falseLabel: string | number;
+    }, false, {}, {}, _$vue.GlobalComponents, _$vue.GlobalDirectives, string, {}, any, _$vue.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<CheckboxProps> & Readonly<{
+      "onUpdate:modelValue"?: ((val: CheckboxValueType) => any) | undefined;
+      onChange?: ((val: CheckboxValueType) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+      name: string;
+      label: string | boolean | number | object;
+      disabled: boolean;
+      modelValue: number | string | boolean;
+      id: string;
+      validateEvent: boolean;
+      value: string | boolean | number | object;
+      trueValue: string | number;
+      falseValue: string | number;
+      trueLabel: string | number;
+      falseLabel: string | number;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & _$vue.ComponentOptionsBase<Readonly<CheckboxProps> & Readonly<{
+    "onUpdate:modelValue"?: ((val: CheckboxValueType) => any) | undefined;
+    onChange?: ((val: CheckboxValueType) => any) | undefined;
+  }>, {}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {
+    change: (val: CheckboxValueType) => void;
+    "update:modelValue": (val: CheckboxValueType) => void;
+  }, string, {
+    name: string;
+    label: string | boolean | number | object;
+    disabled: boolean;
+    modelValue: number | string | boolean;
+    id: string;
+    validateEvent: boolean;
+    value: string | boolean | number | object;
+    trueValue: string | number;
+    falseValue: string | number;
+    trueLabel: string | number;
+    falseLabel: string | number;
+  }, {}, string, {}, _$vue.GlobalComponents, _$vue.GlobalDirectives, string, _$vue.ComponentProvideOptions> & _$vue.VNodeProps & _$vue.AllowedComponentProps & _$vue.ComponentCustomProps & (new () => {
+    $slots: {
+      default?: (props: {}) => any;
+    };
+  }) & _$vue.ObjectPlugin & {
+    setPropsDefaults: (defaults: {
+      readonly modelValue?: string | number | boolean | (() => string | number | boolean) | undefined;
+      readonly label?: string | number | boolean | (() => string | number | boolean | object) | undefined;
+      readonly value?: string | number | boolean | (() => string | number | boolean | object) | undefined;
+      readonly indeterminate?: boolean | (() => boolean) | undefined;
+      readonly disabled?: boolean | (() => boolean) | undefined;
+      readonly checked?: boolean | (() => boolean) | undefined;
+      readonly name?: string | (() => string) | undefined;
+      readonly trueValue?: string | number | (() => string | number) | undefined;
+      readonly falseValue?: string | number | (() => string | number) | undefined;
+      readonly trueLabel?: string | number | (() => string | number) | undefined;
+      readonly falseLabel?: string | number | (() => string | number) | undefined;
+      readonly id?: string | (() => string) | undefined;
+      readonly border?: boolean | (() => boolean) | undefined;
+      readonly size?: "" | "default" | "small" | "large" | (() => "" | "default" | "small" | "large") | undefined;
+      readonly tabindex?: string | number | (() => string | number) | undefined;
+      readonly validateEvent?: boolean | (() => boolean) | undefined;
+      readonly ariaLabel?: string | (() => string) | undefined;
+      readonly ariaControls?: string | (() => string) | undefined;
+    }) => void;
+  } & {
+    CheckboxButton: typeof _default$1;
+    CheckboxGroup: typeof _default$2;
+  };
+  NodeContent: _$vue.DefineComponent<_$vue.ExtractPropTypes<{
+    node: {
+      type: ObjectConstructor;
+      required: true;
+    };
+    renderContent: FunctionConstructor;
+  }>, () => any, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {}, string, _$vue.PublicProps, Readonly<_$vue.ExtractPropTypes<{
+    node: {
+      type: ObjectConstructor;
+      required: true;
+    };
+    renderContent: FunctionConstructor;
+  }>> & Readonly<{}>, {}, {}, {}, {}, string, _$vue.ComponentProvideOptions, true, {}, any>;
+  ElIcon: SFCWithInstall<{
+    new (...args: any[]): _$vue.CreateComponentPublicInstanceWithMixins<Readonly<IconProps> & Readonly<{}>, {}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {}, _$vue.PublicProps, {}, false, {}, {}, _$vue.GlobalComponents, _$vue.GlobalDirectives, string, {}, any, _$vue.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & _$vue.ComponentOptionsBase<Readonly<IconProps> & Readonly<{}>, {}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {}, string, {}, {}, string, {}, _$vue.GlobalComponents, _$vue.GlobalDirectives, string, _$vue.ComponentProvideOptions> & _$vue.VNodeProps & _$vue.AllowedComponentProps & _$vue.ComponentCustomProps & (new () => {
+    $slots: {
+      default?: (props: {}) => any;
+    };
+  })>;
+  Loading: _$vue.DefineComponent<{}, void, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {}, string, _$vue.PublicProps, Readonly<{}>, {}, {}, {}, {}, string, _$vue.ComponentProvideOptions, true, {}, any>;
+}, {}, string, _$vue.ComponentProvideOptions, true, {}, any>;
+//#endregion
+export { _default as default };

frontend/node_modules/element-plus/es/components/tree/src/tree-node.vue_vue_type_script_lang.mjs

@@ -0,0 +1,193 @@
+import { isFunction, isString } from "../../../utils/types.mjs";
+import { debugWarn } from "../../../utils/error.mjs";
+import { useNamespace } from "../../../hooks/use-namespace/index.mjs";
+import { ElIcon } from "../../icon/index.mjs";
+import { ElCheckbox } from "../../checkbox/index.mjs";
+import { ElCollapseTransition } from "../../collapse-transition/index.mjs";
+import { getNodeKey, handleCurrentChange } from "./model/util.mjs";
+import Node from "./model/node.mjs";
+import { NODE_INSTANCE_INJECTION_KEY, ROOT_TREE_INJECTION_KEY } from "./tokens.mjs";
+import tree_node_content_default from "./tree-node-content.mjs";
+import { useNodeExpandEventBroadcast } from "./model/useNodeExpandEventBroadcast.mjs";
+import { dragEventsKey } from "./model/useDragNode.mjs";
+import { CaretRight, Loading } from "@element-plus/icons-vue";
+import { defineComponent, getCurrentInstance, inject, nextTick, provide, ref, watch } from "vue";
+//#region ../../packages/components/tree/src/tree-node.vue?vue&type=script&lang.ts
+var tree_node_vue_vue_type_script_lang_default = defineComponent({
+	name: "ElTreeNode",
+	components: {
+		ElCollapseTransition,
+		ElCheckbox,
+		NodeContent: tree_node_content_default,
+		ElIcon,
+		Loading
+	},
+	props: {
+		node: {
+			type: Node,
+			default: () => ({})
+		},
+		props: {
+			type: Object,
+			default: () => ({})
+		},
+		accordion: Boolean,
+		renderContent: Function,
+		renderAfterExpand: Boolean,
+		showCheckbox: Boolean
+	},
+	emits: ["node-expand"],
+	setup(props, ctx) {
+		const ns = useNamespace("tree");
+		const { broadcastExpanded } = useNodeExpandEventBroadcast(props);
+		const tree = inject(ROOT_TREE_INJECTION_KEY);
+		const expanded = ref(false);
+		const childNodeRendered = ref(false);
+		const oldChecked = ref();
+		const oldIndeterminate = ref();
+		const node$ = ref();
+		const dragEvents = inject(dragEventsKey);
+		const instance = getCurrentInstance();
+		provide(NODE_INSTANCE_INJECTION_KEY, instance);
+		if (!tree) debugWarn("Tree", "Can not find node's tree.");
+		if (props.node.expanded) {
+			expanded.value = true;
+			childNodeRendered.value = true;
+		}
+		const childrenKey = tree.props.props["children"] || "children";
+		watch(() => {
+			const children = props.node.data?.[childrenKey];
+			return children && [...children];
+		}, () => {
+			props.node.updateChildren();
+		});
+		watch(() => props.node.indeterminate, (val) => {
+			handleSelectChange(props.node.checked, val);
+		});
+		watch(() => props.node.checked, (val) => {
+			handleSelectChange(val, props.node.indeterminate);
+		});
+		watch(() => props.node.childNodes.length, () => props.node.reInitChecked());
+		watch(() => props.node.expanded, (val) => {
+			nextTick(() => expanded.value = val);
+			if (val) childNodeRendered.value = true;
+		});
+		const getNodeKey$1 = (node) => {
+			return tree.props.nodeKey ? getNodeKey(tree.props.nodeKey, node.data) : node.id;
+		};
+		const getNodeClass = (node) => {
+			const nodeClassFunc = props.props.class;
+			if (!nodeClassFunc) return {};
+			let className;
+			if (isFunction(nodeClassFunc)) {
+				const { data } = node;
+				className = nodeClassFunc(data, node);
+			} else className = nodeClassFunc;
+			if (isString(className)) return { [className]: true };
+			else return className;
+		};
+		const handleSelectChange = (checked, indeterminate) => {
+			if (oldChecked.value !== checked || oldIndeterminate.value !== indeterminate) tree.ctx.emit("check-change", props.node.data, checked, indeterminate);
+			oldChecked.value = checked;
+			oldIndeterminate.value = indeterminate;
+		};
+		const handleClick = (e) => {
+			handleCurrentChange(tree.store, tree.ctx.emit, () => {
+				if (tree?.props?.nodeKey) {
+					const curNodeKey = getNodeKey$1(props.node);
+					tree.store.value.setCurrentNodeKey(curNodeKey);
+				} else tree.store.value.setCurrentNode(props.node);
+			});
+			tree.currentNode.value = props.node;
+			if (tree.props.expandOnClickNode) handleExpandIconClick();
+			if ((tree.props.checkOnClickNode || props.node.isLeaf && tree.props.checkOnClickLeaf && props.showCheckbox) && !props.node.disabled) handleCheckChange(!props.node.checked);
+			tree.ctx.emit("node-click", props.node.data, props.node, instance, e);
+		};
+		const handleContextMenu = (event) => {
+			if (tree.instance.vnode.props?.["onNodeContextmenu"]) {
+				event.stopPropagation();
+				event.preventDefault();
+			}
+			tree.ctx.emit("node-contextmenu", event, props.node.data, props.node, instance);
+		};
+		const handleExpandIconClick = () => {
+			if (props.node.isLeaf) return;
+			if (expanded.value) {
+				tree.ctx.emit("node-collapse", props.node.data, props.node, instance);
+				props.node.collapse();
+			} else props.node.expand(() => {
+				ctx.emit("node-expand", props.node.data, props.node, instance);
+			});
+		};
+		const handleCheckChange = (value) => {
+			const checkStrictly = tree?.props.checkStrictly;
+			const childNodes = props.node.childNodes;
+			if (!checkStrictly && childNodes.length) value = childNodes.some((node) => !node.isEffectivelyChecked);
+			props.node.setChecked(value, !checkStrictly);
+			nextTick(() => {
+				const store = tree.store.value;
+				tree.ctx.emit("check", props.node.data, {
+					checkedNodes: store.getCheckedNodes(),
+					checkedKeys: store.getCheckedKeys(),
+					halfCheckedNodes: store.getHalfCheckedNodes(),
+					halfCheckedKeys: store.getHalfCheckedKeys()
+				});
+			});
+		};
+		const handleChildNodeExpand = (nodeData, node, instance) => {
+			broadcastExpanded(node);
+			tree.ctx.emit("node-expand", nodeData, node, instance);
+		};
+		const handleDragStart = (event) => {
+			if (!tree.props.draggable) return;
+			dragEvents.treeNodeDragStart({
+				event,
+				treeNode: props
+			});
+		};
+		const handleDragOver = (event) => {
+			event.preventDefault();
+			if (!tree.props.draggable) return;
+			dragEvents.treeNodeDragOver({
+				event,
+				treeNode: {
+					$el: node$.value,
+					node: props.node
+				}
+			});
+		};
+		const handleDrop = (event) => {
+			event.preventDefault();
+		};
+		const handleDragEnd = (event) => {
+			if (!tree.props.draggable) return;
+			dragEvents.treeNodeDragEnd(event);
+		};
+		return {
+			ns,
+			node$,
+			tree,
+			expanded,
+			childNodeRendered,
+			oldChecked,
+			oldIndeterminate,
+			getNodeKey: getNodeKey$1,
+			getNodeClass,
+			handleSelectChange,
+			handleClick,
+			handleContextMenu,
+			handleExpandIconClick,
+			handleCheckChange,
+			handleChildNodeExpand,
+			handleDragStart,
+			handleDragOver,
+			handleDrop,
+			handleDragEnd,
+			CaretRight
+		};
+	}
+});
+//#endregion
+export { tree_node_vue_vue_type_script_lang_default as default };
+
+//# sourceMappingURL=tree-node.vue_vue_type_script_lang.mjs.map

frontend/node_modules/element-plus/es/components/tree/src/tree.d.ts

@@ -0,0 +1,109 @@
+import { EmitFn } from "../../../utils/vue/typescript.js";
+import { EpPropFinalized, EpPropMergeType } from "../../../utils/vue/props/types.js";
+import Node from "./model/node.js";
+import { AllowDragFunction, AllowDropFunction, CheckedInfo, FilterNodeMethodFunction, LoadFunction, NodeDropType, RenderContentFunction, TreeData, TreeKey, TreeOptionProps } from "./tree.type.js";
+import * as _$vue from "vue";
+import { ComponentInternalInstance, PropType } from "vue";
+
+//#region ../../packages/components/tree/src/tree.d.ts
+declare const treeProps: {
+  readonly data: 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: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly nodeKey: StringConstructor;
+  readonly checkStrictly: BooleanConstructor;
+  readonly defaultExpandAll: BooleanConstructor;
+  readonly expandOnClickNode: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly checkOnClickNode: BooleanConstructor;
+  readonly checkOnClickLeaf: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly checkDescendants: BooleanConstructor;
+  readonly autoExpandParent: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly defaultCheckedKeys: {
+    readonly type: PropType<TreeKey[]>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly defaultExpandedKeys: {
+    readonly type: PropType<TreeKey[]>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly currentNodeKey: {
+    readonly type: PropType<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: EpPropFinalized<(new (...args: any[]) => TreeOptionProps) | (() => TreeOptionProps) | (((new (...args: any[]) => TreeOptionProps) | (() => TreeOptionProps)) | null)[], unknown, unknown, () => {
+    children: string;
+    label: string;
+    disabled: string;
+  }, boolean>;
+  readonly lazy: BooleanConstructor;
+  readonly highlightCurrent: BooleanConstructor;
+  readonly load: {
+    readonly type: PropType<LoadFunction>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly filterNodeMethod: {
+    readonly type: PropType<FilterNodeMethodFunction>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly accordion: BooleanConstructor;
+  readonly indent: EpPropFinalized<NumberConstructor, unknown, unknown, 18, boolean>;
+  readonly icon: {
+    readonly type: PropType<EpPropMergeType<(new (...args: any[]) => (string | _$vue.Component) & {}) | (() => string | _$vue.Component) | (((new (...args: any[]) => (string | _$vue.Component) & {}) | (() => string | _$vue.Component)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+};
+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;
+};
+type TreeEmits = EmitFn<typeof treeEmits>;
+//#endregion
+export { TreeEmits, treeEmits, treeProps };

frontend/node_modules/element-plus/es/components/tree/src/tree.mjs

@@ -0,0 +1,77 @@
+import { isBoolean } from "../../../utils/types.mjs";
+import { buildProps, definePropType } from "../../../utils/vue/props/runtime.mjs";
+import { iconPropType } from "../../../utils/vue/icon.mjs";
+//#region ../../packages/components/tree/src/tree.ts
+const treeProps = buildProps({
+	data: {
+		type: definePropType(Array),
+		default: () => []
+	},
+	emptyText: { type: String },
+	renderAfterExpand: {
+		type: Boolean,
+		default: true
+	},
+	nodeKey: String,
+	checkStrictly: Boolean,
+	defaultExpandAll: Boolean,
+	expandOnClickNode: {
+		type: Boolean,
+		default: true
+	},
+	checkOnClickNode: Boolean,
+	checkOnClickLeaf: {
+		type: Boolean,
+		default: true
+	},
+	checkDescendants: Boolean,
+	autoExpandParent: {
+		type: Boolean,
+		default: true
+	},
+	defaultCheckedKeys: { type: Array },
+	defaultExpandedKeys: { type: Array },
+	currentNodeKey: { type: [String, Number] },
+	renderContent: { type: definePropType(Function) },
+	showCheckbox: Boolean,
+	draggable: Boolean,
+	allowDrag: { type: definePropType(Function) },
+	allowDrop: { type: definePropType(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: iconPropType }
+});
+const treeEmits = {
+	"check-change": (data, checked, indeterminate) => data && isBoolean(checked) && isBoolean(indeterminate),
+	"current-change": (data, node) => true,
+	"node-click": (data, node, nodeInstance, evt) => data && node && evt instanceof Event,
+	"node-contextmenu": (evt, data, node, nodeInstance) => evt instanceof Event && data && node,
+	"node-collapse": (data, node, nodeInstance) => data && node,
+	"node-expand": (data, node, nodeInstance) => data && node,
+	check: (data, checkedInfo) => data && checkedInfo,
+	"node-drag-start": (node, evt) => node && evt,
+	"node-drag-end": (draggingNode, dropNode, dropType, evt) => draggingNode && evt,
+	"node-drop": (draggingNode, dropNode, dropType, evt) => draggingNode && dropNode && evt,
+	"node-drag-leave": (draggingNode, oldDropNode, evt) => draggingNode && oldDropNode && evt,
+	"node-drag-enter": (draggingNode, dropNode, evt) => draggingNode && dropNode && evt,
+	"node-drag-over": (draggingNode, dropNode, evt) => draggingNode && dropNode && evt
+};
+//#endregion
+export { treeEmits, treeProps };
+
+//# sourceMappingURL=tree.mjs.map

frontend/node_modules/element-plus/es/components/tree/src/tree.type.d.ts

@@ -0,0 +1,115 @@
+import TreeStore from "./model/tree-store.js";
+import Node from "./model/node.js";
+import { treeEmits } from "./tree.js";
+import { DragEvents } from "./model/useDragNode.js";
+import { Component, ComponentInternalInstance, Ref, SetupContext, VNode, h } from "vue";
+
+//#region ../../packages/components/tree/src/tree.type.d.ts
+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;
+}
+//#endregion
+export { AllowDragFunction, AllowDropFunction, AllowDropType, CheckedInfo, type DragEvents, FakeNode, FilterNodeMethodFunction, FilterValue, LoadFunction, NodeDropType, RenderContentContext, RenderContentFunction, RootTreeType, TreeComponentProps, TreeData, TreeKey, TreeNodeChildState, TreeNodeData, TreeNodeLoadedDefaultProps, TreeNodeOptions, TreeOptionProps, TreeStoreNodesMap, TreeStoreOptions, hType };

frontend/node_modules/element-plus/es/components/tree/src/tree.vue_vue_type_script_lang.mjs

@@ -0,0 +1,218 @@
+import { useLocale } from "../../../hooks/use-locale/index.mjs";
+import { useNamespace } from "../../../hooks/use-namespace/index.mjs";
+import { formItemContextKey } from "../../form/src/constants.mjs";
+import { getNodeKey, handleCurrentChange } from "./model/util.mjs";
+import TreeStore from "./model/tree-store.mjs";
+import { ROOT_TREE_INJECTION_KEY } from "./tokens.mjs";
+import { useNodeExpandEventBroadcast } from "./model/useNodeExpandEventBroadcast.mjs";
+import { useDragNodeHandler } from "./model/useDragNode.mjs";
+import tree_node_default from "./tree-node.mjs";
+import { useKeydown } from "./model/useKeydown.mjs";
+import { treeEmits, treeProps } from "./tree.mjs";
+import { isEqual } from "lodash-unified";
+import { computed, defineComponent, getCurrentInstance, provide, ref, watch } from "vue";
+//#region ../../packages/components/tree/src/tree.vue?vue&type=script&lang.ts
+var tree_vue_vue_type_script_lang_default = defineComponent({
+	name: "ElTree",
+	components: { ElTreeNode: tree_node_default },
+	props: treeProps,
+	emits: treeEmits,
+	setup(props, ctx) {
+		const { t } = useLocale();
+		const ns = useNamespace("tree");
+		const store = ref(new TreeStore({
+			key: props.nodeKey,
+			data: props.data,
+			lazy: props.lazy,
+			props: props.props,
+			load: props.load,
+			currentNodeKey: props.currentNodeKey,
+			checkStrictly: props.checkStrictly,
+			checkDescendants: props.checkDescendants,
+			defaultCheckedKeys: props.defaultCheckedKeys,
+			defaultExpandedKeys: props.defaultExpandedKeys,
+			autoExpandParent: props.autoExpandParent,
+			defaultExpandAll: props.defaultExpandAll,
+			filterNodeMethod: props.filterNodeMethod
+		}));
+		store.value.initialize();
+		const root = ref(store.value.root);
+		const currentNode = ref(null);
+		const el$ = ref(null);
+		const dropIndicator$ = ref(null);
+		const { broadcastExpanded } = useNodeExpandEventBroadcast(props);
+		const { dragState } = useDragNodeHandler({
+			props,
+			ctx,
+			el$,
+			dropIndicator$,
+			store
+		});
+		useKeydown({ el$ }, store);
+		const instance = getCurrentInstance();
+		const isSelectTree = computed(() => {
+			let parent = instance?.parent;
+			while (parent) {
+				if (parent.type.name === "ElTreeSelect") return true;
+				parent = parent.parent;
+			}
+			return false;
+		});
+		const isEmpty = computed(() => {
+			const { childNodes } = root.value;
+			return (!childNodes || childNodes.length === 0 || childNodes.every(({ visible }) => !visible)) && !isSelectTree.value;
+		});
+		watch(() => props.currentNodeKey, (newVal) => {
+			store.value.setCurrentNodeKey(newVal ?? null);
+		});
+		watch(() => props.defaultCheckedKeys, (newVal, oldVal) => {
+			if (isEqual(newVal, oldVal)) return;
+			store.value.setDefaultCheckedKey(newVal ?? []);
+		});
+		watch(() => props.defaultExpandedKeys, (newVal) => {
+			store.value.setDefaultExpandedKeys(newVal ?? []);
+		});
+		watch(() => props.data, (newVal) => {
+			store.value.setData(newVal);
+		}, { deep: true });
+		watch(() => props.checkStrictly, (newVal) => {
+			store.value.checkStrictly = newVal;
+		});
+		const filter = (value) => {
+			if (!props.filterNodeMethod) throw new Error("[Tree] filterNodeMethod is required when filter");
+			store.value.filter(value);
+		};
+		const getNodeKey$1 = (node) => {
+			return props.nodeKey ? getNodeKey(props.nodeKey, node.data) : node.id;
+		};
+		const requireNodeKey = (methodName) => {
+			if (!props.nodeKey) throw new Error(`[Tree] nodeKey is required in ${methodName}`);
+		};
+		const getNodePath = (data) => {
+			requireNodeKey("getNodePath");
+			const node = store.value.getNode(data);
+			if (!node) return [];
+			const path = [node.data];
+			let parent = node.parent;
+			while (parent && parent !== root.value) {
+				path.push(parent.data);
+				parent = parent.parent;
+			}
+			return path.reverse();
+		};
+		const getCheckedNodes = (leafOnly, includeHalfChecked) => {
+			return store.value.getCheckedNodes(leafOnly, includeHalfChecked);
+		};
+		const getCheckedKeys = (leafOnly) => {
+			return store.value.getCheckedKeys(leafOnly);
+		};
+		const getCurrentNode = () => {
+			const currentNode = store.value.getCurrentNode();
+			return currentNode ? currentNode.data : null;
+		};
+		const getCurrentKey = () => {
+			requireNodeKey("getCurrentKey");
+			const currentNode = getCurrentNode();
+			return currentNode ? currentNode[props.nodeKey] : null;
+		};
+		const setCheckedNodes = (nodes, leafOnly) => {
+			requireNodeKey("setCheckedNodes");
+			store.value.setCheckedNodes(nodes, leafOnly);
+		};
+		const setCheckedKeys = (keys, leafOnly) => {
+			requireNodeKey("setCheckedKeys");
+			store.value.setCheckedKeys(keys, leafOnly);
+		};
+		const setChecked = (data, checked, deep = false) => {
+			store.value.setChecked(data, checked, deep);
+		};
+		const getHalfCheckedNodes = () => {
+			return store.value.getHalfCheckedNodes();
+		};
+		const getHalfCheckedKeys = () => {
+			return store.value.getHalfCheckedKeys();
+		};
+		const setCurrentNode = (node, shouldAutoExpandParent = true) => {
+			requireNodeKey("setCurrentNode");
+			handleCurrentChange(store, ctx.emit, () => {
+				broadcastExpanded(node);
+				store.value.setUserCurrentNode(node, shouldAutoExpandParent);
+			});
+		};
+		const setCurrentKey = (key = null, shouldAutoExpandParent = true) => {
+			requireNodeKey("setCurrentKey");
+			handleCurrentChange(store, ctx.emit, () => {
+				broadcastExpanded();
+				store.value.setCurrentNodeKey(key, shouldAutoExpandParent);
+			});
+		};
+		const getNode = (data) => {
+			return store.value.getNode(data);
+		};
+		const remove = (data) => {
+			store.value.remove(data);
+		};
+		const append = (data, parentNode) => {
+			store.value.append(data, parentNode);
+		};
+		const insertBefore = (data, refNode) => {
+			store.value.insertBefore(data, refNode);
+		};
+		const insertAfter = (data, refNode) => {
+			store.value.insertAfter(data, refNode);
+		};
+		const handleNodeExpand = (nodeData, node, instance) => {
+			broadcastExpanded(node);
+			ctx.emit("node-expand", nodeData, node, instance);
+		};
+		const updateKeyChildren = (key, data) => {
+			requireNodeKey("updateKeyChildren");
+			store.value.updateChildren(key, data);
+		};
+		provide(ROOT_TREE_INJECTION_KEY, {
+			ctx,
+			props,
+			store,
+			root,
+			currentNode,
+			instance
+		});
+		provide(formItemContextKey, void 0);
+		return {
+			ns,
+			store,
+			root,
+			currentNode,
+			dragState,
+			el$,
+			dropIndicator$,
+			isEmpty,
+			filter,
+			getNodeKey: getNodeKey$1,
+			getNodePath,
+			getCheckedNodes,
+			getCheckedKeys,
+			getCurrentNode,
+			getCurrentKey,
+			setCheckedNodes,
+			setCheckedKeys,
+			setChecked,
+			getHalfCheckedNodes,
+			getHalfCheckedKeys,
+			setCurrentNode,
+			setCurrentKey,
+			t,
+			getNode,
+			remove,
+			append,
+			insertBefore,
+			insertAfter,
+			handleNodeExpand,
+			updateKeyChildren
+		};
+	}
+});
+//#endregion
+export { tree_vue_vue_type_script_lang_default as default };
+
+//# sourceMappingURL=tree.vue_vue_type_script_lang.mjs.map

frontend/node_modules/element-plus/es/components/tree/src/tree2.mjs

@@ -0,0 +1,52 @@
+import _plugin_vue_export_helper_default from "../../../_virtual/_plugin-vue_export-helper.mjs";
+import tree_vue_vue_type_script_lang_default from "./tree.vue_vue_type_script_lang.mjs";
+import { Fragment, createBlock, createCommentVNode, createElementBlock, createElementVNode, normalizeClass, openBlock, renderList, renderSlot, resolveComponent, toDisplayString, vShow, withDirectives } from "vue";
+//#region ../../packages/components/tree/src/tree.vue
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+	const _component_el_tree_node = resolveComponent("el-tree-node");
+	return openBlock(), createElementBlock("div", {
+		ref: "el$",
+		class: normalizeClass([
+			_ctx.ns.b(),
+			_ctx.ns.is("dragging", !!_ctx.dragState.draggingNode),
+			_ctx.ns.is("drop-not-allow", !_ctx.dragState.allowDrop),
+			_ctx.ns.is("drop-inner", _ctx.dragState.dropType === "inner"),
+			{ [_ctx.ns.m("highlight-current")]: _ctx.highlightCurrent }
+		]),
+		role: "tree"
+	}, [
+		(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.root.childNodes, (child) => {
+			return openBlock(), createBlock(_component_el_tree_node, {
+				key: _ctx.getNodeKey(child),
+				node: child,
+				props: _ctx.props,
+				accordion: _ctx.accordion,
+				"render-after-expand": _ctx.renderAfterExpand,
+				"show-checkbox": _ctx.showCheckbox,
+				"render-content": _ctx.renderContent,
+				onNodeExpand: _ctx.handleNodeExpand
+			}, null, 8, [
+				"node",
+				"props",
+				"accordion",
+				"render-after-expand",
+				"show-checkbox",
+				"render-content",
+				"onNodeExpand"
+			]);
+		}), 128)),
+		_ctx.isEmpty ? (openBlock(), createElementBlock("div", {
+			key: 0,
+			class: normalizeClass(_ctx.ns.e("empty-block"))
+		}, [renderSlot(_ctx.$slots, "empty", {}, () => [createElementVNode("span", { class: normalizeClass(_ctx.ns.e("empty-text")) }, toDisplayString(_ctx.emptyText ?? _ctx.t("el.tree.emptyText")), 3)])], 2)) : createCommentVNode("v-if", true),
+		withDirectives(createElementVNode("div", {
+			ref: "dropIndicator$",
+			class: normalizeClass(_ctx.ns.e("drop-indicator"))
+		}, null, 2), [[vShow, _ctx.dragState.showDropIndicator]])
+	], 2);
+}
+var tree_default = /* @__PURE__ */ _plugin_vue_export_helper_default(tree_vue_vue_type_script_lang_default, [["render", _sfc_render]]);
+//#endregion
+export { tree_default as default };
+
+//# sourceMappingURL=tree2.mjs.map

frontend/node_modules/element-plus/es/components/tree/style/css.mjs

@@ -0,0 +1,4 @@
+import "../../base/style/css.mjs";
+import "../../checkbox/style/css.mjs";
+import "../../text/style/css.mjs";
+import "element-plus/theme-chalk/el-tree.css";

frontend/node_modules/element-plus/es/components/tree/style/index.mjs

@@ -0,0 +1,4 @@
+import "../../base/style/index.mjs";
+import "../../checkbox/style/index.mjs";
+import "../../text/style/index.mjs";
+import "element-plus/theme-chalk/src/tree.scss";