@v-c/tree-select 0.0.1

package/dist/TreeSelectContext.cjs

@@ -0,0 +1,12 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rolldown_runtime = require("./_virtual/rolldown_runtime.cjs");
+let vue = require("vue");
+var TreeSelectContextKey = Symbol("TreeSelectContext");
+function useTreeSelectProvider(value) {
+	(0, vue.provide)(TreeSelectContextKey, value);
+}
+function useTreeSelectContext() {
+	return (0, vue.inject)(TreeSelectContextKey, (0, vue.ref)(null));
+}
+exports.useTreeSelectContext = useTreeSelectContext;
+exports.useTreeSelectProvider = useTreeSelectProvider;

package/dist/TreeSelectContext.d.ts

@@ -0,0 +1,28 @@
+import { DataEntity, ExpandAction } from '@v-c/tree';
+import { Ref } from 'vue';
+import { DataNode, FieldNames, Key, SelectSource } from './interface';
+import { TreeSelectProps } from './TreeSelect';
+export interface TreeSelectContextProps {
+    virtual?: boolean;
+    popupMatchSelectWidth?: boolean | number;
+    listHeight: number;
+    listItemHeight: number;
+    listItemScrollOffset?: number;
+    treeData: DataNode[];
+    fieldNames: FieldNames;
+    onSelect: (value: Key, info: {
+        selected: boolean;
+        source?: SelectSource;
+    }) => void;
+    treeExpandAction?: ExpandAction;
+    treeTitleRender?: (node: any) => any;
+    onPopupScroll?: (event: Event) => void;
+    leftMaxCount: number | null;
+    /** When `true`, only take leaf node as count, or take all as count with `maxCount` limitation */
+    leafCountOnly: boolean;
+    valueEntities: Map<Key, DataEntity>;
+    classNames?: TreeSelectProps['classNames'];
+    styles?: TreeSelectProps['styles'];
+}
+export declare function useTreeSelectProvider(value: Ref<TreeSelectContextProps>): void;
+export declare function useTreeSelectContext(): Ref<TreeSelectContextProps | null>;

package/dist/TreeSelectContext.js

@@ -0,0 +1,9 @@
+import { inject, provide, ref } from "vue";
+var TreeSelectContextKey = Symbol("TreeSelectContext");
+function useTreeSelectProvider(value) {
+	provide(TreeSelectContextKey, value);
+}
+function useTreeSelectContext() {
+	return inject(TreeSelectContextKey, ref(null));
+}
+export { useTreeSelectContext, useTreeSelectProvider };

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,21 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+exports.__toESM = __toESM;

package/dist/hooks/useCache.cjs

@@ -0,0 +1,25 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+let vue = require("vue");
+function useCache(values) {
+	const cacheRef = (0, vue.shallowRef)({ valueLabels: /* @__PURE__ */ new Map() });
+	return [(0, vue.computed)(() => {
+		const { valueLabels } = cacheRef.value;
+		const valueLabelsCache = /* @__PURE__ */ new Map();
+		const merged = values.value.map((item) => {
+			const { value, label } = item;
+			const mergedLabel = label ?? valueLabels.get(value);
+			valueLabelsCache.set(value, mergedLabel);
+			return {
+				...item,
+				label: mergedLabel
+			};
+		});
+		cacheRef.value.valueLabels = valueLabelsCache;
+		return merged;
+	})];
+}
+exports.default = useCache;

package/dist/hooks/useCache.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from 'vue';
+import { LabeledValueType } from '../interface';
+/**
+ * This function will try to cache labels for values to avoid label missing when options removed.
+ */
+export default function useCache(values: Ref<LabeledValueType[]>): [Ref<LabeledValueType[]>];

package/dist/hooks/useCache.js

@@ -0,0 +1,20 @@
+import { computed, shallowRef } from "vue";
+function useCache(values) {
+	const cacheRef = shallowRef({ valueLabels: /* @__PURE__ */ new Map() });
+	return [computed(() => {
+		const { valueLabels } = cacheRef.value;
+		const valueLabelsCache = /* @__PURE__ */ new Map();
+		const merged = values.value.map((item) => {
+			const { value, label } = item;
+			const mergedLabel = label ?? valueLabels.get(value);
+			valueLabelsCache.set(value, mergedLabel);
+			return {
+				...item,
+				label: mergedLabel
+			};
+		});
+		cacheRef.value.valueLabels = valueLabelsCache;
+		return merged;
+	})];
+}
+export { useCache as default };

