vue-devui 1.6.3 → 1.6.4-markdown.0

package/types/date-picker-pro/src/components/month-calendar-panel.d.ts

@@ -1,95 +1,2 @@
-declare const _default: import("vue").DefineComponent<{
-    readonly format: {
-        type: StringConstructor;
-    };
-    readonly showTime: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    readonly size: {
-        type: import("vue").PropType<import("../../../input").InputSize>;
-        default: string;
-    };
-    readonly disabled: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    readonly calendarRange: {
-        type: import("vue").PropType<number[]>;
-        default: number[];
-    };
-    readonly limitDateRange: {
-        type: import("vue").PropType<Date[]>;
-    };
-    readonly type: {
-        type: StringConstructor;
-        default: string;
-    };
-    readonly visible: {
-        readonly type: BooleanConstructor;
-        readonly default: false;
-    };
-    readonly dateValue: {
-        readonly type: import("vue").PropType<import("dayjs").Dayjs | (import("dayjs").Dayjs | undefined)[] | undefined>;
-    };
-    readonly isRangeType: {
-        readonly type: BooleanConstructor;
-        readonly default: false;
-    };
-    readonly focusType: {
-        readonly type: StringConstructor;
-        readonly default: "start";
-    };
-}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, "changeRangeFocusType" | "selectedDate", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
-    readonly format: {
-        type: StringConstructor;
-    };
-    readonly showTime: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    readonly size: {
-        type: import("vue").PropType<import("../../../input").InputSize>;
-        default: string;
-    };
-    readonly disabled: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    readonly calendarRange: {
-        type: import("vue").PropType<number[]>;
-        default: number[];
-    };
-    readonly limitDateRange: {
-        type: import("vue").PropType<Date[]>;
-    };
-    readonly type: {
-        type: StringConstructor;
-        default: string;
-    };
-    readonly visible: {
-        readonly type: BooleanConstructor;
-        readonly default: false;
-    };
-    readonly dateValue: {
-        readonly type: import("vue").PropType<import("dayjs").Dayjs | (import("dayjs").Dayjs | undefined)[] | undefined>;
-    };
-    readonly isRangeType: {
-        readonly type: BooleanConstructor;
-        readonly default: false;
-    };
-    readonly focusType: {
-        readonly type: StringConstructor;
-        readonly default: "start";
-    };
-}>>, {
-    readonly type: string;
-    readonly visible: boolean;
-    readonly disabled: boolean;
-    readonly size: import("../../../input").InputSize;
-    readonly showTime: boolean;
-    readonly calendarRange: number[];
-    readonly isRangeType: boolean;
-    readonly focusType: string;
-}>;
+declare const _default: (props: Record<string, any> & {}) => any;
 export default _default;

package/types/date-picker-pro/src/components/range-date-picker-pro.d.ts

@@ -1,90 +1,3 @@
 import '../date-picker-pro.scss';
-declare const _default: import("vue").DefineComponent<{
-    readonly format: {
-        type: StringConstructor;
-    };
-    readonly showTime: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    readonly size: {
-        type: import("vue").PropType<import("../../../input").InputSize>;
-        default: string;
-    };
-    readonly disabled: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    readonly calendarRange: {
-        type: import("vue").PropType<number[]>;
-        default: number[];
-    };
-    readonly limitDateRange: {
-        type: import("vue").PropType<Date[]>;
-    };
-    readonly type: {
-        type: StringConstructor;
-        default: string;
-    };
-    readonly modelValue: {
-        readonly type: import("vue").PropType<(string | Date)[]>;
-        readonly default: readonly ["", ""];
-    };
-    readonly placeholder: {
-        readonly type: import("vue").PropType<string[]>;
-        readonly default: readonly ["", ""];
-    };
-    readonly separator: {
-        readonly type: StringConstructor;
-        readonly default: "-";
-    };
-}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, "blur" | "focus" | "update:modelValue" | "toggleChange" | "confirmEvent", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
-    readonly format: {
-        type: StringConstructor;
-    };
-    readonly showTime: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    readonly size: {
-        type: import("vue").PropType<import("../../../input").InputSize>;
-        default: string;
-    };
-    readonly disabled: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    readonly calendarRange: {
-        type: import("vue").PropType<number[]>;
-        default: number[];
-    };
-    readonly limitDateRange: {
-        type: import("vue").PropType<Date[]>;
-    };
-    readonly type: {
-        type: StringConstructor;
-        default: string;
-    };
-    readonly modelValue: {
-        readonly type: import("vue").PropType<(string | Date)[]>;
-        readonly default: readonly ["", ""];
-    };
-    readonly placeholder: {
-        readonly type: import("vue").PropType<string[]>;
-        readonly default: readonly ["", ""];
-    };
-    readonly separator: {
-        readonly type: StringConstructor;
-        readonly default: "-";
-    };
-}>>, {
-    readonly type: string;
-    readonly disabled: boolean;
-    readonly size: import("../../../input").InputSize;
-    readonly separator: string;
-    readonly placeholder: string[];
-    readonly modelValue: (string | Date)[];
-    readonly showTime: boolean;
-    readonly calendarRange: number[];
-}>;
+declare const _default: (props: Record<string, any> & {}) => any;
 export default _default;

