@progress/kendo-angular-utils 0.1.0

package/drag-and-drop/models/autoscroll-options.d.ts

@@ -0,0 +1,23 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { ElementRef } from "@angular/core";
+import { ScrollDirection } from "./scroll-direction";
+/**
+ * Represents additional configuration options for the autoScroll functionality of the DragTarget.
+ */
+export interface AutoScrollOptions {
+    /**
+     * Overrides the calculated element used for boundary detection, used to calculate the autoScroll velocity.
+     */
+    boundaryElementRef?: ElementRef;
+    /**
+     * Specifies the direction of the autoScroll functionality.
+     */
+    direction?: ScrollDirection;
+    /**
+     * Specifies whether the autoScroll functionality will be enabled.
+     */
+    enabled?: boolean;
+}

package/drag-and-drop/models/dragaxis.d.ts

@@ -0,0 +1,8 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+/**
+ * Represents the axis to which the dragging will be restricted.
+ */
+export declare type DragAxis = 'horizontal' | 'vertical';

package/drag-and-drop/models/index.d.ts

@@ -0,0 +1,8 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+export { AutoScrollOptions } from './autoscroll-options';
+export { DragAxis } from './dragaxis';
+export { AllowedTargetFn } from './allowed-target';
+export { ScrollDirection } from './scroll-direction';

package/drag-and-drop/models/scroll-direction.d.ts

@@ -0,0 +1,8 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+export interface ScrollDirection {
+    horizontal: boolean;
+    vertical: boolean;
+}

package/drag-and-drop/util.d.ts

@@ -0,0 +1,29 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Renderer2 } from "@angular/core";
+import { DragAndDropAction, DragTarget } from "@progress/kendo-draggable-common";
+/**
+ * @hidden
+ */
+export declare const dragTargetTransition = "transform .3s ease-in-out";
+/**
+ * @hidden
+ */
+export interface Coordinates {
+    x: number;
+    y: number;
+}
+/**
+ * @hidden
+ */
+export declare const getAction: (event: PointerEvent | MouseEvent | TouchEvent | Event, draggable: DragTarget) => DragAndDropAction;
+/**
+ * @hidden
+ */
+export declare const setElementStyles: (renderer: Renderer2, elem: HTMLElement, styles: object) => void;
+/**
+ * @hidden
+ */
+export declare const isPresent: (value: any) => boolean;

package/drag-and-drop.module.d.ts

@@ -0,0 +1,15 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import * as i0 from "@angular/core";
+import * as i1 from "./drag-and-drop/dragtarget.directive";
+import * as i2 from "./drag-and-drop/draghandle.directive";
+import * as i3 from "./drag-and-drop/droptarget.directive";
+import * as i4 from "./drag-and-drop/hint.component";
+import * as i5 from "@angular/common";
+export declare class DragAndDropModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragAndDropModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DragAndDropModule, [typeof i1.DragTargetDirective, typeof i2.DragHandleDirective, typeof i3.DropTargetDirective, typeof i4.HintComponent], [typeof i5.CommonModule], [typeof i1.DragTargetDirective, typeof i2.DragHandleDirective, typeof i3.DropTargetDirective, typeof i4.HintComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DragAndDropModule>;
+}

package/esm2015/drag-and-drop/drag-state.service.js

