vue-devui 1.6.32 → 1.6.34-alpha.0

package/types/tree/src/composables/use-tree-node.d.ts

@@ -1,21 +1,21 @@
-import type { ComputedRef } from 'vue';
-import { IInnerTreeNode } from './use-tree-types';
-export interface IUseTreeNode {
-    nodeClass: ComputedRef<(string | false | undefined)[]>;
-    nodeStyle: ComputedRef<{
-        paddingLeft: string;
-    }>;
-    nodeContentClass: ComputedRef<(string | false | undefined)[]>;
-    nodeTitleClass: ComputedRef<(string | false | undefined)[]>;
-    nodeVLineClass: ComputedRef<(string | false | undefined)[]>;
-    nodeVLineStyles: ComputedRef<{
-        height: string;
-        left: string;
-        top: string;
-    }[]>;
-    nodeHLineClass: ComputedRef<(string | false | undefined)[]>;
-    nodeOperationAreaClass: ComputedRef<string>;
-    matchedContents: ComputedRef<string[]>;
-    highlightCls: string;
-}
-export declare function useTreeNode(data: ComputedRef<IInnerTreeNode>): IUseTreeNode;
+import type { ComputedRef } from 'vue';
+import { IInnerTreeNode } from './use-tree-types';
+export interface IUseTreeNode {
+    nodeClass: ComputedRef<(string | false | undefined)[]>;
+    nodeStyle: ComputedRef<{
+        paddingLeft: string;
+    }>;
+    nodeContentClass: ComputedRef<(string | false | undefined)[]>;
+    nodeTitleClass: ComputedRef<(string | false | undefined)[]>;
+    nodeVLineClass: ComputedRef<(string | false | undefined)[]>;
+    nodeVLineStyles: ComputedRef<{
+        height: string;
+        left: string;
+        top: string;
+    }[]>;
+    nodeHLineClass: ComputedRef<(string | false | undefined)[]>;
+    nodeOperationAreaClass: ComputedRef<string>;
+    matchedContents: ComputedRef<string[]>;
+    highlightCls: string;
+}
+export declare function useTreeNode(data: ComputedRef<IInnerTreeNode>): IUseTreeNode;

package/types/tree/src/composables/use-tree-types.d.ts

