@gct-paas/render-mobile 0.1.5-dev.2 → 0.1.5-dev.3

package/es/components/treePopup/src/treeCheck.vue_vue_type_script_setup_true_lang.mjs

@@ -0,0 +1,276 @@
+import { SelectType } from "./typing.mjs";
+import treeList_default from "./components/treeList.vue.mjs";
+import treeItem_default from "./components/treeItem.vue.mjs";
+import selectList_default from "./components/selectList.vue.mjs";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, normalizeClass, onMounted, openBlock, reactive, ref, renderList, resolveComponent, toDisplayString, unref, vShow, withCtx, withDirectives } from "vue";
+//#region src/components/treePopup/src/treeCheck.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { class: "pt50px flex flex-col h-full" };
+var _hoisted_2 = { class: "text-left text-16px font-bold p12px absolute title" };
+var _hoisted_3 = { class: "overflow-y-auto flex-1" };
+var _hoisted_4 = { class: "w-full p-12px shadow-top" };
+var _hoisted_5 = {
+	key: 0,
+	class: "pb-12px"
+};
+var _hoisted_6 = { class: "pr-8px text-sm mr-8px border-r" };
+var _hoisted_7 = { style: { "color": "var(--van-primary-color)" } };
+var treeCheck_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "treeCheck",
+	props: {
+		options: {},
+		activeKey: {},
+		activeKeys: {},
+		title: {},
+		type: {},
+		hasNoLabels: { type: Boolean },
+		ignoreCase: {},
+		maxTagTextLength: {}
+	},
+	emits: ["checked"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const searchValue = ref("");
+		const multipleKeys = ref([]);
+		const treeSingleData = ref([]);
+		const checkedSingleData = ref([]);
+		const treeListRef = ref();
+		const selectData = ref([]);
+		const emit = __emit;
+		const tree2list = (arr) => {
+			let cloneTree = JSON.parse(JSON.stringify(arr));
+			function iteration(tree, level) {
+				let temp = [];
+				for (const i of tree) {
+					i.level = level;
+					temp.push(i);
+					if (i.children?.length) temp = [...temp, ...iteration(i.children, level + 1)];
+				}
+				return temp;
+			}
+			return iteration(cloneTree, 1);
+		};
+		const optionList = reactive(tree2list(props.options));
+		const addKey = (arr) => arr.map((item) => {
+			if (props.activeKeys.includes(item.value)) multipleKeys.value.push(item);
+			return {
+				label: item.label,
+				value: item.value,
+				parentId: item.parentId,
+				_item: item._item,
+				checked: !!props.activeKeys.includes(item.value),
+				expand: true,
+				children: item.children?.length ? addKey(item.children) : []
+			};
+		});
+		const addAttr2TreeData = (arr) => {
+			let tree = [];
+			const arrClone = JSON.parse(JSON.stringify(arr));
+			if (props.type === SelectType.MULTIPLE) tree = addKey(arrClone);
+			else tree = arrClone;
+			return tree;
+		};
+		const treeData = reactive(addAttr2TreeData(props.options));
+		onMounted(() => {
+			if (props.type === SelectType.SINGLE) {
+				const findItem = optionList.find((i) => i.value === props.activeKey);
+				if (props.activeKey && findItem && findItem?.parentId !== "ROOT") {
+					getfatherData(treeData, findItem, findItem?.parentId);
+					checkedSingleData.value = getFatherChecked(findItem.parentId, []) || [];
+				} else {
+					treeSingleData.value = treeData;
+					checkedSingleData.value = [];
+				}
+			}
+		});
+		const isDisabled = computed(() => {
+			if (props.type === SelectType.SINGLE) if (!treeListRef.value?.active) return optionList.some((i) => i?.noSelectable);
+			else return !!optionList.find((i) => i.value === treeListRef.value?.active)?.noSelectable;
+			return false;
+		});
+		/**
+		* 单选操作开始-------------------------------------------------------------------
+		*/
+		function getFatherChecked(pid, fathers) {
+			const fatherItem = optionList.find((i) => i.value === pid) || {};
+			fathers.unshift(fatherItem);
+			if (fatherItem.parentId === "ROOT") return fathers;
+			return getFatherChecked(fatherItem.parentId, fathers);
+		}
+		const checkTreeData = (value, pid) => {
+			treeSingleData.value = value;
+			if (pid && pid !== "ROOT") checkedSingleData.value = getFatherChecked(pid, []) || [];
+		};
+		const getfatherData = (arr, value, pid) => {
+			for (const val of arr) if (pid && val.value === pid) {
+				treeSingleData.value = val.children;
+				return;
+			} else getfatherData(val.children, value, pid);
+		};
+		const getBackData = (value, pid) => {
+			if (pid && pid === "ROOT") {
+				checkedSingleData.value = [];
+				treeSingleData.value = treeData;
+			} else {
+				getfatherData(treeData, value, pid);
+				checkedSingleData.value = getFatherChecked(value.parentId, []) || [];
+			}
+		};
+		function setSelVal(val) {
+			searchValue.value = "";
+			if (props.type === SelectType.SINGLE) {
+				getBackData(val, val.parentId);
+				const findItem = treeSingleData.value.find((item) => item.value === val.value);
+				treeListRef.value?.setVal(findItem);
+			} else for (const i of val) setMulTreeCheck(treeData, i, i.checked);
+		}
+		/**
+		* 单选操作结束----------------------------------------------------------------------------
+		* 多选操作开始----------------------------------------------------------------------------
+		*/
+		function setMulTreeCheck(arr, value, checked) {
+			for (const val of arr) if (val.value === value.value) {
+				val.checked = checked;
+				if (val.checked) multipleKeys.value.push(val);
+				else multipleKeys.value = multipleKeys.value.filter((val) => val.value !== value.value);
+				return;
+			} else if (val.children?.length) setMulTreeCheck(val.children, value, checked);
+		}
+		function setMulTreeData(val, checked) {
+			setMulTreeCheck(treeData, val, checked);
+		}
+		function setMulToggle(arr, value) {
+			for (const val of arr) if (val.value === value.value) {
+				val.expand = !val.expand;
+				return;
+			} else if (val.children?.length) setMulToggle(val.children, value);
+		}
+		function mulToggle(val) {
+			setMulToggle(treeData, val);
+		}
+		function close(value) {
+			setMulTreeCheck(treeData, value, false);
+		}
+		/**
+		* 多选操作结束---------------------------------------------------------------------------
+		*/
+		function setVal() {
+			if (props.type === SelectType.SINGLE) emit("checked", treeListRef.value?.active);
+			else if (props.type === SelectType.MULTIPLE) emit("checked", multipleKeys.value.map((item) => item.value));
+		}
+		function getParentLabels(arr, pid, labels) {
+			for (const item of arr) if (pid === item.value) {
+				labels.push(item.label);
+				return labels;
+			} else {
+				const options = item.children.length && getParentLabels(item.children, pid, labels);
+				if (options) return options;
+			}
+		}
+		function treeFilter(tree, func, list) {
+			for (const item of tree) {
+				if (func(item)) list.push(item);
+				if (item.children?.length) treeFilter(item.children, func, list);
+			}
+			return list;
+		}
+		const onSearch = (val) => {
+			let options = [];
+			if (props.type == SelectType.SINGLE) if (props.ignoreCase) options = optionList.filter((i) => i.label?.toLowerCase().indexOf(val.toLowerCase()) !== -1) || [];
+			else options = optionList.filter((i) => i.label.indexOf(val) !== -1) || [];
+			else options = treeFilter(treeData, (data) => {
+				if (props.ignoreCase) return data.label?.toLowerCase().indexOf(val.toLowerCase()) !== -1;
+				return data.label?.indexOf(val) !== -1;
+			}, []) || [];
+			for (const item of options) {
+				if (item.parentId && item.parentId === "ROOT") {
+					item.labels = "";
+					continue;
+				}
+				if (props.hasNoLabels) item.labels = "";
+				else item.labels = getParentLabels(treeData, item.parentId, [])?.join("/");
+			}
+			selectData.value = JSON.parse(JSON.stringify(options));
+			selectData.value.forEach((i) => {
+				i.label = ((i.label?.split(new RegExp(`(${val})`, "gi")))?.map((part, index) => part.toLowerCase() === val.toLowerCase() ? `<span key=${index} style='color: var(--van-primary-color);'>${part}</span>` : part))?.join("");
+			});
+		};
+		const handleLabel = (label) => {
+			if (props.maxTagTextLength && label.length > props.maxTagTextLength) return label.slice(0, props.maxTagTextLength) + "...";
+			return label;
+		};
+		return (_ctx, _cache) => {
+			const _component_van_search = resolveComponent("van-search");
+			const _component_van_icon = resolveComponent("van-icon");
+			const _component_van_tag = resolveComponent("van-tag");
+			const _component_van_button = resolveComponent("van-button");
+			return openBlock(), createElementBlock("div", _hoisted_1, [
+				createElementVNode("div", _hoisted_2, toDisplayString(props.title), 1),
+				createVNode(_component_van_search, {
+					modelValue: searchValue.value,
+					"onUpdate:modelValue": [_cache[0] || (_cache[0] = ($event) => searchValue.value = $event), onSearch],
+					class: normalizeClass({ "border-all": searchValue.value }),
+					shape: "round",
+					"left-icon": searchValue.value ? "" : "search",
+					placeholder: "请输入"
+				}, null, 8, [
+					"modelValue",
+					"class",
+					"left-icon"
+				]),
+				createElementVNode("div", _hoisted_3, [
+					withDirectives(createVNode(treeList_default, {
+						ref_key: "treeListRef",
+						ref: treeListRef,
+						"checked-single-data": checkedSingleData.value,
+						"tree-single-data": treeSingleData.value,
+						"active-key": __props.activeKey,
+						type: __props.type,
+						onCheckTreeData: checkTreeData,
+						onGetBackData: getBackData
+					}, null, 8, [
+						"checked-single-data",
+						"tree-single-data",
+						"active-key",
+						"type"
+					]), [[vShow, __props.type === unref(SelectType).SINGLE && !searchValue.value.length]]),
+					withDirectives(createElementVNode("div", null, [createVNode(treeItem_default, {
+						"tree-data": treeData,
+						onSetMulTreeData: setMulTreeData,
+						onMulToggle: mulToggle
+					}, null, 8, ["tree-data"])], 512), [[vShow, __props.type === unref(SelectType).MULTIPLE && !searchValue.value.length]]),
+					withDirectives(createVNode(selectList_default, {
+						ref: "selectListRef",
+						"select-data": selectData.value,
+						type: __props.type,
+						onSetSelectData: setSelVal
+					}, null, 8, ["select-data", "type"]), [[vShow, searchValue.value.length]])
+				]),
+				withDirectives(createElementVNode("div", _hoisted_4, [__props.type === unref(SelectType).MULTIPLE && multipleKeys.value.length ? (openBlock(), createElementBlock("div", _hoisted_5, [createElementVNode("span", _hoisted_6, [_cache[1] || (_cache[1] = createTextVNode(" 已选 ", -1)), createElementVNode("span", _hoisted_7, [createTextVNode(toDisplayString(multipleKeys.value.length) + " ", 1), createVNode(_component_van_icon, { name: "arrow-up" })])]), (openBlock(true), createElementBlock(Fragment, null, renderList(multipleKeys.value, (item, index) => {
+					return openBlock(), createBlock(_component_van_tag, {
+						key: item.label + "_" + index,
+						class: "mx-2px px-2px",
+						size: "medium",
+						round: "",
+						color: "color-mix(in oklch, var(--van-primary-color), transparent 92%)",
+						"text-color": "var(--van-primary-color)",
+						closeable: "",
+						onClose: ($event) => close(item)
+					}, {
+						default: withCtx(() => [createTextVNode(toDisplayString(handleLabel(item.label)), 1)]),
+						_: 2
+					}, 1032, ["onClose"]);
+				}), 128))])) : createCommentVNode("", true), createVNode(_component_van_button, {
+					class: "w-full px-4px",
+					type: "primary",
+					disabled: isDisabled.value,
+					onClick: setVal
+				}, {
+					default: withCtx(() => [..._cache[2] || (_cache[2] = [createTextVNode("完成", -1)])]),
+					_: 1
+				}, 8, ["disabled"])], 512), [[vShow, !searchValue.value.length]])
+			]);
+		};
+	}
+});
+//#endregion
+export { treeCheck_vue_vue_type_script_setup_true_lang_default as default };

