@maxax/ui 1.0.3 → 1.0.6

package/dist/components/tree-drop/TreeDrop.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TreeDrop.vue.d.ts","sourceRoot":"","sources":["../../../src/components/tree-drop/TreeDrop.vue"],"names":[],"mappings":"AAGA;AAGA,OAAO,KAAK,EAAqB,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAC3E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAM7C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAuQhD,iBAAS,cAAc,uCAiM+D,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAE3D,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QACH,GAAG;mBACL,GAAG;EAG9B;AAgCD,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EAQnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAAvG,wBAAwG;AACxG,KAAK,sBAAsB,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,CAAC,CAAC;AACjE,KAAK,6BAA6B,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,EAAE,SAAS,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG;QAAE,IAAI,EAAE,OAAO,KAAK,EAAE,QAAQ,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;KAAE,GAAG;QAAE,IAAI,EAAE,OAAO,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAAC,QAAQ,EAAE,IAAI,CAAA;KAAE;CAAE,CAAC;AAC9M,KAAK,kBAAkB,CAAC,CAAC,EAAE,CAAC,IAAI;KAE1B,CAAC,IAAI,MAAM,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,SAAS,MAAM,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG;QACxE,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;KACb,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACT,CAAC;AACN,KAAK,cAAc,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAG,GAAG,EAAE,CAAC;AACxD,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAAE,QAAO;QAClD,MAAM,EAAE,CAAC,CAAC;KACT,CAAA;CAAE,CAAC"}
+{"version":3,"file":"TreeDrop.vue.d.ts","sourceRoot":"","sources":["../../../src/components/tree-drop/TreeDrop.vue"],"names":[],"mappings":"AAGA;AAqTA,OAAO,EAAY,QAAQ,EAA6C,MAAM,KAAK,CAAA;AACnF,OAAO,KAAK,EAAqB,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAC3E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAM7C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqbhD,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/tree-drop/composable/use-tree-drop-cls.d.ts

@@ -1,6 +1,5 @@
 import { Ref } from 'vue';
 import { TreeDropProps } from '../interface';
-
 export declare const useTreeDropCls: (props: TreeDropProps, options: {
     dropdownVisible: Ref<boolean>;
     checkedCount: Ref<number>;

package/dist/components/tree-drop/composable/use-tree-drop-cls.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-tree-drop-cls.d.ts","sourceRoot":"","sources":["../../../../src/components/tree-drop/composable/use-tree-drop-cls.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAG9B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAEjD,eAAO,MAAM,cAAc,GACzB,OAAO,aAAa,EACpB,SAAS;IACP,eAAe,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IAC7B,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACzB,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAC3B;;;;;;;;;;;;;;CAuEF,CAAA"}
+{"version":3,"file":"use-tree-drop-cls.d.ts","sourceRoot":"","sources":["../../../../src/components/tree-drop/composable/use-tree-drop-cls.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAG9B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAEjD,eAAO,MAAM,cAAc,UAClB,aAAa,WACX;IACP,eAAe,EAAE,IAAI,OAAO,CAAC,CAAA;IAC7B,YAAY,EAAE,IAAI,MAAM,CAAC,CAAA;IACzB,aAAa,EAAE,IAAI,MAAM,CAAC,CAAA;CAC3B;;;;;;;;;;;;;;CAuEF,CAAA"}

package/dist/components/tree-drop/index.d.ts

@@ -1,6 +1,5 @@
 import { SFCWithInstall } from '@maxax/utils';
 import { default as TreeDrop } from './TreeDrop.vue';
-
 export declare const XTreeDrop: SFCWithInstall<typeof TreeDrop>;
 export type TreeDropInstance = InstanceType<typeof TreeDrop>;
 export default XTreeDrop;

package/dist/components/tree-drop/interface.d.ts

@@ -1,6 +1,5 @@
 import { TreeSearchProps } from '../tree-search/interface';
 import { PlacementEnum } from './constants';
-
 export type PlacementType = keyof typeof PlacementEnum;
 export type TreeDropProps = TreeSearchProps & {
     /** 下拉内容高度 */

package/dist/components/tree-node/TreeNode.vue.d.ts

@@ -1,23 +1,13 @@
 import { TreeNode } from '../tree/store';
 import { TreeNodeProps } from './interface';
-
-declare function __VLS_template(): {
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<TreeNodeProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TreeNodeProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    nodeBody: HTMLDivElement;
+}, HTMLDivElement>, {
     default?(_: {
         node: TreeNode;
     }): any;
-};
-declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<TreeNodeProps>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<TreeNodeProps>>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+}>;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToRuntimeProps<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/components/tree-node/TreeNode.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TreeNode.vue.d.ts","sourceRoot":"","sources":["../../../src/components/tree-node/TreeNode.vue"],"names":[],"mappings":"AAGA;AAOA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAE7C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AA+MhD,iBAAS,cAAc;;;QA+QO,GAAG;EAKhC;AAqCD,QAAA,MAAM,eAAe,maAOnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAAvG,wBAAwG;AACxG,KAAK,sBAAsB,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,CAAC,CAAC;AACjE,KAAK,6BAA6B,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,EAAE,SAAS,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG;QAAE,IAAI,EAAE,OAAO,KAAK,EAAE,QAAQ,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;KAAE,GAAG;QAAE,IAAI,EAAE,OAAO,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAAC,QAAQ,EAAE,IAAI,CAAA;KAAE;CAAE,CAAC;AAC9M,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAAE,QAAO;QAClD,MAAM,EAAE,CAAC,CAAC;KACT,CAAA;CAAE,CAAC"}
+{"version":3,"file":"TreeNode.vue.d.ts","sourceRoot":"","sources":["../../../src/components/tree-node/TreeNode.vue"],"names":[],"mappings":"AAGA;AAoRA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAE7C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;;;;;;;;AAuZhD,wBAAoG;AAQpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/tree-node/composable/use-tree-node-cls.d.ts

@@ -1,6 +1,5 @@
 import { Ref } from 'vue';
 import { TreeNodeProps } from '../interface';
-
 export declare const useTreeNodeCls: (props: TreeNodeProps, dragoverRefs: {
     dragoverBody: Ref<boolean>;
     dragoverBefore: Ref<boolean>;

package/dist/components/tree-node/composable/use-tree-node-cls.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-tree-node-cls.d.ts","sourceRoot":"","sources":["../../../../src/components/tree-node/composable/use-tree-node-cls.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAG9B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAEjD,eAAO,MAAM,cAAc,GACzB,OAAO,aAAa,EACpB,cAAc;IACZ,YAAY,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IAC1B,cAAc,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IAC5B,aAAa,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;CAC5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyGF,CAAA"}
+{"version":3,"file":"use-tree-node-cls.d.ts","sourceRoot":"","sources":["../../../../src/components/tree-node/composable/use-tree-node-cls.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAG9B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAEjD,eAAO,MAAM,cAAc,UAClB,aAAa,gBACN;IACZ,YAAY,EAAE,IAAI,OAAO,CAAC,CAAA;IAC1B,cAAc,EAAE,IAAI,OAAO,CAAC,CAAA;IAC5B,aAAa,EAAE,IAAI,OAAO,CAAC,CAAA;CAC5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyGF,CAAA"}

package/dist/components/tree-node/index.d.ts

@@ -1,6 +1,5 @@
 import { SFCWithInstall } from '@maxax/utils';
 import { default as TreeNode } from './TreeNode.vue';
-
 export declare const XTreeNode: SFCWithInstall<typeof TreeNode>;
 export type TreeNodeInstance = InstanceType<typeof TreeNode>;
 export default XTreeNode;

package/dist/components/tree-node/interface.d.ts

@@ -1,6 +1,5 @@
 import { TreeNodeKeyType, TreeProps } from '../tree/interface';
 import { TreeNode } from '../tree/store';
-
 export type GetNodeFn = (_key: TreeNodeKeyType) => TreeNode | null;
 type PickedProps = Required<Pick<TreeProps, 'titleField' | 'keyField' | 'checkable' | 'selectable' | 'unselectOnClick' | 'disableAll' | 'draggable' | 'droppable' | 'nodeIndent'>> & Pick<TreeProps, 'render' | 'showLine' | 'showLeftArrow' | 'showRightArrow'>;
 export type TreeNodeProps = PickedProps & {

package/dist/components/tree-search/TreeSearch.vue.d.ts

@@ -1,64 +1,18 @@
 import { TreeNode } from '../tree';
 import { TreeSearchProps } from './interface';
-
 declare function clearKeyword(): void;
 /** 获取搜索关键字 */
 declare function getKeyword(): string;
 /** 执行搜索 */
 declare function search(keyword1?: string): Promise<void>;
-declare function __VLS_template(): Partial<Record<string, (_: any) => any>> & {
-    "search-input"?(_: {}): any;
-    actions?(_: {}): any;
-    footer?(_: {}): any;
-};
-declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<TreeSearchProps>, {
-    searchPlaceholder: string;
-    showCheckAll: boolean;
-    showCheckedButton: boolean;
-    checkedButtonText: string;
-    showFooter: boolean;
-    searchLength: number;
-    searchDisabled: boolean;
-    searchRemote: boolean;
-    searchDebounceTime: number;
-    showLeftArrow: boolean;
-    showRightArrow: boolean;
-    data: () => never[];
-    unloadDataList: () => never[];
-    showUnloadCheckedNodes: boolean;
-    emptyText: string;
-    titleField: string;
-    keyField: string;
-    separator: string;
-    checkable: boolean;
-    selectable: boolean;
-    filteredNodeCheckable: boolean;
-    cascade: boolean;
-    enableLeafOnly: boolean;
-    disableAll: boolean;
-    defaultExpandAll: boolean;
-    defaultExpandedKeys: () => never[];
-    expandedKeys: () => never[];
-    draggable: boolean;
-    droppable: boolean;
-    beforeDropMethod: () => () => boolean;
-    ignoreMode: import('../tree/constants').ignoreEnum;
-    autoLoad: boolean;
-    expandOnFilter: boolean;
-    unselectOnClick: boolean;
-    loading: boolean;
-    nodeMinHeight: number;
-    nodeIndent: number;
-    renderNodeAmount: number;
-    bufferNodeAmount: number;
-}>>, {
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<TreeSearchProps, {
     clearKeyword: typeof clearKeyword;
     getKeyword: typeof getKeyword;
     search: typeof search;
-    filter: (keyword: string, filterMethod?: import('../tree').FilterFunctionType) => void;
-    scrollTo: (key: import('../tree').TreeNodeKeyType, verticalPosition?: import('../tree/constants').VerticalPositionType | number) => void;
-    append: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, parentKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
+    filter: (keyword: string, filterMethod?: import('../tree').FilterFunctionType | undefined) => void;
     remove: (removedKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
+    scrollTo: (key: import('../tree').TreeNodeKeyType, verticalPosition?: number | "bottom" | "top" | "center") => void;
+    append: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, parentKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
     insertBefore: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, referenceKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
     prepend: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, parentKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
     clearSelected: () => void;
@@ -71,8 +25,8 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
     setExpand: (key: import('../tree').TreeNodeKeyType, value: boolean, expandParent?: boolean) => void;
     setExpandKeys: (keys: import('../tree').TreeNodeKeyType[], value: boolean) => void;
     setExpandAll: (value: boolean) => void;
-    getCheckedNodes: (ignoreMode?: import('../tree').IgnoreType) => TreeNode[];
-    getCheckedKeys: (ignoreMode?: import('../tree').IgnoreType) => import('../tree').TreeNodeKeyType[];
+    getCheckedNodes: (ignoreMode?: "none" | "children" | "parents" | undefined) => TreeNode[];
+    getCheckedKeys: (ignoreMode?: "none" | "children" | "parents" | undefined) => import('../tree').TreeNodeKeyType[];
     getIndeterminateNodes: () => TreeNode[];
     getSelectedNode: () => TreeNode | null;
     getSelectedKey: () => import('../tree').TreeNodeKeyType | null;
@@ -84,51 +38,11 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
     getFlatData: () => TreeNode[];
     getNodesCount: () => number;
     insertAfter: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, referenceKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
-    showCheckedNodes: (showUnloadCheckedNodes?: boolean) => void;
+    showCheckedNodes: (showUnloadCheckedNodes?: boolean | undefined) => void;
     loadRootNodes: () => Promise<void>;
     updateNode: (key: import('../tree').TreeNodeKeyType, newNode: import('../tree').ITreeNodeOptions) => void;
     updateNodes: (newNodes: import('../tree').ITreeNodeOptions[]) => void;
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<TreeSearchProps>, {
-    searchPlaceholder: string;
-    showCheckAll: boolean;
-    showCheckedButton: boolean;
-    checkedButtonText: string;
-    showFooter: boolean;
-    searchLength: number;
-    searchDisabled: boolean;
-    searchRemote: boolean;
-    searchDebounceTime: number;
-    showLeftArrow: boolean;
-    showRightArrow: boolean;
-    data: () => never[];
-    unloadDataList: () => never[];
-    showUnloadCheckedNodes: boolean;
-    emptyText: string;
-    titleField: string;
-    keyField: string;
-    separator: string;
-    checkable: boolean;
-    selectable: boolean;
-    filteredNodeCheckable: boolean;
-    cascade: boolean;
-    enableLeafOnly: boolean;
-    disableAll: boolean;
-    defaultExpandAll: boolean;
-    defaultExpandedKeys: () => never[];
-    expandedKeys: () => never[];
-    draggable: boolean;
-    droppable: boolean;
-    beforeDropMethod: () => () => boolean;
-    ignoreMode: import('../tree/constants').ignoreEnum;
-    autoLoad: boolean;
-    expandOnFilter: boolean;
-    unselectOnClick: boolean;
-    loading: boolean;
-    nodeMinHeight: number;
-    nodeIndent: number;
-    renderNodeAmount: number;
-    bufferNodeAmount: number;
-}>>> & Readonly<{}>, {
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TreeSearchProps> & Readonly<{}>, {
     data: import('../tree').AnyPropsArrayType;
     loading: boolean;
     searchPlaceholder: string;
@@ -143,7 +57,7 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
     defaultExpandedKeys: import('../tree').TreeNodeKeyType[];
     checkable: boolean;
     emptyText: string;
-    ignoreMode: import('../tree').IgnoreType;
+    ignoreMode: "none" | "children" | "parents";
     filteredNodeCheckable: boolean;
     expandOnFilter: boolean;
     showLeftArrow: boolean;
@@ -168,26 +82,238 @@ declare const __VLS_component: import('vue').DefineComponent<import('vue').Extra
     searchDisabled: boolean;
     searchRemote: boolean;
     searchDebounceTime: number;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    treeRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly showLeftArrow?: boolean | undefined;
+            readonly showRightArrow?: boolean | undefined;
+            readonly data?: import('../tree').AnyPropsArrayType | undefined;
+            readonly emptyText?: string | undefined;
+            readonly modelValue?: string | number | import('../tree').TreeNodeKeyType[] | undefined;
+            readonly selectable?: boolean | undefined;
+            readonly checkable?: boolean | undefined;
+            readonly separator?: string | undefined;
+            readonly ignoreMode?: "none" | "children" | "parents" | undefined;
+            readonly titleField?: string | undefined;
+            readonly keyField?: string | undefined;
+            readonly filterMethod?: import('../tree').FilterFunctionType | undefined;
+            readonly showUnloadCheckedNodes?: boolean | undefined;
+            readonly unloadDataList?: import('../tree').AnyPropsArrayType | undefined;
+            readonly load?: import('../tree').LoadFn | undefined;
+            readonly filteredNodeCheckable?: boolean | undefined;
+            readonly cascade?: boolean | undefined;
+            readonly enableLeafOnly?: boolean | undefined;
+            readonly disableAll?: boolean | undefined;
+            readonly defaultExpandAll?: boolean | undefined;
+            readonly defaultExpandedKeys?: import('../tree').TreeNodeKeyType[] | undefined;
+            readonly expandedKeys?: import('../tree').TreeNodeKeyType[] | undefined;
+            readonly draggable?: boolean | undefined;
+            readonly droppable?: boolean | undefined;
+            readonly beforeDropMethod?: ((dragKey: import('../tree').TreeNodeKeyType, dropKey: import('../tree').TreeNodeKeyType, hoverPart: import('../tree/constants').dragHoverPartEnum) => boolean) | undefined;
+            readonly autoLoad?: boolean | undefined;
+            readonly render?: ((node: TreeNode) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                [key: string]: any;
+            }>) | undefined;
+            readonly expandOnFilter?: boolean | undefined;
+            readonly unselectOnClick?: boolean | undefined;
+            readonly loading?: boolean | undefined;
+            readonly nodeClassName?: string | object | (string | object)[] | ((node: TreeNode) => string | object | (string | object)[]) | undefined;
+            readonly showLine?: boolean | import('../tree').ShowLine | undefined;
+            readonly animation?: boolean | undefined;
+            readonly nodeIndent?: number | undefined;
+            readonly renderNodeAmount?: number | undefined;
+            readonly nodeMinHeight?: number | undefined;
+            readonly bufferNodeAmount?: number | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            scrollArea: HTMLDivElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null;
+        $parent: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('../tree').TreeProps> & Readonly<{}>, {
+            setData: (data: import('../tree').AnyPropsArrayType) => void;
+            setChecked: (key: import('../tree').TreeNodeKeyType, value: boolean) => void;
+            setCheckedKeys: (keys: import('../tree').TreeNodeKeyType[], value: boolean) => void;
+            checkAll: () => void;
+            clearChecked: () => void;
+            setSelected: (key: import('../tree').TreeNodeKeyType, value: boolean) => void;
+            clearSelected: () => void;
+            setExpand: (key: import('../tree').TreeNodeKeyType, value: boolean, expandParent?: boolean) => void;
+            setExpandKeys: (keys: import('../tree').TreeNodeKeyType[], value: boolean) => void;
+            setExpandAll: (value: boolean) => void;
+            getCheckedNodes: (ignoreMode?: "none" | "children" | "parents" | undefined) => TreeNode[];
+            getCheckedKeys: (ignoreMode?: "none" | "children" | "parents" | undefined) => import('../tree').TreeNodeKeyType[];
+            getIndeterminateNodes: () => TreeNode[];
+            getSelectedNode: () => TreeNode | null;
+            getSelectedKey: () => import('../tree').TreeNodeKeyType | null;
+            getExpandNodes: () => TreeNode[];
+            getExpandKeys: () => import('../tree').TreeNodeKeyType[];
+            getCurrentVisibleNodes: () => TreeNode[];
+            getNode: (key: import('../tree').TreeNodeKeyType) => TreeNode | null;
+            getTreeData: () => TreeNode[];
+            getFlatData: () => TreeNode[];
+            getNodesCount: () => number;
+            insertBefore: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, referenceKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
+            insertAfter: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, referenceKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
+            append: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, parentKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
+            prepend: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, parentKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
+            remove: (removedKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
+            filter: (keyword: string, filterMethod?: import('../tree').FilterFunctionType | undefined) => void;
+            showCheckedNodes: (showUnloadCheckedNodes?: boolean | undefined) => void;
+            loadRootNodes: () => Promise<void>;
+            updateNode: (key: import('../tree').TreeNodeKeyType, newNode: import('../tree').ITreeNodeOptions) => void;
+            updateNodes: (newNodes: import('../tree').ITreeNodeOptions[]) => void;
+            scrollTo: (key: import('../tree').TreeNodeKeyType, verticalPosition?: number | "bottom" | "top" | "center") => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+            data: import('../tree').AnyPropsArrayType;
+            loading: boolean;
+            draggable: boolean;
+            separator: string;
+            cascade: boolean;
+            defaultExpandAll: boolean;
+            expandedKeys: import('../tree').TreeNodeKeyType[];
+            keyField: string;
+            defaultExpandedKeys: import('../tree').TreeNodeKeyType[];
+            checkable: boolean;
+            emptyText: string;
+            ignoreMode: "none" | "children" | "parents";
+            filteredNodeCheckable: boolean;
+            expandOnFilter: boolean;
+            showLeftArrow: boolean;
+            showRightArrow: boolean;
+            selectable: boolean;
+            titleField: string;
+            showUnloadCheckedNodes: boolean;
+            unloadDataList: import('../tree').AnyPropsArrayType;
+            enableLeafOnly: boolean;
+            disableAll: boolean;
+            droppable: boolean;
+            beforeDropMethod: (dragKey: import('../tree').TreeNodeKeyType, dropKey: import('../tree').TreeNodeKeyType, hoverPart: import('../tree/constants').dragHoverPartEnum) => boolean;
+            autoLoad: boolean;
+            unselectOnClick: boolean;
+            nodeIndent: number;
+            renderNodeAmount: number;
+            nodeMinHeight: number;
+            bufferNodeAmount: number;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+            created?: ((() => void) | (() => void)[]) | undefined;
+            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+            mounted?: ((() => void) | (() => void)[]) | undefined;
+            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+            updated?: ((() => void) | (() => void)[]) | undefined;
+            activated?: ((() => void) | (() => void)[]) | undefined;
+            deactivated?: ((() => void) | (() => void)[]) | undefined;
+            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+            destroyed?: ((() => void) | (() => void)[]) | undefined;
+            unmounted?: ((() => void) | (() => void)[]) | undefined;
+            renderTracked?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
+            renderTriggered?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
+            errorCaptured?: (((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null, info: string) => boolean | void)[]) | undefined;
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R, args_2: import('@vue/reactivity').OnCleanup) => any : (args_0: any, args_1: any, args_2: import('@vue/reactivity').OnCleanup) => any, options?: import('vue').WatchOptions<boolean> | undefined): import('vue').WatchStopHandle;
+    } & Readonly<{
+        data: import('../tree').AnyPropsArrayType;
+        loading: boolean;
+        draggable: boolean;
+        separator: string;
+        cascade: boolean;
+        defaultExpandAll: boolean;
+        expandedKeys: import('../tree').TreeNodeKeyType[];
+        keyField: string;
+        defaultExpandedKeys: import('../tree').TreeNodeKeyType[];
+        checkable: boolean;
+        emptyText: string;
+        ignoreMode: "none" | "children" | "parents";
+        filteredNodeCheckable: boolean;
+        expandOnFilter: boolean;
+        showLeftArrow: boolean;
+        showRightArrow: boolean;
+        selectable: boolean;
+        titleField: string;
+        showUnloadCheckedNodes: boolean;
+        unloadDataList: import('../tree').AnyPropsArrayType;
+        enableLeafOnly: boolean;
+        disableAll: boolean;
+        droppable: boolean;
+        beforeDropMethod: (dragKey: import('../tree').TreeNodeKeyType, dropKey: import('../tree').TreeNodeKeyType, hoverPart: import('../tree/constants').dragHoverPartEnum) => boolean;
+        autoLoad: boolean;
+        unselectOnClick: boolean;
+        nodeIndent: number;
+        renderNodeAmount: number;
+        nodeMinHeight: number;
+        bufferNodeAmount: number;
+    }> & Omit<Readonly<import('../tree').TreeProps> & Readonly<{}>, "filter" | "remove" | "scrollTo" | "append" | "insertBefore" | "prepend" | "clearSelected" | "setData" | "setChecked" | "setCheckedKeys" | "checkAll" | "clearChecked" | "setSelected" | "setExpand" | "setExpandKeys" | "setExpandAll" | "getCheckedNodes" | "getCheckedKeys" | "getIndeterminateNodes" | "getSelectedNode" | "getSelectedKey" | "getExpandNodes" | "getExpandKeys" | "getCurrentVisibleNodes" | "getNode" | "getTreeData" | "getFlatData" | "getNodesCount" | "insertAfter" | "showCheckedNodes" | "loadRootNodes" | "updateNode" | "updateNodes" | ("data" | "loading" | "draggable" | "separator" | "cascade" | "defaultExpandAll" | "expandedKeys" | "keyField" | "defaultExpandedKeys" | "checkable" | "emptyText" | "ignoreMode" | "filteredNodeCheckable" | "expandOnFilter" | "showLeftArrow" | "showRightArrow" | "selectable" | "titleField" | "showUnloadCheckedNodes" | "unloadDataList" | "enableLeafOnly" | "disableAll" | "droppable" | "beforeDropMethod" | "autoLoad" | "unselectOnClick" | "nodeIndent" | "renderNodeAmount" | "nodeMinHeight" | "bufferNodeAmount")> & import('vue').ShallowUnwrapRef<{
+        setData: (data: import('../tree').AnyPropsArrayType) => void;
+        setChecked: (key: import('../tree').TreeNodeKeyType, value: boolean) => void;
+        setCheckedKeys: (keys: import('../tree').TreeNodeKeyType[], value: boolean) => void;
+        checkAll: () => void;
+        clearChecked: () => void;
+        setSelected: (key: import('../tree').TreeNodeKeyType, value: boolean) => void;
+        clearSelected: () => void;
+        setExpand: (key: import('../tree').TreeNodeKeyType, value: boolean, expandParent?: boolean) => void;
+        setExpandKeys: (keys: import('../tree').TreeNodeKeyType[], value: boolean) => void;
+        setExpandAll: (value: boolean) => void;
+        getCheckedNodes: (ignoreMode?: "none" | "children" | "parents" | undefined) => TreeNode[];
+        getCheckedKeys: (ignoreMode?: "none" | "children" | "parents" | undefined) => import('../tree').TreeNodeKeyType[];
+        getIndeterminateNodes: () => TreeNode[];
+        getSelectedNode: () => TreeNode | null;
+        getSelectedKey: () => import('../tree').TreeNodeKeyType | null;
+        getExpandNodes: () => TreeNode[];
+        getExpandKeys: () => import('../tree').TreeNodeKeyType[];
+        getCurrentVisibleNodes: () => TreeNode[];
+        getNode: (key: import('../tree').TreeNodeKeyType) => TreeNode | null;
+        getTreeData: () => TreeNode[];
+        getFlatData: () => TreeNode[];
+        getNodesCount: () => number;
+        insertBefore: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, referenceKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
+        insertAfter: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, referenceKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
+        append: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, parentKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
+        prepend: (insertedNode: import('../tree').TreeNodeKeyType | import('../tree').ITreeNodeOptions, parentKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
+        remove: (removedKey: import('../tree').TreeNodeKeyType) => TreeNode | null;
+        filter: (keyword: string, filterMethod?: import('../tree').FilterFunctionType | undefined) => void;
+        showCheckedNodes: (showUnloadCheckedNodes?: boolean | undefined) => void;
+        loadRootNodes: () => Promise<void>;
+        updateNode: (key: import('../tree').TreeNodeKeyType, newNode: import('../tree').ITreeNodeOptions) => void;
+        updateNodes: (newNodes: import('../tree').ITreeNodeOptions[]) => void;
+        scrollTo: (key: import('../tree').TreeNodeKeyType, verticalPosition?: number | "bottom" | "top" | "center") => void;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            node?(_: {
+                node: TreeNode;
+            }): any;
+            node?(_: {
+                node: TreeNode;
+            }): any;
+            node?(_: {
+                node: TreeNode;
+            }): any;
+            empty?(_: {}): any;
+            loading?(_: {}): any;
+        };
+    }) | null;
+}, any>, Partial<Record<string, (_: any) => any>> & {
+    'search-input'?(_: {}): any;
+    actions?(_: {}): any;
+    footer?(_: {}): any;
+}>;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToRuntimeProps<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};
-type __VLS_WithDefaults<P, D> = {
-    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
-        default: D[K];
-    }> : P[K];
-};
-type __VLS_Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/components/tree-search/TreeSearch.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TreeSearch.vue.d.ts","sourceRoot":"","sources":["../../../src/components/tree-search/TreeSearch.vue"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAOvC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AA4DlD,iBAAS,YAAY,IAAI,IAAI,CAE5B;AAED,cAAc;AACd,iBAAS,UAAU,IAAI,MAAM,CAE5B;AAUD,WAAW;AACX,iBAAS,MAAM,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAkChD;AA6HD,iBAAS,cAAc,uCAiN+D,GAAG;4BAEpD,GAAG;qBACV,GAAG;oBACJ,GAAG;EAG/B;AAkCD,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EAQnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAAvG,wBAAwG;AACxG,KAAK,sBAAsB,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,CAAC,CAAC;AACjE,KAAK,6BAA6B,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,EAAE,SAAS,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG;QAAE,IAAI,EAAE,OAAO,KAAK,EAAE,QAAQ,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;KAAE,GAAG;QAAE,IAAI,EAAE,OAAO,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAAC,QAAQ,EAAE,IAAI,CAAA;KAAE;CAAE,CAAC;AAC9M,KAAK,kBAAkB,CAAC,CAAC,EAAE,CAAC,IAAI;KAE1B,CAAC,IAAI,MAAM,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,SAAS,MAAM,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG;QACxE,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;KACb,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACT,CAAC;AACN,KAAK,cAAc,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAG,GAAG,EAAE,CAAC;AACxD,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAAE,QAAO;QAClD,MAAM,EAAE,CAAC,CAAC;KACT,CAAA;CAAE,CAAC"}
+{"version":3,"file":"TreeSearch.vue.d.ts","sourceRoot":"","sources":["../../../src/components/tree-search/TreeSearch.vue"],"names":[],"mappings":"AAqRA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAOvC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AA2DlD,iBAAS,YAAY,IAAI,IAAI,CAE5B;AAED,cAAc;AACd,iBAAS,UAAU,IAAI,MAAM,CAE5B;AAUD,WAAW;AACX,iBAAS,MAAM,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAkChD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqSD,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/tree-search/composable/use-tree-search-cls.d.ts

@@ -1,6 +1,5 @@
 import { Ref } from 'vue';
 import { TreeSearchProps } from '../interface';
-
 export declare const useTreeSearchCls: (props: TreeSearchProps, options: {
     checkAllStatus: {
         checked: boolean;

package/dist/components/tree-search/composable/use-tree-search-cls.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-tree-search-cls.d.ts","sourceRoot":"","sources":["../../../../src/components/tree-search/composable/use-tree-search-cls.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAG9B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAEnD,eAAO,MAAM,gBAAgB,GAC3B,OAAO,eAAe,EACtB,SAAS;IACP,cAAc,EAAE;QACd,OAAO,EAAE,OAAO,CAAA;QAChB,aAAa,EAAE,OAAO,CAAA;QACtB,QAAQ,EAAE,OAAO,CAAA;KAClB,CAAA;IACD,gBAAgB,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;CAC/B;;;;;;;;;;;;;;;;;;CA6EF,CAAA"}
+{"version":3,"file":"use-tree-search-cls.d.ts","sourceRoot":"","sources":["../../../../src/components/tree-search/composable/use-tree-search-cls.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAG9B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAEnD,eAAO,MAAM,gBAAgB,UACpB,eAAe,WACb;IACP,cAAc,EAAE;QACd,OAAO,EAAE,OAAO,CAAA;QAChB,aAAa,EAAE,OAAO,CAAA;QACtB,QAAQ,EAAE,OAAO,CAAA;KAClB,CAAA;IACD,gBAAgB,EAAE,IAAI,OAAO,CAAC,CAAA;CAC/B;;;;;;;;;;;;;;;;;;CA6EF,CAAA"}

package/dist/components/tree-search/index.d.ts

@@ -1,6 +1,5 @@
 import { SFCWithInstall } from '@maxax/utils';
 import { default as TreeSearch } from './TreeSearch.vue';
-
 export declare const XTreeSearch: SFCWithInstall<typeof TreeSearch>;
 export type TreeSearchInstance = InstanceType<typeof TreeSearch>;
 export default XTreeSearch;

package/dist/components/tree-search/interface.d.ts

@@ -1,5 +1,4 @@
 import { TreeProps } from '../tree/interface';
-
 export type TreeSearchProps = TreeProps & {
     /** 搜索输入框的 placeholder */
     searchPlaceholder?: string;

package/dist/composable/index.d.ts

@@ -1,13 +1,13 @@
 export * from './use-dragable';
 export * from './use-drawer';
 export * from './use-flex-gap-support';
+export * from './use-local-icon';
 export * from './use-locale';
 export * from './use-lockscreen';
 export * from './use-merged-state';
 export * from './use-namespace';
 export * from './use-responsive-observe';
 export * from './use-same-target';
-export * from './use-table-config';
 export * from './use-theme-overrides';
 export * from './use-z-index';
 //# sourceMappingURL=index.d.ts.map

package/dist/composable/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/composable/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAA;AAC9B,cAAc,cAAc,CAAA;AAC5B,cAAc,wBAAwB,CAAA;AACtC,cAAc,cAAc,CAAA;AAC5B,cAAc,kBAAkB,CAAA;AAChC,cAAc,oBAAoB,CAAA;AAClC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,0BAA0B,CAAA;AACxC,cAAc,mBAAmB,CAAA;AACjC,cAAc,oBAAoB,CAAA;AAClC,cAAc,uBAAuB,CAAA;AACrC,cAAc,eAAe,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/composable/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAA;AAC9B,cAAc,cAAc,CAAA;AAC5B,cAAc,wBAAwB,CAAA;AACtC,cAAc,kBAAkB,CAAA;AAChC,cAAc,cAAc,CAAA;AAC5B,cAAc,kBAAkB,CAAA;AAChC,cAAc,oBAAoB,CAAA;AAClC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,0BAA0B,CAAA;AACxC,cAAc,mBAAmB,CAAA;AACjC,cAAc,uBAAuB,CAAA;AACrC,cAAc,eAAe,CAAA"}

package/dist/composable/use-dragable.d.ts

@@ -1,5 +1,4 @@
 import { ComputedRef, Ref } from 'vue';
-
 export declare const useDraggable: (targetRef: Ref<HTMLElement | undefined>, dragRef: Ref<HTMLElement | undefined>, draggable: ComputedRef<boolean>, overflow?: ComputedRef<boolean>) => {
     resetPosition: () => void;
 };

package/dist/composable/use-dragable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-dragable.d.ts","sourceRoot":"","sources":["../../src/composable/use-dragable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAI3C,eAAO,MAAM,YAAY,GAAI,WAAW,GAAG,CAAC,WAAW,GAAG,SAAS,CAAC,EAAE,SAAS,GAAG,CAAC,WAAW,GAAG,SAAS,CAAC,EAAE,WAAW,WAAW,CAAC,OAAO,CAAC,EAAE,WAAW,WAAW,CAAC,OAAO,CAAC;;CA4F5K,CAAA"}
+{"version":3,"file":"use-dragable.d.ts","sourceRoot":"","sources":["../../src/composable/use-dragable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAI3C,eAAO,MAAM,YAAY,cAAe,IAAI,WAAW,GAAG,SAAS,CAAC,WAAW,IAAI,WAAW,GAAG,SAAS,CAAC,aAAa,YAAY,OAAO,CAAC,aAAa,YAAY,OAAO,CAAC;;CA4F5K,CAAA"}

package/dist/composable/use-drawer.d.ts

@@ -1,5 +1,4 @@
 import { BasicDrawerModalContext, BasicDrawerModalHooks, BasicDrawerModalType } from '../types/basic';
-
 export declare function useBasicDrawerModal(params?: BasicDrawerModalHooks): {
     show: (context: BasicDrawerModalContext) => void;
     hide: () => void;

package/dist/composable/use-local-icon.d.ts

@@ -0,0 +1,3 @@
+import { Ref } from 'vue';
+export declare function useLocalIcon(localIcon?: Ref<string | undefined>): string | undefined;
+//# sourceMappingURL=use-local-icon.d.ts.map

package/dist/composable/use-local-icon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-local-icon.d.ts","sourceRoot":"","sources":["../../src/composable/use-local-icon.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAI9B,wBAAgB,YAAY,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,MAAM,GAAG,SAAS,CAGpF"}

package/dist/composable/use-locale.d.ts

@@ -1,5 +1,4 @@
 import { Ref } from 'vue';
 import { Locale, LocaleContext } from '../locale';
-
 export declare function useLocale(localeOverrides?: Ref<Locale | undefined>): LocaleContext;
 //# sourceMappingURL=use-locale.d.ts.map

package/dist/composable/use-lockscreen.d.ts

@@ -1,6 +1,5 @@
 import { Ref } from 'vue';
 import { UseNamespaceReturn } from './use-namespace';
-
 export interface UseLockScreenOptions {
     ns?: UseNamespaceReturn;
 }

package/dist/composable/use-lockscreen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-lockscreen.d.ts","sourceRoot":"","sources":["../../src/composable/use-lockscreen.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAI9B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAGzD,MAAM,WAAW,oBAAoB;IACnC,EAAE,CAAC,EAAE,kBAAkB,CAAA;CAExB;AAED,eAAO,MAAM,aAAa,GAAI,SAAS,GAAG,CAAC,OAAO,CAAC,EAAE,UAAS,oBAAyB,SA+CtF,CAAA"}
+{"version":3,"file":"use-lockscreen.d.ts","sourceRoot":"","sources":["../../src/composable/use-lockscreen.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAI9B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAGzD,MAAM,WAAW,oBAAoB;IACnC,EAAE,CAAC,EAAE,kBAAkB,CAAA;CAExB;AAED,eAAO,MAAM,aAAa,YAAa,IAAI,OAAO,CAAC,YAAW,oBAAoB,SA+CjF,CAAA"}