vue-devui 1.2.0 → 1.2.1-alpha.0

package/types/transfer/types.d.ts

@@ -0,0 +1,24 @@
+export interface IItem {
+    key: string;
+    value: string;
+    disabled: boolean;
+}
+export interface ITitles {
+    [index: number]: string;
+}
+export interface IModel {
+    [index: number]: string | number;
+}
+export interface TState {
+    data: IItem[];
+    allChecked: boolean;
+    checkedNum: number;
+    keyword: string;
+    checkedValues: string[];
+    filterData: IItem[];
+    disabled: boolean;
+}
+export interface TResult {
+    model: string[];
+    data: IItem[];
+}

package/types/tree/__tests__/basic-tree/basic-tree-data.d.ts

@@ -0,0 +1,2 @@
+import type { TreeData } from '../..';
+export declare const basicTreeData: TreeData;

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

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

package/types/tree/__tests__/checkable-tree/checkable-tree-data.d.ts

@@ -0,0 +1,3 @@
+import type { ITreeNode } from '../../';
+export declare const checkableTreeData: ITreeNode[];
+export declare const disabledCheckableTreeData: ITreeNode[];

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

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

package/types/tree/__tests__/dragdrop-tree/dragdrop-tree-data.d.ts

@@ -0,0 +1,2 @@
+import type { ITreeNode } from '../..';
+export declare const dragdropTreeData: ITreeNode[];

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

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

package/types/tree/__tests__/lazy-node-tree/lazy-tree-data.d.ts

@@ -0,0 +1,3 @@
+import type { TreeData } from '../..';
+export declare const lazyTreeData: TreeData;
+export declare const LoadingTreeData: TreeData;

package/types/tree/__tests__/lazy-node-tree/node-lazy-tree.spec.d.ts

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

package/types/tree/__tests__/node-merge/node-merge-data.d.ts

@@ -0,0 +1,2 @@
+import type { TreeData } from '../../';
+export declare const nodeMergeData: TreeData;

package/types/tree/__tests__/node-merge/node-merge.spec.d.ts

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

package/types/tree/__tests__/search-filter-tree/search-filter-data.d.ts

@@ -0,0 +1,2 @@
+import type { TreeData } from '../..';
+export declare const searchFilterData: TreeData;

package/types/tree/__tests__/search-filter-tree/search-filter-tree.spec.d.ts

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

package/types/tree/index.d.ts

@@ -0,0 +1,12 @@
+import type { App } from 'vue';
+import Tree from './src/tree';
+export * from './src/tree-types';
+export * from './src/composables/use-tree-types';
+export { Tree };
+declare const _default: {
+    title: string;
+    category: string;
+    status: string;
+    install(app: App): void;
+};
+export default _default;

package/types/tree/src/components/icon-close.d.ts

@@ -0,0 +1 @@
+export declare const IconClose: () => JSX.Element;

package/types/tree/src/components/icon-open.d.ts

@@ -0,0 +1 @@
+export declare const IconOpen: () => JSX.Element;

package/types/tree/src/components/tree-node-content.d.ts