package/es/components/treePopup/src/treeCheck.vue_vue_type_style_index_0_scoped_00b864e8_lang.css

@@ -0,0 +1,29 @@
+.title[data-v-00b864e8] {
+  z-index: 1;
+  top: 0;
+  width: 100%;
+}
+.title[data-v-00b864e8]:after {
+  position: absolute;
+  box-sizing: border-box;
+  content: ' ';
+  pointer-events: none;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  border-bottom: 1px solid var(--van-cell-border-color);
+}
+.shadow-top[data-v-00b864e8] {
+  box-shadow: 0px -1px 4px 0px rgba(0, 0, 0, 0.12);
+}
+.border-r[data-v-00b864e8] {
+  border-right: 1px solid #eaeaea;
+}
+[data-v-00b864e8] .van-search.border-all .van-search__content {
+  border: 1px solid var(--van-primary-color);
+  background: transparent;
+}
+[data-v-00b864e8] .van-search .van-search__content:focus {
+  border: 1px solid var(--van-primary-color);
+  background: transparent;
+}

package/es/components/treePopup/src/treePopup.vue.d.ts

@@ -0,0 +1,103 @@
+import { optionType } from './typing';
+type __VLS_Props = {
+    api: Fn;
+    title: string;
+    options: optionType[];
+    fieldKey: string;
+    modelKey: string;
+    isTreeData?: boolean;
+    hasNoLabels?: boolean;
+    ignoreCase?: number;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {
+    singleTreeOpen: ({ ids, type, callback }: IObject) => void;
+    multipleTreeOpen: ({ ids, type, callback }: IObject) => Promise<void>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    treeCheckRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        options: optionType[];
+        activeKey: string;
+        activeKeys: string[];
+        title: string;
+        type: string;
+        hasNoLabels?: boolean;
+        ignoreCase?: number;
+        maxTagTextLength?: number;
+    }> & Readonly<{
+        onChecked?: ((...args: any[]) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        checked: (...args: any[]) => void;
+    }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        treeListRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+            checkedSingleData: optionType[];
+            treeSingleData: optionType[];
+            activeKey: string;
+            type: string;
+        }> & Readonly<{
+            onCheckTreeData?: ((...args: any[]) => any) | undefined;
+            onGetBackData?: ((...args: any[]) => any) | undefined;
+        }>, {
+            active: import('vue').Ref<string, string>;
+            setVal: (value: IObject) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            checkTreeData: (...args: any[]) => void;
+            getBackData: (...args: any[]) => void;
+        }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{
+            checkedSingleData: optionType[];
+            treeSingleData: optionType[];
+            activeKey: string;
+            type: string;
+        }> & Readonly<{
+            onCheckTreeData?: ((...args: any[]) => any) | undefined;
+            onGetBackData?: ((...args: any[]) => any) | undefined;
+        }>, {
+            active: import('vue').Ref<string, string>;
+            setVal: (value: IObject) => void;
+        }, {}, {}, {}, {}> | null;
+        selectListRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+            selectData: optionType[];
+            type: string;
+        }> & Readonly<{
+            onSetSelectData?: ((...args: any[]) => any) | undefined;
+        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            setSelectData: (...args: any[]) => void;
+        }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{
+            selectData: optionType[];
+            type: string;
+        }> & Readonly<{
+            onSetSelectData?: ((...args: any[]) => any) | undefined;
+        }>, {}, {}, {}, {}, {}> | null;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        options: optionType[];
+        activeKey: string;
+        activeKeys: string[];
+        title: string;
+        type: string;
+        hasNoLabels?: boolean;
+        ignoreCase?: number;
+        maxTagTextLength?: number;
+    }> & Readonly<{
+        onChecked?: ((...args: any[]) => any) | undefined;
+    }>, {}, {}, {}, {}, {}> | null;
+}, HTMLDivElement>;
+export default _default;

