@v-c/cascader 0.0.1

package/dist/hooks/useEntities.cjs

@@ -0,0 +1,41 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+const require_commonUtil = require("../utils/commonUtil.cjs");
+let vue = require("vue");
+let _v_c_tree = require("@v-c/tree");
+function useEntities(options, fieldNames) {
+	const cacheRef = (0, vue.shallowRef)({
+		options: [],
+		fieldNames: null,
+		info: {
+			keyEntities: {},
+			pathKeyEntities: {}
+		}
+	});
+	const getEntities = () => {
+		const mergedOptions = options.value;
+		const mergedFieldNames = fieldNames.value;
+		if (cacheRef.value.options !== mergedOptions || cacheRef.value.fieldNames !== mergedFieldNames) {
+			cacheRef.value.options = mergedOptions;
+			cacheRef.value.fieldNames = mergedFieldNames;
+			cacheRef.value.info = (0, _v_c_tree.convertDataToEntities)(mergedOptions, {
+				fieldNames: mergedFieldNames,
+				initWrapper: (wrapper) => ({
+					...wrapper,
+					pathKeyEntities: {}
+				}),
+				processEntity: (entity, wrapper) => {
+					const pathKey = entity.nodes.map((node) => node[mergedFieldNames.value]).join(require_commonUtil.VALUE_SPLIT);
+					wrapper.pathKeyEntities[pathKey] = entity;
+					entity.key = pathKey;
+				}
+			});
+		}
+		return cacheRef.value.info.pathKeyEntities;
+	};
+	return getEntities;
+}
+exports.default = useEntities;

package/dist/hooks/useEntities.d.ts

@@ -0,0 +1,10 @@
+import { DataEntity } from '@v-c/tree';
+import { Ref } from 'vue';
+import { DefaultOptionType, InternalFieldNames } from '../Cascader';
+export interface OptionsInfo {
+    keyEntities: Record<string, DataEntity>;
+    pathKeyEntities: Record<string, DataEntity>;
+}
+export type GetEntities = () => OptionsInfo['pathKeyEntities'];
+/** Lazy parse options data into conduct-able info to avoid perf issue in single mode */
+export default function useEntities(options: Ref<DefaultOptionType[]>, fieldNames: Ref<InternalFieldNames>): GetEntities;

package/dist/hooks/useEntities.js

@@ -0,0 +1,36 @@
+import { VALUE_SPLIT } from "../utils/commonUtil.js";
+import { shallowRef } from "vue";
+import { convertDataToEntities } from "@v-c/tree";
+function useEntities(options, fieldNames) {
+	const cacheRef = shallowRef({
+		options: [],
+		fieldNames: null,
+		info: {
+			keyEntities: {},
+			pathKeyEntities: {}
+		}
+	});
+	const getEntities = () => {
+		const mergedOptions = options.value;
+		const mergedFieldNames = fieldNames.value;
+		if (cacheRef.value.options !== mergedOptions || cacheRef.value.fieldNames !== mergedFieldNames) {
+			cacheRef.value.options = mergedOptions;
+			cacheRef.value.fieldNames = mergedFieldNames;
+			cacheRef.value.info = convertDataToEntities(mergedOptions, {
+				fieldNames: mergedFieldNames,
+				initWrapper: (wrapper) => ({
+					...wrapper,
+					pathKeyEntities: {}
+				}),
+				processEntity: (entity, wrapper) => {
+					const pathKey = entity.nodes.map((node) => node[mergedFieldNames.value]).join(VALUE_SPLIT);
+					wrapper.pathKeyEntities[pathKey] = entity;
+					entity.key = pathKey;
+				}
+			});
+		}
+		return cacheRef.value.info.pathKeyEntities;
+	};
+	return getEntities;
+}
+export { useEntities as default };

package/dist/hooks/useMissingValues.cjs