@@ -0,0 +1,16 @@
+import { PropType } from 'vue';
+import { IInnerTreeNode } from '../composables';
+declare const _default: import("vue").DefineComponent<{
+    data: {
+        type: PropType<IInnerTreeNode>;
+        default: () => {};
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    data: {
+        type: PropType<IInnerTreeNode>;
+        default: () => {};
+    };
+}>>, {
+    data: IInnerTreeNode;
+}>;
+export default _default;

package/types/tree/src/components/tree-node-loading.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+export default _default;

package/types/tree/src/components/tree-node-toggle.d.ts

@@ -0,0 +1,16 @@
+import { PropType } from 'vue';
+import { ITreeNode } from '../composables';
+declare const _default: import("vue").DefineComponent<{
+    data: {
+        type: PropType<ITreeNode>;
+        default: () => {};
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    data: {
+        type: PropType<ITreeNode>;
+        default: () => {};
+    };
+}>>, {
+    data: ITreeNode;
+}>;
+export default _default;

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

@@ -0,0 +1,42 @@
+import { IInnerTreeNode } from '../composables';
+declare const _default: import("vue").DefineComponent<{
+    check: {
+        type: import("vue").PropType<import("../composables").ICheck>;
+        default: boolean;
+    };
+    dragdrop: {
+        type: import("vue").PropType<import("../composables").IDragdrop>;
+        default: boolean;
+    };
+    operate: {
+        type: import("vue").PropType<import("../composables").IOperate>;
+        default: boolean;
+    };
+    data: {
+        type: import("vue").PropType<IInnerTreeNode>;
+        default: {};
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    check: {
+        type: import("vue").PropType<import("../composables").ICheck>;
+        default: boolean;
+    };
+    dragdrop: {
+        type: import("vue").PropType<import("../composables").IDragdrop>;
+        default: boolean;
+    };
+    operate: {
+        type: import("vue").PropType<import("../composables").IOperate>;
+        default: boolean;
+    };
+    data: {
+        type: import("vue").PropType<IInnerTreeNode>;
+        default: {};
+    };
+}>>, {
+    data: IInnerTreeNode;
+    check: import("../composables").ICheck;
+    dragdrop: import("../composables").IDragdrop;
+    operate: import("../composables").IOperate;
+}>;
+export default _default;

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

@@ -0,0 +1,15 @@
+export * from './use-check';
+export * from './use-core';
+export * from './use-disable';
+export * from './use-dragdrop';
+export * from './use-init-select-collection';
+export * from './use-lazy-load';
+export * from './use-merge-nodes';
+export * from './use-operate';
+export * from './use-search-filter';
+export * from './use-select';
+export * from './use-toggle';
+export * from './utils';
+export * from './use-tree';
+export * from './use-tree-node';
+export * from './use-tree-types';

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

@@ -0,0 +1,5 @@
+import { Ref, SetupContext } from 'vue';
+import { ICheckStrategy, IInnerTreeNode, IUseCore, IUseCheck } from './use-tree-types';
+export declare function useCheck(options?: Ref<{
+    checkStrategy: ICheckStrategy;
+}>): (data: Ref<IInnerTreeNode[]>, core: IUseCore, context: SetupContext) => IUseCheck;

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

@@ -0,0 +1,3 @@
+import { Ref } from 'vue';
+import { IInnerTreeNode, IUseCore } from './use-tree-types';
+export declare function useCore(): (data: Ref<IInnerTreeNode[]>) => IUseCore;

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

@@ -0,0 +1,3 @@
+import { Ref } from 'vue';
+import { IInnerTreeNode, IUseCore, IUseDisable } from './use-tree-types';
+export declare function useDisable(): (data: Ref<IInnerTreeNode[]>, core: IUseCore) => IUseDisable;

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

@@ -0,0 +1,4 @@
+import type { Ref } from 'vue';
+import type { TreeProps } from '../tree-types';
+import type { IUseDraggable, IInnerTreeNode } from './use-tree-types';
+export declare function useDragdrop(props: TreeProps, data: Ref<IInnerTreeNode[]>): () => IUseDraggable;

package/types/tree/src/composables/use-init-select-collection.d.ts

@@ -0,0 +1,2 @@
+import { IUseInitSelectCollection } from './use-tree-types';
+export declare function useInitSelectCollection(): IUseInitSelectCollection;

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

@@ -0,0 +1,3 @@
+import { Ref, SetupContext } from 'vue';
+import { IInnerTreeNode, IUseCore, IUseLazyLoad } from './use-tree-types';
+export declare function useLazyLoad(): (data: Ref<IInnerTreeNode[]>, core: IUseCore, context: SetupContext) => IUseLazyLoad;

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

@@ -0,0 +1,3 @@
+import { Ref } from 'vue';
+import { IInnerTreeNode, IUseCore, IUseMergeNodes } from './use-tree-types';
+export declare function useMergeNodes(): (data: Ref<IInnerTreeNode[]>, core: IUseCore) => IUseMergeNodes;

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

@@ -0,0 +1,3 @@
+import { Ref } from 'vue';
+import { IInnerTreeNode, IUseCore, IUseOperate } from './use-tree-types';
+export declare function useOperate(): (data: Ref<IInnerTreeNode[]>, core: IUseCore) => IUseOperate;

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

@@ -0,0 +1,3 @@
+import { Ref } from 'vue';
+import { IInnerTreeNode, IUseCore, IUseSearchFilter } from './use-tree-types';
+export declare function useSearchFilter(): (data: Ref<IInnerTreeNode[]>, core: IUseCore) => IUseSearchFilter;

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

@@ -0,0 +1,3 @@
+import { Ref, SetupContext } from 'vue';
+import { IInnerTreeNode, IUseCore, IUseSelect } from './use-tree-types';
+export declare function useSelect(): (data: Ref<IInnerTreeNode[]>, core: IUseCore, context: SetupContext) => IUseSelect;

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

@@ -0,0 +1,3 @@
+import { Ref, SetupContext } from 'vue';
+import { IInnerTreeNode, IUseCore, IUseToggle, IUseLazyLoad } from './use-tree-types';
+export declare function useToggle(): (data: Ref<IInnerTreeNode[]>, core: IUseCore, context: SetupContext, lazyLode: IUseLazyLoad) => IUseToggle;

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

@@ -0,0 +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;

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

@@ -0,0 +1,129 @@
+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 declare 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 declare type ICheckStrategy = 'upward' | 'downward' | 'both' | 'none';
+export declare type ICheck = boolean | ICheckStrategy;
+export declare type IDragdrop = boolean | IDropType;
+export declare type IOperateItem = 'add' | 'delete' | 'edit';
+export declare 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 declare type IUseTree = {
+    treeData: Ref<IInnerTreeNode[]>;
+} & IUseCore & IUseToggle & IUseSelect & IUseCheck & IUseDisable & IUseOperate & IUseMergeNodes & IUseLazyLoad & IUseSearchFilter & IUseDraggable;

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

@@ -0,0 +1,4 @@
+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: SetupContext<import("vue").EmitsOptions>, 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

@@ -0,0 +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[];

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

@@ -0,0 +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;

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

@@ -0,0 +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 declare type TreeProps = ExtractPropTypes<typeof treeProps>;
+export declare type TreeNodeProps = ExtractPropTypes<typeof treeNodeProps>;

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

@@ -0,0 +1,48 @@
+import './tree.scss';
+declare const _default: import("vue").DefineComponent<{
+    height: {
+        type: import("vue").PropType<string | number>;
+    };
+    check: {
+        type: import("vue").PropType<import("./composables").ICheck>;
+        default: boolean;
+    };
+    dragdrop: {
+        type: import("vue").PropType<import("./composables").IDragdrop>;
+        default: boolean;
+    };
+    operate: {
+        type: import("vue").PropType<import("./composables").IOperate>;
+        default: boolean;
+    };
+    data: {
+        type: import("vue").PropType<import("./composables").ITreeNode[]>;
+        default: never[];
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, "toggle-change" | "check-change" | "lazy-load" | "select-change" | "node-click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    height: {
+        type: import("vue").PropType<string | number>;
+    };
+    check: {
+        type: import("vue").PropType<import("./composables").ICheck>;
+        default: boolean;
+    };
+    dragdrop: {
+        type: import("vue").PropType<import("./composables").IDragdrop>;
+        default: boolean;
+    };
+    operate: {
+        type: import("vue").PropType<import("./composables").IOperate>;
+        default: boolean;
+    };
+    data: {
+        type: import("vue").PropType<import("./composables").ITreeNode[]>;
+        default: never[];
+    };
+}>>, {
+    data: import("./composables").ITreeNode[];
+    check: import("./composables").ICheck;
+    dragdrop: import("./composables").IDragdrop;
+    operate: import("./composables").IOperate;
+}>;
+export default _default;

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

@@ -0,0 +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 | undefined) => IInnerTreeNode[];

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

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

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

@@ -0,0 +1,2 @@
+declare const _default: () => JSX.Element;
+export default _default;

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

@@ -0,0 +1,2 @@
+declare const _default: () => JSX.Element;
+export default _default;

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

@@ -0,0 +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;

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

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

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

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

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

@@ -0,0 +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;

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

@@ -0,0 +1,63 @@
+import type { PropType, ExtractPropTypes } from 'vue';
+export interface TreeItem {
+    id: number | string;
+    label: string;
+    parent?: TreeItem;
+    children?: Array<TreeItem>;
+    level?: number;
+    loading?: boolean;
+    opened?: boolean;
+    checked?: boolean;
+    halfchecked?: boolean;
+    disabled?: boolean;
+    [prop: string]: any;
+}
+export declare type TreeData = Array<TreeItem>;
+export declare type ModelValue = number | string | Array<number | string>;
+export declare const treeSelectProps: {
+    readonly modelValue: {
+        readonly type: PropType<ModelValue>;
+        readonly default: "";
+    };
+    readonly treeData: {
+        readonly type: PropType<TreeData>;
+        readonly default: () => never[];
+    };
+    readonly placeholder: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly disabled: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly multiple: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly leafOnly: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly searchable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly allowClear: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly enableLabelization: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly onToggleChange: {
+        readonly type: PropType<(bool: boolean) => void>;
+        readonly default: undefined;
+    };
+    readonly onValueChange: {
+        readonly type: PropType<(item: TreeItem, index: number) => void>;
+        readonly default: undefined;
+    };
+};
+export declare type TreeSelectProps = ExtractPropTypes<typeof treeSelectProps>;