@@ -1,129 +1,135 @@
-import type { ComputedRef, Ref } from 'vue';
-export interface ITreeNode {
-    label: string;
-    id?: string;
-    children?: ITreeNode[];
-    selected?: boolean;
-    checked?: boolean;
-    expanded?: boolean;
-    disableSelect?: boolean;
-    disableCheck?: boolean;
-    disableToggle?: boolean;
-    isLeaf?: boolean;
-}
-export interface IInnerTreeNode extends ITreeNode {
-    id: string;
-    level: number;
-    idType?: 'random';
-    parentId?: string;
-    isLeaf?: boolean;
-    parentChildNodeCount?: number;
-    currentIndex?: number;
-    loading?: boolean;
-    childNodeCount?: number;
-    isMatched?: boolean;
-    childrenMatched?: boolean;
-    isHide?: boolean;
-    matchedText?: string;
-}
-export type valueof<T> = T[keyof T];
-export interface IUseCore {
-    getLevel: (node: IInnerTreeNode) => number;
-    getChildren: (node: IInnerTreeNode, config?: {
-        expanded?: boolean;
-        recursive?: boolean;
-    }) => IInnerTreeNode[];
-    clearNodeMap: () => void;
-    getParent: (node: IInnerTreeNode) => IInnerTreeNode;
-    getExpendedTree: () => ComputedRef<IInnerTreeNode[]>;
-    getIndex: (node: IInnerTreeNode) => number;
-    getNode: (node: IInnerTreeNode) => IInnerTreeNode;
-    setNodeValue: (node: IInnerTreeNode, key: keyof IInnerTreeNode, value: valueof<IInnerTreeNode>) => void;
-    setTree: (newTree: IInnerTreeNode[]) => void;
-    getTree: () => IInnerTreeNode[];
-}
-export interface IUseCheck {
-    checkNode: (node: IInnerTreeNode) => void;
-    uncheckNode: (node: IInnerTreeNode) => void;
-    toggleCheckNode: (node: IInnerTreeNode) => void;
-    getCheckedNodes: () => IInnerTreeNode[];
-}
-export interface IUseDisable {
-    disableSelectNode: (node: IInnerTreeNode) => void;
-    disableCheckNode: (node: IInnerTreeNode) => void;
-    disableToggleNode: (node: IInnerTreeNode) => void;
-    enableSelectNode: (node: IInnerTreeNode) => void;
-    enableCheckNode: (node: IInnerTreeNode) => void;
-    enableToggleNode: (node: IInnerTreeNode) => void;
-}
-export interface IUseOperate {
-    insertBefore: (parentNode: ITreeNode, node: ITreeNode, referenceNode?: ITreeNode) => void;
-    removeNode: (node: ITreeNode) => void;
-    editNode: (node: ITreeNode, label: string) => void;
-}
-export interface IUseSelect {
-    selectNode: (node: IInnerTreeNode) => void;
-    deselectNode: (node: IInnerTreeNode) => void;
-    toggleSelectNode: (node: IInnerTreeNode) => void;
-    getSelectedNode: () => IInnerTreeNode;
-}
-export interface IUseToggle {
-    expandNode: (node: IInnerTreeNode) => void;
-    collapseNode: (node: IInnerTreeNode) => void;
-    toggleNode: (node: IInnerTreeNode) => void;
-    expandAllNodes: () => void;
-}
-export interface IUseMergeNodes {
-    mergeTreeNodes: () => void;
-}
-export interface IUseLazyLoad {
-    lazyLoadNodes: (node: IInnerTreeNode) => void;
-}
-export interface IUseInitSelectCollection {
-    setInitSelectedNode: (node: IInnerTreeNode) => void;
-    getInitSelectedNodes: () => IInnerTreeNode[];
-    clearInitSelectedNodes: () => void;
-}
-export interface SearchFilterOption {
-    isFilter: boolean;
-    matchKey?: string;
-    pattern?: RegExp;
-}
-export interface IUseSearchFilter {
-    virtualListRef: Ref<HTMLElement | undefined>;
-    searchTree: (target: string, option: SearchFilterOption) => void;
-}
-export interface IDropType {
-    dropPrev?: boolean;
-    dropNext?: boolean;
-    dropInner?: boolean;
-}
-export type ICheckStrategy = 'upward' | 'downward' | 'both' | 'none';
-export type ICheck = boolean | ICheckStrategy;
-export type IDragdrop = boolean | IDropType;
-export type IOperateItem = 'add' | 'delete' | 'edit';
-export type IOperate = boolean | IOperateItem | Array<IOperateItem>;
-export interface LazyNodeResult {
-    treeItems: ITreeNode[];
-    node: IInnerTreeNode;
-}
-export interface DragState {
-    dropType?: keyof Required<IDropType>;
-    draggingNode?: HTMLElement | null;
-    draggingTreeNode?: IInnerTreeNode | null;
-}
-export interface IUseDraggable {
-    onDragstart: (event: DragEvent, treeNode: IInnerTreeNode) => void;
-    onDragover: (event: DragEvent) => void;
-    onDragleave: (event: DragEvent) => void;
-    onDrop: (event: DragEvent, dropNode: IInnerTreeNode) => void;
-    onDragend: (event: DragEvent) => void;
-}
-export interface IDropNode {
-    target: ITreeNode[];
-    index: number;
-    item: ITreeNode;
-}
-export type IUseTree = {
-    treeData: Ref<IInnerTreeNode[]>;
-} & IUseCore & IUseToggle & IUseSelect & IUseCheck & IUseDisable & IUseOperate & IUseMergeNodes & IUseLazyLoad & IUseSearchFilter & IUseDraggable;
+import type { ComputedRef, Ref } from 'vue';
+export interface ITreeNode {
+    label: string;
+    id?: string;
+    children?: ITreeNode[];
+    selected?: boolean;
+    checked?: boolean;
+    expanded?: boolean;
+    disableSelect?: boolean;
+    disableCheck?: boolean;
+    disableToggle?: boolean;
+    isLeaf?: boolean;
+}
+export interface IInnerTreeNode extends ITreeNode {
+    id: string;
+    level: number;
+    idType?: 'random';
+    parentId?: string;
+    isLeaf?: boolean;
+    parentChildNodeCount?: number;
+    currentIndex?: number;
+    loading?: boolean;
+    childNodeCount?: number;
+    isMatched?: boolean;
+    childrenMatched?: boolean;
+    isHide?: boolean;
+    matchedText?: string;
+    showNode?: boolean;
+    childList?: IInnerTreeNode[];
+}
+export type valueof<T> = T[keyof T];
+export interface IUseCore {
+    getLevel: (node: IInnerTreeNode) => number;
+    getChildren: (node: IInnerTreeNode, config?: {
+        expanded?: boolean;
+        recursive?: boolean;
+    }) => IInnerTreeNode[];
+    clearNodeMap: () => void;
+    getParent: (node: IInnerTreeNode) => IInnerTreeNode;
+    getExpendedTree: () => ComputedRef<IInnerTreeNode[]>;
+    getIndex: (node: IInnerTreeNode) => number;
+    getNode: (node: IInnerTreeNode) => IInnerTreeNode;
+    setNodeValue: (node: IInnerTreeNode, key: keyof IInnerTreeNode, value: valueof<IInnerTreeNode>) => void;
+    setTree: (newTree: IInnerTreeNode[]) => void;
+    getTree: () => IInnerTreeNode[];
+    updateHashTreeData: () => void;
+    toggleChildNodeVisible: (node: IInnerTreeNode, visible: boolean) => void;
+    hashTreeData: Ref<Record<string | number, IInnerTreeNode>>;
+    getFlattenChildren: (node: IInnerTreeNode) => IInnerTreeNode[];
+}
+export interface IUseCheck {
+    checkNode: (node: IInnerTreeNode) => void;
+    uncheckNode: (node: IInnerTreeNode) => void;
+    toggleCheckNode: (node: IInnerTreeNode) => void;
+    getCheckedNodes: () => IInnerTreeNode[];
+}
+export interface IUseDisable {
+    disableSelectNode: (node: IInnerTreeNode) => void;
+    disableCheckNode: (node: IInnerTreeNode) => void;
+    disableToggleNode: (node: IInnerTreeNode) => void;
+    enableSelectNode: (node: IInnerTreeNode) => void;
+    enableCheckNode: (node: IInnerTreeNode) => void;
+    enableToggleNode: (node: IInnerTreeNode) => void;
+}
+export interface IUseOperate {
+    insertBefore: (parentNode: ITreeNode, node: ITreeNode, referenceNode?: ITreeNode) => void;
+    removeNode: (node: ITreeNode) => void;
+    editNode: (node: ITreeNode, label: string) => void;
+}
+export interface IUseSelect {
+    selectNode: (node: IInnerTreeNode) => void;
+    deselectNode: (node: IInnerTreeNode) => void;
+    toggleSelectNode: (node: IInnerTreeNode) => void;
+    getSelectedNode: () => IInnerTreeNode;
+}
+export interface IUseToggle {
+    expandNode: (node: IInnerTreeNode) => void;
+    collapseNode: (node: IInnerTreeNode) => void;
+    toggleNode: (node: IInnerTreeNode) => void;
+    expandAllNodes: () => void;
+}
+export interface IUseMergeNodes {
+    mergeTreeNodes: () => void;
+}
+export interface IUseLazyLoad {
+    lazyLoadNodes: (node: IInnerTreeNode) => void;
+}
+export interface IUseInitSelectCollection {
+    setInitSelectedNode: (node: IInnerTreeNode) => void;
+    getInitSelectedNodes: () => IInnerTreeNode[];
+    clearInitSelectedNodes: () => void;
+}
+export interface SearchFilterOption {
+    isFilter: boolean;
+    matchKey?: string;
+    pattern?: RegExp;
+}
+export interface IUseSearchFilter {
+    virtualListRef: Ref<HTMLElement | undefined>;
+    searchTree: (target: string, option: SearchFilterOption) => void;
+}
+export interface IDropType {
+    dropPrev?: boolean;
+    dropNext?: boolean;
+    dropInner?: boolean;
+}
+export type ICheckStrategy = 'upward' | 'downward' | 'both' | 'none';
+export type ICheck = boolean | ICheckStrategy;
+export type IDragdrop = boolean | IDropType;
+export type IOperateItem = 'add' | 'delete' | 'edit';
+export type IOperate = boolean | IOperateItem | Array<IOperateItem>;
+export interface LazyNodeResult {
+    treeItems: ITreeNode[];
+    node: IInnerTreeNode;
+}
+export interface DragState {
+    dropType?: keyof Required<IDropType>;
+    draggingNode?: HTMLElement | null;
+    draggingTreeNode?: IInnerTreeNode | null;
+}
+export interface IUseDraggable {
+    onDragstart: (event: DragEvent, treeNode: IInnerTreeNode) => void;
+    onDragover: (event: DragEvent) => void;
+    onDragleave: (event: DragEvent) => void;
+    onDrop: (event: DragEvent, dropNode: IInnerTreeNode) => void;
+    onDragend: (event: DragEvent) => void;
+}
+export interface IDropNode {
+    target: ITreeNode[];
+    index: number;
+    item: ITreeNode;
+}
+export type IUseTree = {
+    treeData: Ref<IInnerTreeNode[]>;
+} & IUseCore & IUseToggle & IUseSelect & IUseCheck & IUseDisable & IUseOperate & IUseMergeNodes & IUseLazyLoad & IUseSearchFilter & IUseDraggable;

