vue-devui 1.6.3-select.0 → 1.6.4-alpha.0

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

@@ -0,0 +1,45 @@
+import { InjectionKey, DirectiveBinding } from 'vue';
+import { NgDirectiveBase } from './directive-base';
+import { DragDropService } from './drag-drop.service';
+import { IDragPreviewTemplate } from './drag-preview.component';
+export interface IDragPreviewBinding {
+    dragPreview?: IDragPreviewTemplate;
+    dragPreviewData?: any;
+    dragPreviewOptions?: {
+        skipBatchPreview: boolean;
+    };
+    [props: string]: any;
+    context: any;
+}
+export declare class DragPreviewDirective extends NgDirectiveBase<IDragPreviewBinding> {
+    private dragDropService;
+    static INSTANCE_KEY: string;
+    static TOKEN: InjectionKey<DragPreviewDirective>;
+    inputNameMap?: {
+        [key: string]: string;
+    } | undefined;
+    dragPreviewTemplate: IDragPreviewTemplate;
+    dragPreviewData: any;
+    dragPreviewOptions: {
+        skipBatchPreview: boolean;
+    };
+    previewRef: any;
+    context: any;
+    el: {
+        nativeElement: any;
+    };
+    constructor(el: HTMLElement, dragDropService: DragDropService);
+    createPreview(): void;
+    destroyPreview(): void;
+    getPreviewElement(): any;
+    private getDragSyncDOMElements;
+}
+declare const _default: {
+    mounted(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<IDragPreviewBinding>, vNode: any): void;
+    updated(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<IDragPreviewBinding>): void;
+};
+export default _default;

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

