vft 0.0.185 → 0.0.187

package/es/components/tree/model/node.d.ts

@@ -1,49 +0,0 @@
-import type { Nullable } from 'vft/es/utils';
-import type { FakeNode, TreeKey, TreeNodeChildState, TreeNodeData, TreeNodeLoadedDefaultProps, TreeNodeOptions } from '../tree.type';
-import type TreeStore from './tree-store';
-export declare const getChildState: (node: Node[]) => TreeNodeChildState;
-declare class Node {
-    id: number;
-    text: string;
-    checked: boolean;
-    indeterminate: boolean;
-    data: TreeNodeData;
-    expanded: boolean;
-    parent: Node;
-    visible: boolean;
-    isCurrent: boolean;
-    store: TreeStore;
-    isLeafByUser: boolean;
-    isLeaf: boolean;
-    canFocus: boolean;
-    level: number;
-    loaded: boolean;
-    childNodes: Node[];
-    loading: boolean;
-    constructor(options: TreeNodeOptions);
-    initialize(): void;
-    setData(data: TreeNodeData): void;
-    get label(): string;
-    get key(): TreeKey;
-    get disabled(): boolean;
-    get nextSibling(): Nullable<Node>;
-    get previousSibling(): Nullable<Node>;
-    contains(target: Node, deep?: boolean): boolean;
-    remove(): void;
-    insertChild(child?: FakeNode | Node, index?: number, batch?: boolean): void;
-    updateNode(data: any): void;
-    insertBefore(child: FakeNode | Node, ref: Node): void;
-    insertAfter(child: FakeNode | Node, ref: Node): void;
-    removeChild(child: Node): void;
-    removeChildByData(data: TreeNodeData): void;
-    expand(callback?: () => void, expandParent?: boolean): void;
-    doCreateChildren(array: TreeNodeData[], defaultProps?: TreeNodeLoadedDefaultProps): void;
-    collapse(): void;
-    shouldLoadData(): boolean;
-    updateLeafState(): void;
-    setChecked(value?: boolean | string, deep?: boolean, recursion?: boolean, passValue?: boolean): void;
-    getChildren(forceInit?: boolean): TreeNodeData | TreeNodeData[] | null;
-    updateChildren(): void;
-    loadData(callback: (node: Node) => void, defaultProps?: TreeNodeLoadedDefaultProps): void;
-}
-export default Node;

package/es/components/tree/model/tree-store.d.ts

@@ -1,52 +0,0 @@
-import type { FilterNodeMethodFunction, FilterValue, LoadFunction, TreeData, TreeKey, TreeNodeData, TreeOptionProps, TreeStoreNodesMap, TreeStoreOptions } from '../tree.type';
-import Node from './node';
-export default class TreeStore {
-    currentNode: Node;
-    currentNodeKey: TreeKey;
-    nodesMap: TreeStoreNodesMap;
-    root: Node;
-    data: TreeData;
-    lazy: boolean;
-    load: LoadFunction;
-    filterNodeMethod: FilterNodeMethodFunction;
-    key: TreeKey;
-    defaultCheckedKeys: TreeKey[];
-    checkStrictly: boolean;
-    defaultExpandedKeys: TreeKey[];
-    autoExpandParent: boolean;
-    defaultExpandAll: boolean;
-    checkDescendants: boolean;
-    props: TreeOptionProps;
-    constructor(options: TreeStoreOptions);
-    initialize(): void;
-    filter(value: FilterValue): void;
-    setData(newVal: TreeData): void;
-    getNode(data: TreeKey | TreeNodeData | Node): Node;
-    insertBefore(data: TreeNodeData, refData: TreeKey | TreeNodeData | Node): void;
-    insertAfter(data: TreeNodeData, refData: TreeKey | TreeNodeData | Node): void;
-    updateNode(data: TreeNodeData, refData: TreeKey | TreeNodeData | Node): void;
-    remove(data: TreeNodeData | Node): void;
-    append(data: TreeNodeData, parentData: TreeNodeData | TreeKey | Node): void;
-    updateChildren(key: TreeKey, data: TreeData): void;
-    _initDefaultCheckedNodes(): void;
-    _initDefaultCheckedNode(node: Node): void;
-    setDefaultCheckedKey(newVal: TreeKey[]): void;
-    registerNode(node: Node): void;
-    deregisterNode(node: Node): void;
-    getCheckedNodes(leafOnly?: boolean, includeHalfChecked?: boolean): TreeNodeData[];
-    getCheckedKeys(leafOnly?: boolean): TreeKey[];
-    getHalfCheckedNodes(): TreeNodeData[];
-    getHalfCheckedKeys(): TreeKey[];
-    _getAllNodes(): Node[];
-    _setCheckedKeys(key: TreeKey, leafOnly: boolean | undefined, checkedKeys: {
-        [key: string]: boolean;
-    }): void;
-    setCheckedNodes(array: Node[], leafOnly?: boolean): void;
-    setCheckedKeys(keys: TreeKey[], leafOnly?: boolean): void;
-    setDefaultExpandedKeys(keys: TreeKey[]): void;
-    setChecked(data: TreeKey | TreeNodeData, checked: boolean, deep: boolean): void;
-    getCurrentNode(): Node;
-    setCurrentNode(currentNode: Node): void;
-    setUserCurrentNode(node: Node, shouldAutoExpandParent?: boolean): void;
-    setCurrentNodeKey(key?: TreeKey, shouldAutoExpandParent?: boolean): void;
-}