package/dist/hooks/useCheckedKeys.cjs

@@ -0,0 +1,25 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+let vue = require("vue");
+let _v_c_tree = require("@v-c/tree");
+function useCheckedKeys(rawLabeledValues, rawHalfCheckedValues, treeConduction, keyEntities) {
+	const merged = (0, vue.computed)(() => {
+		const extractValues = (values) => values.map(({ value }) => value);
+		const checkedKeys = extractValues(rawLabeledValues.value);
+		const halfCheckedKeys = extractValues(rawHalfCheckedValues.value);
+		const missingValues = checkedKeys.filter((key) => !keyEntities.value[String(key)]);
+		let finalCheckedKeys = checkedKeys;
+		let finalHalfCheckedKeys = halfCheckedKeys;
+		if (treeConduction.value) {
+			const conductResult = (0, _v_c_tree.conductCheck)(checkedKeys, true, keyEntities.value);
+			finalCheckedKeys = conductResult.checkedKeys;
+			finalHalfCheckedKeys = conductResult.halfCheckedKeys;
+		}
+		return [Array.from(new Set([...missingValues, ...finalCheckedKeys])), finalHalfCheckedKeys];
+	});
+	return [(0, vue.computed)(() => merged.value[0]), (0, vue.computed)(() => merged.value[1])];
+}
+exports.default = useCheckedKeys;

package/dist/hooks/useCheckedKeys.d.ts

@@ -0,0 +1,4 @@
+import { DataEntity } from '@v-c/tree';
+import { Ref } from 'vue';
+import { Key, LabeledValueType } from '../interface';
+export default function useCheckedKeys(rawLabeledValues: Ref<LabeledValueType[]>, rawHalfCheckedValues: Ref<LabeledValueType[]>, treeConduction: Ref<boolean>, keyEntities: Ref<Record<string, DataEntity>>): readonly [Ref<Key[]>, Ref<Key[]>];

package/dist/hooks/useCheckedKeys.js

@@ -0,0 +1,20 @@
+import { computed } from "vue";
+import { conductCheck } from "@v-c/tree";
+function useCheckedKeys(rawLabeledValues, rawHalfCheckedValues, treeConduction, keyEntities) {
+	const merged = computed(() => {
+		const extractValues = (values) => values.map(({ value }) => value);
+		const checkedKeys = extractValues(rawLabeledValues.value);
+		const halfCheckedKeys = extractValues(rawHalfCheckedValues.value);
+		const missingValues = checkedKeys.filter((key) => !keyEntities.value[String(key)]);
+		let finalCheckedKeys = checkedKeys;
+		let finalHalfCheckedKeys = halfCheckedKeys;
+		if (treeConduction.value) {
+			const conductResult = conductCheck(checkedKeys, true, keyEntities.value);
+			finalCheckedKeys = conductResult.checkedKeys;
+			finalHalfCheckedKeys = conductResult.halfCheckedKeys;
+		}
+		return [Array.from(new Set([...missingValues, ...finalCheckedKeys])), finalHalfCheckedKeys];
+	});
+	return [computed(() => merged.value[0]), computed(() => merged.value[1])];
+}
+export { useCheckedKeys as default };

package/dist/hooks/useDataEntities.cjs

