@minilo/ui 0.0.2 → 0.0.3

package/minilo/es/components/search-table/index.d.ts

@@ -26,11 +26,11 @@ export declare const MlSearchTable: {
         };
         paramsHandler: {
             type: FunctionConstructor;
-            default: null;
+            default: any;
         };
         render: {
             type: FunctionConstructor;
-            default: null;
+            default: any;
         };
         searchProps: {
             type: ObjectConstructor;
@@ -59,22 +59,22 @@ export declare const MlSearchTable: {
                 fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
                 readonly [Symbol.species]: ArrayConstructor;
             };
-            default: () => never[];
+            default: () => any[];
         };
         search: {
             type: import('vue').PropType<import('../search/props').SearchModel>;
         };
     }>> & Readonly<{
-        onReset?: ((...args: any[]) => any) | undefined;
-        "onUpdate:search"?: ((value: import('../search/props').SearchModel) => any) | undefined;
+        onReset?: (...args: any[]) => any;
+        "onUpdate:search"?: (value: import('../search/props').SearchModel) => any;
     }>, {
         handleSearch: (reset?: boolean) => Promise<void>;
     }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
         reset: (...args: any[]) => void;
         "update:search": (value: import('../search/props').SearchModel) => void;
     }, import('vue').PublicProps, {
-        url: string;
         render: Function;
+        url: string;
         methodType: import('./props').RequestMethodType;
         responseDataField: string;
         responseTotalField: string;
@@ -118,11 +118,11 @@ export declare const MlSearchTable: {
         };
         paramsHandler: {
             type: FunctionConstructor;
-            default: null;
+            default: any;
         };
         render: {
             type: FunctionConstructor;
-            default: null;
+            default: any;
         };
         searchProps: {
             type: ObjectConstructor;
@@ -151,19 +151,19 @@ export declare const MlSearchTable: {
                 fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
                 readonly [Symbol.species]: ArrayConstructor;
             };
-            default: () => never[];
+            default: () => any[];
         };
         search: {
             type: import('vue').PropType<import('../search/props').SearchModel>;
         };
     }>> & Readonly<{
-        onReset?: ((...args: any[]) => any) | undefined;
-        "onUpdate:search"?: ((value: import('../search/props').SearchModel) => any) | undefined;
+        onReset?: (...args: any[]) => any;
+        "onUpdate:search"?: (value: import('../search/props').SearchModel) => any;
     }>, {
         handleSearch: (reset?: boolean) => Promise<void>;
     }, {}, {}, {}, {
-        url: string;
         render: Function;
+        url: string;
         methodType: import('./props').RequestMethodType;
         responseDataField: string;
         responseTotalField: string;
@@ -204,11 +204,11 @@ export declare const MlSearchTable: {
     };
     paramsHandler: {
         type: FunctionConstructor;
-        default: null;
+        default: any;
     };
     render: {
         type: FunctionConstructor;
-        default: null;
+        default: any;
     };
     searchProps: {
         type: ObjectConstructor;
@@ -237,22 +237,22 @@ export declare const MlSearchTable: {
             fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
             readonly [Symbol.species]: ArrayConstructor;
         };
-        default: () => never[];
+        default: () => any[];
     };
     search: {
         type: import('vue').PropType<import('../search/props').SearchModel>;
     };
 }>> & Readonly<{
-    onReset?: ((...args: any[]) => any) | undefined;
-    "onUpdate:search"?: ((value: import('../search/props').SearchModel) => any) | undefined;
+    onReset?: (...args: any[]) => any;
+    "onUpdate:search"?: (value: import('../search/props').SearchModel) => any;
 }>, {
     handleSearch: (reset?: boolean) => Promise<void>;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     reset: (...args: any[]) => void;
     "update:search": (value: import('../search/props').SearchModel) => void;
 }, string, {
-    url: string;
     render: Function;
+    url: string;
     methodType: import('./props').RequestMethodType;
     responseDataField: string;
     responseTotalField: string;

package/minilo/es/components/search-table/index.vue.d.ts

@@ -40,11 +40,11 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
     };
     paramsHandler: {
         type: FunctionConstructor;
-        default: null;
+        default: any;
     };
     render: {
         type: FunctionConstructor;
-        default: null;
+        default: any;
     };
     searchProps: {
         type: ObjectConstructor;
@@ -73,7 +73,7 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
             fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
             readonly [Symbol.species]: ArrayConstructor;
         };