package/es/components/tree/model/useDragNode.d.ts

@@ -1,32 +0,0 @@
-import type { InjectionKey } from 'vue';
-import type Node from './node';
-interface TreeNode {
-    node: Node;
-    $el?: HTMLElement;
-}
-interface DragOptions {
-    event: DragEvent;
-    treeNode: TreeNode;
-}
-export interface DragEvents {
-    treeNodeDragStart: (options: DragOptions) => void;
-    treeNodeDragOver: (options: DragOptions) => void;
-    treeNodeDragEnd: (event: DragEvent) => void;
-}
-export declare const dragEventsKey: InjectionKey<DragEvents>;
-export declare function useDragNodeHandler({ props, ctx, el$, dropIndicator$, store }: {
-    props: any;
-    ctx: any;
-    el$: any;
-    dropIndicator$: any;
-    store: any;
-}): {
-    dragState: globalThis.Ref<{
-        showDropIndicator: boolean;
-        draggingNode: null;
-        dropNode: null;
-        allowDrop: boolean;
-        dropType: null;
-    }>;
-};
-export {};

package/es/components/tree/model/useKeydown.d.ts

@@ -1,7 +0,0 @@
-import type { Ref } from 'vue';
-import type TreeStore from './tree-store';
-interface UseKeydownOption {
-    el$: Ref<HTMLElement>;
-}
-export declare function useKeydown({ el$ }: UseKeydownOption, store: Ref<TreeStore>): void;
-export {};

package/es/components/tree/model/useNodeExpandEventBroadcast.d.ts

@@ -1,4 +0,0 @@
-import type Node from '../model/node';
-export declare function useNodeExpandEventBroadcast(props: any): {
-    broadcastExpanded: (node: Node) => void;
-};

package/es/components/tree/model/util.d.ts

@@ -1,7 +0,0 @@
-import type { SetupContext } from 'vue';
-import type { RootTreeType, TreeKey, TreeNodeData } from '../tree.type';
-import type Node from './node';
-export declare const NODE_KEY = "$treeNodeId";
-export declare const markNodeData: (node: Node, data: TreeNodeData) => void;
-export declare const getNodeKey: (key: TreeKey, data: TreeNodeData) => any;
-export declare const handleCurrentChange: (store: RootTreeType['store'], emit: SetupContext['emit'], setCurrent: () => void) => void;

package/es/components/tree/style/css.d.ts

@@ -1,2 +0,0 @@
-import 'vft/es/components/checkbox/style/css';
-import 'vft/theme-style/vft-tree.css';

package/es/components/tree/style/index.d.ts

@@ -1,2 +0,0 @@
-import 'vft/es/components/checkbox/style';
-import 'vft/theme-style/src/tree.scss';

package/es/components/tree/tree-node-content.vue.d.ts

@@ -1,14 +0,0 @@
-declare const _default: import("vue").DefineComponent<{
-    node: {
-        type: ObjectConstructor;
-        required: true;
-    };
-    renderContent: FunctionConstructor;
-}, () => any, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<{
-    node: {
-        type: ObjectConstructor;
-        required: true;
-    };
-    renderContent: FunctionConstructor;
-}>>, {}, {}>;
-export default _default;

package/es/components/tree/tree-node.vue.d.ts