package/types/date-picker-pro/src/components/time-picker-panel.d.ts

@@ -1,23 +1,2 @@
-declare const _default: import("vue").DefineComponent<{
-    readonly visible: {
-        readonly type: BooleanConstructor;
-        readonly default: false;
-    };
-    readonly bindData: {
-        readonly type: StringConstructor;
-        readonly default: "";
-    };
-}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, "selectedTime", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
-    readonly visible: {
-        readonly type: BooleanConstructor;
-        readonly default: false;
-    };
-    readonly bindData: {
-        readonly type: StringConstructor;
-        readonly default: "";
-    };
-}>>, {
-    readonly visible: boolean;
-    readonly bindData: string;
-}>;
+declare const _default: (props: Record<string, any> & {}) => any;
 export default _default;

package/types/date-picker-pro/src/components/year-calendar-panel.d.ts

@@ -1,95 +1,2 @@
-declare const _default: import("vue").DefineComponent<{
-    readonly format: {
-        type: StringConstructor;
-    };
-    readonly showTime: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    readonly size: {
-        type: import("vue").PropType<import("../../../input").InputSize>;
-        default: string;
-    };
-    readonly disabled: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    readonly calendarRange: {
-        type: import("vue").PropType<number[]>;
-        default: number[];
-    };
-    readonly limitDateRange: {
-        type: import("vue").PropType<Date[]>;
-    };
-    readonly type: {
-        type: StringConstructor;
-        default: string;
-    };
-    readonly visible: {
-        readonly type: BooleanConstructor;
-        readonly default: false;
-    };
-    readonly dateValue: {
-        readonly type: import("vue").PropType<import("dayjs").Dayjs | (import("dayjs").Dayjs | undefined)[] | undefined>;
-    };
-    readonly isRangeType: {
-        readonly type: BooleanConstructor;
-        readonly default: false;
-    };
-    readonly focusType: {
-        readonly type: StringConstructor;
-        readonly default: "start";
-    };
-}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, "changeRangeFocusType" | "selectedDate", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
-    readonly format: {
-        type: StringConstructor;
-    };
-    readonly showTime: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    readonly size: {
-        type: import("vue").PropType<import("../../../input").InputSize>;
-        default: string;
-    };
-    readonly disabled: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    readonly calendarRange: {
-        type: import("vue").PropType<number[]>;
-        default: number[];
-    };
-    readonly limitDateRange: {
-        type: import("vue").PropType<Date[]>;
-    };
-    readonly type: {
-        type: StringConstructor;
-        default: string;
-    };
-    readonly visible: {
-        readonly type: BooleanConstructor;
-        readonly default: false;
-    };
-    readonly dateValue: {
-        readonly type: import("vue").PropType<import("dayjs").Dayjs | (import("dayjs").Dayjs | undefined)[] | undefined>;
-    };
-    readonly isRangeType: {
-        readonly type: BooleanConstructor;
-        readonly default: false;
-    };
-    readonly focusType: {
-        readonly type: StringConstructor;
-        readonly default: "start";
-    };
-}>>, {
-    readonly type: string;
-    readonly visible: boolean;
-    readonly disabled: boolean;
-    readonly size: import("../../../input").InputSize;
-    readonly showTime: boolean;
-    readonly calendarRange: number[];
-    readonly isRangeType: boolean;
-    readonly focusType: string;
-}>;
+declare const _default: (props: Record<string, any> & {}) => any;
 export default _default;