@@ -0,0 +1,40 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+const require_valueUtil = require("../utils/valueUtil.cjs");
+let vue = require("vue");
+let _v_c_tree = require("@v-c/tree");
+let _v_c_util = require("@v-c/util");
+function useDataEntities(treeData, fieldNames) {
+	const valueEntities = (0, vue.shallowRef)(/* @__PURE__ */ new Map());
+	const keyEntities = (0, vue.shallowRef)({});
+	(0, vue.watchEffect)(() => {
+		const mergedFieldNames = fieldNames.value;
+		const collection = (0, _v_c_tree.convertDataToEntities)(treeData.value, {
+			fieldNames: mergedFieldNames,
+			initWrapper: (wrapper) => ({
+				...wrapper,
+				valueEntities: /* @__PURE__ */ new Map()
+			}),
+			processEntity: (entity, wrapper) => {
+				const val = entity.node[mergedFieldNames.value];
+				if (process.env.NODE_ENV !== "production") {
+					const key = entity.node.key;
+					(0, _v_c_util.warning)(!require_valueUtil.isNil(val), "TreeNode `value` is invalidate: undefined");
+					(0, _v_c_util.warning)(!wrapper.valueEntities.has(val), `Same \`value\` exist in the tree: ${val}`);
+					(0, _v_c_util.warning)(!key || String(key) === String(val), `\`key\` or \`value\` with TreeNode must be the same or you can remove one of them. key: ${key}, value: ${val}.`);
+				}
+				wrapper.valueEntities.set(val, entity);
+			}
+		});
+		keyEntities.value = collection.keyEntities;
+		valueEntities.value = collection.valueEntities;
+	});
+	return {
+		valueEntities,
+		keyEntities
+	};
+}
+exports.default = useDataEntities;

package/dist/hooks/useDataEntities.d.ts

@@ -0,0 +1,7 @@
+import { DataEntity, KeyEntities } from '@v-c/tree';
+import { Ref } from 'vue';
+import { DataNode, FieldNames, SafeKey } from '../interface';
+export default function useDataEntities(treeData: Ref<DataNode[]>, fieldNames: Ref<FieldNames>): {
+    valueEntities: Ref<Map<SafeKey, DataEntity>>;
+    keyEntities: Ref<KeyEntities>;
+};

package/dist/hooks/useDataEntities.js

@@ -0,0 +1,35 @@
+import { isNil } from "../utils/valueUtil.js";
+import { shallowRef, watchEffect } from "vue";
+import { convertDataToEntities } from "@v-c/tree";
+import { warning } from "@v-c/util";
+function useDataEntities(treeData, fieldNames) {
+	const valueEntities = shallowRef(/* @__PURE__ */ new Map());
+	const keyEntities = shallowRef({});
+	watchEffect(() => {
+		const mergedFieldNames = fieldNames.value;
+		const collection = convertDataToEntities(treeData.value, {
+			fieldNames: mergedFieldNames,
+			initWrapper: (wrapper) => ({
+				...wrapper,
+				valueEntities: /* @__PURE__ */ new Map()
+			}),
+			processEntity: (entity, wrapper) => {
+				const val = entity.node[mergedFieldNames.value];
+				if (process.env.NODE_ENV !== "production") {
+					const key = entity.node.key;
+					warning(!isNil(val), "TreeNode `value` is invalidate: undefined");
+					warning(!wrapper.valueEntities.has(val), `Same \`value\` exist in the tree: ${val}`);
+					warning(!key || String(key) === String(val), `\`key\` or \`value\` with TreeNode must be the same or you can remove one of them. key: ${key}, value: ${val}.`);
+				}
+				wrapper.valueEntities.set(val, entity);
+			}
+		});
+		keyEntities.value = collection.keyEntities;
+		valueEntities.value = collection.valueEntities;
+	});
+	return {
+		valueEntities,
+		keyEntities
+	};
+}
+export { useDataEntities as default };

package/dist/hooks/useFilterTreeData.cjs

@@ -0,0 +1,28 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+const require_legacyUtil = require("../utils/legacyUtil.cjs");
+let vue = require("vue");
+function useFilterTreeData(treeData, searchValue, options) {
+	return (0, vue.computed)(() => {
+		const { children: fieldChildren } = options.fieldNames.value;
+		const mergedSearchValue = searchValue.value;
+		if (!mergedSearchValue || options.filterTreeNode.value === false) return treeData.value;
+		const filterOptionFunc = typeof options.filterTreeNode.value === "function" ? options.filterTreeNode.value : (_, dataNode) => String(dataNode[options.treeNodeFilterProp.value]).toUpperCase().includes(mergedSearchValue.toUpperCase());
+		const filterTreeNodes = (nodes, keepAll = false) => nodes.reduce((filtered, node) => {
+			const children = node[fieldChildren];
+			const isMatch = keepAll || filterOptionFunc(mergedSearchValue, require_legacyUtil.fillLegacyProps(node));
+			const filteredChildren = filterTreeNodes(children || [], isMatch);
+			if (isMatch || filteredChildren.length) filtered.push({
+				...node,
+				isLeaf: void 0,
+				[fieldChildren]: filteredChildren
+			});
+			return filtered;
+		}, []);
+		return filterTreeNodes(treeData.value);
+	});
+}
+exports.default = useFilterTreeData;

