vue-devui 1.2.0 → 1.2.1-alpha.0

package/types/upload/src/upload.d.ts

@@ -0,0 +1,388 @@
+/// <reference types="node" />
+import type { IFileResponse } from './upload-types';
+import { UploadStatus } from './upload-types';
+import './upload.scss';
+declare const _default: import("vue").DefineComponent<{
+    readonly accept: {
+        readonly type: StringConstructor;
+    };
+    readonly webkitdirectory: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly uploadOptions: {
+        readonly type: import("vue").PropType<import("./upload-types").IUploadOptions>;
+    };
+    readonly multiple: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly autoUpload: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly placeholder: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly modelValue: {
+        readonly type: import("vue").PropType<File[]>;
+        readonly default: () => never[];
+    };
+    readonly droppable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly beforeUpload: {
+        readonly type: import("vue").PropType<(file: {
+            status: UploadStatus;
+            response: unknown;
+            percentage: number;
+            file: {
+                readonly lastModified: number;
+                readonly name: string;
+                readonly webkitRelativePath: string;
+                readonly size: number;
+                readonly type: string;
+                arrayBuffer: {
+                    (): Promise<ArrayBuffer>;
+                    (): Promise<ArrayBuffer>;
+                };
+                slice: {
+                    (start?: number | undefined, end?: number | undefined, contentType?: string | undefined): Blob;
+                    (start?: number | undefined, end?: number | undefined, contentType?: string | undefined): Blob;
+                };
+                stream: {
+                    (): ReadableStream<any>;
+                    (): NodeJS.ReadableStream;
+                };
+                text: {
+                    (): Promise<string>;
+                    (): Promise<string>;
+                };
+            };
+            uploadOptions?: {
+                uri: string | {
+                    hash: string;
+                    host: string;
+                    hostname: string;
+                    href: string;
+                    toString: () => string;
+                    readonly origin: string;
+                    password: string;
+                    pathname: string;
+                    port: string;
+                    protocol: string;
+                    search: string;
+                    readonly searchParams: {
+                        append: (name: string, value: string) => void;
+                        delete: (name: string) => void;
+                        get: (name: string) => string | null;
+                        getAll: (name: string) => string[];
+                        has: (name: string) => boolean;
+                        set: (name: string, value: string) => void;
+                        sort: () => void;
+                        toString: () => string;
+                        forEach: (callbackfn: (value: string, key: string, parent: URLSearchParams) => void, thisArg?: any) => void;
+                        entries: () => IterableIterator<[string, string]>;
+                        keys: () => IterableIterator<string>;
+                        values: () => IterableIterator<string>;
+                        [Symbol.iterator]: () => IterableIterator<[string, string]>;
+                    };
+                    username: string;
+                    toJSON: () => string;
+                };
+                method?: string | undefined;
+                maximumSize?: number | undefined;
+                headers?: {
+                    [key: string]: string;
+                } | undefined;
+                authToken?: string | undefined;
+                authTokenHeader?: string | undefined;
+                additionalParameter?: {
+                    [key: string]: string | Blob;
+                } | undefined;
+                fileFieldName?: string | undefined;
+                checkSameName?: boolean | undefined;
+                withCredentials?: boolean | undefined;
+                responseType?: "text" | "arraybuffer" | "blob" | "json" | undefined;
+            } | undefined;
+            send: (uploadFiles?: any[] | undefined) => Promise<IFileResponse<unknown>>;
+            parallelUploadFiles: (fileFieldName_: string, additionalParameter: Record<string, string | Blob> | undefined) => FormData;
+            oneTimeUploadFiles: (fileFieldName_: string, additionalParameter: Record<string, string | Blob> | undefined, uploadFiles: any[]) => FormData;
+            cancel: () => void;
+        }[]) => boolean | Promise<boolean>>;
+    };
+    readonly dynamicUploadOptionsFn: {
+        readonly type: import("vue").PropType<(files: unknown, uploadOptions: unknown) => import("./upload-types").IUploadOptions>;
+    };
+    readonly disabled: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly onChange: {
+        readonly type: import("vue").PropType<(files: File[], uploadFiles: File[]) => void>;
+    };
+    readonly fileDrop: {
+        readonly type: import("vue").PropType<(v: unknown) => void>;
+        readonly default: undefined;
+    };
+    readonly fileOver: {
+        readonly type: import("vue").PropType<(v: boolean) => void>;
+        readonly default: undefined;
+    };
+    readonly fileSelect: {
+        readonly type: import("vue").PropType<(v: File) => void>;
+        readonly default: undefined;
+    };
+    readonly deleteUploadedFile: {
+        readonly type: import("vue").PropType<(v: string) => void>;
+        readonly default: undefined;
+    };
+    readonly onError: {
+        readonly type: import("vue").PropType<(v: {
+            file: File;
+            response: unknown;
+        }) => void>;
+        readonly default: undefined;
+    };
+    readonly onSuccess: {
+        readonly type: import("vue").PropType<(v: {
+            file: File;
+            response: unknown;
+        }[]) => void>;
+        readonly default: undefined;
+    };
+    readonly onExceed: {
+        readonly type: import("vue").PropType<(files: File[], uploadFiles: File[]) => void>;
+        readonly default: undefined;
+    };
+    readonly onProgress: {
+        readonly type: import("vue").PropType<(files: File[], uploadFiles: File[]) => void>;
+        readonly default: undefined;
+    };
+    readonly onPreview: {
+        readonly type: import("vue").PropType<(file: File) => void>;
+        readonly default: undefined;
+    };
+    readonly oneTimeUpload: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly limit: {
+        readonly type: NumberConstructor;
+        readonly default: 0;
+    };
+    readonly httpRequest: {
+        readonly type: import("vue").PropType<(files: File[]) => void>;
+        readonly default: undefined;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "fileDrop" | "fileOver" | "fileSelect" | "deleteUploadedFile")[], "update:modelValue" | "fileDrop" | "fileOver" | "fileSelect" | "deleteUploadedFile", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly accept: {
+        readonly type: StringConstructor;
+    };
+    readonly webkitdirectory: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly uploadOptions: {
+        readonly type: import("vue").PropType<import("./upload-types").IUploadOptions>;
+    };
+    readonly multiple: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly autoUpload: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly placeholder: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly modelValue: {
+        readonly type: import("vue").PropType<File[]>;
+        readonly default: () => never[];
+    };
+    readonly droppable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly beforeUpload: {
+        readonly type: import("vue").PropType<(file: {
+            status: UploadStatus;
+            response: unknown;
+            percentage: number;
+            file: {
+                readonly lastModified: number;
+                readonly name: string;
+                readonly webkitRelativePath: string;
+                readonly size: number;
+                readonly type: string;
+                arrayBuffer: {
+                    (): Promise<ArrayBuffer>;
+                    (): Promise<ArrayBuffer>;
+                };
+                slice: {
+                    (start?: number | undefined, end?: number | undefined, contentType?: string | undefined): Blob;
+                    (start?: number | undefined, end?: number | undefined, contentType?: string | undefined): Blob;
+                };
+                stream: {
+                    (): ReadableStream<any>;
+                    (): NodeJS.ReadableStream;
+                };
+                text: {
+                    (): Promise<string>;
+                    (): Promise<string>;
+                };
+            };
+            uploadOptions?: {
+                uri: string | {
+                    hash: string;
+                    host: string;
+                    hostname: string;
+                    href: string;
+                    toString: () => string;
+                    readonly origin: string;
+                    password: string;
+                    pathname: string;
+                    port: string;
+                    protocol: string;
+                    search: string;
+                    readonly searchParams: {
+                        append: (name: string, value: string) => void;
+                        delete: (name: string) => void;
+                        get: (name: string) => string | null;
+                        getAll: (name: string) => string[];
+                        has: (name: string) => boolean;
+                        set: (name: string, value: string) => void;
+                        sort: () => void;
+                        toString: () => string;
+                        forEach: (callbackfn: (value: string, key: string, parent: URLSearchParams) => void, thisArg?: any) => void;
+                        entries: () => IterableIterator<[string, string]>;
+                        keys: () => IterableIterator<string>;
+                        values: () => IterableIterator<string>;
+                        [Symbol.iterator]: () => IterableIterator<[string, string]>;
+                    };
+                    username: string;
+                    toJSON: () => string;
+                };
+                method?: string | undefined;
+                maximumSize?: number | undefined;
+                headers?: {
+                    [key: string]: string;
+                } | undefined;
+                authToken?: string | undefined;
+                authTokenHeader?: string | undefined;
+                additionalParameter?: {
+                    [key: string]: string | Blob;
+                } | undefined;
+                fileFieldName?: string | undefined;
+                checkSameName?: boolean | undefined;
+                withCredentials?: boolean | undefined;
+                responseType?: "text" | "arraybuffer" | "blob" | "json" | undefined;
+            } | undefined;
+            send: (uploadFiles?: any[] | undefined) => Promise<IFileResponse<unknown>>;
+            parallelUploadFiles: (fileFieldName_: string, additionalParameter: Record<string, string | Blob> | undefined) => FormData;
+            oneTimeUploadFiles: (fileFieldName_: string, additionalParameter: Record<string, string | Blob> | undefined, uploadFiles: any[]) => FormData;
+            cancel: () => void;
+        }[]) => boolean | Promise<boolean>>;
+    };
+    readonly dynamicUploadOptionsFn: {
+        readonly type: import("vue").PropType<(files: unknown, uploadOptions: unknown) => import("./upload-types").IUploadOptions>;
+    };
+    readonly disabled: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly onChange: {
+        readonly type: import("vue").PropType<(files: File[], uploadFiles: File[]) => void>;
+    };
+    readonly fileDrop: {
+        readonly type: import("vue").PropType<(v: unknown) => void>;
+        readonly default: undefined;
+    };
+    readonly fileOver: {
+        readonly type: import("vue").PropType<(v: boolean) => void>;
+        readonly default: undefined;
+    };
+    readonly fileSelect: {
+        readonly type: import("vue").PropType<(v: File) => void>;
+        readonly default: undefined;
+    };
+    readonly deleteUploadedFile: {
+        readonly type: import("vue").PropType<(v: string) => void>;
+        readonly default: undefined;
+    };
+    readonly onError: {
+        readonly type: import("vue").PropType<(v: {
+            file: File;
+            response: unknown;
+        }) => void>;
+        readonly default: undefined;
+    };
+    readonly onSuccess: {
+        readonly type: import("vue").PropType<(v: {
+            file: File;
+            response: unknown;
+        }[]) => void>;
+        readonly default: undefined;
+    };
+    readonly onExceed: {
+        readonly type: import("vue").PropType<(files: File[], uploadFiles: File[]) => void>;
+        readonly default: undefined;
+    };
+    readonly onProgress: {
+        readonly type: import("vue").PropType<(files: File[], uploadFiles: File[]) => void>;
+        readonly default: undefined;
+    };
+    readonly onPreview: {
+        readonly type: import("vue").PropType<(file: File) => void>;
+        readonly default: undefined;
+    };
+    readonly oneTimeUpload: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly limit: {
+        readonly type: NumberConstructor;
+        readonly default: 0;
+    };
+    readonly httpRequest: {
+        readonly type: import("vue").PropType<(files: File[]) => void>;
+        readonly default: undefined;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onFileDrop?: ((...args: any[]) => any) | undefined;
+    onFileOver?: ((...args: any[]) => any) | undefined;
+    onFileSelect?: ((...args: any[]) => any) | undefined;
+    onDeleteUploadedFile?: ((...args: any[]) => any) | undefined;
+}, {
+    readonly disabled: boolean;
+    readonly multiple: boolean;
+    readonly onError: (v: {
+        file: File;
+        response: unknown;
+    }) => void;
+    readonly onProgress: (files: File[], uploadFiles: File[]) => void;
+    readonly placeholder: string;
+    readonly modelValue: File[];
+    readonly webkitdirectory: boolean;
+    readonly autoUpload: boolean;
+    readonly droppable: boolean;
+    readonly fileDrop: (v: unknown) => void;
+    readonly fileOver: (v: boolean) => void;
+    readonly fileSelect: (v: File) => void;
+    readonly deleteUploadedFile: (v: string) => void;
+    readonly onSuccess: (v: {
+        file: File;
+        response: unknown;
+    }[]) => void;
+    readonly onExceed: (files: File[], uploadFiles: File[]) => void;
+    readonly onPreview: (file: File) => void;
+    readonly oneTimeUpload: boolean;
+    readonly limit: number;
+    readonly httpRequest: (files: File[]) => void;
+}>;
+export default _default;

package/types/virtual-list/index.d.ts

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

package/types/virtual-list/src/components/container.d.ts

@@ -0,0 +1,28 @@
+declare const _default: import("vue").DefineComponent<{
+    readonly height: {
+        readonly type: NumberConstructor;
+    };
+    readonly offset: {
+        readonly type: NumberConstructor;
+    };
+    readonly disabled: {
+        readonly type: import("vue").PropType<() => void>;
+    };
+    readonly onInnerResize: {
+        readonly type: import("vue").PropType<() => void>;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly height: {
+        readonly type: NumberConstructor;
+    };
+    readonly offset: {
+        readonly type: NumberConstructor;
+    };
+    readonly disabled: {
+        readonly type: import("vue").PropType<() => void>;
+    };
+    readonly onInnerResize: {
+        readonly type: import("vue").PropType<() => void>;
+    };
+}>>, {}>;
+export default _default;

package/types/virtual-list/src/components/item.d.ts

@@ -0,0 +1,12 @@
+import type { FunctionalComponent, VNode } from 'vue';
+import { RenderFunc, SharedConfig } from '../virtual-list-types';
+export interface ItemProps {
+    setRef: (element: HTMLElement & {
+        $el: never;
+    }) => void;
+}
+declare const Item: FunctionalComponent<ItemProps>;
+export declare function renderChildren<T>(list: T[], startIndex: number, endIndex: number, setNodeRef: (item: T, element: HTMLElement & {
+    $el: never;
+}) => void, { getKey }: SharedConfig<T>, renderFunc: RenderFunc<T>): string | VNode[];
+export default Item;

package/types/virtual-list/src/components/scroll-bar.d.ts

@@ -0,0 +1,46 @@
+declare const _default: import("vue").DefineComponent<{
+    readonly scrollTop: {
+        readonly type: NumberConstructor;
+    };
+    readonly scrollHeight: {
+        readonly type: NumberConstructor;
+    };
+    readonly height: {
+        readonly type: NumberConstructor;
+    };
+    readonly count: {
+        readonly type: NumberConstructor;
+    };
+    readonly onScroll: {
+        readonly type: import("vue").PropType<(scrollTop: number) => void>;
+    };
+    readonly onStartMove: {
+        readonly type: import("vue").PropType<() => void>;
+    };
+    readonly onStopMove: {
+        readonly type: import("vue").PropType<() => void>;
+    };
+}, () => 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<{
+    readonly scrollTop: {
+        readonly type: NumberConstructor;
+    };
+    readonly scrollHeight: {
+        readonly type: NumberConstructor;
+    };
+    readonly height: {
+        readonly type: NumberConstructor;
+    };
+    readonly count: {
+        readonly type: NumberConstructor;
+    };
+    readonly onScroll: {
+        readonly type: import("vue").PropType<(scrollTop: number) => void>;
+    };
+    readonly onStartMove: {
+        readonly type: import("vue").PropType<() => void>;
+    };
+    readonly onStopMove: {
+        readonly type: import("vue").PropType<() => void>;
+    };
+}>>, {}>;
+export default _default;

package/types/virtual-list/src/const.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_ITEM_HEIGHT = 20;

package/types/virtual-list/src/hooks/use-frame-wheel.d.ts

@@ -0,0 +1,7 @@
+import type { Ref } from 'vue';
+interface FireFoxDOMMouseScrollEvent {
+    detail?: number;
+    preventDefault?: () => void;
+}
+export default function useFrameWheel(inVirtual: Ref<boolean>, isScrollAtTop: Ref<boolean>, isScrollAtBottom: Ref<boolean>, onWheelDelta: (offset: number) => void): [(e: WheelEvent) => void, (e: FireFoxDOMMouseScrollEvent) => void];
+export {};

package/types/virtual-list/src/hooks/use-heights.d.ts

@@ -0,0 +1,5 @@
+import type { Ref, ShallowRef } from 'vue';
+import { GetKey, CacheMap } from '../virtual-list-types';
+export default function useHeights<T>(mergedData: ShallowRef<unknown[]>, getKey: GetKey<T>): [(item: T, instance: HTMLElement & {
+    $el: never;
+}) => void, () => void, CacheMap, Ref<symbol>];

package/types/virtual-list/src/hooks/use-mobile-touch-move.d.ts

@@ -0,0 +1,2 @@
+import type { Ref } from 'vue';
+export default function useMobileTouchMove(inVirtual: Ref<boolean>, listRef: Ref<HTMLDivElement | undefined>, callback: (offsetY: number, smoothOffset?: boolean) => boolean): void;

package/types/virtual-list/src/hooks/use-origin-scroll.d.ts

@@ -0,0 +1,3 @@
+import type { Ref } from 'vue';
+declare const _default: (isScrollAtTop: Ref<boolean>, isScrollAtBottom: Ref<boolean>) => (deltaY: number, smoothOffset: boolean) => boolean;
+export default _default;

package/types/virtual-list/src/hooks/use-virtual.d.ts

@@ -0,0 +1,8 @@
+import type { ComputedRef } from 'vue';
+import { VirtualListProps } from '../virtual-list-types';
+interface IUseVirtual {
+    isVirtual: ComputedRef<boolean>;
+    inVirtual: ComputedRef<boolean>;
+}
+export default function useVirtual(props: VirtualListProps): IUseVirtual;
+export {};

package/types/virtual-list/src/utils.d.ts

@@ -0,0 +1,12 @@
+import type { VNode, ComponentInternalInstance } from 'vue';
+export declare const isValid: (value?: unknown) => boolean;
+export declare const isEmptyElement: (c?: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | undefined) => boolean;
+export declare const flattenChildren: (children?: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, filterEmpty?: boolean) => VNode[];
+export declare const findDOMNode: (instance: (ComponentInternalInstance & {
+    $el: VNode['el'];
+}) | null) => VNode['el'];
+export declare const isFF: boolean;

package/types/virtual-list/src/virtual-list-types.d.ts

@@ -0,0 +1,93 @@
+import type { PropType, ExtractPropTypes, CSSProperties, VNodeTypes } from 'vue';
+interface ResizeObserverSize {
+    width: number;
+    height: number;
+    offsetWidth: number;
+    offsetHeight: number;
+}
+export declare const virtualListProps: {
+    readonly data: {
+        readonly type: PropType<Record<string, never>[]>;
+        readonly default: () => never[];
+    };
+    readonly component: {
+        readonly type: StringConstructor;
+        readonly default: "div";
+    };
+    readonly height: {
+        readonly type: NumberConstructor;
+        readonly default: 100;
+    };
+    readonly itemHeight: {
+        readonly type: NumberConstructor;
+        readonly default: 20;
+    };
+    readonly virtual: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly fullHeight: {
+        readonly type: BooleanConstructor;
+    };
+    readonly itemKey: {
+        readonly type: PropType<string | number | ((item: Record<string, never>) => string | number)>;
+    };
+};
+export declare const resizeObserverContainerProps: {
+    readonly height: {
+        readonly type: NumberConstructor;
+    };
+    readonly offset: {
+        readonly type: NumberConstructor;
+    };
+    readonly disabled: {
+        readonly type: PropType<() => void>;
+    };
+    readonly onInnerResize: {
+        readonly type: PropType<() => void>;
+    };
+};
+export declare const scrollBarProps: {
+    readonly scrollTop: {
+        readonly type: NumberConstructor;
+    };
+    readonly scrollHeight: {
+        readonly type: NumberConstructor;
+    };
+    readonly height: {
+        readonly type: NumberConstructor;
+    };
+    readonly count: {
+        readonly type: NumberConstructor;
+    };
+    readonly onScroll: {
+        readonly type: PropType<(scrollTop: number) => void>;
+    };
+    readonly onStartMove: {
+        readonly type: PropType<() => void>;
+    };
+    readonly onStopMove: {
+        readonly type: PropType<() => void>;
+    };
+};
+export declare const resizeObserverProps: {
+    readonly disabled: {
+        readonly type: BooleanConstructor;
+    };
+    readonly onResize: {
+        readonly type: PropType<(size: ResizeObserverSize, element: HTMLElement) => void>;
+    };
+};
+export declare type RenderFunc<T> = (item: T, index: number, props: {
+    style?: CSSProperties;
+}) => VNodeTypes;
+export interface SharedConfig<T> {
+    getKey: (item: T) => string | number | undefined;
+}
+export interface IScrollBarExposeFunction {
+    onShowBar?: () => void;
+}
+export declare type GetKey<T = Record<string, never>> = (item: T) => string | number | undefined;
+export declare type CacheMap = Map<unknown, number>;
+export declare type VirtualListProps = ExtractPropTypes<typeof virtualListProps>;
+export {};