package/types/tree/src/composables/use-tree.d.ts

@@ -1,22 +1,22 @@
-import { SetupContext } from 'vue';
-import { IInnerTreeNode, ITreeNode, IUseCore, IUseTree } from './use-tree-types';
-export declare const DEFAULT_TREE_PLUGINS: ((data: import("vue").Ref<IInnerTreeNode[]>, core: IUseCore, context: {
-    attrs: {
-        [x: string]: unknown;
-    };
-    slots: Readonly<{
-        [name: string]: import("vue").Slot<any> | undefined;
-    }>;
-    emit: (event: string, ...args: any[]) => void;
-    expose: (exposed?: Record<string, any> | undefined) => void;
-} | {
-    attrs: {
-        [x: string]: unknown;
-    };
-    slots: Readonly<{
-        [name: string]: import("vue").Slot<any> | undefined;
-    }>;
-    emit: (event: string, ...args: any[]) => void;
-    expose: (exposed?: Record<string, any> | undefined) => void;
-}, lazyLode: import("./use-tree-types").IUseLazyLoad) => import("./use-tree-types").IUseToggle)[];
-export declare function useTree(tree: ITreeNode[], plugins: never[] | undefined, context: SetupContext): Partial<IUseTree>;
+import { SetupContext } from 'vue';
+import { IInnerTreeNode, ITreeNode, IUseCore, IUseTree } from './use-tree-types';
+export declare const DEFAULT_TREE_PLUGINS: ((data: import("vue").Ref<IInnerTreeNode[], IInnerTreeNode[]>, core: IUseCore, context: {
+    attrs: {
+        [x: string]: unknown;
+    };
+    slots: Readonly<{
+        [name: string]: import("vue").Slot<any> | undefined;
+    }>;
+    emit: (event: string, ...args: any[]) => void;
+    expose: <Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed | undefined) => void;
+} | {
+    attrs: {
+        [x: string]: unknown;
+    };
+    slots: Readonly<{
+        [name: string]: import("vue").Slot<any> | undefined;
+    }>;
+    emit: (event: string, ...args: any[]) => void;
+    expose: <Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed | undefined) => void;
+}, lazyLode: import("./use-tree-types").IUseLazyLoad) => import("./use-tree-types").IUseToggle)[];
+export declare function useTree(tree: ITreeNode[], plugins: never[] | undefined, context: SetupContext): Partial<IUseTree>;