package/es/components/treePopup/src/treePopup.vue.mjs

@@ -0,0 +1,6 @@
+import treePopup_vue_vue_type_script_setup_true_name_treePopup_lang_default from "./treePopup.vue_vue_type_script_setup_true_name_treePopup_lang.mjs";
+import './treePopup.vue_vue_type_style_index_0_lang.css';/* empty css                                               */
+//#region src/components/treePopup/src/treePopup.vue
+var treePopup_default = treePopup_vue_vue_type_script_setup_true_name_treePopup_lang_default;
+//#endregion
+export { treePopup_default as default };

package/es/components/treePopup/src/treePopup.vue_vue_type_script_setup_true_name_treePopup_lang.mjs

@@ -0,0 +1,129 @@
+import { SelectType } from "./typing.mjs";
+import treeCheck_default from "./treeCheck.vue.mjs";
+import { useAsyncFileAttrs } from "@gct-paas/render";
+import { createBlock, createCommentVNode, createElementBlock, createVNode, defineComponent, openBlock, ref, resolveComponent, unref, watch, withCtx } from "vue";
+import { cloneDeep } from "lodash-es";
+//#region src/components/treePopup/src/treePopup.vue?vue&type=script&setup=true&name=treePopup&lang.ts
+var _hoisted_1 = { class: "tree-popup" };
+var treePopup_vue_vue_type_script_setup_true_name_treePopup_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "treePopup",
+	props: {
+		api: {},
+		title: {},
+		options: {},
+		fieldKey: {},
+		modelKey: {},
+		isTreeData: { type: Boolean },
+		hasNoLabels: { type: Boolean },
+		ignoreCase: {}
+	},
+	setup(__props, { expose: __expose }) {
+		const props = __props;
+		const showPopup = ref(false);
+		const activeKey = ref("");
+		const activeKeys = ref([]);
+		const orgOptions = ref([]);
+		const optionlist = ref(props.options);
+		let handleSingleOk;
+		let handleMutipleOk;
+		let checkedType = ref("");
+		const { getmaxTagLength, attrObj } = useAsyncFileAttrs();
+		watch(() => props.options, () => {
+			orgOptions.value = [...setOrgOptions()];
+		}, {
+			immediate: true,
+			deep: true
+		});
+		function setOrgOptions() {
+			let treeOptions = [];
+			const arrClone = cloneDeep(optionlist.value);
+			arrClone.forEach((i) => {
+				!arrClone.find((o) => o.value === i._item.parentId) && (i._item.parentId = "ROOT");
+			});
+			if (props.isTreeData) treeOptions = arrClone;
+			else {
+				const mapInfo = arrClone.reduce((obj, item) => {
+					item.parentId = item._item.parentId;
+					item.children = [];
+					obj[item.value] = item;
+					return obj;
+				}, {});
+				arrClone.forEach((i) => {
+					const parent = mapInfo[i.parentId];
+					parent ? parent.children.push(i) : treeOptions.push(i);
+				});
+			}
+			return treeOptions;
+		}
+		const checked = (value) => {
+			if (checkedType.value === SelectType.SINGLE) {
+				activeKey.value = value;
+				handleSingleOk && handleSingleOk(value);
+			} else if (checkedType.value === SelectType.MULTIPLE) {
+				activeKeys.value = value;
+				handleMutipleOk && handleMutipleOk(value);
+			}
+			showPopup.value = false;
+		};
+		const singleTreeOpen = ({ ids, type, callback }) => {
+			activeKey.value = ids || "";
+			checkedType.value = type;
+			showPopup.value = true;
+			handleSingleOk = callback;
+		};
+		const multipleTreeOpen = async ({ ids, type, callback }) => {
+			activeKeys.value = ids || [];
+			checkedType.value = type;
+			showPopup.value = true;
+			await getmaxTagLength({
+				fieldKey: props.fieldKey,
+				modelKey: props.modelKey
+			});
+			handleMutipleOk = callback;
+		};
+		__expose({
+			singleTreeOpen,
+			multipleTreeOpen
+		});
+		return (_ctx, _cache) => {
+			const _component_van_popup = resolveComponent("van-popup");
+			return openBlock(), createElementBlock("div", _hoisted_1, [createVNode(_component_van_popup, {
+				show: showPopup.value,
+				"onUpdate:show": _cache[0] || (_cache[0] = ($event) => showPopup.value = $event),
+				position: "bottom",
+				closeable: "",
+				style: {
+					height: "80%",
+					overflow: "hidden"
+				},
+				round: ""
+			}, {
+				default: withCtx(() => [showPopup.value ? (openBlock(), createBlock(treeCheck_default, {
+					key: 0,
+					ref: "treeCheckRef",
+					type: unref(checkedType),
+					options: orgOptions.value,
+					"active-key": activeKey.value,
+					"active-keys": activeKeys.value,
+					title: __props.title,
+					"has-no-labels": __props.hasNoLabels,
+					"ignore-case": __props.ignoreCase,
+					"max-tag-text-length": unref(attrObj)?.maxTagTextLength,
+					onChecked: checked
+				}, null, 8, [
+					"type",
+					"options",
+					"active-key",
+					"active-keys",
+					"title",
+					"has-no-labels",
+					"ignore-case",
+					"max-tag-text-length"
+				])) : createCommentVNode("", true)]),
+				_: 1
+			}, 8, ["show"])]);
+		};
+	}
+});
+//#endregion
+export { treePopup_vue_vue_type_script_setup_true_name_treePopup_lang_default as default };