package/dist/hooks/useFilterTreeData.d.ts

@@ -0,0 +1,8 @@
+import { Ref } from 'vue';
+import { DataNode, FieldNames } from '../interface';
+import { TreeSelectProps } from '../TreeSelect';
+export default function useFilterTreeData(treeData: Ref<DataNode[]>, searchValue: Ref<string>, options: {
+    fieldNames: Ref<FieldNames>;
+    treeNodeFilterProp: Ref<string>;
+    filterTreeNode: Ref<TreeSelectProps['filterTreeNode']>;
+}): Ref<DataNode[]>;

package/dist/hooks/useFilterTreeData.js

@@ -0,0 +1,23 @@
+import { fillLegacyProps } from "../utils/legacyUtil.js";
+import { computed } from "vue";
+function useFilterTreeData(treeData, searchValue, options) {
+	return computed(() => {
+		const { children: fieldChildren } = options.fieldNames.value;
+		const mergedSearchValue = searchValue.value;
+		if (!mergedSearchValue || options.filterTreeNode.value === false) return treeData.value;
+		const filterOptionFunc = typeof options.filterTreeNode.value === "function" ? options.filterTreeNode.value : (_, dataNode) => String(dataNode[options.treeNodeFilterProp.value]).toUpperCase().includes(mergedSearchValue.toUpperCase());
+		const filterTreeNodes = (nodes, keepAll = false) => nodes.reduce((filtered, node) => {
+			const children = node[fieldChildren];
+			const isMatch = keepAll || filterOptionFunc(mergedSearchValue, fillLegacyProps(node));
+			const filteredChildren = filterTreeNodes(children || [], isMatch);
+			if (isMatch || filteredChildren.length) filtered.push({
+				...node,
+				isLeaf: void 0,
+				[fieldChildren]: filteredChildren
+			});
+			return filtered;
+		}, []);
+		return filterTreeNodes(treeData.value);
+	});
+}
+export { useFilterTreeData as default };

package/dist/hooks/useRefFunc.cjs

@@ -0,0 +1,15 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+let vue = require("vue");
+function useRefFunc(callback) {
+	const callbackRef = (0, vue.shallowRef)(callback);
+	callbackRef.value = callback;
+	const cacheFn = ((...args) => {
+		return callbackRef.value(...args);
+	});
+	return cacheFn;
+}
+exports.default = useRefFunc;

package/dist/hooks/useRefFunc.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Same as `useCallback` but always return a memoized function
+ * which will call latest callback from ref.
+ */
+export default function useRefFunc<T extends (...args: any[]) => any>(callback: T): T;

package/dist/hooks/useRefFunc.js

@@ -0,0 +1,10 @@
+import { shallowRef } from "vue";
+function useRefFunc(callback) {
+	const callbackRef = shallowRef(callback);
+	callbackRef.value = callback;
+	const cacheFn = ((...args) => {
+		return callbackRef.value(...args);
+	});
+	return cacheFn;
+}
+export { useRefFunc as default };

package/dist/hooks/useSearchConfig.cjs

@@ -0,0 +1,23 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+let vue = require("vue");
+function useSearchConfig(showSearch, props) {
+	return [(0, vue.computed)(() => {
+		return typeof showSearch.value === "object" ? true : showSearch.value;
+	}), (0, vue.computed)(() => {
+		const { searchValue, inputValue, onSearch, autoClearSearchValue, filterTreeNode, treeNodeFilterProp } = props.value;
+		const isObject = typeof showSearch.value === "object";
+		return {
+			searchValue: searchValue ?? inputValue,
+			onSearch,
+			autoClearSearchValue,
+			filterTreeNode,
+			treeNodeFilterProp,
+			...isObject ? showSearch.value : {}
+		};
+	})];
+}
+exports.default = useSearchConfig;

package/dist/hooks/useSearchConfig.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from 'vue';
+import { SearchConfig } from '../TreeSelect';
+export type SearchConfigResult = [Ref<boolean | undefined>, Ref<SearchConfig>];
+export default function useSearchConfig(showSearch: Ref<boolean | SearchConfig | undefined>, props: Ref<SearchConfig & {
+    inputValue?: string;
+}>): SearchConfigResult;