-        default: () => never[];
+        default: () => any[];
     };
     search: {
         type: import('vue').PropType<SearchModel>;
@@ -110,11 +110,11 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
     };
     paramsHandler: {
         type: FunctionConstructor;
-        default: null;
+        default: any;
     };
     render: {
         type: FunctionConstructor;
-        default: null;
+        default: any;
     };
     searchProps: {
         type: ObjectConstructor;
@@ -143,17 +143,17 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
             fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
             readonly [Symbol.species]: ArrayConstructor;
         };
-        default: () => never[];
+        default: () => any[];
     };
     search: {
         type: import('vue').PropType<SearchModel>;
     };
 }>> & Readonly<{
-    onReset?: ((...args: any[]) => any) | undefined;
-    "onUpdate:search"?: ((value: SearchModel) => any) | undefined;
+    onReset?: (...args: any[]) => any;
+    "onUpdate:search"?: (value: SearchModel) => any;
 }>, {
-    url: string;
     render: Function;
+    url: string;
     methodType: RequestMethodType;
     responseDataField: string;
     responseTotalField: string;

package/minilo/es/components/search-table/index.vue2.mjs

@@ -4,8 +4,8 @@ import { searchTableProps, RequestMethodType } from './props.mjs';
 import { ElTable, ElTableColumn, ElPagination } from 'element-plus';
 import Render from './render.mjs';
 import { bem } from '../../utils/index.mjs';
-import { initRequestInstance } from '../../packages/utils/dist/request/index.mjs';
-import { getNestedValue } from '../../packages/utils/dist/func/common.mjs';
+import { initRequestInstance } from '../../node_modules/.pnpm/@minilo_utils@0.0.2_vue@3.5.26_typescript@5.9.3_/node_modules/@minilo/utils/dist/request/index.mjs';
+import { getNestedValue } from '../../node_modules/.pnpm/@minilo_utils@0.0.2_vue@3.5.26_typescript@5.9.3_/node_modules/@minilo/utils/dist/func/common.mjs';
 
 var _sfc_main = /* @__PURE__ */ defineComponent({
   ...{

package/minilo/es/components/search-table/props.d.ts

@@ -31,11 +31,11 @@ export declare const searchTableProps: {
     };
     paramsHandler: {
         type: FunctionConstructor;
-        default: null;
+        default: any;
     };
     render: {
         type: FunctionConstructor;
-        default: null;
+        default: any;
     };
     searchProps: {
         type: ObjectConstructor;
@@ -64,6 +64,6 @@ export declare const searchTableProps: {
             fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
             readonly [Symbol.species]: ArrayConstructor;
         };
-        default: () => never[];
+        default: () => any[];
     };
 };

package/minilo/es/components/tree-select/index.d.ts

@@ -0,0 +1,32 @@
+export declare const MlTreeSelect: <T = any>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    slots: {
+        footer?(_: {}): any;
+    };
+    attrs: any;
+    emit: ((evt: "input", value: string) => void) & ((evt: "confirm", selectedData: T | T[]) => void) & ((evt: "cancel") => void);
+}, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+        readonly onInput?: (value: string) => any;
+        readonly onConfirm?: (selectedData: T | T[]) => any;
+        readonly onCancel?: () => any;
+        treeData: T[];
+        treeProps?: Record<string, any>;
+        multiple?: boolean;
+        defaultExpandAll?: boolean;
+        defaultSelectedKeys?: any[];
+        nodeKey?: string;
+        showSearch?: boolean;
+        expandOnClickNode?: boolean;
+        placeholder?: string;
+    } & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<import('./type').TreeSelectExpose>): void;
+    attrs: any;
+    slots: {
+        footer?(_: {}): any;
+    };
+    emit: ((evt: "input", value: string) => void) & ((evt: "confirm", selectedData: T | T[]) => void) & ((evt: "cancel") => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default MlTreeSelect;
+export * from './type';

package/minilo/es/components/tree-select/index.mjs

@@ -0,0 +1,6 @@
+import { withInstall } from '../../utils/index.mjs';
+import _sfc_main from './index.vue2.mjs';
+
+const MlTreeSelect = withInstall(_sfc_main);
+
+export { MlTreeSelect, MlTreeSelect as default };

package/minilo/es/components/tree-select/index.vue.d.ts

@@ -0,0 +1,20 @@
+import { TreeSelectProps, TreeSelectExpose } from './type';
+declare const _default: <T = any>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onInput?: (value: string) => any;
+        readonly onConfirm?: (selectedData: T | T[]) => any;
+        readonly onCancel?: () => any;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onInput" | "onConfirm" | "onCancel"> & TreeSelectProps<T> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<TreeSelectExpose>): void;
+    attrs: any;
+    slots: {
+        footer?(_: {}): any;
+    };
+    emit: ((evt: "input", value: string) => void) & ((evt: "confirm", selectedData: T | T[]) => void) & ((evt: "cancel") => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/minilo/es/components/tree-select/index.vue.mjs

@@ -0,0 +1,5 @@
+import _sfc_main from './index.vue2.mjs';
+
+
+
+export { _sfc_main as default };

package/minilo/es/components/tree-select/index.vue2.mjs

@@ -0,0 +1,226 @@
+import { defineComponent, ref, watch, computed, resolveComponent, createElementBlock, openBlock, normalizeClass, unref, createCommentVNode, createBlock, createElementVNode, createVNode, mergeProps, toHandlers, renderSlot, withCtx, createTextVNode, nextTick } from 'vue';
+import { ElTree, ElMessage } from 'element-plus';
+import { Search as search_default } from '../../node_modules/.pnpm/@element-plus_icons-vue@2.3.1_vue@3.5.26_typescript@5.9.3_/node_modules/@element-plus/icons-vue/dist/index.mjs';
+import { bem } from '../../utils/index.mjs';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "MlTreeSelect"
+  },
+  __name: "index",
+  props: {
+    treeData: { type: Array, required: true },
+    treeProps: { type: Object, required: false, default: () => ({ label: "label", children: "children" }) },
+    multiple: { type: Boolean, required: false, default: false },
+    defaultExpandAll: { type: Boolean, required: false, default: true },
+    defaultSelectedKeys: { type: Array, required: false, default: () => [] },
+    nodeKey: { type: String, required: false, default: "id" },
+    showSearch: { type: Boolean, required: false, default: true },
+    expandOnClickNode: { type: Boolean, required: false },
+    placeholder: { type: String, required: false, default: "\u8BF7\u8F93\u5165\u5173\u952E\u8BCD\u641C\u7D22" }
+  },
+  emits: ["confirm", "cancel", "input"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const searchKeyword = ref("");
+    const treeRef = ref();
+    const selectedKeys = ref([]);
+    const selectedData = ref(props.multiple ? [] : {});
+    const initSelection = () => {
+      selectedKeys.value = [...props.defaultSelectedKeys];
+      nextTick(() => {
+        if (treeRef.value) {
+          if (props.multiple) {
+            treeRef.value.setCheckedKeys(props.defaultSelectedKeys);
+          } else {
+            treeRef.value.setCurrentKey(props.defaultSelectedKeys[0]);
+          }
+        }
+      });
+    };
+    watch(
+      () => props.defaultSelectedKeys,
+      () => {
+        initSelection();
+      },
+      { immediate: true }
+    );
+    const filteredTreeData = computed(() => {
+      if (!searchKeyword.value) return props.treeData;
+      const filterNode = (nodes) => {
+        return nodes.map((node) => {
+          const children = filterNode(node[props.treeProps.children || "children"] || []);
+          const isMatch = node[props.treeProps.label || "label"].includes(
+            searchKeyword.value
+          );
+          if (isMatch || children.length > 0) {
+            return { ...node, [props.treeProps.children || "children"]: children };
+          }
+          return null;
+        }).filter(Boolean);
+      };
+      return filterNode(props.treeData);
+    });
+    const handleCheckChange = (data, checked) => {
+      const nodeKeyField = props.nodeKey;
+      if (checked) {
+        selectedKeys.value.push(data[nodeKeyField]);
+        if (Array.isArray(selectedData.value)) {
+          selectedData.value.push(data);
+        }
+      } else {
+        selectedKeys.value = selectedKeys.value.filter((key) => key !== data[nodeKeyField]);
+        if (Array.isArray(selectedData.value)) {
+          selectedData.value = selectedData.value.filter(
+            (item) => item[nodeKeyField] !== data[nodeKeyField]
+          );
+        }
+      }
+    };
+    const handleNodeClick = (data) => {
+      if (!props.multiple) {
+        const nodeKeyField = props.nodeKey;
+        selectedKeys.value = [data[nodeKeyField]];
+        selectedData.value = data;
+      }
+    };
+    const reset = () => {
+      searchKeyword.value = "";
+      selectedKeys.value = [];
+      selectedData.value = props.multiple ? [] : {};
+      if (treeRef.value) {
+        if (props.multiple) {
+          treeRef.value.setCheckedKeys([]);
+        } else {
+          treeRef.value.setCurrentKey(void 0);
+        }
+      }
+    };
+    const getSelectedData = () => selectedData.value;
+    const getSelectedKeys = () => selectedKeys.value;
+    const handleConfirm = () => {
+      if (selectedKeys.value.length === 0) {
+        ElMessage.warning("\u8BF7\u9009\u62E9\u81F3\u5C11\u4E00\u4E2A\u8282\u70B9");
+        return;
+      }
+      emit("confirm", selectedData.value);
+    };
+    const handleCancel = () => {
+      emit("cancel");
+    };
+    __expose({
+      reset,
+      getSelectedData,
+      getSelectedKeys,
+      // el-tree 方法透传
+      getCheckedNodes: () => treeRef.value?.getCheckedNodes() || [],
+      getCheckedKeys: () => treeRef.value?.getCheckedKeys() || [],
+      getHalfCheckedNodes: () => treeRef.value?.getHalfCheckedNodes() || [],
+      getHalfCheckedKeys: () => treeRef.value?.getHalfCheckedKeys() || [],
+      getCurrentKey: () => treeRef.value?.getCurrentKey() ?? void 0,
+      getCurrentNode: () => treeRef.value?.getCurrentNode(),
+      setCheckedKeys: (keys) => treeRef.value?.setCheckedKeys(keys),
+      setCheckedNodes: (nodes) => treeRef.value?.setCheckedNodes(nodes),
+      setCurrentKey: (key) => treeRef.value?.setCurrentKey(key),
+      setCurrentNode: (node) => treeRef.value?.setCurrentNode(node),
+      getNode: (key) => treeRef.value?.getNode(key),
+      filter: (value) => treeRef.value?.filter(value),
+      updateKeyChildren: (key, children) => treeRef.value?.updateKeyChildren(key, children),
+      remove: (node) => treeRef.value?.remove(node),
+      append: (data, parentNode) => treeRef.value?.append(data, parentNode),
+      insertBefore: (data, refNode) => treeRef.value?.insertBefore(data, refNode),
+      insertAfter: (data, refNode) => treeRef.value?.insertAfter(data, refNode),
+      //
+      input: (value) => emit("input", value)
+    });
+    return (_ctx, _cache) => {
+      const _component_el_input = resolveComponent("el-input");
+      const _component_el_button = resolveComponent("el-button");
+      return openBlock(), createElementBlock(
+        "div",
+        {
+          class: normalizeClass(unref(bem)("tree-select"))
+        },
+        [
+          createCommentVNode(" \u641C\u7D22\u6846 "),
+          __props.showSearch ? (openBlock(), createBlock(_component_el_input, {
+            key: 0,
+            modelValue: searchKeyword.value,
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => searchKeyword.value = $event),
+            placeholder: __props.placeholder,
+            clearable: "",
+            "prefix-icon": unref(search_default),
+            class: normalizeClass(unref(bem)("tree-select", "search")),
+            onInput: _cache[1] || (_cache[1] = (value) => emit("input", value))
+          }, null, 8, ["modelValue", "placeholder", "prefix-icon", "class"])) : createCommentVNode("v-if", true),
+          createCommentVNode(" \u6811\u5F62\u9009\u62E9 "),
+          createElementVNode(
+            "div",
+            {
+              class: normalizeClass(unref(bem)("tree-select", "tree"))
+            },
+            [
+              createVNode(unref(ElTree), mergeProps({
+                ref_key: "treeRef",
+                ref: treeRef,
+                data: filteredTreeData.value,
+                props: __props.treeProps,
+                "show-checkbox": __props.multiple,
+                "default-expand-all": __props.defaultExpandAll,
+                "expand-on-click-node": __props.expandOnClickNode,
+                "node-key": __props.nodeKey,
+                onCheckChange: handleCheckChange,
+                onNodeClick: handleNodeClick
+              }, _ctx.$attrs, toHandlers(_ctx.$attrs)), null, 16, ["data", "props", "show-checkbox", "default-expand-all", "expand-on-click-node", "node-key"])
+            ],
+            2
+            /* CLASS */
+          ),
+          createCommentVNode(" \u5E95\u90E8\u6309\u94AE\u63D2\u69FD "),
+          createElementVNode(
+            "div",
+            {
+              class: normalizeClass(unref(bem)("tree-select", "footer"))
+            },
+            [
+              renderSlot(_ctx.$slots, "footer", {}, () => [
+                createVNode(_component_el_button, { onClick: handleCancel }, {
+                  default: withCtx(() => [..._cache[2] || (_cache[2] = [
+                    createTextVNode(
+                      "\u53D6\u6D88",
+                      -1
+                      /* CACHED */
+                    )
+                  ])]),
+                  _: 1
+                  /* STABLE */
+                }),
+                createVNode(_component_el_button, {
+                  type: "primary",
+                  onClick: handleConfirm
+                }, {
+                  default: withCtx(() => [..._cache[3] || (_cache[3] = [
+                    createTextVNode(
+                      "\u786E\u5B9A",
+                      -1
+                      /* CACHED */
+                    )
+                  ])]),
+                  _: 1
+                  /* STABLE */
+                })
+              ])
+            ],
+            2
+            /* CLASS */
+          )
+        ],
+        2
+        /* CLASS */
+      );
+    };
+  }
+});
+
+export { _sfc_main as default };