package/es/components/treePopup/src/treePopup.vue_vue_type_style_index_0_lang.css

@@ -0,0 +1,7 @@
+
+.tree-popup > .van-popup > .van-popup__close-icon {
+  position: absolute;
+  right: 12px;
+  color: #c3c3c3;
+  font-size: 16px;
+}

package/es/components/treePopup/src/typing.d.ts

@@ -0,0 +1,53 @@
+export interface Options extends Props {
+    callback?: (value: IObject) => void;
+}
+export interface Props {
+    api?: Fn;
+    title: string;
+    options?: optionType[];
+    fieldKey?: string;
+    modelKey?: string;
+    isTreeData?: boolean;
+    hasNoLabels?: boolean;
+}
+export interface optionType {
+    label: string;
+    value: string;
+    parentId?: string;
+    labels?: string[];
+    checked?: boolean;
+    selectable?: boolean;
+    _item: DeptItem;
+}
+export declare enum SelectType {
+    SINGLE = "single",
+    MULTIPLE = "multiple"
+}
+export declare enum DEPT_TYPE {
+    GROUP = "GROUP",
+    DEPARTMENT = "DEPARTMENT"
+}
+export interface openPickerByType {
+    ids?: string[] | string;
+    type: SelectType;
+    callback: openPickerByCallback;
+}
+export type openPickerByCallback = (value: string[] | string) => void;
+export interface DeptItem {
+    id: string;
+    name: string;
+    parentId: string;
+    type: DEPT_TYPE;
+    sortNum?: number;
+}
+export interface TreeOptions {
+    label: string;
+    value: string;
+    labels?: string[];
+    _item: DeptItem;
+    parentId?: string;
+    checked?: boolean;
+    expand?: boolean;
+    selectable?: boolean;
+    children: TreeOptions[];
+}

