@sdata/web-vue 1.3.0 → 1.4.0

package/lib/tree/tree.vue_vue_type_script_lang.js

@@ -1,547 +0,0 @@
-require("../_virtual/_rolldown/runtime.js");
-const require_global_config = require("../_utils/global-config.js");
-const require_is = require("../_utils/is.js");
-const require_index = require("../_components/virtual-list-v2/index.js");
-const require_use_merge_state = require("../_hooks/use-merge-state.js");
-const require_use_pick_slots = require("../_hooks/use-pick-slots.js");
-const require_asyncToGenerator = require("../_virtual/_@oxc-project_runtime@0.124.0/helpers/asyncToGenerator.js");
-const require_context = require("./context.js");
-const require_check_utils = require("./utils/check-utils.js");
-const require_use_checked_state = require("./hooks/use-checked-state.js");
-const require_index$1 = require("./utils/index.js");
-const require_use_tree_data = require("./hooks/use-tree-data.js");
-const require_node = require("./node.js");
-let vue = require("vue");
-//#region components/tree/tree.vue?vue&type=script&lang.ts
-var tree_vue_vue_type_script_lang_default = (0, vue.defineComponent)({
-	name: "Tree",
-	components: {
-		VirtualList: require_index.default,
-		TreeNode: require_node.default
-	},
-	props: {
-		size: {
-			type: String,
-			default: "medium"
-		},
-		blockNode: { type: Boolean },
-		defaultExpandAll: {
-			type: Boolean,
-			default: true
-		},
-		multiple: { type: Boolean },
-		checkable: {
-			type: [
-				Boolean,
-				String,
-				Function
-			],
-			default: false
-		},
-		selectable: {
-			type: [Boolean, Function],
-			default: true
-		},
-		checkStrictly: { type: Boolean },
-		checkedStrategy: {
-			type: String,
-			default: "all"
-		},
-		defaultSelectedKeys: { type: Array },
-		selectedKeys: { type: Array },
-		defaultCheckedKeys: { type: Array },
-		checkedKeys: { type: Array },
-		defaultExpandedKeys: { type: Array },
-		expandedKeys: { type: Array },
-		data: {
-			type: Array,
-			default: () => []
-		},
-		fieldNames: { type: Object },
-		showLine: { type: Boolean },
-		loadMore: { type: Function },
-		draggable: { type: Boolean },
-		allowDrop: { type: Function },
-		filterTreeNode: { type: Function },
-		searchValue: {
-			type: String,
-			default: ""
-		},
-		virtualListProps: { type: Object },
-		defaultExpandSelected: { type: Boolean },
-		defaultExpandChecked: { type: Boolean },
-		autoExpandParent: {
-			type: Boolean,
-			default: true
-		},
-		halfCheckedKeys: { type: Array },
-		onlyCheckLeaf: {
-			type: Boolean,
-			default: false
-		},
-		animation: {
-			type: Boolean,
-			default: true
-		},
-		actionOnNodeClick: { type: String },
-		disableSelectActionOnly: {
-			type: Boolean,
-			default: false
-		}
-	},
-	emits: {
-		"select": (selectedKeys, data) => true,
-		"update:selectedKeys": (selectedKeys) => true,
-		"check": (checkedKeys, data) => true,
-		"update:checkedKeys": (checkedKeys) => true,
-		"update:halfCheckedKeys": (halfCheckedKeys) => true,
-		"expand": (expandKeys, data) => true,
-		"update:expandedKeys": (expandKeys) => true,
-		"dragStart": (ev, node) => true,
-		"dragEnd": (ev, node) => true,
-		"dragOver": (ev, node) => true,
-		"dragLeave": (ev, node) => true,
-		"drop": (data) => true
-	},
-	setup(props, { emit, slots }) {
-		const { data: propTreeData, showLine, multiple, loadMore, checkStrictly, checkedKeys: propCheckedKeys, defaultCheckedKeys, selectedKeys: propSelectedKeys, defaultSelectedKeys, expandedKeys: propExpandedKeys, defaultExpandedKeys, checkedStrategy, selectable, checkable, blockNode, fieldNames, size, defaultExpandAll, filterTreeNode, draggable, allowDrop, defaultExpandSelected, defaultExpandChecked, autoExpandParent, halfCheckedKeys, onlyCheckLeaf, animation } = (0, vue.toRefs)(props);
-		const prefixCls = require_global_config.getPrefixCls("tree");
-		const classNames = (0, vue.computed)(() => [
-			`${prefixCls}`,
-			{
-				[`${prefixCls}-checkable`]: checkable.value,
-				[`${prefixCls}-show-line`]: showLine.value
-			},
-			`${prefixCls}-size-${size.value}`
-		]);
-		const switcherIcon = require_use_pick_slots.default(slots, "switcher-icon");
-		const loadingIcon = require_use_pick_slots.default(slots, "loading-icon");
-		const dragIcon = require_use_pick_slots.default(slots, "drag-icon");
-		const nodeIcon = require_use_pick_slots.default(slots, "icon");
-		const nodeTitle = require_use_pick_slots.default(slots, "title");
-		const nodeExtra = require_use_pick_slots.default(slots, "extra");
-		const { treeData, flattenTreeData, key2TreeNode } = require_use_tree_data.default((0, vue.reactive)({
-			treeData: propTreeData,
-			selectable,
-			showLine,
-			blockNode,
-			checkable,
-			fieldNames,
-			loadMore,
-			draggable
-		}));
-		const { checkedKeys, indeterminateKeys, setCheckedState } = require_use_checked_state.default((0, vue.reactive)({
-			defaultCheckedKeys,
-			checkedKeys: propCheckedKeys,
-			checkStrictly,
-			key2TreeNode,
-			halfCheckedKeys,
-			onlyCheckLeaf
-		}));
-		const [selectedKeys, setSelectedState] = require_use_merge_state.default((defaultSelectedKeys === null || defaultSelectedKeys === void 0 ? void 0 : defaultSelectedKeys.value) || [], (0, vue.reactive)({ value: propSelectedKeys }));
-		const loadingKeys = (0, vue.ref)([]);
-		const dragNode = (0, vue.ref)();
-		function getDefaultExpandedKeys() {
-			if (defaultExpandedKeys === null || defaultExpandedKeys === void 0 ? void 0 : defaultExpandedKeys.value) {
-				const expandedKeysSet = /* @__PURE__ */ new Set([]);
-				defaultExpandedKeys.value.forEach((_key) => {
-					if (expandedKeysSet.has(_key)) return;
-					const node = key2TreeNode.value.get(_key);
-					if (!node) return;
-					[...autoExpandParent.value ? node.pathParentKeys : [], _key].forEach((_key) => expandedKeysSet.add(_key));
-				});
-				return [...expandedKeysSet];
-			}
-			if (defaultExpandAll.value) return flattenTreeData.value.filter((node) => node.children && node.children.length).map((node) => node.key);
-			if (defaultExpandSelected.value || defaultExpandChecked.value) {
-				const expandedKeysSet = /* @__PURE__ */ new Set([]);
-				const addToExpandKeysSet = (keys) => {
-					keys.forEach((key) => {
-						const node = key2TreeNode.value.get(key);
-						if (!node) return;
-						(node.pathParentKeys || []).forEach((k) => expandedKeysSet.add(k));
-					});
-				};
-				if (defaultExpandSelected.value) addToExpandKeysSet(selectedKeys.value);
-				if (defaultExpandChecked.value) addToExpandKeysSet(checkedKeys.value);
-				return [...expandedKeysSet];
-			}
-			return [];
-		}
-		const [expandedKeys, setExpandState] = require_use_merge_state.default(getDefaultExpandedKeys(), (0, vue.reactive)({ value: propExpandedKeys }));
-		const currentExpandKeys = (0, vue.ref)([]);
-		const visibleTreeNodeList = (0, vue.computed)(() => {
-			const expandedKeysSet = new Set(expandedKeys.value);
-			const currentExpandKeysSet = new Set(currentExpandKeys.value);
-			return flattenTreeData.value.filter((node) => {
-				var _node$pathParentKeys;
-				if (!(!filterTreeNode || !filterTreeNode.value || (filterTreeNode === null || filterTreeNode === void 0 ? void 0 : filterTreeNode.value(node.treeNodeData)))) return false;
-				const isRoot = require_is.isUndefined(node.parentKey);
-				const isVisibleNode = (_node$pathParentKeys = node.pathParentKeys) === null || _node$pathParentKeys === void 0 ? void 0 : _node$pathParentKeys.every((_key) => expandedKeysSet.has(_key) && !currentExpandKeysSet.has(_key));
-				return isRoot || isVisibleNode;
-			});
-		});
-		function getPublicCheckedKeys(rawCheckedKeys, rawCheckedStrategy = checkedStrategy.value) {
-			let publicCheckedKeys = [...rawCheckedKeys];
-			if (rawCheckedStrategy === "parent") publicCheckedKeys = rawCheckedKeys.filter((_key) => {
-				const item = key2TreeNode.value.get(_key);
-				return item && !(!require_is.isUndefined(item.parentKey) && rawCheckedKeys.includes(item.parentKey));
-			});
-			else if (rawCheckedStrategy === "child") publicCheckedKeys = rawCheckedKeys.filter((_key) => {
-				var _key2TreeNode$value$g;
-				return !((_key2TreeNode$value$g = key2TreeNode.value.get(_key)) === null || _key2TreeNode$value$g === void 0 || (_key2TreeNode$value$g = _key2TreeNode$value$g.children) === null || _key2TreeNode$value$g === void 0 ? void 0 : _key2TreeNode$value$g.length);
-			});
-			return publicCheckedKeys;
-		}
-		function getNodes(keys) {
-			return keys.map((key) => {
-				var _key2TreeNode$value$g2;
-				return ((_key2TreeNode$value$g2 = key2TreeNode.value.get(key)) === null || _key2TreeNode$value$g2 === void 0 ? void 0 : _key2TreeNode$value$g2.treeNodeData) || void 0;
-			}).filter(Boolean);
-		}
-		function emitCheckEvent(options) {
-			const { targetKey, targetChecked, newCheckedKeys, newIndeterminateKeys, event } = options;
-			const targetNode = targetKey ? key2TreeNode.value.get(targetKey) : void 0;
-			const publicCheckedKeys = getPublicCheckedKeys(newCheckedKeys);
-			emit("update:checkedKeys", publicCheckedKeys);
-			emit("update:halfCheckedKeys", newIndeterminateKeys);
-			emit("check", publicCheckedKeys, {
-				checked: targetChecked,
-				node: targetNode === null || targetNode === void 0 ? void 0 : targetNode.treeNodeData,
-				checkedNodes: getNodes(publicCheckedKeys),
-				halfCheckedKeys: newIndeterminateKeys,
-				halfCheckedNodes: getNodes(newIndeterminateKeys),
-				e: event
-			});
-		}
-		function emitSelectEvent(options) {
-			const { targetKey, targetSelected, newSelectedKeys, event } = options;
-			const targetNode = targetKey ? key2TreeNode.value.get(targetKey) : void 0;
-			emit("update:selectedKeys", newSelectedKeys);
-			emit("select", newSelectedKeys, {
-				selected: targetSelected,
-				node: targetNode === null || targetNode === void 0 ? void 0 : targetNode.treeNodeData,
-				selectedNodes: getNodes(newSelectedKeys),
-				e: event
-			});
-		}
-		function emitExpandEvent(options) {
-			const { targetKey, targetExpanded, newExpandedKeys, event } = options;
-			const targetNode = targetKey ? key2TreeNode.value.get(targetKey) : void 0;
-			emit("expand", newExpandedKeys, {
-				expanded: targetExpanded,
-				node: targetNode === null || targetNode === void 0 ? void 0 : targetNode.treeNodeData,
-				expandedNodes: getNodes(newExpandedKeys),
-				e: event
-			});
-			emit("update:expandedKeys", newExpandedKeys);
-		}
-		function setCheckedKeys(keys) {
-			const [newCheckedKeys, newIndeterminateKeys] = setCheckedState(keys, [], true);
-			emitCheckEvent({
-				newCheckedKeys,
-				newIndeterminateKeys
-			});
-		}
-		function setSelectedKeys(keys) {
-			let newSelectedKeys = keys;
-			if (!multiple.value && keys.length > 1) newSelectedKeys = [keys[0]];
-			setSelectedState(newSelectedKeys);
-			emitSelectEvent({ newSelectedKeys });
-		}
-		function setExpandedKeys(keys) {
-			currentExpandKeys.value = [];
-			setExpandState(keys);
-			emitExpandEvent({ newExpandedKeys: keys });
-		}
-		function checkNodes(keys, checked, targetKey) {
-			if (!keys.length) return;
-			let newCheckedKeys = [...checkedKeys.value];
-			let newIndeterminateKeys = [...indeterminateKeys.value];
-			keys.forEach((key) => {
-				const node = key2TreeNode.value.get(key);
-				if (node) [newCheckedKeys, newIndeterminateKeys] = require_check_utils.getCheckedStateByCheck({
-					node,
-					checked,
-					checkedKeys: [...newCheckedKeys],
-					indeterminateKeys: [...newIndeterminateKeys],
-					checkStrictly: checkStrictly.value
-				});
-			});
-			setCheckedState(newCheckedKeys, newIndeterminateKeys);
-			emitCheckEvent({
-				targetKey,
-				targetChecked: require_is.isUndefined(targetKey) ? void 0 : checked,
-				newCheckedKeys,
-				newIndeterminateKeys
-			});
-		}
-		function selectNodes(keys, selected, targetKey) {
-			if (!keys.length) return;
-			let newSelectedKeys;
-			if (multiple.value) {
-				const selectedKeysSet = new Set(selectedKeys.value);
-				keys.forEach((key) => {
-					selected ? selectedKeysSet.add(key) : selectedKeysSet.delete(key);
-				});
-				newSelectedKeys = [...selectedKeysSet];
-			} else newSelectedKeys = selected ? [keys[0]] : [];
-			setSelectedState(newSelectedKeys);
-			emitSelectEvent({
-				targetKey,
-				targetSelected: require_is.isUndefined(targetKey) ? void 0 : selected,
-				newSelectedKeys
-			});
-		}
-		function expandNodes(keys, expanded, targetKey) {
-			const expandedKeysSet = new Set(expandedKeys.value);
-			keys.forEach((key) => {
-				expanded ? expandedKeysSet.add(key) : expandedKeysSet.delete(key);
-				onExpandEnd(key);
-			});
-			const newExpandedKeys = [...expandedKeysSet];
-			setExpandState(newExpandedKeys);
-			emitExpandEvent({
-				targetKey,
-				targetExpanded: require_is.isUndefined(targetKey) ? void 0 : expanded,
-				newExpandedKeys
-			});
-		}
-		function onCheck(checked, key, e) {
-			const node = key2TreeNode.value.get(key);
-			if (!node) return;
-			const [newCheckedKeys, newIndeterminateKeys] = require_check_utils.getCheckedStateByCheck({
-				node,
-				checked,
-				checkedKeys: checkedKeys.value,
-				indeterminateKeys: indeterminateKeys.value,
-				checkStrictly: checkStrictly.value
-			});
-			setCheckedState(newCheckedKeys, newIndeterminateKeys);
-			emitCheckEvent({
-				targetKey: key,
-				targetChecked: checked,
-				newCheckedKeys,
-				newIndeterminateKeys,
-				event: e
-			});
-		}
-		function onSelect(key, e) {
-			if (!key2TreeNode.value.get(key)) return;
-			let newSelectedKeys;
-			let selected;
-			if (multiple.value) {
-				const selectedKeysSet = new Set(selectedKeys.value);
-				selected = !selectedKeysSet.has(key);
-				selected ? selectedKeysSet.add(key) : selectedKeysSet.delete(key);
-				newSelectedKeys = [...selectedKeysSet];
-			} else {
-				selected = true;
-				newSelectedKeys = [key];
-			}
-			setSelectedState(newSelectedKeys);
-			emitSelectEvent({
-				targetKey: key,
-				targetSelected: selected,
-				newSelectedKeys,
-				event: e
-			});
-		}
-		function onExpand(expanded, key, e) {
-			if (currentExpandKeys.value.includes(key)) return;
-			if (!key2TreeNode.value.get(key)) return;
-			const expandedKeysSet = new Set(expandedKeys.value);
-			expanded ? expandedKeysSet.add(key) : expandedKeysSet.delete(key);
-			const newExpandedKeys = [...expandedKeysSet];
-			setExpandState(newExpandedKeys);
-			if (animation.value) currentExpandKeys.value.push(key);
-			emitExpandEvent({
-				targetKey: key,
-				targetExpanded: expanded,
-				newExpandedKeys,
-				event: e
-			});
-		}
-		function onExpandEnd(key) {
-			const index = currentExpandKeys.value.indexOf(key);
-			currentExpandKeys.value.splice(index, 1);
-		}
-		const treeContext = (0, vue.reactive)({
-			treeProps: props,
-			switcherIcon,
-			loadingIcon,
-			dragIcon,
-			nodeIcon,
-			nodeTitle,
-			nodeExtra,
-			treeData,
-			flattenTreeData,
-			key2TreeNode,
-			checkedKeys,
-			indeterminateKeys,
-			selectedKeys,
-			expandedKeys,
-			loadingKeys,
-			currentExpandKeys,
-			onLoadMore: (0, vue.computed)(() => (loadMore === null || loadMore === void 0 ? void 0 : loadMore.value) ? function() {
-				var _ref = require_asyncToGenerator._asyncToGenerator(function* (key) {
-					if (!require_is.isFunction(loadMore.value)) return;
-					const node = key2TreeNode.value.get(key);
-					if (!node) return;
-					const { treeNodeData } = node;
-					loadingKeys.value = [...new Set([...loadingKeys.value, key])];
-					try {
-						yield loadMore.value(treeNodeData);
-						loadingKeys.value = loadingKeys.value.filter((v) => v !== key);
-						onExpand(true, key);
-						if (checkedKeys.value.includes(key)) onCheck(true, key);
-					} catch (err) {
-						loadingKeys.value = loadingKeys.value.filter((v) => v !== key);
-						console.error("[tree]load data error: ", err);
-					}
-				});
-				return function(_x) {
-					return _ref.apply(this, arguments);
-				};
-			}() : void 0),
-			filterTreeNode,
-			onCheck,
-			onSelect,
-			onExpand,
-			onExpandEnd,
-			allowDrop(key, dropPosition) {
-				const node = key2TreeNode.value.get(key);
-				if (node && require_is.isFunction(allowDrop.value)) return !!allowDrop.value({
-					dropNode: node.treeNodeData,
-					dropPosition
-				});
-				return true;
-			},
-			onDragStart(key, e) {
-				const node = key2TreeNode.value.get(key);
-				dragNode.value = node;
-				if (node) emit("dragStart", e, node.treeNodeData);
-			},
-			onDragEnd(key, e) {
-				const node = key2TreeNode.value.get(key);
-				dragNode.value = void 0;
-				if (node) emit("dragEnd", e, node.treeNodeData);
-			},
-			onDragOver(key, e) {
-				const node = key2TreeNode.value.get(key);
-				if (node) emit("dragOver", e, node.treeNodeData);
-			},
-			onDragLeave(key, e) {
-				const node = key2TreeNode.value.get(key);
-				if (node) emit("dragLeave", e, node.treeNodeData);
-			},
-			onDrop(key, dropPosition, e) {
-				const node = key2TreeNode.value.get(key);
-				if (dragNode.value && node && !(node.key === dragNode.value.key || node.pathParentKeys.includes(dragNode.value.key || ""))) emit("drop", {
-					e,
-					dragNode: dragNode.value.treeNodeData,
-					dropNode: node.treeNodeData,
-					dropPosition
-				});
-			}
-		});
-		(0, vue.provide)(require_context.TreeInjectionKey, treeContext);
-		return {
-			classNames,
-			visibleTreeNodeList,
-			treeContext,
-			virtualListRef: (0, vue.ref)(),
-			computedSelectedKeys: selectedKeys,
-			computedExpandedKeys: expandedKeys,
-			computedCheckedKeys: checkedKeys,
-			computedIndeterminateKeys: indeterminateKeys,
-			getPublicCheckedKeys,
-			getNodes,
-			internalCheckNodes: checkNodes,
-			internalSetCheckedKeys: setCheckedKeys,
-			internalSelectNodes: selectNodes,
-			internalSetSelectedKeys: setSelectedKeys,
-			internalExpandNodes: expandNodes,
-			internalSetExpandedKeys: setExpandedKeys
-		};
-	},
-	methods: {
-		toggleCheck(key, e) {
-			const { key2TreeNode, onCheck, checkedKeys } = this.treeContext;
-			const checked = !checkedKeys.includes(key);
-			const node = key2TreeNode.get(key);
-			if (node && require_check_utils.isNodeCheckable(node)) onCheck(checked, key, e);
-		},
-		scrollIntoView(options) {
-			this.virtualListRef && this.virtualListRef.scrollTo(options);
-		},
-		getSelectedNodes() {
-			return this.getNodes(this.computedSelectedKeys);
-		},
-		getCheckedNodes(options = {}) {
-			const { checkedStrategy, includeHalfChecked } = options;
-			const checkedKeys = this.getPublicCheckedKeys(this.computedCheckedKeys, checkedStrategy);
-			return [...this.getNodes(checkedKeys), ...includeHalfChecked ? this.getHalfCheckedNodes() : []];
-		},
-		getHalfCheckedNodes() {
-			return this.getNodes(this.computedIndeterminateKeys);
-		},
-		getExpandedNodes() {
-			return this.getNodes(this.computedExpandedKeys);
-		},
-		checkAll(checked = true) {
-			const { key2TreeNode } = this.treeContext;
-			const newKeys = checked ? [...key2TreeNode.keys()].filter((key) => {
-				const node = key2TreeNode.get(key);
-				return node && require_check_utils.isNodeCheckable(node);
-			}) : [];
-			this.internalSetCheckedKeys(newKeys);
-		},
-		checkNode(key, checked = true, onlyCheckLeaf = false) {
-			const { checkStrictly, treeContext } = this;
-			const { key2TreeNode } = treeContext;
-			const isBatch = require_is.isArray(key);
-			const keys = (isBatch ? key : [key]).filter((key) => {
-				const node = key2TreeNode.get(key);
-				return node && require_check_utils.isNodeCheckable(node) && (checkStrictly || !onlyCheckLeaf || require_index$1.isLeafNode(node));
-			});
-			this.internalCheckNodes(keys, checked, isBatch ? void 0 : key);
-		},
-		selectAll(selected = true) {
-			const { key2TreeNode } = this.treeContext;
-			const newKeys = selected ? [...key2TreeNode.keys()].filter((key) => {
-				const node = key2TreeNode.get(key);
-				return node && require_index$1.isNodeSelectable(node);
-			}) : [];
-			this.internalSetSelectedKeys(newKeys);
-		},
-		selectNode(key, selected = true) {
-			const { key2TreeNode } = this.treeContext;
-			const isBatch = require_is.isArray(key);
-			const keys = (isBatch ? key : [key]).filter((key) => {
-				const node = key2TreeNode.get(key);
-				return node && require_index$1.isNodeSelectable(node);
-			});
-			this.internalSelectNodes(keys, selected, isBatch ? void 0 : key);
-		},
-		expandAll(expanded = true) {
-			const { key2TreeNode } = this.treeContext;
-			const newKeys = expanded ? [...key2TreeNode.keys()].filter((key) => {
-				const node = key2TreeNode.get(key);
-				return node && require_index$1.isNodeExpandable(node);
-			}) : [];
-			this.internalSetExpandedKeys(newKeys);
-		},
-		expandNode(key, expanded = true) {
-			const { key2TreeNode } = this.treeContext;
-			const isBatch = require_is.isArray(key);
-			const keys = (isBatch ? key : [key]).filter((key) => {
-				const node = key2TreeNode.get(key);
-				return node && require_index$1.isNodeExpandable(node);
-			});
-			this.internalExpandNodes(keys, expanded, isBatch ? void 0 : key);
-		}
-	}
-});
-//#endregion
-exports.default = tree_vue_vue_type_script_lang_default;