@@ -0,0 +1,17 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_treeUtil = require("../utils/treeUtil.cjs");
+function useMissingValues(options, fieldNames) {
+	return (rawValues) => {
+		const missingValues = [];
+		const existsValues = [];
+		rawValues.forEach((valueCell) => {
+			if (require_treeUtil.toPathOptions(valueCell, options.value, fieldNames.value).every((opt) => opt.option)) existsValues.push(valueCell);
+			else missingValues.push(valueCell);
+		});
+		return [existsValues, missingValues];
+	};
+}
+exports.default = useMissingValues;

package/dist/hooks/useMissingValues.d.ts

@@ -0,0 +1,4 @@
+import { Ref } from 'vue';
+import { DefaultOptionType, InternalFieldNames, SingleValueType } from '../Cascader';
+export type GetMissValues = ReturnType<typeof useMissingValues>;
+export default function useMissingValues(options: Ref<DefaultOptionType[]>, fieldNames: Ref<InternalFieldNames>): (rawValues: SingleValueType[]) => [SingleValueType[], SingleValueType[]];

package/dist/hooks/useMissingValues.js

@@ -0,0 +1,13 @@
+import { toPathOptions } from "../utils/treeUtil.js";
+function useMissingValues(options, fieldNames) {
+	return (rawValues) => {
+		const missingValues = [];
+		const existsValues = [];
+		rawValues.forEach((valueCell) => {
+			if (toPathOptions(valueCell, options.value, fieldNames.value).every((opt) => opt.option)) existsValues.push(valueCell);
+			else missingValues.push(valueCell);
+		});
+		return [existsValues, missingValues];
+	};
+}
+export { useMissingValues as default };

package/dist/hooks/useOptions.cjs

@@ -0,0 +1,25 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+const require_useEntities = require("./useEntities.cjs");
+let vue = require("vue");
+function useOptions(mergedFieldNames, options) {
+	const emptyOptions = [];
+	const mergedOptions = (0, vue.computed)(() => options.value || emptyOptions);
+	const getPathKeyEntities = require_useEntities.default(mergedOptions, mergedFieldNames);
+	const getValueByKeyPath = (pathKeys) => {
+		const keyPathEntities = getPathKeyEntities();
+		return pathKeys.map((pathKey) => {
+			const { nodes } = keyPathEntities[pathKey];
+			return nodes.map((node) => node[mergedFieldNames.value.value]);
+		});
+	};
+	return [
+		mergedOptions,
+		getPathKeyEntities,
+		getValueByKeyPath
+	];
+}
+exports.default = useOptions;

package/dist/hooks/useOptions.d.ts

@@ -0,0 +1,9 @@
+import { Ref } from 'vue';
+import { DefaultOptionType } from '..';
+import { InternalFieldNames, LegacyKey, SingleValueType } from '../Cascader';
+import { GetEntities } from './useEntities';
+export default function useOptions(mergedFieldNames: Ref<InternalFieldNames>, options: Ref<DefaultOptionType[] | undefined>): [
+    mergedOptions: Ref<DefaultOptionType[]>,
+    getPathKeyEntities: GetEntities,
+    getValueByKeyPath: (pathKeys: LegacyKey[]) => SingleValueType[]
+];

package/dist/hooks/useOptions.js

@@ -0,0 +1,20 @@
+import useEntities from "./useEntities.js";
+import { computed } from "vue";
+function useOptions(mergedFieldNames, options) {
+	const emptyOptions = [];
+	const mergedOptions = computed(() => options.value || emptyOptions);
+	const getPathKeyEntities = useEntities(mergedOptions, mergedFieldNames);
+	const getValueByKeyPath = (pathKeys) => {
+		const keyPathEntities = getPathKeyEntities();
+		return pathKeys.map((pathKey) => {
+			const { nodes } = keyPathEntities[pathKey];
+			return nodes.map((node) => node[mergedFieldNames.value.value]);
+		});
+	};
+	return [
+		mergedOptions,
+		getPathKeyEntities,
+		getValueByKeyPath
+	];
+}
+export { useOptions as default };

package/dist/hooks/useSearchConfig.cjs