package/minilo/es/components/tree-select/type.d.ts

@@ -0,0 +1,34 @@
+export interface TreeSelectProps<T = any> {
+    treeData: T[];
+    treeProps?: Record<string, any>;
+    multiple?: boolean;
+    defaultExpandAll?: boolean;
+    defaultSelectedKeys?: any[];
+    nodeKey?: string;
+    showSearch?: boolean;
+    expandOnClickNode?: boolean;
+    placeholder?: string;
+}
+export interface TreeSelectExpose {
+    reset: () => void;
+    getSelectedData: () => any;
+    getSelectedKeys: () => any[];
+    getCheckedNodes: () => any[];
+    getCheckedKeys: () => any[];
+    getHalfCheckedNodes: () => any[];
+    getHalfCheckedKeys: () => any[];
+    getCurrentKey: () => string | number | undefined;
+    getCurrentNode: () => any;
+    setCheckedKeys: (keys: any[]) => void;
+    setCheckedNodes: (nodes: any[]) => void;
+    setCurrentKey: (key: string | number | undefined) => void;
+    setCurrentNode: (node: any) => void;
+    getNode: (key: string | number) => any;
+    filter: (value: string) => void;
+    updateKeyChildren: (key: string | number, children: any[]) => void;
+    remove: (node: any) => void;
+    append: (data: any, parentNode?: any) => void;
+    insertBefore: (data: any, refNode: any) => void;
+    insertAfter: (data: any, refNode: any) => void;
+    input: (value: string) => void;
+}

