naive-ui 2.34.2 → 2.34.4

package/es/transfer/src/interface.d.ts

@@ -1,24 +1,24 @@
-import { Ref, VNodeChild } from 'vue';
+import type { Ref, VNodeChild } from 'vue';
 import type { MergedTheme } from '../../_mixins';
 import type { TransferTheme } from '../styles';
-export declare type OptionValue = string | number;
+export type OptionValue = string | number;
 export interface Option {
     label: string;
     value: OptionValue;
     disabled?: boolean;
 }
-export declare type Filter = (pattern: string, option: Option, from: 'source' | 'target') => boolean;
+export type Filter = (pattern: string, option: Option, from: 'source' | 'target') => boolean;
 export interface RenderLabelProps {
     option: Option;
 }
-export declare type TransferRenderTargetLabel = (props: RenderLabelProps) => VNodeChild;
-export declare type TransferRenderSourceLabel = (props: RenderLabelProps) => VNodeChild;
+export type TransferRenderTargetLabel = (props: RenderLabelProps) => VNodeChild;
+export type TransferRenderSourceLabel = (props: RenderLabelProps) => VNodeChild;
 export interface RenderListProps {
     onCheck: (checkedValueList: OptionValue[]) => void;
     checkedOptions: Option[];
     pattern: string;
 }