package/types/tree/src/composables/utils.d.ts

@@ -1,3 +1,3 @@
-import { IInnerTreeNode, ITreeNode } from './use-tree-types';
-export declare function flatToNested(flatTree: IInnerTreeNode[]): ITreeNode[];
-export declare function generateInnerTree(tree: ITreeNode[], key?: string, level?: number, path?: ITreeNode[]): IInnerTreeNode[];
+import { IInnerTreeNode, ITreeNode } from './use-tree-types';
+export declare function flatToNested(flatTree: IInnerTreeNode[]): ITreeNode[];
+export declare function generateInnerTree(tree: ITreeNode[], key?: string, level?: number, parentNode?: IInnerTreeNode): IInnerTreeNode[];

package/types/tree/src/const.d.ts

@@ -1,4 +1,4 @@
-export declare const USE_TREE_TOKEN = "use-tree-token";
-export declare const TREE_INSTANCE = "tree-instance";
-export declare const NODE_HEIGHT = 30;
-export declare const NODE_INDENT = 24;
+export declare const USE_TREE_TOKEN = "use-tree-token";
+export declare const TREE_INSTANCE = "tree-instance";
+export declare const NODE_HEIGHT = 30;
+export declare const NODE_INDENT = 24;

package/types/tree/src/tree-types.d.ts