package/minilo/es/components/tree-select/type.mjs

@@ -0,0 +1 @@
+

package/minilo/es/components/tree-select-dialog/index.d.ts

@@ -0,0 +1,60 @@
+export declare const MlTreeSelectDialog: <T = any>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    slots: {};
+    attrs: any;
+    emit: (((evt: "input", value: string) => void) & ((evt: "confirm", selectedData: T | T[]) => void) & ((evt: "close") => void)) & ((evt: "update:modelValue", value: boolean) => void);
+}, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+        readonly onInput?: (value: string) => any;
+        readonly "onUpdate:modelValue"?: (value: boolean) => any;
+        readonly onClose?: () => any;
+        readonly onConfirm?: (selectedData: T | T[]) => any;
+        modelValue?: boolean;
+        treeData: T[];
+        treeProps?: Record<string, any>;
+        multiple?: boolean;
+        defaultExpandAll?: boolean;
+        defaultSelectedKeys?: any[];
+        nodeKey?: string;
+        showSearch?: boolean;
+        expandOnClickNode?: boolean;
+        placeholder?: string;
+        title?: string;
+        width?: string;
+        readonly overflow?: boolean;
+        readonly center?: boolean;
+        readonly appendTo?: string | HTMLElement;
+        readonly showClose?: boolean;
+        readonly draggable?: boolean;
+        readonly appendToBody?: boolean;
+        readonly destroyOnClose?: boolean;
+        readonly closeOnClickModal?: boolean;
+        readonly closeOnPressEscape?: boolean;
+        readonly lockScroll?: boolean;
+        readonly modal?: boolean;
+        readonly openDelay?: number;
+        readonly closeDelay?: number;
+        readonly trapFocus?: boolean;
+        readonly headerAriaLevel?: string;
+        readonly alignCenter?: boolean;
+        readonly fullscreen?: boolean;
+        readonly ariaLevel?: string;
+        readonly top?: string;
+        readonly zIndex?: number;
+        readonly beforeClose?: import('element-plus').DialogBeforeCloseFn;
+        readonly modalClass?: string;
+        readonly headerClass?: string;
+        readonly bodyClass?: string;
+        readonly footerClass?: string;
+        readonly closeIcon?: unknown;
+    } & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        input: (value: string) => void;
+    }>): void;
+    attrs: any;
+    slots: {};
+    emit: (((evt: "input", value: string) => void) & ((evt: "confirm", selectedData: T | T[]) => void) & ((evt: "close") => void)) & ((evt: "update:modelValue", value: boolean) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default MlTreeSelectDialog;
+export * from './type';

package/minilo/es/components/tree-select-dialog/index.mjs

@@ -0,0 +1,7 @@
+import { withInstall } from '../../utils/index.mjs';
+import _sfc_main from './index.vue2.mjs';
+export { dialogPropKeys } from './type.mjs';
+
+const MlTreeSelectDialog = withInstall(_sfc_main);
+
+export { MlTreeSelectDialog, MlTreeSelectDialog as default };

package/minilo/es/components/tree-select-dialog/index.vue.d.ts

@@ -0,0 +1,23 @@
+import { TreeSelectDialogProps } from './type';
+declare const _default: <T = any>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onInput?: (value: string) => any;
+        readonly "onUpdate:modelValue"?: (value: boolean) => any;
+        readonly onConfirm?: (selectedData: T | T[]) => any;
+        readonly onClose?: () => any;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onInput" | "onUpdate:modelValue" | "onClose" | "onConfirm"> & ({
+        modelValue?: boolean;
+    } & TreeSelectDialogProps<T>) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        input: (value: string) => void;
+    }>): void;
+    attrs: any;
+    slots: {};
+    emit: (((evt: "input", value: string) => void) & ((evt: "confirm", selectedData: T | T[]) => void) & ((evt: "close") => void)) & ((evt: "update:modelValue", value: boolean) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/minilo/es/components/tree-select-dialog/index.vue.mjs

@@ -0,0 +1,5 @@
+import _sfc_main from './index.vue2.mjs';
+
+
+
+export { _sfc_main as default };