-export declare type TransferRenderSourceList = (props: RenderListProps) => VNodeChild;
+export type TransferRenderSourceList = (props: RenderListProps) => VNodeChild;
 export interface TransferInjection {
     targetValueSetRef: Ref<Set<OptionValue>>;
     mergedClsPrefixRef: Ref<string>;
@@ -35,4 +35,4 @@ export interface TransferInjection {
     showSelectedRef: Ref<boolean>;
 }
 export declare const transferInjectionKey: import("vue").InjectionKey<TransferInjection>;
-export declare type OnUpdateValue = (value: OptionValue[]) => void;
+export type OnUpdateValue = (value: OptionValue[]) => void;

package/es/transfer/src/use-transfer-data.d.ts

@@ -4,9 +4,9 @@ interface UseTransferDataProps {
     value?: OptionValue[] | null;
     options: Option[];
     filterable: boolean | undefined;
-    sourceFilterable: Boolean;
-    targetFilterable: Boolean;
-    showSelected: Boolean;
+    sourceFilterable: boolean;
+    targetFilterable: boolean;
+    showSelected: boolean;
     filter: Filter;
 }
 export declare function useTransferData(props: UseTransferDataProps): {
@@ -24,7 +24,7 @@ export declare function useTransferData(props: UseTransferDataProps): {
     allCheckedRef: import("vue").ComputedRef<boolean>;
     srcPatternRef: import("vue").Ref<string>;
     tgtPatternRef: import("vue").Ref<string>;
-    mergedSrcFilterableRef: import("vue").ComputedRef<Boolean>;
+    mergedSrcFilterableRef: import("vue").ComputedRef<boolean>;
     handleSrcFilterUpdateValue: (value: string | null) => void;
     handleTgtFilterUpdateValue: (value: string | null) => void;
 };

package/es/transfer/styles/light.d.ts

@@ -36,7 +36,7 @@ declare const self: (vars: ThemeCommonVars) => {
     headerHeightMedium: string;
     headerHeightLarge: string;
 };
-export declare type TransferThemeVars = ReturnType<typeof self>;
+export type TransferThemeVars = ReturnType<typeof self>;
 declare const transferLight: import("../../_mixins").Theme<"Transfer", {
     itemHeightSmall: string;
     itemHeightMedium: string;
@@ -102,6 +102,7 @@ declare const transferLight: import("../../_mixins").Theme<"Transfer", {
         sizeMedium: string;
         sizeLarge: string;
         labelPadding: string;
+        labelFontWeight: string;
     }, any>;
     Scrollbar: import("../../_mixins").Theme<"Scrollbar", {
         color: string;
@@ -387,4 +388,4 @@ declare const transferLight: import("../../_mixins").Theme<"Transfer", {
     }, any>;
 }>;
 export default transferLight;
-export declare type TransferTheme = typeof transferLight;
+export type TransferTheme = typeof transferLight;

package/es/tree/src/MotionWrapper.d.ts

@@ -1,5 +1,5 @@
-import { PropType } from 'vue';
-import { TmNode } from './interface';
+import { type PropType } from 'vue';
+import { type TmNode } from './interface';
 declare const _default: import("vue").DefineComponent<{
     clsPrefix: {
         type: StringConstructor;

package/es/tree/src/Tree.d.ts

@@ -1,42 +1,41 @@
-import { PropType, VNodeChild } from 'vue';
-import { TreeMateOptions, CheckStrategy } from 'treemate';
+import { type PropType, type VNodeChild } from 'vue';
+import { type TreeMateOptions, type CheckStrategy } from 'treemate';
 import type { ExtractPublicPropTypes, MaybeArray } from '../../_utils';
-import type { TreeDragInfo, TreeDropInfo, TreeOptions, Key, TreeOption, AllowDrop, RenderSwitcherIcon, TreeNodeProps, CheckOnClick } from './interface';
+import type { TreeDragInfo, TreeDropInfo, TreeOptions, Key, TreeOption, AllowDrop, RenderSwitcherIcon, TreeNodeProps, CheckOnClick, GetChildren, OnLoad } from './interface';
 import { defaultAllowDrop } from './dnd';
-export declare function createTreeMateOptions<T>(keyField: string, childrenField: string, disabledField: string): TreeMateOptions<T, T, T>;
-export declare type OnUpdateCheckedKeys = (value: Array<string & number>, option: Array<TreeOption | null>, meta: {
+export declare function createTreeMateOptions<T>(keyField: string, childrenField: string, disabledField: string, getChildren: GetChildren | undefined): TreeMateOptions<T, T, T>;
+export type OnUpdateCheckedKeys = (value: Array<string & number>, option: Array<TreeOption | null>, meta: {
     node: TreeOption | null;
     action: 'check' | 'uncheck';
 }) => void;
-export declare type OnUpdateCheckedKeysImpl = (value: Key[], option: Array<TreeOption | null>, meta: {
+export type OnUpdateCheckedKeysImpl = (value: Key[], option: Array<TreeOption | null>, meta: {
     node: TreeOption | null;
     action: 'check' | 'uncheck';
 }) => void;
-export declare type OnUpdateIndeterminateKeys = (value: Array<string & number>, option: Array<TreeOption | null>) => void;
-export declare type OnUpdateIndeterminateKeysImpl = (value: Key[], option: Array<TreeOption | null>) => void;
-export declare type OnUpdateSelectedKeys = (value: Array<string & number>, option: Array<TreeOption | null>, meta: {
+export type OnUpdateIndeterminateKeys = (value: Array<string & number>, option: Array<TreeOption | null>) => void;
+export type OnUpdateIndeterminateKeysImpl = (value: Key[], option: Array<TreeOption | null>) => void;
+export type OnUpdateSelectedKeys = (value: Array<string & number>, option: Array<TreeOption | null>, meta: {
     node: TreeOption | null;
     action: 'select' | 'unselect';
 }) => void;
-export declare type OnUpdateSelectedKeysImpl = (value: Key[], option: Array<TreeOption | null>, meta: {
+export type OnUpdateSelectedKeysImpl = (value: Key[], option: Array<TreeOption | null>, meta: {
     node: TreeOption | null;
     action: 'select' | 'unselect';
 }) => void;
-export declare type onUpdateExpandedKeys = (value: Key[], option: Array<TreeOption | null>, meta: {
+export type onUpdateExpandedKeys = (value: Array<string & number>, option: Array<TreeOption | null>, meta: {
     node: TreeOption;
     action: 'expand' | 'collapse';
 } | {
     node: null;
     action: 'filter';
 }) => void;
-export declare type OnUpdateExpandedKeysImpl = (value: Key[], option: Array<TreeOption | null>, meta: {
+export type OnUpdateExpandedKeysImpl = (value: Key[], option: Array<TreeOption | null>, meta: {
     node: TreeOption;
     action: 'expand' | 'collapse';
 } | {
     node: null;
     action: 'filter';
 }) => void;
-declare type OnLoad = (node: TreeOption) => Promise<void>;
 export declare const treeSharedProps: {
     readonly allowCheckingNotLoaded: BooleanConstructor;
     readonly filter: PropType<(pattern: string, node: TreeOption) => boolean>;
@@ -196,6 +195,7 @@ export declare const treeProps: {
         readonly type: BooleanConstructor;
         readonly default: true;
     };
+    readonly getChildren: PropType<GetChildren>;
     readonly onDragenter: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
     readonly onDragleave: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
     readonly onDragend: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
@@ -246,6 +246,7 @@ export declare const treeProps: {
             sizeMedium: string;
             sizeLarge: string;
             labelPadding: string;
+            labelFontWeight: string;
         }, any>;
         Scrollbar: import("../../_mixins").Theme<"Scrollbar", {
             color: string;
@@ -305,6 +306,7 @@ export declare const treeProps: {
             sizeMedium: string;
             sizeLarge: string;
             labelPadding: string;
+            labelFontWeight: string;
         }, any>;
         Scrollbar: import("../../_mixins").Theme<"Scrollbar", {
             color: string;
@@ -364,6 +366,7 @@ export declare const treeProps: {
             sizeMedium: string;
             sizeLarge: string;
             labelPadding: string;
+            labelFontWeight: string;
         }, any>;
         Scrollbar: import("../../_mixins").Theme<"Scrollbar", {
             color: string;
@@ -384,7 +387,7 @@ export declare const treeProps: {
         }, any>;
     }>>>;
 };
-export declare type TreeProps = ExtractPublicPropTypes<typeof treeProps>;
+export type TreeProps = ExtractPublicPropTypes<typeof treeProps>;
 declare const _default: import("vue").DefineComponent<{
     readonly internalTreeSelect: BooleanConstructor;
     readonly internalScrollable: BooleanConstructor;
@@ -512,6 +515,7 @@ declare const _default: import("vue").DefineComponent<{
         readonly type: BooleanConstructor;
         readonly default: true;
     };
+    readonly getChildren: PropType<GetChildren>;
     readonly onDragenter: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
     readonly onDragleave: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
     readonly onDragend: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
@@ -562,6 +566,7 @@ declare const _default: import("vue").DefineComponent<{
             sizeMedium: string;
             sizeLarge: string;
             labelPadding: string;
+            labelFontWeight: string;
         }, any>;
         Scrollbar: import("../../_mixins").Theme<"Scrollbar", {
             color: string;
@@ -621,6 +626,7 @@ declare const _default: import("vue").DefineComponent<{
             sizeMedium: string;
             sizeLarge: string;
             labelPadding: string;
+            labelFontWeight: string;
         }, any>;
         Scrollbar: import("../../_mixins").Theme<"Scrollbar", {
             color: string;
@@ -680,6 +686,7 @@ declare const _default: import("vue").DefineComponent<{
             sizeMedium: string;
             sizeLarge: string;
             labelPadding: string;
+            labelFontWeight: string;
         }, any>;
         Scrollbar: import("../../_mixins").Theme<"Scrollbar", {
             color: string;
@@ -848,6 +855,7 @@ declare const _default: import("vue").DefineComponent<{
                 sizeMedium: string;
                 sizeLarge: string;
                 labelPadding: string;
+                labelFontWeight: string;
             }, any>;
             Scrollbar: import("../../_mixins").Theme<"Scrollbar", {
                 color: string;
@@ -1312,6 +1320,7 @@ declare const _default: import("vue").DefineComponent<{
         readonly type: BooleanConstructor;
         readonly default: true;
     };
+    readonly getChildren: PropType<GetChildren>;
     readonly onDragenter: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
     readonly onDragleave: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
     readonly onDragend: PropType<MaybeArray<(e: TreeDragInfo) => void>>;
@@ -1362,6 +1371,7 @@ declare const _default: import("vue").DefineComponent<{
             sizeMedium: string;
             sizeLarge: string;
             labelPadding: string;
+            labelFontWeight: string;
         }, any>;
         Scrollbar: import("../../_mixins").Theme<"Scrollbar", {
             color: string;
@@ -1421,6 +1431,7 @@ declare const _default: import("vue").DefineComponent<{
             sizeMedium: string;
             sizeLarge: string;
             labelPadding: string;
+            labelFontWeight: string;
         }, any>;
         Scrollbar: import("../../_mixins").Theme<"Scrollbar", {
             color: string;
@@ -1480,6 +1491,7 @@ declare const _default: import("vue").DefineComponent<{
             sizeMedium: string;
             sizeLarge: string;
             labelPadding: string;
+            labelFontWeight: string;
         }, any>;
         Scrollbar: import("../../_mixins").Theme<"Scrollbar", {
             color: string;
@@ -1511,12 +1523,12 @@ declare const _default: import("vue").DefineComponent<{
     readonly checkable: boolean;
     readonly animated: boolean;
     readonly cancelable: boolean;
+    readonly keyboard: boolean;
     readonly childrenField: string;
     readonly defaultExpandAll: boolean;
     readonly allowCheckingNotLoaded: boolean;
     readonly cascade: boolean;
     readonly indent: number;
-    readonly keyboard: boolean;
     readonly internalScrollable: boolean;
     readonly checkStrategy: CheckStrategy;
     readonly disabledField: string;

package/es/tree/src/Tree.js

@@ -18,6 +18,7 @@ import { useConfig, useTheme, useThemeClass, useRtl } from '../../_mixins';
 import { call, createDataKey, resolveSlot, warn, warnOnce } from '../../_utils';
 import { NxScrollbar } from '../../_internal';
 import { treeLight } from '../styles';
+import { NEmpty } from '../../empty';
 import NTreeNode from './TreeNode';
 import { keysWithFilter, emptyImage, filterTree, isNodeDisabled, useMergedCheckStrategy } from './utils';
 import { useKeyboard } from './keyboard';
@@ -25,12 +26,15 @@ import { treeInjectionKey } from './interface';
 import MotionWrapper from './MotionWrapper';
 import { defaultAllowDrop } from './dnd';
 import style from './styles/index.cssr';
-import { NEmpty } from '../../empty';
 // TODO:
 // During expanding, some node are mis-applied with :active style
 // Async dnd has bug
 const ITEM_SIZE = 30; // 24 + 3 + 3
-export function createTreeMateOptions(keyField, childrenField, disabledField) {
+export function createTreeMateOptions(keyField, childrenField, disabledField, getChildren) {
+    const settledGetChildren = getChildren ||
+        ((node) => {
+            return node[childrenField];
+        });
     return {
         getIsGroup() {
             return false;
@@ -38,9 +42,7 @@ export function createTreeMateOptions(keyField, childrenField, disabledField) {
         getKey(node) {
             return node[keyField];
         },
-        getChildren(node) {
-            return node[childrenField];
-        },
+        getChildren: settledGetChildren,
         getDisabled(node) {
             return !!(node[disabledField] || node.checkboxDisabled);
         }
@@ -117,7 +119,7 @@ export const treeProps = Object.assign(Object.assign(Object.assign(Object.assign
     }, virtualScroll: Boolean, watchProps: Array, renderLabel: Function, renderPrefix: Function, renderSuffix: Function, nodeProps: Function, keyboard: {
         type: Boolean,
         default: true
-    }, onDragenter: [Function, Array], onDragleave: [Function, Array], onDragend: [Function, Array], onDragstart: [Function, Array], onDragover: [Function, Array], onDrop: [Function, Array], onUpdateCheckedKeys: [Function, Array], 'onUpdate:checkedKeys': [Function, Array], onUpdateSelectedKeys: [Function, Array], 'onUpdate:selectedKeys': [Function, Array] }), treeSharedProps), { 
+    }, getChildren: Function, onDragenter: [Function, Array], onDragleave: [Function, Array], onDragend: [Function, Array], onDragstart: [Function, Array], onDragover: [Function, Array], onDrop: [Function, Array], onUpdateCheckedKeys: [Function, Array], 'onUpdate:checkedKeys': [Function, Array], onUpdateSelectedKeys: [Function, Array], 'onUpdate:selectedKeys': [Function, Array] }), treeSharedProps), { 
     // internal props for tree-select
     internalTreeSelect: Boolean, internalScrollable: Boolean, internalScrollablePadding: String, 
     // use it to display
@@ -161,6 +163,21 @@ export default defineComponent({
             var _a;
             return (_a = virtualListInstRef.value) === null || _a === void 0 ? void 0 : _a.itemsElRef;
         }
+        const mergedFilterRef = computed(() => {
+            const { filter } = props;
+            if (filter)
+                return filter;
+            const { labelField } = props;
+            return (pattern, node) => {
+                if (!pattern.length)
+                    return true;
+                const label = node[labelField];
+                if (typeof label === 'string') {
+                    return label.toLowerCase().includes(pattern.toLowerCase());
+                }
+                return false;
+            };
+        });
         const filteredTreeInfoRef = computed(() => {
             const { pattern } = props;
             if (!pattern) {
@@ -182,7 +199,7 @@ export default defineComponent({
         // We don't expect data source to change so we just determine it once
         const displayTreeMateRef = computed(() => createTreeMate(props.showIrrelevantNodes
             ? props.data
-            : filteredTreeInfoRef.value.filteredTree, createTreeMateOptions(props.keyField, props.childrenField, props.disabledField)));
+            : filteredTreeInfoRef.value.filteredTree, createTreeMateOptions(props.keyField, props.childrenField, props.disabledField, props.getChildren)));
         const treeSelectInjection = inject(treeSelectInjectionKey, null);
         const dataTreeMateRef = props.internalTreeSelect
             ? treeSelectInjection.dataTreeMate
@@ -237,11 +254,11 @@ export default defineComponent({
         };
         if (watchProps === null || watchProps === void 0 ? void 0 : watchProps.includes('defaultExpandedKeys')) {
             // if watching defaultExpandedKeys, we use access props.defaultExpandedKeys inside initiator
-            watchEffect(() => initUncontrolledExpandedKeys(undefined));
+            watchEffect(() => { initUncontrolledExpandedKeys(undefined); });
         }
         else {
             // We by default watchEffect since if defaultExpandAll is true, we should remain tree expand if data changes
-            watchEffect(() => initUncontrolledExpandedKeys(props.defaultExpandedKeys));
+            watchEffect(() => { initUncontrolledExpandedKeys(props.defaultExpandedKeys); });
         }
         const controlledExpandedKeysRef = toRef(props, 'expandedKeys');
         const mergedExpandedKeysRef = useMergedState(controlledExpandedKeysRef, uncontrolledExpandedKeysRef);
@@ -282,21 +299,6 @@ export default defineComponent({
             // }
             return droppingNode.parent;
         });
-        const mergedFilterRef = computed(() => {
-            const { filter } = props;
-            if (filter)
-                return filter;
-            const { labelField } = props;
-            return (pattern, node) => {
-                if (!pattern.length)
-                    return true;
-                const label = node[labelField];
-                if (typeof label === 'string') {
-                    return label.toLowerCase().includes(pattern.toLowerCase());
-                }
-                return false;
-            };
-        });
         // shallow watch data
         watch(toRef(props, 'data'), () => {
             loadingKeysRef.value.clear();
@@ -355,23 +357,24 @@ export default defineComponent({
                     if (process.env.NODE_ENV !== 'production') {
                         warn('tree', 'There is unloaded node in data but props.onLoad is not specified.');
                     }
-                    return yield Promise.resolve();
+                    yield Promise.resolve();
+                    return;
                 }
                 const { value: loadingKeys } = loadingKeysRef;
-                return yield new Promise((resolve) => {
-                    if (!loadingKeys.has(node.key)) {
-                        loadingKeys.add(node.key);
-                        onLoad(node.rawNode)
-                            .then(() => {
-                            loadingKeys.delete(node.key);
-                            resolve();
-                        })
-                            .catch((loadError) => {
-                            console.error(loadError);
+                if (!loadingKeys.has(node.key)) {
+                    loadingKeys.add(node.key);
+                    try {
+                        const loadResult = yield onLoad(node.rawNode);
+                        if (loadResult === false) {
                             resetDragExpandState();
-                        });
+                        }
                     }
-                });
+                    catch (loadError) {
+                        console.error(loadError);
+                        resetDragExpandState();
+                    }
+                    loadingKeys.delete(node.key);
+                }
             });
         }
         watchEffect(() => {

package/es/tree/src/TreeNode.d.ts

@@ -1,5 +1,5 @@
-import { PropType, ComponentPublicInstance } from 'vue';
-import { TmNode } from './interface';
+import { type PropType, type ComponentPublicInstance } from 'vue';
+import { type TmNode } from './interface';
 declare const TreeNode: import("vue").DefineComponent<{
     clsPrefix: {
         type: StringConstructor;
@@ -34,7 +34,7 @@ declare const TreeNode: import("vue").DefineComponent<{
     droppingOffsetLevel: import("vue").Ref<number>;
     indent: import("vue").Ref<number>;
     checkboxPlacement: "left" | "right";
-    contentInstRef: import("vue").Ref<ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null>;
+    contentInstRef: import("vue").Ref<ComponentPublicInstance | null>;
     contentElRef: {
         value: HTMLElement | null;
     };

package/es/tree/src/TreeNode.js

@@ -55,8 +55,10 @@ const TreeNode = defineComponent({
                 const { onLoadRef: { value: onLoad } } = NTree;
                 if (onLoad) {
                     void onLoad(tmNode.rawNode)
-                        .then(() => {
-                        NTree.handleSwitcherClick(tmNode);
+                        .then((value) => {
+                        if (value !== false) {
+                            NTree.handleSwitcherClick(tmNode);
+                        }
                     })
                         .finally(() => {
                         NTree.loadingKeysRef.value.delete(tmNode.key);

package/es/tree/src/TreeNodeCheckbox.d.ts

@@ -1,4 +1,4 @@
-import { PropType } from 'vue';
+import { type PropType } from 'vue';
 declare const _default: import("vue").DefineComponent<{
     clsPrefix: {
         type: StringConstructor;
@@ -159,6 +159,7 @@ declare const _default: import("vue").DefineComponent<{
                 sizeMedium: string;
                 sizeLarge: string;
                 labelPadding: string;
+                labelFontWeight: string;
             }, any>;
             Scrollbar: import("../../_mixins").Theme<"Scrollbar", {
                 color: string;

package/es/tree/src/TreeNodeCheckbox.js

@@ -20,8 +20,9 @@ export default defineComponent({
         const NTree = inject(treeInjectionKey);
         function doCheck(value) {
             const { onCheck } = props;
-            if (onCheck)
-                return onCheck(value);
+            if (onCheck) {
+                onCheck(value);
+            }
         }
         function handleUpdateValue(value) {
             if (props.indeterminate) {

package/es/tree/src/TreeNodeContent.d.ts

@@ -1,5 +1,5 @@
-import { PropType, HTMLAttributes } from 'vue';
-import { TmNode } from './interface';
+import { type PropType, type HTMLAttributes } from 'vue';
+import { type TmNode } from './interface';
 declare const _default: import("vue").DefineComponent<{
     clsPrefix: {
         type: StringConstructor;

package/es/tree/src/TreeNodeSwitcher.d.ts

@@ -1,4 +1,4 @@
-import { PropType } from 'vue';
+import { type PropType } from 'vue';
 declare const _default: import("vue").DefineComponent<{
     clsPrefix: {
         type: StringConstructor;

package/es/tree/src/dnd.d.ts

@@ -1,5 +1,5 @@
-import { VNode } from 'vue';
-import { DropPosition, TreeOption } from './interface';
+import { type VNode } from 'vue';
+import { type DropPosition, type TreeOption } from './interface';
 export declare function renderDropMark({ position, offsetLevel, indent, el }: {
     position: 'before' | 'inside' | 'after';
     offsetLevel: number;

package/es/tree/src/interface.d.ts

@@ -1,8 +1,9 @@
-import { CheckStrategy, TreeNode } from 'treemate';
-import { HTMLAttributes, Ref, VNodeChild } from 'vue';
+import { type CheckStrategy, type TreeNode } from 'treemate';
+import { type HTMLAttributes, type Ref, type VNodeChild } from 'vue';
 import type { MergedTheme } from '../../_mixins';
 import type { TreeTheme } from '../styles';
-export declare type Key = string | number;
+export type Key = string | number;
+export type OnLoad = (node: TreeOption) => Promise<unknown>;
 export interface TreeOptionBase {
     key?: Key;
     label?: string;
@@ -13,20 +14,18 @@ export interface TreeOptionBase {
     prefix?: () => VNodeChild;
     suffix?: () => VNodeChild;
 }
-export declare type TreeOption = TreeOptionBase & {
-    [k: string]: unknown;
-};
-export declare type TreeOptions = TreeOption[];
+export type TreeOption = TreeOptionBase & Record<string, unknown>;
+export type TreeOptions = TreeOption[];
 export interface TreeRenderProps {
     option: TreeOption;
     checked: boolean;
     selected: boolean;
 }
-declare type RenderTreePart = ({ option, checked, selected }: TreeRenderProps) => VNodeChild;
-export declare type RenderLabel = RenderTreePart;
-export declare type RenderPrefix = RenderTreePart;
-export declare type RenderSuffix = RenderTreePart;
-export declare type TreeNodeProps = (info: {
+type RenderTreePart = ({ option, checked, selected }: TreeRenderProps) => VNodeChild;
+export type RenderLabel = RenderTreePart;
+export type RenderPrefix = RenderTreePart;
+export type RenderSuffix = RenderTreePart;
+export type TreeNodeProps = (info: {
     option: TreeOption;
 }) => HTMLAttributes & Record<string, unknown>;
 export interface TreeDragInfo {
@@ -43,8 +42,8 @@ export interface InternalDragInfo {
     event: DragEvent;
     node: TmNode;
 }
-export declare type DropPosition = 'before' | 'inside' | 'after';
-export declare type AllowDrop = (info: {
+export type DropPosition = 'before' | 'inside' | 'after';
+export type AllowDrop = (info: {
     dropPosition: DropPosition;
     node: TreeOption;
     phase: 'drag' | 'drop';
@@ -54,11 +53,11 @@ export interface InternalDropInfo {
     node: TmNode;
     dropPosition: DropPosition;
 }
-export declare type RenderSwitcherIcon = (props: {
+export type RenderSwitcherIcon = (props: {
     expanded: boolean;
     selected: boolean;
 }) => VNodeChild;
-export declare type CheckOnClick = (option: TreeOption) => boolean;
+export type CheckOnClick = (option: TreeOption) => boolean;
 export interface TreeInjection {
     loadingKeysRef: Ref<Set<Key>>;
     highlightKeySetRef: Ref<Set<Key> | null>;
@@ -69,7 +68,7 @@ export interface TreeInjection {
     fNodesRef: Ref<Array<TreeNode<TreeOption>>>;
     draggableRef: Ref<boolean>;
     mergedThemeRef: Ref<MergedTheme<TreeTheme>>;
-    onLoadRef: Ref<((node: TreeOption) => Promise<void>) | undefined>;
+    onLoadRef: Ref<OnLoad | undefined>;
     blockLineRef: Ref<boolean>;
     indentRef: Ref<number>;
     draggingNodeRef: Ref<TmNode | null>;
@@ -108,7 +107,7 @@ export interface TreeInjection {
     handleDrop: (info: InternalDropInfo) => void;
 }
 export declare const treeInjectionKey: import("vue").InjectionKey<TreeInjection>;
-export declare type TmNode = TreeNode<TreeOption>;
+export type TmNode = TreeNode<TreeOption>;
 export interface MotionData {
     __motion: true;
     height: number | undefined;
@@ -131,4 +130,5 @@ export interface TreeInst {
         options: Array<TreeOption | null>;
     };
 }
+export type GetChildren = (option: any) => unknown;
 export {};

package/es/tree/src/keyboard.d.ts

@@ -1,6 +1,6 @@
-import { Ref } from 'vue';
-import { TreeNode } from 'treemate';
-import { Key, TmNode, TreeOption } from './interface';
+import { type Ref } from 'vue';
+import { type TreeNode } from 'treemate';
+import { type Key, type TmNode, type TreeOption } from './interface';
 export declare function useKeyboard({ props, fNodesRef, mergedExpandedKeysRef, mergedSelectedKeysRef, handleSelect, handleSwitcherClick }: {
     props: {
         keyboard: boolean;

package/es/tree/src/utils.d.ts

@@ -1,6 +1,6 @@
-import { ComputedRef } from 'vue';
-import { CheckStrategy } from 'treemate';
-import { Key, TmNode, TreeOption } from './interface';
+import { type ComputedRef } from 'vue';
+import { type CheckStrategy } from 'treemate';
+import { type Key, type TmNode, type TreeOption } from './interface';
 export declare function useMergedCheckStrategy(props: {
     leafOnly: boolean;
     checkStrategy: CheckStrategy;

package/es/tree/styles/light.d.ts

@@ -11,7 +11,7 @@ export declare const self: (vars: ThemeCommonVars) => {
     loadingColor: string;
     dropMarkColor: string;
 };
-export declare type TreeThemeVars = ReturnType<typeof self>;
+export type TreeThemeVars = ReturnType<typeof self>;
 declare const treeLight: import("../../_mixins/use-theme").Theme<"Tree", {
     fontSize: string;
     nodeBorderRadius: string;
@@ -52,6 +52,7 @@ declare const treeLight: import("../../_mixins/use-theme").Theme<"Tree", {
         sizeMedium: string;
         sizeLarge: string;
         labelPadding: string;
+        labelFontWeight: string;
     }, any>;
     Scrollbar: import("../../_mixins/use-theme").Theme<"Scrollbar", {
         color: string;
@@ -72,4 +73,4 @@ declare const treeLight: import("../../_mixins/use-theme").Theme<"Tree", {
     }, any>;
 }>;
 export default treeLight;
-export declare type TreeTheme = typeof treeLight;
+export type TreeTheme = typeof treeLight;