package/types/date-picker-pro/src/date-picker-pro.d.ts

@@ -1,81 +1,3 @@
 import './date-picker-pro.scss';
-declare const _default: import("vue").DefineComponent<{
-    readonly format: {
-        type: StringConstructor;
-    };
-    readonly showTime: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    readonly size: {
-        type: import("vue").PropType<import("../../input").InputSize>;
-        default: string;
-    };
-    readonly disabled: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    readonly calendarRange: {
-        type: import("vue").PropType<number[]>;
-        default: number[];
-    };
-    readonly limitDateRange: {
-        type: import("vue").PropType<Date[]>;
-    };
-    readonly type: {
-        type: StringConstructor;
-        default: string;
-    };
-    readonly modelValue: {
-        readonly type: import("vue").PropType<string | Date>;
-        readonly default: "";
-    };
-    readonly placeholder: {
-        readonly type: StringConstructor;
-        readonly default: "";
-    };
-}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, "blur" | "focus" | "update:modelValue" | "toggleChange" | "confirmEvent", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
-    readonly format: {
-        type: StringConstructor;
-    };
-    readonly showTime: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    readonly size: {
-        type: import("vue").PropType<import("../../input").InputSize>;
-        default: string;
-    };
-    readonly disabled: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    readonly calendarRange: {
-        type: import("vue").PropType<number[]>;
-        default: number[];
-    };
-    readonly limitDateRange: {
-        type: import("vue").PropType<Date[]>;
-    };
-    readonly type: {
-        type: StringConstructor;
-        default: string;
-    };
-    readonly modelValue: {
-        readonly type: import("vue").PropType<string | Date>;
-        readonly default: "";
-    };
-    readonly placeholder: {
-        readonly type: StringConstructor;
-        readonly default: "";
-    };
-}>>, {
-    readonly type: string;
-    readonly disabled: boolean;
-    readonly size: import("../../input").InputSize;
-    readonly placeholder: string;
-    readonly modelValue: string | Date;
-    readonly showTime: boolean;
-    readonly calendarRange: number[];
-}>;
+declare const _default: (props: Record<string, any> & {}) => any;
 export default _default;

package/types/dragdrop-new/index.d.ts

@@ -0,0 +1,23 @@
+import { App } from 'vue';
+import { default as Draggable } from './src/draggable.directive';
+import { default as Droppable } from './src/droppable.directive';
+import { default as Sortable } from './src/sortable.directive';
+import { default as DropScrollEnhanced } from './src/drop-scroll-enhance.directive';
+export * from './src/drag-drop.service';
+export * from './src/draggable.directive';
+export * from './src/droppable.directive';
+export * from './src/sortable.directive';
+export * from './src/drop-scroll-enhance.directive';
+export * from './src/batch-draggable.directive';
+export * from './src/drag-preview.component';
+export * from './src/drag-preview.directive';
+export * from './src/drag-preview-clone-dom-ref.component';
+export * from './src/sync';
+export { Draggable, Droppable, Sortable, DropScrollEnhanced };
+declare const _default: {
+    title: string;
+    category: string;
+    status: string;
+    install(app: App): void;
+};
+export default _default;

package/types/dragdrop-new/src/batch-draggable.directive.d.ts