package/es/components/treePopup/src/typing.mjs

@@ -0,0 +1,13 @@
+//#region src/components/treePopup/src/typing.ts
+var SelectType = /* @__PURE__ */ function(SelectType) {
+	SelectType["SINGLE"] = "single";
+	SelectType["MULTIPLE"] = "multiple";
+	return SelectType;
+}({});
+var DEPT_TYPE = /* @__PURE__ */ function(DEPT_TYPE) {
+	DEPT_TYPE["GROUP"] = "GROUP";
+	DEPT_TYPE["DEPARTMENT"] = "DEPARTMENT";
+	return DEPT_TYPE;
+}({});
+//#endregion
+export { DEPT_TYPE, SelectType };

package/es/index.mjs

@@ -1,9 +1,16 @@
 import { setupPageEvent, usePageEvent } from "./Event/Events.mjs";
 import { createNumKeyboardPopup } from "./components/numKeyboard/index.mjs";
+import tag_label_default from "./components/form-component/tag-label.vue.mjs";
+import FieldSelect_default from "./components/form-component/FieldSelect.mjs";
+import FieldRadio_default from "./components/form-component/FieldRadio.mjs";
+import FieldCheckbox_default from "./components/form-component/FieldCheckbox.mjs";
+import { DEPT_TYPE, SelectType } from "./components/treePopup/src/typing.mjs";
+import { createTreePopup } from "./components/treePopup/index.mjs";
+import { createTimePicker } from "./components/timePicker/index.mjs";
 import "./components/index.mjs";
 //#region src/index.ts
 function run() {
 	console.log("Hello World!");
 }
 //#endregion
-export { createNumKeyboardPopup, run, setupPageEvent, usePageEvent };
+export { DEPT_TYPE, FieldCheckbox_default as FieldCheckbox, FieldRadio_default as FieldRadio, FieldSelect_default as FieldSelect, SelectType, tag_label_default as Taglabel, createNumKeyboardPopup, createTimePicker, createTreePopup, run, setupPageEvent, usePageEvent };