@@ -1,83 +0,0 @@
-import type { Nullable } from 'vft/es/utils';
-import type { ComponentInternalInstance } from 'vue';
-import Node from './model/node';
-import type { RootTreeType, TreeNodeData } from './tree.type';
-declare const _default: import("vue").DefineComponent<{
-    node: {
-        type: typeof Node;
-        default: () => {};
-    };
-    props: {
-        type: ObjectConstructor;
-        default: () => {};
-    };
-    accordion: BooleanConstructor;
-    renderContent: FunctionConstructor;
-    renderAfterExpand: BooleanConstructor;
-    showCheckbox: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}, {
-    ns: {
-        namespace: globalThis.Ref<string>;
-        b: (blockSuffix?: string) => string;
-        e: (element?: string | undefined) => string;
-        m: (modifier?: string | undefined) => string;
-        be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
-        em: (element?: string | undefined, modifier?: string | undefined) => string;
-        bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
-        bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
-        is: {
-            (name: string, state: boolean | undefined): string;
-            (name: string): string;
-        };
-        cssVar: (object: Record<string, string | undefined>) => Record<string, string>;
-        cssVarName: (name: string) => string;
-        cssVarBlock: (object: Record<string, string | undefined>) => Record<string, string>;
-        cssVarBlockName: (name: string) => string;
-    };
-    node$: globalThis.Ref<Nullable<HTMLElement>>;
-    tree: RootTreeType | undefined;
-    expanded: globalThis.Ref<boolean>;
-    childNodeRendered: globalThis.Ref<boolean>;
-    oldChecked: globalThis.Ref<boolean>;
-    oldIndeterminate: globalThis.Ref<boolean>;
-    getNodeKey: (node: Node) => any;
-    getNodeClass: (node: Node) => any;
-    handleSelectChange: (checked: boolean, indeterminate: boolean) => void;
-    handleClick: (e: MouseEvent) => void;
-    handleContextMenu: (event: Event) => void;
-    handleExpandIconClick: () => void;
-    handleCheckChange: (value: any, ev: any) => void;
-    handleChildNodeExpand: (nodeData: TreeNodeData, node: Node, instance: ComponentInternalInstance) => void;
-    handleDragStart: (event: DragEvent) => void;
-    handleDragOver: (event: DragEvent) => void;
-    handleDrop: (event: DragEvent) => void;
-    handleDragEnd: (event: DragEvent) => void;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "node-expand"[], "node-expand", import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<{
-    node: {
-        type: typeof Node;
-        default: () => {};
-    };
-    props: {
-        type: ObjectConstructor;
-        default: () => {};
-    };
-    accordion: BooleanConstructor;
-    renderContent: FunctionConstructor;
-    renderAfterExpand: BooleanConstructor;
-    showCheckbox: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}>> & {
-    "onNode-expand"?: ((...args: any[]) => any) | undefined;
-}, {
-    props: Record<string, any>;
-    node: Node;
-    accordion: boolean;
-    renderAfterExpand: boolean;
-    showCheckbox: boolean;
-}, {}>;
-export default _default;

package/es/components/tree/tree.type.d.ts

@@ -1,103 +0,0 @@
-import type { Component, ComponentInternalInstance, h, Ref, SetupContext, VNode } from 'vue';
-import type Node from './model/node';
-import type TreeStore from './model/tree-store';
-export interface RootTreeType {
-    ctx: SetupContext<any>;
-    props: TreeComponentProps;
-    store: Ref<TreeStore>;
-    root: Ref<Node>;
-    currentNode: Ref<Node>;
-    instance: ComponentInternalInstance;
-}
-export declare type hType = typeof h;
-export declare type TreeData = TreeNodeData[];
-export declare type TreeKey = string | number;
-export declare interface FakeNode {
-    data: TreeNodeData;
-}
-export declare interface TreeNodeData {
-    [key: string]: any;
-}
-export declare interface TreeNodeLoadedDefaultProps {
-    checked?: boolean;
-}
-export declare interface TreeNodeChildState {
-    all: boolean;
-    none: boolean;
-    allWithoutDisable: boolean;
-    half: boolean;
-}
-export declare interface TreeNodeOptions {
-    data: TreeNodeData;
-    store: TreeStore;
-    parent?: Node;
-}
-export declare interface TreeStoreNodesMap {
-    [key: string]: Node;
-}
-export declare interface TreeStoreOptions {
-    key: TreeKey;
-    data: TreeData;
-    lazy: boolean;
-    props: TreeOptionProps;
-    load: LoadFunction;
-    currentNodeKey: TreeKey;
-    checkStrictly: boolean;
-    checkDescendants: boolean;
-    defaultCheckedKeys: TreeKey[];
-    defaultExpandedKeys: TreeKey[];
-    autoExpandParent: boolean;
-    defaultExpandAll: boolean;
-    filterNodeMethod: FilterNodeMethodFunction;
-}
-export declare interface TreeOptionProps {
-    children?: string;
-    label?: string | ((data: TreeNodeData, node: Node) => string);
-    disabled?: string | ((data: TreeNodeData, node: Node) => string);
-    isLeaf?: string | ((data: TreeNodeData, node: Node) => boolean);
-    class?: (data: TreeNodeData, node: Node) => string | {
-        [key: string]: boolean;
-    };
-}
-export declare type RenderContentFunction = (h: hType, context: RenderContentContext) => VNode | VNode[];
-export declare interface RenderContentContext {
-    _self: ComponentInternalInstance;
-    node: Node;
-    data: TreeNodeData;
-    store: TreeStore;
-}
-export declare type AllowDragFunction = (node: Node) => boolean;
-export declare type AllowDropType = 'inner' | 'prev' | 'next';
-export declare type AllowDropFunction = (draggingNode: Node, dropNode: Node, type: AllowDropType) => boolean;
-export declare type LoadFunction = (rootNode: Node, loadedCallback: (data: TreeData) => void) => void;
-export declare type FilterValue = any;
-export declare type FilterNodeMethodFunction = (value: FilterValue, data: TreeNodeData, child: Node) => boolean;
-export declare interface TreeComponentProps {
-    data: TreeData;
-    emptyText: string;
-    renderAfterExpand: boolean;
-    nodeKey: string;
-    checkStrictly: boolean;
-    expandOnClickNode: boolean;
-    defaultExpandAll: boolean;
-    checkOnClickNode: boolean;
-    checkDescendants: boolean;
-    autoExpandParent: boolean;
-    defaultCheckedKeys: TreeKey[];
-    defaultExpandedKeys: TreeKey[];
-    currentNodeKey: TreeKey;
-    renderContent: RenderContentFunction;
-    showCheckbox: boolean;
-    draggable: boolean;
-    allowDrag: AllowDragFunction;
-    allowDrop: AllowDropFunction;
-    props: TreeOptionProps;
-    lazy: boolean;
-    highlightCurrent: boolean;
-    load: LoadFunction;
-    filterNodeMethod: FilterNodeMethodFunction;
-    accordion: boolean;
-    indent: number;
-    icon: string | Component;
-}
-export declare type NodeDropType = 'before' | 'after' | 'inner' | 'none';

package/es/components/tree/tree.vue.d.ts

@@ -1,138 +0,0 @@
-import { IconProps } from 'vft/es/components/icon';
-import type { ComponentInternalInstance } from 'vue';
-import type Node from './model/node';
-import type { TreeComponentProps, TreeData, TreeKey, TreeNodeData } from './tree.type';
-export interface TreeProps {
-    data?: Array<any>;
-    emptyText?: string;
-    renderAfterExpand?: boolean;
-    nodeKey?: string;
-    checkStrictly?: boolean;
-    defaultExpandAll?: boolean;
-    expandOnClickNode?: boolean;
-    checkOnClickNode?: boolean;
-    checkDescendants?: boolean;
-    autoExpandParent?: boolean;
-    defaultCheckedKeys?: TreeComponentProps['defaultCheckedKeys'];
-    defaultExpandedKeys?: TreeComponentProps['defaultExpandedKeys'];
-    currentNodeKey?: string | number;
-    renderContent?: any;
-    showCheckbox?: boolean;
-    draggable?: boolean;
-    allowDrag?: any;
-    allowDrop?: any;
-    props?: TreeComponentProps['props'];
-    lazy?: boolean;
-    highlightCurrent?: boolean;
-    load?: TreeComponentProps['load'];
-    filterNodeMethod?: TreeComponentProps['filterNodeMethod'];
-    accordion?: boolean;
-    indent?: number;
-    icon?: IconProps;
-}
-declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<TreeProps>, {
-    renderAfterExpand: boolean;
-    expandOnClickNode: boolean;
-    data: never[];
-    autoExpandParent: boolean;
-    props: {
-        children: string;
-        label: string;
-        disabled: string;
-    };
-    indent: number;
-}>, {
-    filter: (value: any) => void;
-    getNodeKey: (node: Node) => any;
-    getNodePath: (data: TreeNodeData | TreeKey) => TreeNodeData[];
-    getCheckedNodes: (leafOnly?: boolean | undefined, includeHalfChecked?: boolean | undefined) => TreeNodeData[];
-    getCheckedKeys: (leafOnly?: boolean | undefined) => TreeKey[];
-    getCurrentNode: () => TreeNodeData;
-    getCurrentKey: () => any;
-    setCheckedNodes: (nodes: Node[], leafOnly?: boolean | undefined) => void;
-    setCheckedKeys: (keys: TreeKey[], leafOnly?: boolean | undefined) => void;
-    setChecked: (data: TreeNodeData | TreeKey, checked: boolean, deep: boolean) => void;
-    getHalfCheckedNodes: () => TreeNodeData[];
-    getHalfCheckedKeys: () => TreeKey[];
-    setCurrentNode: (node: Node, shouldAutoExpandParent?: boolean) => void;
-    setCurrentKey: (key?: TreeKey | undefined, shouldAutoExpandParent?: boolean) => void;
-    getNode: (data: TreeNodeData | TreeKey) => Node;
-    remove: (data: Node | TreeNodeData) => void;
-    append: (data: TreeNodeData, parentNode: Node | TreeNodeData | TreeKey) => void;
-    insertBefore: (data: TreeNodeData, refNode: Node | TreeNodeData | TreeKey) => void;
-    insertAfter: (data: TreeNodeData, refNode: Node | TreeNodeData | TreeKey) => void;
-    handleNodeExpand: (nodeData: TreeNodeData, node: Node, instance: ComponentInternalInstance) => void;
-    updateKeyChildren: (key: TreeKey, data: TreeData) => void;
-    updateNode: (data: TreeData, refNode: Node | TreeNodeData | TreeKey) => void;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    check: () => void;
-    "current-change": () => void;
-    "node-drag-start": () => void;
-    "node-drag-leave": () => void;
-    "node-drag-enter": () => void;
-    "node-drag-over": () => void;
-    "node-drag-end": () => void;
-    "node-drop": () => void;
-    "node-expand": () => void;
-    "check-change": () => void;
-    "node-click": () => void;
-    "node-contextmenu": () => void;
-    "node-collapse": () => void;
-}, string, import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<TreeProps>, {
-    renderAfterExpand: boolean;
-    expandOnClickNode: boolean;
-    data: never[];
-    autoExpandParent: boolean;
-    props: {
-        children: string;
-        label: string;
-        disabled: string;
-    };
-    indent: number;
-}>>> & {
-    "onCurrent-change"?: (() => any) | undefined;
-    "onNode-expand"?: (() => any) | undefined;
-    onCheck?: (() => any) | undefined;
-    "onNode-drag-start"?: (() => any) | undefined;
-    "onNode-drag-leave"?: (() => any) | undefined;
-    "onNode-drag-enter"?: (() => any) | undefined;
-    "onNode-drag-over"?: (() => any) | undefined;
-    "onNode-drag-end"?: (() => any) | undefined;
-    "onNode-drop"?: (() => any) | undefined;
-    "onCheck-change"?: (() => any) | undefined;
-    "onNode-click"?: (() => any) | undefined;
-    "onNode-contextmenu"?: (() => any) | undefined;
-    "onNode-collapse"?: (() => any) | undefined;
-}, {
-    data: any[];
-    props: import("./tree.type").TreeOptionProps;
-    autoExpandParent: boolean;
-    renderAfterExpand: boolean;
-    expandOnClickNode: boolean;
-    indent: number;
-}, {}>, {
-    empty?(_: {}): 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/es/components/types.d.ts

@@ -1,10 +0,0 @@
-export type ComponentSize = number | string | 'large' | 'small' | '';
-export type Nullable<T> = T | null;
-export type Recordable<T = any> = Record<string, T>;
-export type Awaitable<T> = Promise<T> | T;
-export type Arrayable<T> = T | T[];
-export type ClassObjectType = Record<string, boolean>;
-export type ClassType = string | ClassObjectType | ClassType[];
-export interface Fn<T = any, R = T> {
-    (...arg: T[]): R;
-}

package/es/components/upload/ajax.d.ts

@@ -1,9 +0,0 @@
-import type { UploadRequestHandler } from './types';
-export declare class UploadAjaxError extends Error {
-    name: string;
-    status: number;
-    method: string;
-    url: string;
-    constructor(message: string, status: number, method: string, url: string);
-}
-export declare const ajaxUpload: UploadRequestHandler;

package/es/components/upload/constants.d.ts

@@ -1,6 +0,0 @@
-import type { ComputedRef, InjectionKey } from 'vue';
-export interface UploadContext {
-    accept: ComputedRef<string>;
-}
-export declare const uploadContextKey: InjectionKey<UploadContext>;
-export declare const genFileId: () => number;