@@ -0,0 +1,126 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Injectable } from '@angular/core';
+import { dispatchDragAndDrop, getScrollableParent, autoScroll } from '@progress/kendo-draggable-common';
+import * as i0 from "@angular/core";
+/**
+ * @hidden
+ */
+export class DragStateService {
+    constructor() {
+        this.dragTarget = null;
+        this.dropTarget = null;
+        this.dragTargets = [];
+        this.dropTargets = [];
+        this.pressed = false;
+        this.ignoreMouse = false;
+        this.autoScroll = true;
+        this.isScrolling = false;
+        this.scrollableParent = null;
+        this.autoScrollDirection = { horizontal: true, vertical: true };
+        this.initialClientOffset = { x: 0, y: 0 };
+        this.clientOffset = { x: 0, y: 0 };
+        this.initialScrollOffset = { x: 0, y: 0 };
+        this.scrollOffset = { x: 0, y: 0 };
+        this.offset = { x: 0, y: 0 };
+        this.pageOffset = { x: 0, y: 0 };
+        this.velocity = { x: 0, y: 0 };
+        this.callbacks = {};
+        this.scrollInterval = null;
+        this.setCallbacks();
+    }
+    handleDragAndDrop(action) {
+        this.updateState();
+        dispatchDragAndDrop(this.state, action, this.callbacks);
+    }
+    setPressed(pressed) {
+        this.pressed = pressed;
+    }
+    setScrolling(isScrolling) {
+        this.isScrolling = isScrolling;
+        if (isScrolling) {
+            const scrollableParent = getScrollableParent(document.elementFromPoint(this.clientOffset.x, this.clientOffset.y));
+            window.clearInterval(this.scrollInterval);
+            this.scrollInterval = window.setInterval(() => {
+                autoScroll(scrollableParent, { x: this.velocity.x, y: this.velocity.y });
+            }, 50);
+        }
+        else {
+            if (this.scrollInterval) {
+                window.clearInterval(this.scrollInterval);
+                this.scrollInterval = null;
+            }
+        }
+    }
+    setVelocity(velocity) {
+        this.velocity = velocity;
+    }
+    setOffset(offset) {
+        this.offset = offset;
+    }
+    setClientOffset(clientOffset) {
+        this.clientOffset = clientOffset;
+    }
+    setPageOffset(pageOffset) {
+        this.pageOffset = pageOffset;
+    }
+    setInitialClientOffset(initialClientOffset) {
+        this.initialClientOffset = initialClientOffset;
+    }
+    setScrollOffset(scrollOffset) {
+        this.scrollOffset = scrollOffset;
+    }
+    setInitialScrollOffset(initialScrollOffset) {
+        this.initialScrollOffset = initialScrollOffset;
+    }
+    updateState() {
+        this.state = {
+            drag: this.dragTarget,
+            drop: this.dropTarget,
+            drags: this.dragTargets,
+            drops: this.dropTargets,
+            pressed: this.pressed,
+            ignoreMouse: this.ignoreMouse,
+            autoScroll: this.autoScroll,
+            isScrolling: this.isScrolling,
+            scrollableParent: this.scrollableParent,
+            autoScrollDirection: this.autoScrollDirection,
+            initialClientOffset: this.initialClientOffset,
+            clientOffset: this.clientOffset,
+            initialScrollOffset: this.initialScrollOffset,
+            scrollOffset: this.scrollOffset,
+            offset: this.offset,
+            pageOffset: this.pageOffset,
+            velocity: this.velocity
+        };
+    }
+    setCallbacks() {
+        this.callbacks = {
+            onVelocityChange: this.setVelocity.bind(this),
+            onOffsetChange: this.setOffset.bind(this),
+            onClientOffsetChange: this.setClientOffset.bind(this),
+            onPageOffsetChange: this.setPageOffset.bind(this),
+            onInitialClientOffsetChange: this.setInitialClientOffset.bind(this),
+            onScrollOffsetChange: this.setScrollOffset.bind(this),
+            onInitialScrollOffsetChange: this.setInitialScrollOffset.bind(this),
+            onIsPressedChange: this.setPressed.bind(this),
+            onIsScrollingChange: this.setScrolling.bind(this)
+        };
+    }
+    ngOnDestroy() {
+        if (this.scrollInterval) {
+            window.clearInterval(this.scrollInterval);
+            this.scrollInterval = null;
+        }
+    }
+}
+DragStateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: DragStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+DragStateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: DragStateService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: DragStateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });

package/esm2015/drag-and-drop/draghandle.directive.js

@@ -0,0 +1,27 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Directive, HostBinding } from "@angular/core";
+import * as i0 from "@angular/core";
+/**
+ * Represents the Kendo UI DragHandle directive for Angular.
+ */
+export class DragHandleDirective {
+    constructor(element) {
+        this.element = element;
+        this.hostClass = true;
+    }
+}
+DragHandleDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: DragHandleDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+DragHandleDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: DragHandleDirective, selector: "[kendoDragHandle]", host: { properties: { "class.k-cursor-pointer": "this.hostClass" } }, exportAs: ["kendoDragHandle"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: DragHandleDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[kendoDragHandle]',
+                    exportAs: 'kendoDragHandle'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { hostClass: [{
+                type: HostBinding,
+                args: ['class.k-cursor-pointer']
+            }] } });

package/esm2015/drag-and-drop/dragtarget.directive.js

@@ -0,0 +1,389 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Directive, EventEmitter, HostBinding, Output, Input, ContentChildren } from "@angular/core";
+import { validatePackage } from '@progress/kendo-licensing';
+import { packageMetadata } from '../package-metadata';
+import { DragHandleDirective } from "./draghandle.directive";
+import { getScrollableParent } from "@progress/kendo-draggable-common";
+import { DragStartEvent, DragEndEvent, PressEvent, ReleaseEvent, DragEvent } from "./events/drag-target";
+import { getAction, isPresent, setElementStyles, dragTargetTransition } from './util';
+import { contains, isDocumentAvailable } from "@progress/kendo-angular-common";
+import { HintComponent } from "./hint.component";
+import * as i0 from "@angular/core";
+import * as i1 from "./drag-state.service";
+/**
+ * Represents the Kendo UI DragTarget directive for Angular.
+ */
+export class DragTargetDirective {
+    constructor(element, renderer, ngZone, service, viewContainer, resolver) {
+        this.element = element;
+        this.renderer = renderer;
+        this.ngZone = ngZone;
+        this.service = service;
+        this.viewContainer = viewContainer;
+        this.resolver = resolver;
+        /**
+         * The number of pixels the pointer moves in any direction before the dragging starts ([see example]({% slug minimum_distance %})).
+         *
+         * @default 0
+         */
+        this.threshold = 0;
+        /**
+         * Defines the automatic container scrolling behavior when close to the edge ([see example]({% slug auto_scroll %})).
+         *
+         * @default true
+         */
+        this.autoScroll = true;
+        /**
+         * Defines the delay in milliseconds after which the drag will begin ([see example]({% slug drag_delay %})).
+         *
+         * @default 0
+         */
+        this.dragDelay = 0;
+        /**
+         * Fires when the user presses the DragTarget element.
+         * This event is preventable. Preventing it allows full logic customization.
+         */
+        this.press = new EventEmitter();
+        /**
+         * Fires when the dragging of the DragTarget element begins.
+         * This event is preventable. Preventing it allows full logic customization.
+         */
+        this.dragStart = new EventEmitter();
+        /**
+         * Fires while the user drags the DragTarget element.
+         * This event is preventable. Preventing it allows full logic customization.
+         */
+        this.drag = new EventEmitter();
+        /**
+         * Fires when the user releases the DragTarget element.
+         * This event is preventable. Preventing it allows full logic customization.
+         */
+        this.release = new EventEmitter();
+        /**
+         * Fires when the dragging of the DragTarget element ends.
+         * This event is preventable. Preventing it allows full logic customization.
+         */
+        this.dragEnd = new EventEmitter();
+        this.touchAction = 'none';
+        this.dragTarget = null;
+        this.domSubscriptions = [];
+        this.hint = null;
+        this.initialPosition = { x: 0, y: 0 };
+        this.dragStarted = false;
+        this.pressed = false;
+        this.dragTimeout = null;
+        validatePackage(packageMetadata);
+    }
+    /**
+     * @hidden
+     */
+    get nativeElement() {
+        return this.element.nativeElement;
+    }
+    /**
+     * @hidden
+     */
+    get hintElem() {
+        return this.hint.instance.element.nativeElement;
+    }
+    /**
+     * @hidden
+     */
+    onPointerDown(event) {
+        if (this.dragHandles.length && !this.isDragHandle(event.target)) {
+            return;
+        }
+        event.preventDefault();
+        const action = getAction(event, this.dragTarget);
+        this.service.handleDragAndDrop(action);
+        this.service.autoScroll = typeof this.autoScroll === 'object' ? this.autoScroll.enabled !== false : this.autoScroll;
+        this.service.scrollableParent = this.getAutoScrollContainer();
+        this.service.autoScrollDirection = typeof this.autoScroll === 'object' ? this.autoScroll.direction : { horizontal: true, vertical: true };
+        this.ngZone.runOutsideAngular(() => {
+            this.attachDomHandlers();
+        });
+    }
+    /**
+     * @hidden
+     */
+    onPointerMove(event) {
+        event.preventDefault();
+        const action = getAction(event, this.dragTarget);
+        this.service.handleDragAndDrop(action);
+    }
+    /**
+     * @hidden
+     */
+    onPointerUp(event) {
+        event.preventDefault();
+        const action = getAction(event, this.dragTarget);
+        this.service.handleDragAndDrop(action);
+        this.ngZone.runOutsideAngular(() => {
+            this.attachDomHandlers();
+        });
+    }
+    ngOnInit() {
+        this.initializeDraggable();
+    }
+    ngAfterContentInit() {
+        if (isPresent(this.element) || isPresent(this.dragTarget)) {
+            this.ngZone.runOutsideAngular(() => {
+                this.attachDomHandlers();
+                if (!this.dragHandles.length) {
+                    this.renderer.addClass(this.nativeElement, 'k-cursor-pointer');
+                }
+            });
+        }
+        this.service.dragTargets.push(this.dragTarget);
+    }
+    ngOnDestroy() {
+        this.domSubscriptions.forEach(subscription => subscription());
+    }
+    /**
+     * @hidden
+     */
+    handlePress(event) {
+        if (this.dragDelay > 0) {
+            this.dragTimeout = setTimeout(() => {
+                this.pressed = true;
+            }, this.dragDelay);
+        }
+        else {
+            this.pressed = true;
+        }
+        this.ngZone.run(() => {
+            const eventArgs = new PressEvent({ event, element: this.nativeElement });
+            this.press.emit(eventArgs);
+        });
+    }
+    /**
+     * @hidden
+     */
+    handleDragStart(event) {
+        if (!this.pressed) {
+            if (this.dragTimeout) {
+                clearTimeout(this.dragTimeout);
+                this.dragTimeout = null;
+            }
+            return;
+        }
+        if (isPresent(this.hintTemplate)) {
+            this.createHint();
+            if (isPresent(this.hint)) {
+                this.renderer.setStyle(this.nativeElement, 'opacity', '0.7');
+            }
+        }
+        this.dragStarted = this.threshold === 0;
+        this.service.dragTarget = this.dragTarget;
+        this.service.dragTargetDirective = this;
+        this.initialPosition = { x: event.clientX, y: event.clientY };
+        this.ngZone.run(() => {
+            const eventArgs = new DragStartEvent({ event, element: this.nativeElement });
+            this.dragStart.emit(eventArgs);
+        });
+    }
+    /**
+     * @hidden
+     */
+    handleDrag(event) {
+        if (!this.pressed) {
+            return;
+        }
+        const elem = this.hint ? this.hintElem : this.nativeElement;
+        let coordinates = { x: 0, y: 0 };
+        if (this.restrictByAxis === 'horizontal') {
+            coordinates = { x: event.clientX - this.initialPosition.x + event.scrollX, y: 0 };
+        }
+        else if (this.restrictByAxis === 'vertical') {
+            coordinates = { x: 0, y: event.clientY - this.initialPosition.y + event.scrollY };
+        }
+        else {
+            coordinates = { x: event.clientX - this.initialPosition.x + event.scrollX, y: event.clientY - this.initialPosition.y + event.scrollY };
+        }
+        const thresholdNotReached = Math.abs(coordinates.x) < this.threshold && Math.abs(coordinates.y) < this.threshold;
+        if (!this.dragStarted && thresholdNotReached) {
+            return;
+        }
+        const transform = `translate(${coordinates.x}px, ${coordinates.y}px)`;
+        setElementStyles(this.renderer, elem, {
+            transform: transform,
+            transition: 'none'
+        });
+        if (!this.dragStarted && this.threshold > 0) {
+            this.dragStarted = true;
+        }
+        this.ngZone.run(() => {
+            const eventArgs = new DragEvent({ event, element: this.nativeElement });
+            this.drag.emit(eventArgs);
+        });
+    }
+    /**
+     * @hidden
+     */
+    handleRelease(event) {
+        if (this.dragTimeout) {
+            clearTimeout(this.dragTimeout);
+            this.dragTimeout = null;
+            this.pressed = false;
+        }
+        this.service.dragTarget = null;
+        this.service.dragTargetDirective = null;
+        this.ngZone.run(() => {
+            const eventArgs = new ReleaseEvent({ event, element: this.nativeElement });
+            this.release.emit(eventArgs);
+        });
+    }
+    /**
+     * @hidden
+     */
+    handleDragEnd(event) {
+        if (!this.dragStarted) {
+            return;
+        }
+        this.dragStarted = false;
+        const elem = this.hint ? this.hintElem : this.nativeElement;
+        if (isPresent(this.hint)) {
+            this.renderer.removeStyle(this.nativeElement, 'opacity');
+            this.destroyHint();
+        }
+        this.renderer.removeStyle(elem, 'transform');
+        setElementStyles(this.renderer, elem, {
+            transition: dragTargetTransition
+        });
+        this.ngZone.run(() => {
+            const eventArgs = new DragEndEvent({ event, element: this.nativeElement });
+            this.dragEnd.emit(eventArgs);
+        });
+    }
+    /**
+     * @hidden
+     */
+    initializeDraggable() {
+        this.dragTarget = {
+            element: this.nativeElement,
+            hint: null,
+            onPress: this.handlePress.bind(this),
+            onRelease: this.handleRelease.bind(this),
+            onDragStart: this.handleDragStart.bind(this),
+            onDrag: this.handleDrag.bind(this),
+            onDragEnd: this.handleDragEnd.bind(this)
+        };
+    }
+    /**
+     * @hidden
+     */
+    attachDomHandlers() {
+        if (this.domSubscriptions.length > 0) {
+            this.domSubscriptions.forEach(subscription => subscription());
+        }
+        if (!(isDocumentAvailable() && isPresent(this.element))) {
+            return;
+        }
+        if (this.service.pressed) {
+            this.onPointerMove = this.onPointerMove.bind(this);
+            this.onPointerUp = this.onPointerUp.bind(this);
+            let scrollable = getScrollableParent(this.nativeElement);
+            this.domSubscriptions = [
+                this.renderer.listen(document, 'pointermove', this.onPointerMove),
+                this.renderer.listen(document, 'mousemove', this.onPointerMove),
+                this.renderer.listen(document, 'touchmove', this.onPointerMove),
+                this.renderer.listen(document, 'pointerup', this.onPointerUp),
+                this.renderer.listen(document, 'pointercancel', this.onPointerUp),
+                this.renderer.listen(document, 'mouseup', this.onPointerUp),
+                this.renderer.listen(document, 'contextmenu', this.onPointerUp),
+                this.renderer.listen(document, 'touchend', this.onPointerUp),
+                this.renderer.listen(document, 'touchcancel', this.onPointerUp)
+            ];
+            if (scrollable) {
+                if (scrollable === document.getElementsByTagName('html')[0]) {
+                    scrollable = document;
+                }
+                this.domSubscriptions.push(this.renderer.listen(scrollable, 'scroll', this.onPointerMove));
+            }
+        }
+        else {
+            this.onPointerDown = this.onPointerDown.bind(this);
+            const element = this.nativeElement;
+            this.domSubscriptions = [
+                this.renderer.listen(element, 'pointerdown', this.onPointerDown),
+                this.renderer.listen(element, 'mousedown', this.onPointerDown),
+                this.renderer.listen(element, 'touchstart', this.onPointerDown)
+            ];
+        }
+    }
+    /**
+     * @hidden
+     */
+    isDragHandle(el) {
+        return this.dragHandles.toArray().some(dh => contains(dh.element.nativeElement, el, true));
+    }
+    /**
+     * @hidden
+     */
+    getAutoScrollContainer() {
+        return typeof this.autoScroll === 'object' &&
+            this.autoScroll.boundaryElementRef &&
+            this.autoScroll.boundaryElementRef.nativeElement ?
+            this.autoScroll.boundaryElementRef.nativeElement : null;
+    }
+    /**
+     * @hidden
+     */
+    createHint() {
+        const hintComponent = this.resolver.resolveComponentFactory(HintComponent);
+        this.hint = this.viewContainer.createComponent(hintComponent);
+        this.hint.instance.template = this.hintTemplate;
+        this.hint.instance.directive = this;
+        this.hint.changeDetectorRef.detectChanges();
+        this.dragTarget.hint = this.hint.instance.element.nativeElement;
+    }
+    /**
+     * @hidden
+     */
+    destroyHint() {
+        this.hint.destroy();
+        this.hint.changeDetectorRef.detectChanges();
+        this.hint = null;
+        this.dragTarget.hint = null;
+    }
+}
+DragTargetDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: DragTargetDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.NgZone }, { token: i1.DragStateService }, { token: i0.ViewContainerRef }, { token: i0.ComponentFactoryResolver }], target: i0.ɵɵFactoryTarget.Directive });
+DragTargetDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: DragTargetDirective, selector: "[kendoDragTarget]", inputs: { hintTemplate: "hintTemplate", threshold: "threshold", autoScroll: "autoScroll", link: "link", dragDelay: "dragDelay", restrictByAxis: "restrictByAxis" }, outputs: { press: "press", dragStart: "dragStart", drag: "drag", release: "release", dragEnd: "dragEnd" }, host: { properties: { "style.touch-action": "this.touchAction" } }, queries: [{ propertyName: "dragHandles", predicate: DragHandleDirective }], exportAs: ["kendoDragTarget"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: DragTargetDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[kendoDragTarget]',
+                    exportAs: 'kendoDragTarget'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.NgZone }, { type: i1.DragStateService }, { type: i0.ViewContainerRef }, { type: i0.ComponentFactoryResolver }]; }, propDecorators: { hintTemplate: [{
+                type: Input
+            }], threshold: [{
+                type: Input
+            }], autoScroll: [{
+                type: Input
+            }], link: [{
+                type: Input
+            }], dragDelay: [{
+                type: Input
+            }], restrictByAxis: [{
+                type: Input
+            }], press: [{
+                type: Output
+            }], dragStart: [{
+                type: Output
+            }], drag: [{
+                type: Output
+            }], release: [{
+                type: Output
+            }], dragEnd: [{
+                type: Output
+            }], touchAction: [{
+                type: HostBinding,
+                args: ['style.touch-action']
+            }], dragHandles: [{
+                type: ContentChildren,
+                args: [DragHandleDirective]
+            }] } });