@@ -0,0 +1,34 @@
+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_util = require("@v-c/util");
+function useSearchConfig(showSearch, props) {
+	const mergedShowSearch = (0, vue.computed)(() => {
+		if (!showSearch.value) return false;
+		return typeof showSearch.value === "object" ? true : !!showSearch.value;
+	});
+	return [mergedShowSearch, (0, vue.computed)(() => {
+		if (!mergedShowSearch.value) return {};
+		const { autoClearSearchValue, searchValue, onSearch } = props.value;
+		let config = {
+			matchInputWidth: true,
+			limit: 50,
+			autoClearSearchValue,
+			searchValue,
+			onSearch
+		};
+		if (showSearch.value && typeof showSearch.value === "object") config = {
+			...config,
+			...showSearch.value
+		};
+		if (config.limit <= 0) {
+			config.limit = false;
+			if (process.env.NODE_ENV !== "production") (0, _v_c_util.warning)(false, "'limit' of showSearch should be positive number or false.");
+		}
+		return config;
+	})];
+}
+exports.default = useSearchConfig;

package/dist/hooks/useSearchConfig.d.ts

@@ -0,0 +1,4 @@
+import { Ref } from 'vue';
+import { CascaderProps, SearchConfig } from '../Cascader';
+export type SearchConfigResult = [Ref<boolean>, Ref<SearchConfig>];
+export default function useSearchConfig(showSearch: Ref<CascaderProps['showSearch']>, props: Ref<Pick<CascaderProps, 'autoClearSearchValue' | 'searchValue' | 'onSearch'>>): SearchConfigResult;

package/dist/hooks/useSearchConfig.js

@@ -0,0 +1,29 @@
+import { computed } from "vue";
+import { warning } from "@v-c/util";
+function useSearchConfig(showSearch, props) {
+	const mergedShowSearch = computed(() => {
+		if (!showSearch.value) return false;
+		return typeof showSearch.value === "object" ? true : !!showSearch.value;
+	});
+	return [mergedShowSearch, computed(() => {
+		if (!mergedShowSearch.value) return {};
+		const { autoClearSearchValue, searchValue, onSearch } = props.value;
+		let config = {
+			matchInputWidth: true,
+			limit: 50,
+			autoClearSearchValue,
+			searchValue,
+			onSearch
+		};
+		if (showSearch.value && typeof showSearch.value === "object") config = {
+			...config,
+			...showSearch.value
+		};
+		if (config.limit <= 0) {
+			config.limit = false;
+			if (process.env.NODE_ENV !== "production") warning(false, "'limit' of showSearch should be positive number or false.");
+		}
+		return config;
+	})];
+}
+export { useSearchConfig as default };

package/dist/hooks/useSearchOptions.cjs

@@ -0,0 +1,46 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+let vue = require("vue");
+const SEARCH_MARK = "__vc_cascader_search_mark__";
+var defaultFilter = (search, options, { label = "" }) => options.some((opt) => String(opt[label]).toLowerCase().includes(search.toLowerCase()));
+var defaultRender = (_inputValue, path, _prefixCls, fieldNames) => path.map((opt) => opt[fieldNames.label]).join(" / ");
+function useSearchOptions(search, options, fieldNames, prefixCls, config, enableHalfPath) {
+	return (0, vue.computed)(() => {
+		const mergedSearch = search.value;
+		const mergedOptions = options.value;
+		const mergedFieldNames = fieldNames.value;
+		const mergedPrefixCls = prefixCls.value;
+		const { filter = defaultFilter, render = defaultRender, limit = 50, sort } = config.value;
+		const filteredOptions = [];
+		if (!mergedSearch) return [];
+		function dig(list, pathOptions, parentDisabled = false) {
+			list.forEach((option) => {
+				if (!sort && limit !== false && limit > 0 && filteredOptions.length >= limit) return;
+				const connectedPathOptions = [...pathOptions, option];
+				const children = option[mergedFieldNames.children];
+				const mergedDisabled = parentDisabled || option.disabled;
+				if (!children || children.length === 0 || enableHalfPath?.value) {
+					if (filter?.(mergedSearch, connectedPathOptions, { label: mergedFieldNames.label })) filteredOptions.push({
+						...option,
+						disabled: mergedDisabled,
+						[mergedFieldNames.label]: render?.(mergedSearch, connectedPathOptions, mergedPrefixCls, mergedFieldNames),
+						[SEARCH_MARK]: connectedPathOptions,
+						[mergedFieldNames.children]: void 0
+					});
+				}
+				if (children) dig(option[mergedFieldNames.children], connectedPathOptions, mergedDisabled);
+			});
+		}
+		dig(mergedOptions, []);
+		if (sort) filteredOptions.sort((a, b) => {
+			return sort(a[SEARCH_MARK], b[SEARCH_MARK], mergedSearch, mergedFieldNames);
+		});
+		return limit !== false && limit > 0 ? filteredOptions.slice(0, limit) : filteredOptions;
+	});
+}
+var useSearchOptions_default = useSearchOptions;
+exports.SEARCH_MARK = SEARCH_MARK;
+exports.default = useSearchOptions_default;