@@ -0,0 +1,59 @@
+import { EventEmitter } from './preserve-next-event-emitter';
+import { DragDropService } from './drag-drop.service';
+import { NgDirectiveBase, NgSimpleChanges } from './directive-base';
+import { DraggableDirective } from './draggable.directive';
+import { DirectiveBinding } from 'vue';
+export declare type BatchDragStyle = 'badge' | 'stack' | string;
+export interface IBatchDraggableBinding {
+    batchDragGroup?: string;
+    batchDragActive?: boolean;
+    batchDragLastOneAutoActiveEventKeys?: Array<string>;
+    batchDragStyle?: string | Array<string>;
+}
+export interface IBatchDraggableListener {
+    '@batchDragActiveEvent'?: (_: any) => void;
+}
+export declare class BatchDraggableDirective extends NgDirectiveBase<IBatchDraggableBinding, IBatchDraggableListener> {
+    private draggable;
+    private dragDropService;
+    static INSTANCE_KEY: string;
+    batchDragGroup: string;
+    batchDragActive: boolean;
+    batchDragLastOneAutoActiveEventKeys: string[];
+    batchDragStyle: Array<BatchDragStyle>;
+    batchDragActiveEvent: EventEmitter<any>;
+    dragData?: any;
+    needToRestore: boolean;
+    constructor(draggable: DraggableDirective, dragDropService: DragDropService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: NgSimpleChanges): void;
+    ngAfterViewInit(): void;
+    initDragDataByIdentity(): {
+        identity?: any;
+        draggable: DraggableDirective;
+        dragData: any;
+    } | null | undefined;
+    registerRestoreDragDataViewAfterViewInitWhiteDragging(): void;
+    restoreDragDataViewAfterViewInit(): void;
+    allowAddToBatchGroup(): boolean;
+    addToBatchGroup(dragData?: any): void;
+    removeFromBatchGroup(dragData?: any): void;
+    private addToArrayIfNotExist;
+    private deleteFromArrayIfExist;
+    private findInBatchDragDataByIdentities;
+    active(): void;
+    updateDragData(): void;
+}
+declare const _default: {
+    mounted(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<IBatchDraggableBinding & IBatchDraggableListener>, vNode: any): void;
+    updated(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<IBatchDraggableBinding & IBatchDraggableListener>): void;
+    beforeUnmount(el: HTMLElement & {
+        [props: string]: any;
+    }): void;
+};
+export default _default;

package/types/dragdrop-new/src/directive-base.d.ts

@@ -0,0 +1,49 @@
+export interface ISimpleChange {
+    previousValue: any;
+    currentValue: any;
+    firstChange: boolean;
+}
+export declare class NgSimpleChange {
+    previousValue: any;
+    currentValue: any;
+    firstChange: boolean;
+    constructor(previousValue: any, currentValue: any, firstChange: boolean);
+    isFirstChange(): boolean;
+}
+export declare type NgSimpleChanges = Record<string, NgSimpleChange>;
+export declare class NgDirectiveBase<IInput extends {
+    [prop: string]: any;
+} = {
+    [prop: string]: any;
+}, IOutput = {
+    [prop: string]: (e: any) => void;
+}> {
+    private __eventListenerMap;
+    mounted(): void;
+    el: {
+        nativeElement: any;
+    };
+    setInput(props: IInput & IOutput & {
+        [props: string]: any;
+    }): void;
+    updateInput(props: IInput & IOutput, old: IInput & IOutput): void;
+    hostBinding(key: string, valueKey: string): void;
+    hostListener(key: string, functionKey: string): void;
+    eventListener(key: string, userFunction: (e: any) => void): void;
+    ngOnChanges?(changes: NgSimpleChanges): void;
+    hostBindingMap?: {
+        [key: string]: string;
+    };
+    hostListenerMap?: {
+        [key: string]: string;
+    };
+    inputNameMap?: {
+        [key: string]: string;
+    };
+    outputNameMap?: {
+        [key: string]: string;
+    };
+    getInputKey(key: string): string;
+    getOutputKey(key: string): string;
+    notifyOnChanges(changes: Map<string, ISimpleChange>): void;
+}

package/types/dragdrop-new/src/drag-drop.service.d.ts