package/lib/tree/utils/check-utils.js

@@ -1,92 +0,0 @@
-//#region components/tree/utils/check-utils.ts
-function SetAdd(set) {
-	return Set.prototype.add.bind(set);
-}
-function SetDelete(set) {
-	return Set.prototype.delete.bind(set);
-}
-function isNodeCheckable(node) {
-	if (node.disabled || node.disableCheckbox) return false;
-	return !!node.checkable;
-}
-function getChildrenKeys(node) {
-	var _node$children;
-	const keys = [];
-	(_node$children = node.children) === null || _node$children === void 0 || _node$children.forEach((child) => {
-		if (isNodeCheckable(child)) keys.push(child.key, ...getChildrenKeys(child));
-	});
-	return keys;
-}
-function updateParent(options) {
-	const { node, checkedKeySet, indeterminateKeySet } = options;
-	let parentNode = node.parent;
-	while (parentNode) {
-		if (isNodeCheckable(parentNode)) {
-			var _parentNode$children;
-			const parentKey = parentNode.key;
-			const children = ((_parentNode$children = parentNode.children) === null || _parentNode$children === void 0 ? void 0 : _parentNode$children.filter(isNodeCheckable)) || [];
-			let checkedCount = 0;
-			const total = children.length;
-			children.some(({ key: childKey }) => {
-				if (checkedKeySet.has(childKey)) checkedCount += 1;
-				else if (indeterminateKeySet.has(childKey)) {
-					checkedCount += .5;
-					return true;
-				}
-				return false;
-			});
-			if (checkedCount && checkedCount !== total) indeterminateKeySet.add(parentKey);
-			else indeterminateKeySet.delete(parentKey);
-			if (checkedCount && checkedCount === total) checkedKeySet.add(parentKey);
-			else checkedKeySet.delete(parentKey);
-		}
-		parentNode = parentNode.parent;
-	}
-}
-function getCheckedStateByCheck(options) {
-	const { node, checked, checkedKeys, indeterminateKeys, checkStrictly = false } = options;
-	const { key } = node;
-	const checkedKeySet = new Set(checkedKeys);
-	const indeterminateKeySet = new Set(indeterminateKeys);
-	checked ? checkedKeySet.add(key) : checkedKeySet.delete(key);
-	indeterminateKeySet.delete(key);
-	if (!checkStrictly) {
-		const childKeys = getChildrenKeys(node);
-		if (checked) childKeys.forEach(SetAdd(checkedKeySet));
-		else childKeys.forEach(SetDelete(checkedKeySet));
-		childKeys.forEach(SetDelete(indeterminateKeySet));
-		updateParent({
-			node,
-			checkedKeySet,
-			indeterminateKeySet
-		});
-	}
-	return [[...checkedKeySet], [...indeterminateKeySet]];
-}
-function getCheckedStateByInitKeys(options) {
-	const { initCheckedKeys, key2TreeNode, checkStrictly, onlyCheckLeaf } = options;
-	const checkedKeySet = /* @__PURE__ */ new Set();
-	const childCheckedKeySet = /* @__PURE__ */ new Set();
-	const indeterminateKeySet = /* @__PURE__ */ new Set();
-	if (!checkStrictly) initCheckedKeys.forEach((key) => {
-		var _node$children2;
-		const node = key2TreeNode.get(key);
-		if (!node || childCheckedKeySet.has(key) || onlyCheckLeaf && ((_node$children2 = node.children) === null || _node$children2 === void 0 ? void 0 : _node$children2.length)) return;
-		const childKeys = getChildrenKeys(node);
-		childKeys.forEach(SetAdd(childCheckedKeySet));
-		childKeys.forEach(SetDelete(indeterminateKeySet));
-		checkedKeySet.add(key);
-		indeterminateKeySet.delete(key);
-		updateParent({
-			node,
-			checkedKeySet,
-			indeterminateKeySet
-		});
-	});
-	else initCheckedKeys.forEach(SetAdd(checkedKeySet));
-	return [[...checkedKeySet, ...childCheckedKeySet], [...indeterminateKeySet]];
-}
-//#endregion
-exports.getCheckedStateByCheck = getCheckedStateByCheck;
-exports.getCheckedStateByInitKeys = getCheckedStateByInitKeys;
-exports.isNodeCheckable = isNodeCheckable;