package/dist/hooks/useSearchConfig.js

@@ -0,0 +1,18 @@
+import { computed } from "vue";
+function useSearchConfig(showSearch, props) {
+	return [computed(() => {
+		return typeof showSearch.value === "object" ? true : showSearch.value;
+	}), computed(() => {
+		const { searchValue, inputValue, onSearch, autoClearSearchValue, filterTreeNode, treeNodeFilterProp } = props.value;
+		const isObject = typeof showSearch.value === "object";
+		return {
+			searchValue: searchValue ?? inputValue,
+			onSearch,
+			autoClearSearchValue,
+			filterTreeNode,
+			treeNodeFilterProp,
+			...isObject ? showSearch.value : {}
+		};
+	})];
+}
+export { useSearchConfig as default };

package/dist/hooks/useTreeData.cjs

@@ -0,0 +1,43 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+let vue = require("vue");
+function buildTreeStructure(nodes, config) {
+	const { id, pId, rootPId } = config;
+	const nodeMap = /* @__PURE__ */ new Map();
+	const rootNodes = [];
+	nodes.forEach((node) => {
+		const nodeKey = node[id];
+		const clonedNode = {
+			...node,
+			key: node.key || nodeKey
+		};
+		nodeMap.set(nodeKey, clonedNode);
+	});
+	nodeMap.forEach((node) => {
+		const parentKey = node[pId];
+		const parent = nodeMap.get(parentKey);
+		if (parent) {
+			parent.children = parent.children || [];
+			parent.children.push(node);
+		} else if (parentKey === rootPId || rootPId === null) rootNodes.push(node);
+	});
+	return rootNodes;
+}
+function useTreeData(treeData, simpleMode) {
+	return (0, vue.computed)(() => {
+		if (simpleMode.value) {
+			const config = {
+				id: "id",
+				pId: "pId",
+				rootPId: null,
+				...typeof simpleMode.value === "object" ? simpleMode.value : {}
+			};
+			return buildTreeStructure(treeData.value, config);
+		}
+		return treeData.value;
+	});
+}
+exports.default = useTreeData;

package/dist/hooks/useTreeData.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from 'vue';
+import { DataNode, SimpleModeConfig } from '../interface';
+/**
+ * Convert `treeData` by `simpleMode` config.
+ */
+export default function useTreeData(treeData: Ref<DataNode[]>, simpleMode: Ref<boolean | SimpleModeConfig | undefined>): Ref<DataNode[]>;

package/dist/hooks/useTreeData.js

@@ -0,0 +1,38 @@
+import { computed } from "vue";
+function buildTreeStructure(nodes, config) {
+	const { id, pId, rootPId } = config;
+	const nodeMap = /* @__PURE__ */ new Map();
+	const rootNodes = [];
+	nodes.forEach((node) => {
+		const nodeKey = node[id];
+		const clonedNode = {
+			...node,
+			key: node.key || nodeKey
+		};
+		nodeMap.set(nodeKey, clonedNode);
+	});
+	nodeMap.forEach((node) => {
+		const parentKey = node[pId];
+		const parent = nodeMap.get(parentKey);
+		if (parent) {
+			parent.children = parent.children || [];
+			parent.children.push(node);
+		} else if (parentKey === rootPId || rootPId === null) rootNodes.push(node);
+	});
+	return rootNodes;
+}
+function useTreeData(treeData, simpleMode) {
+	return computed(() => {
+		if (simpleMode.value) {
+			const config = {
+				id: "id",
+				pId: "pId",
+				rootPId: null,
+				...typeof simpleMode.value === "object" ? simpleMode.value : {}
+			};
+			return buildTreeStructure(treeData.value, config);
+		}
+		return treeData.value;
+	});
+}
+export { useTreeData as default };

package/dist/index.cjs