@@ -0,0 +1,119 @@
+import { Subject, Subscription } from 'rxjs';
+import { EventEmitter, PreserveNextEventEmitter } from './preserve-next-event-emitter';
+import { DragDropService } from './drag-drop.service';
+import { DirectiveBinding, InjectionKey, VNode } from 'vue';
+import { NgDirectiveBase } from './directive-base';
+import { DragPreviewDirective } from './drag-preview.directive';
+export interface IDraggableBinding {
+    dragData?: any;
+    dragHandle?: string;
+    dragEffect?: string;
+    dragScope?: string | Array<string>;
+    dragHandleClass?: string;
+    dragOverClass?: string;
+    disabled?: boolean;
+    enableDragFollow?: boolean;
+    dragFollowOptions?: {
+        appendToBody?: boolean;
+    };
+    originPlaceholder?: {
+        show?: boolean;
+        tag?: string;
+        style?: {
+            [cssProperties: string]: string;
+        };
+        text?: string;
+        removeDelay?: number;
+    };
+    dragIdentity?: any;
+    dragItemParentName?: string;
+    dragItemChildrenName?: string;
+}
+export interface IDraggableListener {
+    '@dragStartEvent'?: (_: any) => void;
+    '@dragEvent'?: (_: any) => void;
+    '@dragEndEvent'?: (_: any) => void;
+    '@dropEndEvent'?: (_: any) => void;
+}
+export declare class DraggableDirective extends NgDirectiveBase<IDraggableBinding, IDraggableListener> {
+    static INSTANCE_KEY: string;
+    static TOKEN: InjectionKey<DraggableDirective>;
+    hostBindingMap?: {
+        [key: string]: string;
+    } | undefined;
+    draggable: boolean;
+    dragData?: any;
+    dragScope: string | Array<string>;
+    dragHandle?: string;
+    dragHandleClass: string;
+    dragOverClass?: string;
+    dragEffect: string;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    dragStartEvent: EventEmitter<any>;
+    dragEvent: PreserveNextEventEmitter<any>;
+    dragEndEvent: EventEmitter<any>;
+    dropEndEvent: PreserveNextEventEmitter<any>;
+    document: Document;
+    private mouseOverElement;
+    enableDragFollow: boolean;
+    dragFollowOptions?: {
+        appendToBody?: boolean;
+    };
+    originPlaceholder?: {
+        show?: boolean;
+        tag?: string;
+        style?: {
+            [cssProperties: string]: string;
+        };
+        text?: string;
+        removeDelay?: number;
+    };
+    dragIdentity: any;
+    dragItemParentName: string;
+    dragItemChildrenName: string;
+    dragsSub: Subscription;
+    destroyDragEndSub?: Subscription;
+    isDestroyed?: boolean;
+    private delayRemoveOriginPlaceholderTimer?;
+    batchDraggable: undefined | any;
+    private dragOriginPlaceholder?;
+    private dragOriginPlaceholderNextSibling?;
+    dragElShowHideEvent: Subject<boolean>;
+    beforeDragStartEvent: Subject<boolean>;
+    el: {
+        nativeElement: any;
+    };
+    dragDropService: DragDropService;
+    dragPreviewDirective?: DragPreviewDirective;
+    constructor(el: HTMLElement, dragDropService: DragDropService, dragPreviewDirective?: DragPreviewDirective);
+    ngOnInit(): void;
+    dropSubscription(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    dragStart(e: DragEvent): void;
+    dragEnd(e: DragEvent): void;
+    mouseover(e: MouseEvent): void;
+    private allowDrag;
+    private applyDragHandleClass;
+    private getDragHandleElement;
+    private mousePosition;
+    insertOriginPlaceholder: (directShow?: boolean, updateService?: boolean) => void;
+    removeOriginPlaceholder: (updateService?: boolean) => void;
+    delayRemoveOriginPlaceholder: (updateService?: boolean) => void;
+    findNextSibling(currentNextSibling: Element): Element;
+    private checkAndGetViewPointChange;
+}
+declare const _default: {
+    mounted(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<IDraggableBinding & IDraggableListener>, vNode: VNode): void;
+    updated(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<IDraggableBinding & IDraggableListener>): void;
+    beforeUnmount(el: HTMLElement & {
+        [props: string]: any;
+    }): void;
+};
+export default _default;

package/types/dragdrop-new/src/drop-scroll-enhance.directive.d.ts

@@ -0,0 +1,111 @@
+import { DragDropService } from './drag-drop.service';
+import { DirectiveBinding } from 'vue';
+import { NgDirectiveBase } from './directive-base';
+export declare type DropScrollEdgeDistancePercent = number;
+export declare type DropScrollSpeed = number;
+export declare type DropScrollSpeedFunction = (x: DropScrollEdgeDistancePercent) => DropScrollSpeed;
+export declare type DropScrollDirection = 'h' | 'v';
+export declare enum DropScrollOrientation {
+    forward = 0,
+    backward = 1
+}
+export interface DropScrollAreaOffset {
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+    widthOffset?: number;
+    heightOffset?: number;
+}
+export declare type DropScrollTriggerEdge = 'left' | 'right' | 'top' | 'bottom';
+export declare const DropScrollEnhanceTimingFunctionGroup: {
+    default: (x: number) => number;
+};
+export interface IDropScrollEnhancedBinding {
+    minSpeed?: DropScrollSpeed;
+    maxSpeed?: DropScrollSpeed;
+    responseEdgeWidth?: string | ((total: number) => string);
+    speedFn?: DropScrollSpeedFunction;
+    direction?: DropScrollDirection;
+    viewOffset?: {
+        forward?: DropScrollAreaOffset;
+        backward?: DropScrollAreaOffset;
+    };
+    dropScrollScope?: string | Array<string>;
+    backSpaceDroppable?: boolean;
+}
+export interface IDropScrollEnhancedListener {
+}
+export declare class DropScrollEnhancedDirective extends NgDirectiveBase<IDropScrollEnhancedBinding, IDropScrollEnhancedListener> {
+    static INSTANCE_KEY: string;
+    minSpeed: DropScrollSpeed;
+    maxSpeed: DropScrollSpeed;
+    responseEdgeWidth: string | ((total: number) => string);
+    speedFn: DropScrollSpeedFunction;
+    direction: DropScrollDirection;
+    viewOffset?: {
+        forward?: DropScrollAreaOffset;
+        backward?: DropScrollAreaOffset;
+    };
+    dropScrollScope?: string | Array<string>;
+    backSpaceDroppable: boolean;
+    private forwardScrollArea?;
+    private backwardScrollArea?;
+    private subscription;
+    private forwardScrollFn?;
+    private backwardScrollFn?;
+    private lastScrollTime?;
+    private animationFrameId?;
+    document: Document;
+    el: {
+        nativeElement: any;
+    };
+    private dragDropService;
+    constructor(el: HTMLElement, dragDropService: DragDropService);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    createScrollFn(direction: DropScrollDirection, orientation: DropScrollOrientation, speedFn: DropScrollSpeedFunction): ((event: DragEvent) => void) | undefined;
+    delegateDropEvent(event: DragEvent): void;
+    getCriticalEdge(direction: DropScrollDirection, orientation: DropScrollOrientation): DropScrollTriggerEdge;
+    getSecondEdge(direction: DropScrollDirection): DropScrollTriggerEdge;
+    createScrollArea(direction: DropScrollDirection, orientation: DropScrollOrientation): HTMLDivElement;
+    setAreaSize(area: HTMLElement, direction: DropScrollDirection, orientation: DropScrollOrientation): void;
+    setAreaStyleLayout(area: HTMLElement, direction: DropScrollDirection, orientation: DropScrollOrientation): void;
+    getRelatedPosition(target: HTMLElement, relatedTarget: HTMLElement, edge: DropScrollTriggerEdge, offsetValue?: number): string;
+    resizeArea(): void;
+    toggleScrollToOneEnd(scrollElement: any, toggleElement: HTMLElement, direction: DropScrollDirection, orientation: DropScrollOrientation): void;
+    cleanLastScrollTime(): void;
+    toggleActiveClass(target: HTMLElement, active: boolean): void;
+    allowScroll(): boolean;
+}
+declare const _default: {
+    mounted(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<IDropScrollEnhancedBinding & IDropScrollEnhancedListener>, vNode: any): void;
+    updated(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<IDropScrollEnhancedBinding & IDropScrollEnhancedListener>): void;
+    beforeUnmount(el: HTMLElement & {
+        [props: string]: any;
+    }): void;
+};
+export default _default;
+export declare class DropScrollEnhancedSideDirective extends DropScrollEnhancedDirective {
+    inputNameMap?: {
+        [key: string]: string;
+    } | undefined;
+    sideDirection: DropScrollDirection;
+    direction: DropScrollDirection;
+    ngOnInit(): void;
+}
+export declare const DropScrollEnhancedSide: {
+    mounted(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<IDropScrollEnhancedBinding & IDropScrollEnhancedListener>, vNode: any): void;
+    updated(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<IDropScrollEnhancedBinding & IDropScrollEnhancedListener>): void;
+    beforeUnmount(el: HTMLElement & {
+        [props: string]: any;
+    }): void;
+};

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

@@ -0,0 +1,137 @@
+import { Subject } from 'rxjs';
+import { EventEmitter } from './preserve-next-event-emitter';
+import { DragDropService } from './drag-drop.service';
+import { DirectiveBinding, InjectionKey, VNode } from 'vue';
+import { NgDirectiveBase } from './directive-base';
+export declare type DropIndexFlag = 'beforeAll' | 'afterAll';
+export interface IDroppableBinding {
+    dragOverClass?: string;
+    dropScope?: string | Array<string>;
+    placeholderTag?: string;
+    placeholderStyle?: Record<string, string>;
+    placeholderText?: string;
+    allowDropOnItem?: boolean;
+    dragOverItemClass?: string;
+    nestingTargetRect?: {
+        height?: number;
+        width?: number;
+    };
+    switchWhileCrossEdge?: boolean;
+    defaultDropPosition?: 'closest' | 'before' | 'after';
+    dropSortCountSelector: string;
+    dropSortVirtualScrollOption?: {
+        totalLength?: number;
+        startIndex?: number;
+    };
+}
+export interface IDroppableListener {
+    '@dragEnterEvent'?: (_: any) => void;
+    '@dragOverEvent'?: (_: any) => void;
+    '@dragLeaveEvent'?: (_: any) => void;
+    '@dropEvent'?: (_: any) => void;
+}
+export declare class DropEvent {
+    nativeEvent: any;
+    dragData: any;
+    batchDragData: any;
+    dropSubject: Subject<any>;
+    dropIndex?: number;
+    dragFromIndex?: number;
+    dropOnItem?: boolean;
+    dropOnOrigin?: boolean;
+    constructor(event: any, data: any, dropSubject: Subject<any>, dropIndex?: number, dragFromIndex?: number, dropOnItem?: boolean, dropOnOrigin?: boolean, batchDragData?: Array<any>);
+}
+export interface DragPlaceholderInsertionEvent {
+    command: 'insertBefore' | 'append' | 'remove';
+    container?: HTMLElement;
+    relatedEl?: Element;
+}
+export interface DragPlaceholderInsertionIndexEvent {
+    command: 'insertBefore' | 'append' | 'remove';
+    index?: number;
+}
+export declare class DroppableDirective extends NgDirectiveBase<IDroppableBinding, IDroppableListener> {
+    static INSTANCE_KEY: string;
+    static TOKEN: InjectionKey<DroppableDirective>;
+    hostListenerMap?: {
+        [key: string]: string;
+    } | undefined;
+    dragEnterEvent: EventEmitter<any>;
+    dragOverEvent: EventEmitter<any>;
+    dragLeaveEvent: EventEmitter<any>;
+    dropEvent: EventEmitter<DropEvent>;
+    dragOverClass?: string;
+    dropScope: string | Array<string>;
+    placeholderTag: string;
+    placeholderStyle: any;
+    placeholderText: string;
+    allowDropOnItem: boolean;
+    dragOverItemClass?: string;
+    nestingTargetRect?: {
+        height?: number;
+        width?: number;
+    };
+    switchWhileCrossEdge: boolean;
+    defaultDropPosition: 'closest' | 'before' | 'after';
+    dropSortCountSelector?: string;
+    dropSortVirtualScrollOption?: {
+        totalLength?: number;
+        startIndex?: number;
+    };
+    private dropFlag?;
+    private sortContainer;
+    private sortDirection?;
+    private sortDirectionZMode?;
+    private placeholder;
+    private dragCount;
+    private dropIndex?;
+    private dragStartSubscription?;
+    private dragEndSubscription?;
+    private dropEndSubscription?;
+    private overElement?;
+    private dragPartEventSub?;
+    private allowDropCache?;
+    private dragElIndex?;
+    placeholderInsertionEvent: Subject<DragPlaceholderInsertionEvent>;
+    placeholderRenderEvent: Subject<any>;
+    document: Document;
+    el: {
+        nativeElement: any;
+    };
+    private dragDropService;
+    constructor(el: HTMLElement, dragDropService: DragDropService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    dragEnter(e: DragEvent): void;
+    dragOver(e: DragEvent): void;
+    dragLeave(e: DragEvent): void;
+    drop(e: DragEvent): void;
+    allowDrop(e: DragEvent): boolean;
+    private dropSortCountSelectorFilterFn;
+    private findSortableEl;
+    private calcPosition;
+    private calcPositionOutside;
+    setPlaceholder: () => void;
+    private insertPlaceholder;
+    private isDragPlaceholderPosition;
+    private hitDragOriginPlaceholder;
+    private removePlaceholder;
+    private removeDragoverItemClass;
+    private checkSelfFromIndex;
+    private getRealIndex;
+    getBoundingRectAndRealPosition(targetElement: HTMLElement): any;
+    getSortContainer(): any;
+}
+declare const _default: {
+    mounted(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<IDroppableBinding & IDroppableListener>, vNode: VNode): void;
+    updated(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<IDroppableBinding & IDroppableListener>): void;
+    beforeUnmount(el: HTMLElement & {
+        [props: string]: any;
+    }): void;
+};
+export default _default;

package/types/dragdrop-new/src/preserve-next-event-emitter.d.ts

@@ -0,0 +1,15 @@
+import { Subject, Subscription } from 'rxjs';
+export declare class EventEmitter<T = any> extends Subject<T> {
+    protected __isAsync: boolean;
+    constructor(isAsync?: boolean);
+    emit(value?: any): void;
+    subscribe(generatorOrNext?: any, error?: any, complete?: any): Subscription;
+}
+export declare class PreserveNextEventEmitter<T> extends EventEmitter<T> {
+    private _schedulerFns;
+    private _isAsync;
+    get schedulerFns(): Set<any> | undefined;
+    forceCallback(value: T, once?: boolean): void;
+    cleanCallbackFn(): void;
+    subscribe(generatorOrNext?: any, error?: any, complete?: any): any;
+}

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

@@ -0,0 +1,32 @@
+import { DirectiveBinding } from 'vue';
+import { NgDirectiveBase } from './directive-base';
+export interface ISortableBinding {
+    dSortableZMode?: any;
+    dSortable?: 'v' | 'h';
+    [props: string]: any;
+}
+export declare class SortableDirective extends NgDirectiveBase<ISortableBinding> {
+    static INSTANCE_KEY: string;
+    dSortDirection: string;
+    dSortableZMode: boolean;
+    dSortable: boolean;
+    hostBindingMap?: {
+        [key: string]: string;
+    } | undefined;
+    inputNameMap?: {
+        [key: string]: string;
+    } | undefined;
+    el: {
+        nativeElement: any;
+    };
+    constructor(el: HTMLElement);
+}
+declare const _default: {
+    mounted(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<ISortableBinding>): void;
+    updated(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<ISortableBinding>): void;
+};
+export default _default;

package/types/dragdrop-new/src/sync/desc-reg.service.d.ts

@@ -0,0 +1,31 @@
+import { Observable, Subject, Subscription } from 'rxjs';
+import { QueryList } from './query-list';
+import { NgDirectiveBase } from '../directive-base';
+export declare class DescendantRegisterService<T> {
+    protected _result: Array<T>;
+    protected changeSubject: Subject<Array<T>>;
+    changes: Observable<Array<T>>;
+    register(t: T): void;
+    unregister(t: T): void;
+    queryResult(): T[];
+}
+export declare class DescendantChildren<T, I extends {
+    [prop: string]: any;
+} = {
+    [prop: string]: any;
+}, O = {
+    [prop: string]: (e: any) => void;
+}> extends NgDirectiveBase<I, O> {
+    private drs;
+    constructor(drs: DescendantRegisterService<T>);
+    protected descendantItem: T;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+}
+export declare class DescendantRoot<T> extends QueryList<T> {
+    private drs;
+    protected sub: Subscription;
+    constructor(drs: DescendantRegisterService<T>);
+    on(): void;
+    off(): void;
+}

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

@@ -0,0 +1,10 @@
+import { DragSyncDirective } from './drag-sync.directive';
+import { DropSortSyncDirective } from './drop-sort-sync.directive';
+import { DescendantRegisterService } from './desc-reg.service';
+import { InjectionKey } from 'vue';
+export declare class DragSyncDescendantRegisterService extends DescendantRegisterService<DragSyncDirective> {
+    static TOKEN: InjectionKey<DragSyncDescendantRegisterService>;
+}
+export declare class DropSortSyncDescendantRegisterService extends DescendantRegisterService<DropSortSyncDirective> {
+    static TOKEN: InjectionKey<DropSortSyncDescendantRegisterService>;
+}

package/types/dragdrop-new/src/sync/drag-drop-sync-box.directive.d.ts

@@ -0,0 +1,36 @@
+import { DirectiveBinding } from 'vue';
+import { Subscription } from 'rxjs';
+import { DescendantRoot } from './desc-reg.service';
+import { DragSyncDescendantRegisterService, DropSortSyncDescendantRegisterService } from './drag-drop-descendant-sync.service';
+import { DragDropSyncService } from './drag-drop-sync.service';
+import { DragSyncDirective } from './drag-sync.directive';
+import { DropSortSyncDirective } from './drop-sort-sync.directive';
+import { NgDirectiveBase } from '../directive-base';
+export declare class DragDropSyncBoxDirective extends NgDirectiveBase {
+    private dragDropSyncService;
+    private dragSyncDrs;
+    private dropSortSyncDrs;
+    static INSTANCE_KEY: string;
+    sub: Subscription;
+    dragSyncList: DescendantRoot<DragSyncDirective>;
+    dropSyncList: DescendantRoot<DropSortSyncDirective>;
+    constructor(dragDropSyncService: DragDropSyncService, dragSyncDrs: DragSyncDescendantRegisterService, dropSortSyncDrs: DropSortSyncDescendantRegisterService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+}
+declare const _default: {
+    created(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<{}>, vNode: any): void;
+    mounted(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<{}>, vNode: any): void;
+    updated(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<{}>): void;
+    beforeUnmount(el: HTMLElement & {
+        [props: string]: any;
+    }): void;
+};
+export default _default;

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

@@ -0,0 +1,13 @@
+import { InjectionKey } from 'vue';
+import { DragSyncDirective } from './drag-sync.directive';
+import { DropSortSyncDirective } from './drop-sort-sync.directive';
+import { QueryList } from './query-list';
+export declare class DragDropSyncService {
+    static TOKEN: InjectionKey<DragDropSyncService>;
+    dragSyncList: QueryList<DragSyncDirective>;
+    dropSortSyncList: QueryList<DropSortSyncDirective>;
+    updateDragSyncList(list: QueryList<DragSyncDirective>): void;
+    getDragSyncByGroup(groupName: string): DragSyncDirective[];
+    updateDropSyncList(list: QueryList<DropSortSyncDirective>): void;
+    getDropSyncByGroup(groupName: string): DropSortSyncDirective[];
+}

package/types/dragdrop-new/src/sync/drag-sync.directive.d.ts

@@ -0,0 +1,44 @@
+import { DirectiveBinding } from 'vue';
+import { Subscription } from 'rxjs';
+import { DescendantChildren } from './desc-reg.service';
+import { DragSyncDescendantRegisterService } from './drag-drop-descendant-sync.service';
+import { DragDropSyncService } from './drag-drop-sync.service';
+import { DragDropService } from '../drag-drop.service';
+import { DraggableDirective } from '../draggable.directive';
+export interface IDragSyncBinding {
+    dragSync?: string;
+    dragSyncGroup?: string;
+    [props: string]: any;
+}
+export declare class DragSyncDirective extends DescendantChildren<DragSyncDirective, IDragSyncBinding> {
+    private draggable;
+    private dragDropSyncService;
+    private dragDropService;
+    static INSTANCE_KEY: string;
+    inputNameMap?: {
+        [key: string]: string;
+    } | undefined;
+    dragSyncGroup: string;
+    subscription: Subscription;
+    syncGroupDirectives?: Array<DragSyncDirective>;
+    el: {
+        nativeElement: any;
+    };
+    constructor(el: HTMLElement, draggable: DraggableDirective, dragDropSyncService: DragDropSyncService, dragDropService: DragDropService, dragSyncDrs: DragSyncDescendantRegisterService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    subDragElEvent: (bool: boolean) => void;
+    renderDisplay(nativeEl: HTMLElement, bool: boolean): void;
+}
+declare const _default: {
+    mounted(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<IDragSyncBinding>, vNode: any): void;
+    updated(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<IDragSyncBinding>): void;
+    beforeUnmount(el: HTMLElement & {
+        [props: string]: any;
+    }): void;
+};
+export default _default;

package/types/dragdrop-new/src/sync/drop-sort-sync.directive.d.ts

@@ -0,0 +1,55 @@
+import { DirectiveBinding } from 'vue';
+import { Subscription } from 'rxjs';
+import { DescendantChildren } from './desc-reg.service';
+import { DropSortSyncDescendantRegisterService } from './drag-drop-descendant-sync.service';
+import { DragDropSyncService } from './drag-drop-sync.service';
+import { DroppableDirective, type DragPlaceholderInsertionEvent, type DragPlaceholderInsertionIndexEvent } from '../droppable.directive';
+export interface IDropSortSyncBinding {
+    dropSortSync?: string;
+    dropSyncGroup?: string;
+    dropSyncDirection?: 'v' | 'h';
+    [props: string]: any;
+}
+export declare class DropSortSyncDirective extends DescendantChildren<DropSortSyncDirective, IDropSortSyncBinding> {
+    private droppable;
+    private dragDropSyncService;
+    static INSTANCE_KEY: string;
+    inputNameMap?: {
+        [key: string]: string;
+    } | undefined;
+    dropSyncGroup: string;
+    direction: 'v' | 'h';
+    subscription: Subscription;
+    syncGroupDirectives: Array<DropSortSyncDirective>;
+    placeholder: HTMLElement;
+    sortContainer: HTMLElement;
+    el: {
+        nativeElement: any;
+    };
+    constructor(el: HTMLElement, droppable: DroppableDirective, dragDropSyncService: DragDropSyncService, dropSortSyncDrs: DropSortSyncDescendantRegisterService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    subRenderEvent: (nativeStyle: {
+        width: number;
+        height: number;
+    }) => void;
+    subInsertionEvent: (cmd: DragPlaceholderInsertionIndexEvent) => void;
+    getChildrenElByIndex(target: any, index?: any): Element | null;
+    renderPlaceholder(nativeStyle: {
+        width: number;
+        height: number;
+    }, droppable: any): void;
+    insertPlaceholderCommand(cmd: DragPlaceholderInsertionEvent): void;
+}
+declare const _default: {
+    mounted(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<IDropSortSyncBinding>, vNode: any): void;
+    updated(el: HTMLElement & {
+        [props: string]: any;
+    }, binding: DirectiveBinding<IDropSortSyncBinding>): void;
+    beforeUnmount(el: HTMLElement & {
+        [props: string]: any;
+    }): void;
+};
+export default _default;

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

@@ -0,0 +1,17 @@
+import { App } from 'vue';
+import { default as DragDropSyncBox } from './drag-drop-sync-box.directive';
+import { default as DragSync } from './drag-sync.directive';
+import { default as DropSortSync } from './drop-sort-sync.directive';
+export * from './desc-reg.service';
+export * from './drag-drop-descendant-sync.service';
+export * from './drag-drop-sync.service';
+export * from './drag-drop-sync-box.directive';
+export * from './drag-sync.directive';
+export * from './drop-sort-sync.directive';
+export { DragDropSyncBox, DragSync, DropSortSync };
+declare const _default: {
+    title: string;
+    category: string;
+    install(app: App): void;
+};
+export default _default;