@@ -1,43 +1,43 @@
-import type { ExtractPropTypes, PropType } from 'vue';
-import type { ICheck, IOperate, ITreeNode, IDragdrop, IInnerTreeNode } from './composables/use-tree-types';
-export declare const treeProps: {
-    height: {
-        type: PropType<string | number>;
-    };
-    check: {
-        type: PropType<ICheck>;
-        default: boolean;
-    };
-    dragdrop: {
-        type: PropType<IDragdrop>;
-        default: boolean;
-    };
-    operate: {
-        type: PropType<IOperate>;
-        default: boolean;
-    };
-    data: {
-        type: PropType<ITreeNode[]>;
-        default: never[];
-    };
-};
-export declare const treeNodeProps: {
-    check: {
-        type: PropType<ICheck>;
-        default: boolean;
-    };
-    dragdrop: {
-        type: PropType<IDragdrop>;
-        default: boolean;
-    };
-    operate: {
-        type: PropType<IOperate>;
-        default: boolean;
-    };
-    data: {
-        type: PropType<IInnerTreeNode>;
-        default: {};
-    };
-};
-export type TreeProps = ExtractPropTypes<typeof treeProps>;
-export type TreeNodeProps = ExtractPropTypes<typeof treeNodeProps>;
+import type { ExtractPropTypes, PropType } from 'vue';
+import type { ICheck, IOperate, ITreeNode, IDragdrop, IInnerTreeNode } from './composables/use-tree-types';
+export declare const treeProps: {
+    height: {
+        type: PropType<string | number>;
+    };
+    check: {
+        type: PropType<ICheck>;
+        default: boolean;
+    };
+    dragdrop: {
+        type: PropType<IDragdrop>;
+        default: boolean;
+    };
+    operate: {
+        type: PropType<IOperate>;
+        default: boolean;
+    };
+    data: {
+        type: PropType<ITreeNode[]>;
+        default: never[];
+    };
+};
+export declare const treeNodeProps: {
+    check: {
+        type: PropType<ICheck>;
+        default: boolean;
+    };
+    dragdrop: {
+        type: PropType<IDragdrop>;
+        default: boolean;
+    };
+    operate: {
+        type: PropType<IOperate>;
+        default: boolean;
+    };
+    data: {
+        type: PropType<IInnerTreeNode>;
+        default: {};
+    };
+};
+export type TreeProps = ExtractPropTypes<typeof treeProps>;
+export type TreeNodeProps = ExtractPropTypes<typeof treeNodeProps>;

package/types/tree/src/tree.d.ts