package/lib/tree/utils/index.js

@@ -1,37 +0,0 @@
-const require_is = require("../../_utils/is.js");
-//#region components/tree/utils/index.ts
-function getFlattenTreeData(tree) {
-	const flattenTreeData = [];
-	function preOrder(tree) {
-		if (!tree) return;
-		tree.forEach((node) => {
-			flattenTreeData.push(node);
-			preOrder(node.children);
-		});
-	}
-	preOrder(tree);
-	return flattenTreeData;
-}
-function getKey2TreeNode(flattenTreeData) {
-	const key2TreeNode = /* @__PURE__ */ new Map();
-	flattenTreeData.forEach((node) => {
-		key2TreeNode.set(node.key, node);
-	});
-	return key2TreeNode;
-}
-function isNodeSelectable(node) {
-	return node.selectable && !node.disabled;
-}
-function isNodeExpandable(node) {
-	return !node.isLeaf && node.children;
-}
-function isLeafNode(node) {
-	if (require_is.isBoolean(node.isLeaf)) return node.isLeaf;
-	return !node.children;
-}
-//#endregion
-exports.getFlattenTreeData = getFlattenTreeData;
-exports.getKey2TreeNode = getKey2TreeNode;
-exports.isLeafNode = isLeafNode;
-exports.isNodeExpandable = isNodeExpandable;
-exports.isNodeSelectable = isNodeSelectable;