package/dist/hooks/useSearchOptions.d.ts

@@ -0,0 +1,5 @@
+import { ComputedRef, Ref } from 'vue';
+import { DefaultOptionType, InternalFieldNames, SearchConfig } from '../Cascader';
+export declare const SEARCH_MARK = "__vc_cascader_search_mark__";
+declare function useSearchOptions(search: Ref<string>, options: Ref<DefaultOptionType[]>, fieldNames: Ref<InternalFieldNames>, prefixCls: Ref<string>, config: Ref<SearchConfig>, enableHalfPath?: Ref<boolean>): ComputedRef<DefaultOptionType[]>;
+export default useSearchOptions;

package/dist/hooks/useSearchOptions.js

@@ -0,0 +1,40 @@
+import { computed } from "vue";
+const SEARCH_MARK = "__vc_cascader_search_mark__";
+var defaultFilter = (search, options, { label = "" }) => options.some((opt) => String(opt[label]).toLowerCase().includes(search.toLowerCase()));
+var defaultRender = (_inputValue, path, _prefixCls, fieldNames) => path.map((opt) => opt[fieldNames.label]).join(" / ");
+function useSearchOptions(search, options, fieldNames, prefixCls, config, enableHalfPath) {
+	return computed(() => {
+		const mergedSearch = search.value;
+		const mergedOptions = options.value;
+		const mergedFieldNames = fieldNames.value;
+		const mergedPrefixCls = prefixCls.value;
+		const { filter = defaultFilter, render = defaultRender, limit = 50, sort } = config.value;
+		const filteredOptions = [];
+		if (!mergedSearch) return [];
+		function dig(list, pathOptions, parentDisabled = false) {
+			list.forEach((option) => {
+				if (!sort && limit !== false && limit > 0 && filteredOptions.length >= limit) return;
+				const connectedPathOptions = [...pathOptions, option];
+				const children = option[mergedFieldNames.children];
+				const mergedDisabled = parentDisabled || option.disabled;
+				if (!children || children.length === 0 || enableHalfPath?.value) {
+					if (filter?.(mergedSearch, connectedPathOptions, { label: mergedFieldNames.label })) filteredOptions.push({
+						...option,
+						disabled: mergedDisabled,
+						[mergedFieldNames.label]: render?.(mergedSearch, connectedPathOptions, mergedPrefixCls, mergedFieldNames),
+						[SEARCH_MARK]: connectedPathOptions,
+						[mergedFieldNames.children]: void 0
+					});
+				}
+				if (children) dig(option[mergedFieldNames.children], connectedPathOptions, mergedDisabled);
+			});
+		}
+		dig(mergedOptions, []);
+		if (sort) filteredOptions.sort((a, b) => {
+			return sort(a[SEARCH_MARK], b[SEARCH_MARK], mergedSearch, mergedFieldNames);
+		});
+		return limit !== false && limit > 0 ? filteredOptions.slice(0, limit) : filteredOptions;
+	});
+}
+var useSearchOptions_default = useSearchOptions;
+export { SEARCH_MARK, useSearchOptions_default as default };