@@ -0,0 +1,75 @@
+import { Subject, Subscription } from 'rxjs';
+import { DraggableDirective } from './draggable.directive';
+import { InjectionKey } from 'vue';
+import { DragPreviewDirective } from './drag-preview.directive';
+export declare class DragDropService {
+    static TOKEN: InjectionKey<DragDropService>;
+    dragData: any;
+    draggedEl: any;
+    draggedElIdentity: any;
+    batchDragData?: Array<{
+        identity?: any;
+        draggable: DraggableDirective;
+        dragData: any;
+    }>;
+    batchDragGroup?: string;
+    batchDragStyle?: Array<string>;
+    batchDragging?: boolean;
+    scope?: string | Array<string>;
+    dropTargets: Array<{
+        nativeElement: any;
+    }>;
+    dropEvent: Subject<any>;
+    dragEndEvent: Subject<any>;
+    dragStartEvent: Subject<any>;
+    dropOnItem?: boolean;
+    dragFollow?: boolean;
+    dragFollowOptions?: {
+        appendToBody?: boolean;
+    };
+    dropOnOrigin?: boolean;
+    draggedElFollowingMouse?: boolean;
+    dragOffset?: {
+        top: number;
+        left: number;
+        offsetLeft: number | null;
+        offsetTop: number | null;
+        width?: number;
+        height?: number;
+    };
+    subscription: Subscription;
+    private _dragEmptyImage?;
+    get dragEmptyImage(): HTMLImageElement;
+    dragCloneNode: any;
+    dragOriginPlaceholder: any;
+    dragItemContainer: any;
+    dragItemParentName: string;
+    dragItemChildrenName: string;
+    intersectionObserver: any;
+    sub?: Subscription;
+    dragOriginPlaceholderNextSibling: any;
+    touchInstance: any;
+    dragElShowHideEvent: Subject<boolean>;
+    dragSyncGroupDirectives?: any;
+    dragPreviewDirective?: DragPreviewDirective;
+    get document(): Document;
+    constructor();
+    newSubscription(): Subscription;
+    enableDraggedCloneNodeFollowMouse(): void;
+    disableDraggedCloneNodeFollowMouse(): void;
+    interceptChildNode(parentNode: Node, childNodeList: NodeListOf<Node>): void;
+    setChildNodeHide(entries: any): void;
+    followMouse4CloneNode: (event: DragEvent) => void;
+    getBatchDragData(identity?: any, order?: ((a: any, b: any) => number) | 'select' | 'draggedElFirst'): any[];
+    /** usage:
+     * constructor(..., private dragDropService: DragDropService) {}
+     * cleanBatchDragData() { this.dragDropService.cleanBatchDragData(); }
+     */
+    cleanBatchDragData(): {
+        identity?: any;
+        draggable: DraggableDirective;
+        dragData: any;
+    }[] | undefined;
+    copyStyle(source: HTMLElement, target: HTMLElement): void;
+}
+export declare function useDragDropService(): DragDropService;

package/types/dragdrop-new/src/drag-preview-clone-dom-ref.component.d.ts

@@ -0,0 +1,43 @@
+import { DragDropService } from './drag-drop.service';
+import { NgDirectiveBase, NgSimpleChanges } from './directive-base';
+import { PropType } from 'vue';
+export interface IDragPreviewCloneDomRefBinding {
+    domRef?: HTMLElement;
+    copyStyle?: boolean;
+    [props: string]: any;
+}
+export declare class DragPreviewCloneDomRefComponent extends NgDirectiveBase<IDragPreviewCloneDomRefBinding> {
+    el: {
+        nativeElement: any;
+    };
+    private dragDropService;
+    static NAME: string;
+    domRef: HTMLElement;
+    copyStyle: boolean;
+    cloneNode: any;
+    constructor(el: {
+        nativeElement: any;
+    }, dragDropService: DragDropService);
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: NgSimpleChanges): void;
+    ngOnDestroy(): void;
+    createView(): void;
+    destroyView(): void;
+    updateTemplate(): void;
+}
+declare const _default: import("vue").DefineComponent<{
+    domRef: PropType<HTMLElement>;
+    copyStyle: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    domRef: PropType<HTMLElement>;
+    copyStyle: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    copyStyle: boolean;
+}, {}>;
+export default _default;

package/types/dragdrop-new/src/drag-preview.component.d.ts

@@ -0,0 +1,20 @@
+import { PropType, VNodeChild } from 'vue';
+export interface IDragPreviewContext {
+    data: any;
+    draggedEl: HTMLElement;
+    dragData: any;
+    batchDragData?: any[];
+    dragSyncDOMElements?: HTMLElement[];
+}
+export interface IDragPreviewTemplate {
+    template: (context: IDragPreviewContext) => VNodeChild;
+}
+export declare const DragPreviewTemplate: import("vue").DefineComponent<{}, () => null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+export declare const DragPreviewComponent: import("vue").DefineComponent<{
+    template: PropType<(context: IDragPreviewContext) => VNodeChild>;
+    context: PropType<IDragPreviewContext>;
+}, () => VNodeChild, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    template: PropType<(context: IDragPreviewContext) => VNodeChild>;
+    context: PropType<IDragPreviewContext>;
+}>>, {}, {}>;
+export default DragPreviewComponent;