@@ -1,3 +1,3 @@
-import './tree.scss';
-declare const _default: import("vue").DefineSetupFnComponent<Record<string, any>, {}, {}, Record<string, any> & {}, import("vue").PublicProps>;
-export default _default;
+import './tree.scss';
+declare const _default: import("vue").DefineSetupFnComponent<Record<string, any>, {}, {}, Record<string, any> & {}, import("vue").PublicProps>;
+export default _default;

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

@@ -1,15 +1,15 @@
-import type { ICheck, ICheckStrategy, ITreeNode, IInnerTreeNode } from './composables/use-tree-types';
-/**
- * true 默认为 both，false 默认为 none。
- * "true" defaults to "both" and "false" to "none".
- */
-export declare const formatCheckStatus: (check: ICheck) => ICheckStrategy;
-/**
- * Standardized tree node
- * @param trees
- * @param keyName
- * @param childrenName
- * @param parentId
- * @returns IInnerTreeNode[]
- */
-export declare const formatBasicTree: (trees: ITreeNode[], keyName?: string, childrenName?: string, parentId?: string) => IInnerTreeNode[];
+import type { ICheck, ICheckStrategy, ITreeNode, IInnerTreeNode } from './composables/use-tree-types';
+/**
+ * true 默认为 both，false 默认为 none。
+ * "true" defaults to "both" and "false" to "none".
+ */
+export declare const formatCheckStatus: (check: ICheck) => ICheckStrategy;
+/**
+ * Standardized tree node
+ * @param trees
+ * @param keyName
+ * @param childrenName
+ * @param parentId
+ * @returns IInnerTreeNode[]
+ */
+export declare const formatBasicTree: (trees: ITreeNode[], keyName?: string, childrenName?: string, parentId?: string) => IInnerTreeNode[];

package/types/tree-select/__tests__/tree-select.spec.d.ts

@@ -1 +1 @@
-export {};
+export {};

package/types/tree-select/assets/close.d.ts

@@ -1,2 +1,2 @@
-declare const _default: () => any;
-export default _default;
+declare const _default: () => any;
+export default _default;

package/types/tree-select/assets/open.d.ts

@@ -1,2 +1,2 @@
-declare const _default: () => any;
-export default _default;
+declare const _default: () => any;
+export default _default;

package/types/tree-select/hooks/use-clear.d.ts

@@ -1,3 +1,3 @@
-import type { SetupContext, Ref } from 'vue';
-import { TreeSelectProps } from '../src/tree-select-types';
-export default function useClear(props: TreeSelectProps, ctx: SetupContext, data: Ref): any;
+import type { SetupContext, Ref } from 'vue';
+import { TreeSelectProps } from '../src/tree-select-types';
+export default function useClear(props: TreeSelectProps, ctx: SetupContext, data: Ref): any;

package/types/tree-select/hooks/use-select.d.ts

@@ -1,2 +1,2 @@
-import { TreeSelectProps } from '../src/tree-select-types';
-export default function useSelect(props: TreeSelectProps): any;
+import { TreeSelectProps } from '../src/tree-select-types';
+export default function useSelect(props: TreeSelectProps): any;

package/types/tree-select/hooks/use-toggle.d.ts

@@ -1,2 +1,2 @@
-import { TreeSelectProps } from '../src/tree-select-types';
-export default function useToggle(props: TreeSelectProps): any;
+import { TreeSelectProps } from '../src/tree-select-types';
+export default function useToggle(props: TreeSelectProps): any;

package/types/tree-select/index.d.ts

@@ -1,10 +1,10 @@
-import type { App } from 'vue';
-import TreeSelect from './src/tree-select';
-export { TreeSelect };
-declare const _default: {
-    title: string;
-    category: string;
-    status: string;
-    install(app: App): void;
-};
-export default _default;
+import type { App } from 'vue';
+import TreeSelect from './src/tree-select';
+export { TreeSelect };
+declare const _default: {
+    title: string;
+    category: string;
+    status: string;
+    install(app: App): void;
+};
+export default _default;