package/dist/hooks/useSelect.cjs

@@ -0,0 +1,36 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+const require_commonUtil = require("../utils/commonUtil.cjs");
+const require_treeUtil = require("../utils/treeUtil.cjs");
+let _v_c_tree = require("@v-c/tree");
+function useSelect(multiple, triggerChange, checkedValues, halfCheckedValues, missingCheckedValues, getPathKeyEntities, getValueByKeyPath, showCheckedStrategy) {
+	return (valuePath) => {
+		if (!multiple.value) triggerChange(valuePath);
+		else {
+			const pathKey = require_commonUtil.toPathKey(valuePath);
+			const checkedPathKeys = require_commonUtil.toPathKeys(checkedValues.value);
+			const halfCheckedPathKeys = require_commonUtil.toPathKeys(halfCheckedValues.value);
+			const existInChecked = checkedPathKeys.includes(pathKey);
+			const existInMissing = missingCheckedValues.value.some((valueCells) => require_commonUtil.toPathKey(valueCells) === pathKey);
+			let nextCheckedValues = checkedValues.value;
+			let nextMissingValues = missingCheckedValues.value;
+			if (existInMissing && !existInChecked) nextMissingValues = missingCheckedValues.value.filter((valueCells) => require_commonUtil.toPathKey(valueCells) !== pathKey);
+			else {
+				const nextRawCheckedKeys = existInChecked ? checkedPathKeys.filter((key) => key !== pathKey) : [...checkedPathKeys, pathKey];
+				const pathKeyEntities = getPathKeyEntities();
+				let checkedKeys;
+				if (existInChecked) ({checkedKeys} = (0, _v_c_tree.conductCheck)(nextRawCheckedKeys, {
+					checked: false,
+					halfCheckedKeys: halfCheckedPathKeys
+				}, pathKeyEntities));
+				else ({checkedKeys} = (0, _v_c_tree.conductCheck)(nextRawCheckedKeys, true, pathKeyEntities));
+				nextCheckedValues = getValueByKeyPath(require_treeUtil.formatStrategyValues(checkedKeys, getPathKeyEntities, showCheckedStrategy?.value));
+			}
+			triggerChange([...nextMissingValues, ...nextCheckedValues]);
+		}
+	};
+}
+exports.default = useSelect;

package/dist/hooks/useSelect.d.ts

@@ -0,0 +1,4 @@
+import { Ref } from 'vue';
+import { InternalValueType, LegacyKey, ShowCheckedStrategy, SingleValueType } from '../Cascader';
+import { GetEntities } from './useEntities';
+export default function useSelect(multiple: Ref<boolean>, triggerChange: (nextValues: InternalValueType) => void, checkedValues: Ref<SingleValueType[]>, halfCheckedValues: Ref<SingleValueType[]>, missingCheckedValues: Ref<SingleValueType[]>, getPathKeyEntities: GetEntities, getValueByKeyPath: (pathKeys: LegacyKey[]) => SingleValueType[], showCheckedStrategy?: Ref<ShowCheckedStrategy | undefined>): (valuePath: SingleValueType) => void;

package/dist/hooks/useSelect.js