@@ -0,0 +1,18 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_TreeNode = require("./TreeNode.cjs");
+const require_strategyUtil = require("./utils/strategyUtil.cjs");
+const require_TreeSelect = require("./TreeSelect.cjs");
+var ExportTreeSelect = require_TreeSelect.default;
+ExportTreeSelect.TreeNode = require_TreeNode.default;
+ExportTreeSelect.SHOW_ALL = require_strategyUtil.SHOW_ALL;
+ExportTreeSelect.SHOW_PARENT = require_strategyUtil.SHOW_PARENT;
+ExportTreeSelect.SHOW_CHILD = require_strategyUtil.SHOW_CHILD;
+var src_default = ExportTreeSelect;
+exports.SHOW_ALL = require_strategyUtil.SHOW_ALL;
+exports.SHOW_CHILD = require_strategyUtil.SHOW_CHILD;
+exports.SHOW_PARENT = require_strategyUtil.SHOW_PARENT;
+exports.TreeNode = require_TreeNode.default;
+exports.default = src_default;

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import { TreeSelectProps, default as TreeSelect } from './TreeSelect';
+import { default as TreeNode } from './TreeNode';
+import { SHOW_ALL, SHOW_CHILD, SHOW_PARENT } from './utils/strategyUtil';
+export { SHOW_ALL, SHOW_CHILD, SHOW_PARENT, TreeNode };
+export type { TreeSelectProps };
+type TreeSelectType = typeof TreeSelect & {
+    TreeNode: typeof TreeNode;
+    SHOW_ALL: typeof SHOW_ALL;
+    SHOW_PARENT: typeof SHOW_PARENT;
+    SHOW_CHILD: typeof SHOW_CHILD;
+};
+declare const ExportTreeSelect: TreeSelectType;
+export default ExportTreeSelect;
+export type { DataNode } from './interface';

package/dist/index.js

@@ -0,0 +1,10 @@
+import TreeNode_default from "./TreeNode.js";
+import { SHOW_ALL, SHOW_CHILD, SHOW_PARENT } from "./utils/strategyUtil.js";
+import TreeSelect_default from "./TreeSelect.js";
+var ExportTreeSelect = TreeSelect_default;
+ExportTreeSelect.TreeNode = TreeNode_default;
+ExportTreeSelect.SHOW_ALL = SHOW_ALL;
+ExportTreeSelect.SHOW_PARENT = SHOW_PARENT;
+ExportTreeSelect.SHOW_CHILD = SHOW_CHILD;
+var src_default = ExportTreeSelect;
+export { SHOW_ALL, SHOW_CHILD, SHOW_PARENT, TreeNode_default as TreeNode, src_default as default };

package/dist/interface.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });

package/dist/interface.d.ts

@@ -0,0 +1,57 @@
+import { Key, DataNode as TreeDataNode } from '@v-c/tree';
+export type { Key };
+export type SafeKey = Key;
+export interface DataNode extends Record<string, any>, Omit<TreeDataNode, 'key' | 'children'> {
+    key?: Key;
+    value?: Key;
+    children?: DataNode[];
+}
+export type SelectSource = 'option' | 'selection' | 'input' | 'clear';
+export interface LabeledValueType {
+    key?: Key;
+    value?: Key;
+    label?: any;
+    /** Only works on `treeCheckStrictly` */
+    halfChecked?: boolean;
+}
+export type DefaultValueType = Key | LabeledValueType | (Key | LabeledValueType)[];
+export interface LegacyDataNode extends DataNode {
+    props: any;
+}
+export interface FlattenDataNode {
+    data: DataNode;
+    key: Key;
+    value: Key;
+    level: number;
+    parent?: FlattenDataNode;
+}
+export interface SimpleModeConfig {
+    id?: string;
+    pId?: string;
+    rootPId?: SafeKey | null;
+}
+/** @deprecated This is only used for legacy compatible. Not works on new code. */
+export interface LegacyCheckedNode {
+    pos: string;
+    node: any;
+    children?: LegacyCheckedNode[];
+}
+export interface ChangeEventExtra {
+    /** @deprecated Please save prev value by control logic instead */
+    preValue: LabeledValueType[];
+    triggerValue: Key;
+    /** @deprecated Use `onSelect` or `onDeselect` instead. */
+    selected?: boolean;
+    /** @deprecated Use `onSelect` or `onDeselect` instead. */
+    checked?: boolean;
+    /** @deprecated This prop not work as react node anymore. */
+    triggerNode: any;
+    /** @deprecated This prop not work as react node anymore. */
+    allCheckedNodes: LegacyCheckedNode[];
+}
+export interface FieldNames {
+    value?: string;
+    label?: string;
+    children?: string;
+    _title?: string[];
+}