@@ -0,0 +1,31 @@
+import { toPathKey, toPathKeys } from "../utils/commonUtil.js";
+import { formatStrategyValues } from "../utils/treeUtil.js";
+import { conductCheck } from "@v-c/tree";
+function useSelect(multiple, triggerChange, checkedValues, halfCheckedValues, missingCheckedValues, getPathKeyEntities, getValueByKeyPath, showCheckedStrategy) {
+	return (valuePath) => {
+		if (!multiple.value) triggerChange(valuePath);
+		else {
+			const pathKey = toPathKey(valuePath);
+			const checkedPathKeys = toPathKeys(checkedValues.value);
+			const halfCheckedPathKeys = toPathKeys(halfCheckedValues.value);
+			const existInChecked = checkedPathKeys.includes(pathKey);
+			const existInMissing = missingCheckedValues.value.some((valueCells) => toPathKey(valueCells) === pathKey);
+			let nextCheckedValues = checkedValues.value;
+			let nextMissingValues = missingCheckedValues.value;
+			if (existInMissing && !existInChecked) nextMissingValues = missingCheckedValues.value.filter((valueCells) => toPathKey(valueCells) !== pathKey);
+			else {
+				const nextRawCheckedKeys = existInChecked ? checkedPathKeys.filter((key) => key !== pathKey) : [...checkedPathKeys, pathKey];
+				const pathKeyEntities = getPathKeyEntities();
+				let checkedKeys;
+				if (existInChecked) ({checkedKeys} = conductCheck(nextRawCheckedKeys, {
+					checked: false,
+					halfCheckedKeys: halfCheckedPathKeys
+				}, pathKeyEntities));
+				else ({checkedKeys} = conductCheck(nextRawCheckedKeys, true, pathKeyEntities));
+				nextCheckedValues = getValueByKeyPath(formatStrategyValues(checkedKeys, getPathKeyEntities, showCheckedStrategy?.value));
+			}
+			triggerChange([...nextMissingValues, ...nextCheckedValues]);
+		}
+	};
+}
+export { useSelect as default };

package/dist/hooks/useValues.cjs

@@ -0,0 +1,25 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+const require_commonUtil = require("../utils/commonUtil.cjs");
+let vue = require("vue");
+let _v_c_tree = require("@v-c/tree");
+function useValues(multiple, rawValues, getPathKeyEntities, getValueByKeyPath, getMissingValues) {
+	return (0, vue.computed)(() => {
+		const [existValues, missingValues] = getMissingValues(rawValues.value);
+		if (!multiple.value || !rawValues.value.length) return [
+			existValues,
+			[],
+			missingValues
+		];
+		const { checkedKeys, halfCheckedKeys } = (0, _v_c_tree.conductCheck)(require_commonUtil.toPathKeys(existValues), true, getPathKeyEntities());
+		return [
+			getValueByKeyPath(checkedKeys),
+			getValueByKeyPath(halfCheckedKeys),
+			missingValues
+		];
+	});
+}
+exports.default = useValues;

package/dist/hooks/useValues.d.ts

@@ -0,0 +1,9 @@
+import { DataEntity } from '@v-c/tree';
+import { ComputedRef, Ref } from 'vue';
+import { LegacyKey, SingleValueType } from '../Cascader';
+import { GetMissValues } from './useMissingValues';
+export default function useValues(multiple: Ref<boolean>, rawValues: Ref<SingleValueType[]>, getPathKeyEntities: () => Record<string, DataEntity>, getValueByKeyPath: (pathKeys: LegacyKey[]) => SingleValueType[], getMissingValues: GetMissValues): ComputedRef<[
+    checkedValues: SingleValueType[],
+    halfCheckedValues: SingleValueType[],
+    missingCheckedValues: SingleValueType[]
+]>;

package/dist/hooks/useValues.js

@@ -0,0 +1,20 @@
+import { toPathKeys } from "../utils/commonUtil.js";
+import { computed } from "vue";
+import { conductCheck } from "@v-c/tree";
+function useValues(multiple, rawValues, getPathKeyEntities, getValueByKeyPath, getMissingValues) {
+	return computed(() => {
+		const [existValues, missingValues] = getMissingValues(rawValues.value);
+		if (!multiple.value || !rawValues.value.length) return [
+			existValues,
+			[],
+			missingValues
+		];
+		const { checkedKeys, halfCheckedKeys } = conductCheck(toPathKeys(existValues), true, getPathKeyEntities());
+		return [
+			getValueByKeyPath(checkedKeys),
+			getValueByKeyPath(halfCheckedKeys),
+			missingValues
+		];
+	});
+}
+export { useValues as default };

package/dist/index.cjs

@@ -0,0 +1,16 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_commonUtil = require("./utils/commonUtil.cjs");
+const require_Cascader = require("./Cascader.cjs");
+const require_Panel = require("./Panel.cjs");
+var ExportCascader = require_Cascader.default;
+ExportCascader.Panel = require_Panel.default;
+ExportCascader.SHOW_PARENT = require_commonUtil.SHOW_PARENT;
+ExportCascader.SHOW_CHILD = require_commonUtil.SHOW_CHILD;
+var src_default = ExportCascader;
+exports.Panel = require_Panel.default;
+exports.SHOW_CHILD = require_commonUtil.SHOW_CHILD;
+exports.SHOW_PARENT = require_commonUtil.SHOW_PARENT;
+exports.default = src_default;

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { default as Cascader } from './Cascader';
+import { default as Panel } from './Panel';
+import { SHOW_CHILD, SHOW_PARENT } from './utils/commonUtil';
+export type { BaseOptionType, CascaderProps, CascaderRef, DefaultOptionType, FieldNames, SearchConfig, } from './Cascader';
+export { Panel, SHOW_CHILD, SHOW_PARENT };
+type CascaderType = typeof Cascader & {
+    Panel: typeof Panel;
+    SHOW_PARENT: typeof SHOW_PARENT;
+    SHOW_CHILD: typeof SHOW_CHILD;
+};
+declare const ExportCascader: CascaderType;
+export default ExportCascader;

package/dist/index.js

@@ -0,0 +1,9 @@
+import { SHOW_CHILD, SHOW_PARENT } from "./utils/commonUtil.js";
+import Cascader_default from "./Cascader.js";
+import Panel_default from "./Panel.js";
+var ExportCascader = Cascader_default;
+ExportCascader.Panel = Panel_default;
+ExportCascader.SHOW_PARENT = SHOW_PARENT;
+ExportCascader.SHOW_CHILD = SHOW_CHILD;
+var src_default = ExportCascader;
+export { Panel_default as Panel, SHOW_CHILD, SHOW_PARENT, src_default as default };

package/dist/utils/commonUtil.cjs

@@ -0,0 +1,56 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_useSearchOptions = require("../hooks/useSearchOptions.cjs");
+const VALUE_SPLIT = "__VC_CASCADER_SPLIT__";
+const SHOW_PARENT = "SHOW_PARENT";
+const SHOW_CHILD = "SHOW_CHILD";
+function toPathKey(value) {
+	return value.join(VALUE_SPLIT);
+}
+function toPathKeys(value) {
+	return value.map(toPathKey);
+}
+function toPathValueStr(pathKey) {
+	return pathKey.split(VALUE_SPLIT);
+}
+function fillFieldNames(fieldNames) {
+	const { label, value, children } = fieldNames || {};
+	const val = value || "value";
+	return {
+		label: label || "label",
+		value: val,
+		key: val,
+		children: children || "children"
+	};
+}
+function isLeaf(option, fieldNames) {
+	return option.isLeaf ?? !option[fieldNames.children]?.length;
+}
+function scrollIntoParentView(element) {
+	const parent = element.parentElement;
+	if (!parent) return;
+	const elementToParent = element.offsetTop - parent.offsetTop;
+	if (elementToParent - parent.scrollTop < 0) parent.scrollTo({ top: elementToParent });
+	else if (elementToParent + element.offsetHeight - parent.scrollTop > parent.offsetHeight) parent.scrollTo({ top: elementToParent + element.offsetHeight - parent.offsetHeight });
+}
+function getFullPathKeys(options, fieldNames) {
+	return options.map((item) => item[require_useSearchOptions.SEARCH_MARK]?.map((opt) => opt[fieldNames.value]));
+}
+function isMultipleValue(value) {
+	return Array.isArray(value) && Array.isArray(value[0]);
+}
+function toRawValues(value) {
+	if (!value) return [];
+	if (isMultipleValue(value)) return value;
+	return (value.length === 0 ? [] : [value]).map((val) => Array.isArray(val) ? val : [val]);
+}
+exports.SHOW_CHILD = SHOW_CHILD;
+exports.SHOW_PARENT = SHOW_PARENT;
+exports.VALUE_SPLIT = VALUE_SPLIT;
+exports.fillFieldNames = fillFieldNames;
+exports.getFullPathKeys = getFullPathKeys;
+exports.isLeaf = isLeaf;
+exports.scrollIntoParentView = scrollIntoParentView;
+exports.toPathKey = toPathKey;
+exports.toPathKeys = toPathKeys;
+exports.toPathValueStr = toPathValueStr;
+exports.toRawValues = toRawValues;

package/dist/utils/commonUtil.d.ts

@@ -0,0 +1,18 @@
+import { DefaultOptionType, FieldNames, InternalFieldNames, InternalValueType, SingleValueType } from '../Cascader';
+export declare const VALUE_SPLIT = "__VC_CASCADER_SPLIT__";
+export declare const SHOW_PARENT = "SHOW_PARENT";
+export declare const SHOW_CHILD = "SHOW_CHILD";
+/**
+ * Will convert value to string, and join with `VALUE_SPLIT`
+ */
+export declare function toPathKey(value: SingleValueType): string;
+/**
+ * Batch convert value to string, and join with `VALUE_SPLIT`
+ */
+export declare function toPathKeys(value: SingleValueType[]): string[];
+export declare function toPathValueStr(pathKey: string): string[];
+export declare function fillFieldNames(fieldNames?: FieldNames): InternalFieldNames;
+export declare function isLeaf(option: DefaultOptionType, fieldNames: FieldNames): boolean;
+export declare function scrollIntoParentView(element: HTMLElement): void;
+export declare function getFullPathKeys(options: DefaultOptionType[], fieldNames: FieldNames): any[];
+export declare function toRawValues(value?: InternalValueType): SingleValueType[];

package/dist/utils/commonUtil.js

@@ -0,0 +1,45 @@
+import { SEARCH_MARK } from "../hooks/useSearchOptions.js";
+const VALUE_SPLIT = "__VC_CASCADER_SPLIT__";
+const SHOW_PARENT = "SHOW_PARENT";
+const SHOW_CHILD = "SHOW_CHILD";
+function toPathKey(value) {
+	return value.join(VALUE_SPLIT);
+}
+function toPathKeys(value) {
+	return value.map(toPathKey);
+}
+function toPathValueStr(pathKey) {
+	return pathKey.split(VALUE_SPLIT);
+}
+function fillFieldNames(fieldNames) {
+	const { label, value, children } = fieldNames || {};
+	const val = value || "value";
+	return {
+		label: label || "label",
+		value: val,
+		key: val,
+		children: children || "children"
+	};
+}
+function isLeaf(option, fieldNames) {
+	return option.isLeaf ?? !option[fieldNames.children]?.length;
+}
+function scrollIntoParentView(element) {
+	const parent = element.parentElement;
+	if (!parent) return;
+	const elementToParent = element.offsetTop - parent.offsetTop;
+	if (elementToParent - parent.scrollTop < 0) parent.scrollTo({ top: elementToParent });
+	else if (elementToParent + element.offsetHeight - parent.scrollTop > parent.offsetHeight) parent.scrollTo({ top: elementToParent + element.offsetHeight - parent.offsetHeight });
+}
+function getFullPathKeys(options, fieldNames) {
+	return options.map((item) => item[SEARCH_MARK]?.map((opt) => opt[fieldNames.value]));
+}
+function isMultipleValue(value) {
+	return Array.isArray(value) && Array.isArray(value[0]);
+}
+function toRawValues(value) {
+	if (!value) return [];
+	if (isMultipleValue(value)) return value;
+	return (value.length === 0 ? [] : [value]).map((val) => Array.isArray(val) ? val : [val]);
+}
+export { SHOW_CHILD, SHOW_PARENT, VALUE_SPLIT, fillFieldNames, getFullPathKeys, isLeaf, scrollIntoParentView, toPathKey, toPathKeys, toPathValueStr, toRawValues };