@angular/cdk 10.0.0-rc.3 → 10.1.0

package/esm2015/drag-drop/directives/drag.js

@@ -7,350 +7,344 @@
  */
 import { Directionality } from '@angular/cdk/bidi';
 import { DOCUMENT } from '@angular/common';
-import { ContentChild, ContentChildren, Directive, ElementRef, EventEmitter, Inject, InjectionToken, Input, NgZone, Optional, Output, QueryList, SkipSelf, ViewContainerRef, ChangeDetectorRef, isDevMode, } from '@angular/core';
+import { ContentChild, ContentChildren, Directive, ElementRef, EventEmitter, Inject, Input, NgZone, Optional, Output, QueryList, SkipSelf, ViewContainerRef, ChangeDetectorRef, isDevMode, Self, } from '@angular/core';
 import { coerceBooleanProperty, coerceNumberProperty, coerceElement } from '@angular/cdk/coercion';
 import { Observable, Subject, merge } from 'rxjs';
 import { startWith, take, map, takeUntil, switchMap, tap } from 'rxjs/operators';
-import { CdkDragHandle } from './drag-handle';
-import { CdkDragPlaceholder } from './drag-placeholder';
-import { CdkDragPreview } from './drag-preview';
+import { CDK_DRAG_HANDLE, CdkDragHandle } from './drag-handle';
+import { CDK_DRAG_PLACEHOLDER, CdkDragPlaceholder } from './drag-placeholder';
+import { CDK_DRAG_PREVIEW, CdkDragPreview } from './drag-preview';
 import { CDK_DRAG_PARENT } from '../drag-parent';
+import { CDK_DROP_LIST } from './drop-list';
 import { DragDrop } from '../drag-drop';
 import { CDK_DRAG_CONFIG } from './config';
-/**
- * Injection token that is used to provide a CdkDropList instance to CdkDrag.
- * Used for avoiding circular imports.
- */
-export const CDK_DROP_LIST = new InjectionToken('CDK_DROP_LIST');
 /** Element that can be moved inside a CdkDropList container. */
-let CdkDrag = /** @class */ (() => {
-    class CdkDrag {
-        constructor(
-        /** Element that the draggable is attached to. */
-        element, 
-        /** Droppable container that the draggable is a part of. */
-        dropContainer, _document, _ngZone, _viewContainerRef, config, _dir, dragDrop, _changeDetectorRef) {
-            this.element = element;
-            this.dropContainer = dropContainer;
-            this._document = _document;
-            this._ngZone = _ngZone;
-            this._viewContainerRef = _viewContainerRef;
-            this._dir = _dir;
-            this._changeDetectorRef = _changeDetectorRef;
-            this._destroyed = new Subject();
-            /** Emits when the user starts dragging the item. */
-            this.started = new EventEmitter();
-            /** Emits when the user has released a drag item, before any animations have started. */
-            this.released = new EventEmitter();
-            /** Emits when the user stops dragging an item in the container. */
-            this.ended = new EventEmitter();
-            /** Emits when the user has moved the item into a new container. */
-            this.entered = new EventEmitter();
-            /** Emits when the user removes the item its container by dragging it into another container. */
-            this.exited = new EventEmitter();
-            /** Emits when the user drops the item inside a container. */
-            this.dropped = new EventEmitter();
-            /**
-             * Emits as the user is dragging the item. Use with caution,
-             * because this event will fire for every pixel that the user has dragged.
-             */
-            this.moved = new Observable((observer) => {
-                const subscription = this._dragRef.moved.pipe(map(movedEvent => ({
-                    source: this,
-                    pointerPosition: movedEvent.pointerPosition,
-                    event: movedEvent.event,
-                    delta: movedEvent.delta,
-                    distance: movedEvent.distance
-                }))).subscribe(observer);
-                return () => {
-                    subscription.unsubscribe();
-                };
-            });
-            this._dragRef = dragDrop.createDrag(element, {
-                dragStartThreshold: config && config.dragStartThreshold != null ?
-                    config.dragStartThreshold : 5,
-                pointerDirectionChangeThreshold: config && config.pointerDirectionChangeThreshold != null ?
-                    config.pointerDirectionChangeThreshold : 5,
-                zIndex: config === null || config === void 0 ? void 0 : config.zIndex
-            });
-            this._dragRef.data = this;
-            if (config) {
-                this._assignDefaults(config);
-            }
-            // Note that usually the container is assigned when the drop list is picks up the item, but in
-            // some cases (mainly transplanted views with OnPush, see #18341) we may end up in a situation
-            // where there are no items on the first change detection pass, but the items get picked up as
-            // soon as the user triggers another pass by dragging. This is a problem, because the item would
-            // have to switch from standalone mode to drag mode in the middle of the dragging sequence which
-            // is too late since the two modes save different kinds of information. We work around it by
-            // assigning the drop container both from here and the list.
-            if (dropContainer) {
-                this._dragRef._withDropContainer(dropContainer._dropListRef);
-                dropContainer.addItem(this);
-            }
-            this._syncInputs(this._dragRef);
-            this._handleEvents(this._dragRef);
-        }
-        /** Whether starting to drag this element is disabled. */
-        get disabled() {
-            return this._disabled || (this.dropContainer && this.dropContainer.disabled);
-        }
-        set disabled(value) {
-            this._disabled = coerceBooleanProperty(value);
-            this._dragRef.disabled = this._disabled;
-        }
+export class CdkDrag {
+    constructor(
+    /** Element that the draggable is attached to. */
+    element, 
+    /** Droppable container that the draggable is a part of. */
+    dropContainer, _document, _ngZone, _viewContainerRef, config, _dir, dragDrop, _changeDetectorRef, _selfHandle) {
+        this.element = element;
+        this.dropContainer = dropContainer;
+        this._document = _document;
+        this._ngZone = _ngZone;
+        this._viewContainerRef = _viewContainerRef;
+        this._dir = _dir;
+        this._changeDetectorRef = _changeDetectorRef;
+        this._selfHandle = _selfHandle;
+        this._destroyed = new Subject();
+        /** Emits when the user starts dragging the item. */
+        this.started = new EventEmitter();
+        /** Emits when the user has released a drag item, before any animations have started. */
+        this.released = new EventEmitter();
+        /** Emits when the user stops dragging an item in the container. */
+        this.ended = new EventEmitter();
+        /** Emits when the user has moved the item into a new container. */
+        this.entered = new EventEmitter();
+        /** Emits when the user removes the item its container by dragging it into another container. */
+        this.exited = new EventEmitter();
+        /** Emits when the user drops the item inside a container. */
+        this.dropped = new EventEmitter();
         /**
-         * Returns the element that is being used as a placeholder
-         * while the current element is being dragged.
-         * @deprecated No longer being used to be removed.
-         * @breaking-change 11.0.0
+         * Emits as the user is dragging the item. Use with caution,
+         * because this event will fire for every pixel that the user has dragged.
          */
-        getPlaceholderElement() {
-            return this._dragRef.getPlaceholderElement();
+        this.moved = new Observable((observer) => {
+            const subscription = this._dragRef.moved.pipe(map(movedEvent => ({
+                source: this,
+                pointerPosition: movedEvent.pointerPosition,
+                event: movedEvent.event,
+                delta: movedEvent.delta,
+                distance: movedEvent.distance
+            }))).subscribe(observer);
+            return () => {
+                subscription.unsubscribe();
+            };
+        });
+        this._dragRef = dragDrop.createDrag(element, {
+            dragStartThreshold: config && config.dragStartThreshold != null ?
+                config.dragStartThreshold : 5,
+            pointerDirectionChangeThreshold: config && config.pointerDirectionChangeThreshold != null ?
+                config.pointerDirectionChangeThreshold : 5,
+            zIndex: config === null || config === void 0 ? void 0 : config.zIndex
+        });
+        this._dragRef.data = this;
+        if (config) {
+            this._assignDefaults(config);
         }
-        /**
-         * Returns the root draggable element.
-         * @deprecated No longer being used to be removed.
-         * @breaking-change 11.0.0
-         */
-        getRootElement() {
-            return this._dragRef.getRootElement();
+        // Note that usually the container is assigned when the drop list is picks up the item, but in
+        // some cases (mainly transplanted views with OnPush, see #18341) we may end up in a situation
+        // where there are no items on the first change detection pass, but the items get picked up as
+        // soon as the user triggers another pass by dragging. This is a problem, because the item would
+        // have to switch from standalone mode to drag mode in the middle of the dragging sequence which
+        // is too late since the two modes save different kinds of information. We work around it by
+        // assigning the drop container both from here and the list.
+        if (dropContainer) {
+            this._dragRef._withDropContainer(dropContainer._dropListRef);
+            dropContainer.addItem(this);
         }
-        /** Resets a standalone drag item to its initial position. */
-        reset() {
-            this._dragRef.reset();
-        }
-        /**
-         * Gets the pixel coordinates of the draggable outside of a drop container.
-         */
-        getFreeDragPosition() {
-            return this._dragRef.getFreeDragPosition();
-        }
-        ngAfterViewInit() {
-            // We need to wait for the zone to stabilize, in order for the reference
-            // element to be in the proper place in the DOM. This is mostly relevant
-            // for draggable elements inside portals since they get stamped out in
-            // their original DOM position and then they get transferred to the portal.
-            this._ngZone.onStable.asObservable()
-                .pipe(take(1), takeUntil(this._destroyed))
-                .subscribe(() => {
-                this._updateRootElement();
-                // Listen for any newly-added handles.
-                this._handles.changes.pipe(startWith(this._handles), 
-                // Sync the new handles with the DragRef.
-                tap((handles) => {
-                    const childHandleElements = handles
-                        .filter(handle => handle._parentDrag === this)
-                        .map(handle => handle.element);
-                    this._dragRef.withHandles(childHandleElements);
-                }), 
-                // Listen if the state of any of the handles changes.
-                switchMap((handles) => {
-                    return merge(...handles.map(item => {
-                        return item._stateChanges.pipe(startWith(item));
-                    }));
-                }), takeUntil(this._destroyed)).subscribe(handleInstance => {
-                    // Enabled/disable the handle that changed in the DragRef.
-                    const dragRef = this._dragRef;
-                    const handle = handleInstance.element.nativeElement;
-                    handleInstance.disabled ? dragRef.disableHandle(handle) : dragRef.enableHandle(handle);
-                });
-                if (this.freeDragPosition) {
-                    this._dragRef.setFreeDragPosition(this.freeDragPosition);
+        this._syncInputs(this._dragRef);
+        this._handleEvents(this._dragRef);
+    }
+    /** Whether starting to drag this element is disabled. */
+    get disabled() {
+        return this._disabled || (this.dropContainer && this.dropContainer.disabled);
+    }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+        this._dragRef.disabled = this._disabled;
+    }
+    /**
+     * Returns the element that is being used as a placeholder
+     * while the current element is being dragged.
+     */
+    getPlaceholderElement() {
+        return this._dragRef.getPlaceholderElement();
+    }
+    /** Returns the root draggable element. */
+    getRootElement() {
+        return this._dragRef.getRootElement();
+    }
+    /** Resets a standalone drag item to its initial position. */
+    reset() {
+        this._dragRef.reset();
+    }
+    /**
+     * Gets the pixel coordinates of the draggable outside of a drop container.
+     */
+    getFreeDragPosition() {
+        return this._dragRef.getFreeDragPosition();
+    }
+    ngAfterViewInit() {
+        // We need to wait for the zone to stabilize, in order for the reference
+        // element to be in the proper place in the DOM. This is mostly relevant
+        // for draggable elements inside portals since they get stamped out in
+        // their original DOM position and then they get transferred to the portal.
+        this._ngZone.onStable.asObservable()
+            .pipe(take(1), takeUntil(this._destroyed))
+            .subscribe(() => {
+            this._updateRootElement();
+            // Listen for any newly-added handles.
+            this._handles.changes.pipe(startWith(this._handles), 
+            // Sync the new handles with the DragRef.
+            tap((handles) => {
+                const childHandleElements = handles
+                    .filter(handle => handle._parentDrag === this)
+                    .map(handle => handle.element);
+                // Usually handles are only allowed to be a descendant of the drag element, but if
+                // the consumer defined a different drag root, we should allow the drag element
+                // itself to be a handle too.
+                if (this._selfHandle && this.rootElementSelector) {
+                    childHandleElements.push(this.element);
                 }
+                this._dragRef.withHandles(childHandleElements);
+            }), 
+            // Listen if the state of any of the handles changes.
+            switchMap((handles) => {
+                return merge(...handles.map(item => {
+                    return item._stateChanges.pipe(startWith(item));
+                }));
+            }), takeUntil(this._destroyed)).subscribe(handleInstance => {
+                // Enabled/disable the handle that changed in the DragRef.
+                const dragRef = this._dragRef;
+                const handle = handleInstance.element.nativeElement;
+                handleInstance.disabled ? dragRef.disableHandle(handle) : dragRef.enableHandle(handle);
             });
-        }
-        ngOnChanges(changes) {
-            const rootSelectorChange = changes['rootElementSelector'];
-            const positionChange = changes['freeDragPosition'];
-            // We don't have to react to the first change since it's being
-            // handled in `ngAfterViewInit` where it needs to be deferred.
-            if (rootSelectorChange && !rootSelectorChange.firstChange) {
-                this._updateRootElement();
-            }
-            // Skip the first change since it's being handled in `ngAfterViewInit`.
-            if (positionChange && !positionChange.firstChange && this.freeDragPosition) {
+            if (this.freeDragPosition) {
                 this._dragRef.setFreeDragPosition(this.freeDragPosition);
             }
+        });
+    }
+    ngOnChanges(changes) {
+        const rootSelectorChange = changes['rootElementSelector'];
+        const positionChange = changes['freeDragPosition'];
+        // We don't have to react to the first change since it's being
+        // handled in `ngAfterViewInit` where it needs to be deferred.
+        if (rootSelectorChange && !rootSelectorChange.firstChange) {
+            this._updateRootElement();
         }
-        ngOnDestroy() {
-            if (this.dropContainer) {
-                this.dropContainer.removeItem(this);
-            }
-            this._destroyed.next();
-            this._destroyed.complete();
-            this._dragRef.dispose();
+        // Skip the first change since it's being handled in `ngAfterViewInit`.
+        if (positionChange && !positionChange.firstChange && this.freeDragPosition) {
+            this._dragRef.setFreeDragPosition(this.freeDragPosition);
         }
-        /** Syncs the root element with the `DragRef`. */
-        _updateRootElement() {
-            const element = this.element.nativeElement;
-            const rootElement = this.rootElementSelector ?
-                getClosestMatchingAncestor(element, this.rootElementSelector) : element;
-            if (rootElement && rootElement.nodeType !== this._document.ELEMENT_NODE) {
-                throw Error(`cdkDrag must be attached to an element node. ` +
-                    `Currently attached to "${rootElement.nodeName}".`);
-            }
-            this._dragRef.withRootElement(rootElement || element);
+    }
+    ngOnDestroy() {
+        if (this.dropContainer) {
+            this.dropContainer.removeItem(this);
         }
-        /** Gets the boundary element, based on the `boundaryElement` value. */
-        _getBoundaryElement() {
-            const boundary = this.boundaryElement;
-            if (!boundary) {
-                return null;
-            }
-            if (typeof boundary === 'string') {
-                return getClosestMatchingAncestor(this.element.nativeElement, boundary);
-            }
-            const element = coerceElement(boundary);
-            if (isDevMode() && !element.contains(this.element.nativeElement)) {
-                throw Error('Draggable element is not inside of the node passed into cdkDragBoundary.');
-            }
-            return element;
+        this._destroyed.next();
+        this._destroyed.complete();
+        this._dragRef.dispose();
+    }
+    /** Syncs the root element with the `DragRef`. */
+    _updateRootElement() {
+        const element = this.element.nativeElement;
+        const rootElement = this.rootElementSelector ?
+            getClosestMatchingAncestor(element, this.rootElementSelector) : element;
+        if (rootElement && rootElement.nodeType !== this._document.ELEMENT_NODE) {
+            throw Error(`cdkDrag must be attached to an element node. ` +
+                `Currently attached to "${rootElement.nodeName}".`);
         }
-        /** Syncs the inputs of the CdkDrag with the options of the underlying DragRef. */
-        _syncInputs(ref) {
-            ref.beforeStarted.subscribe(() => {
-                if (!ref.isDragging()) {
-                    const dir = this._dir;
-                    const dragStartDelay = this.dragStartDelay;
-                    const placeholder = this._placeholderTemplate ? {
-                        template: this._placeholderTemplate.templateRef,
-                        context: this._placeholderTemplate.data,
-                        viewContainer: this._viewContainerRef
-                    } : null;
-                    const preview = this._previewTemplate ? {
-                        template: this._previewTemplate.templateRef,
-                        context: this._previewTemplate.data,
-                        matchSize: this._previewTemplate.matchSize,
-                        viewContainer: this._viewContainerRef
-                    } : null;
-                    ref.disabled = this.disabled;
-                    ref.lockAxis = this.lockAxis;
-                    ref.dragStartDelay = (typeof dragStartDelay === 'object' && dragStartDelay) ?
-                        dragStartDelay : coerceNumberProperty(dragStartDelay);
-                    ref.constrainPosition = this.constrainPosition;
-                    ref.previewClass = this.previewClass;
-                    ref
-                        .withBoundaryElement(this._getBoundaryElement())
-                        .withPlaceholderTemplate(placeholder)
-                        .withPreviewTemplate(preview);
-                    if (dir) {
-                        ref.withDirection(dir.value);
-                    }
-                }
-            });
+        this._dragRef.withRootElement(rootElement || element);
+    }
+    /** Gets the boundary element, based on the `boundaryElement` value. */
+    _getBoundaryElement() {
+        const boundary = this.boundaryElement;
+        if (!boundary) {
+            return null;
         }
-        /** Handles the events from the underlying `DragRef`. */
-        _handleEvents(ref) {
-            ref.started.subscribe(() => {
-                this.started.emit({ source: this });
-                // Since all of these events run outside of change detection,
-                // we need to ensure that everything is marked correctly.
-                this._changeDetectorRef.markForCheck();
-            });
-            ref.released.subscribe(() => {
-                this.released.emit({ source: this });
-            });
-            ref.ended.subscribe(event => {
-                this.ended.emit({ source: this, distance: event.distance });
-                // Since all of these events run outside of change detection,
-                // we need to ensure that everything is marked correctly.
-                this._changeDetectorRef.markForCheck();
-            });
-            ref.entered.subscribe(event => {
-                this.entered.emit({
-                    container: event.container.data,
-                    item: this,
-                    currentIndex: event.currentIndex
-                });
+        if (typeof boundary === 'string') {
+            return getClosestMatchingAncestor(this.element.nativeElement, boundary);
+        }
+        const element = coerceElement(boundary);
+        if (isDevMode() && !element.contains(this.element.nativeElement)) {
+            throw Error('Draggable element is not inside of the node passed into cdkDragBoundary.');
+        }
+        return element;
+    }
+    /** Syncs the inputs of the CdkDrag with the options of the underlying DragRef. */
+    _syncInputs(ref) {
+        ref.beforeStarted.subscribe(() => {
+            if (!ref.isDragging()) {
+                const dir = this._dir;
+                const dragStartDelay = this.dragStartDelay;
+                const placeholder = this._placeholderTemplate ? {
+                    template: this._placeholderTemplate.templateRef,
+                    context: this._placeholderTemplate.data,
+                    viewContainer: this._viewContainerRef
+                } : null;
+                const preview = this._previewTemplate ? {
+                    template: this._previewTemplate.templateRef,
+                    context: this._previewTemplate.data,
+                    matchSize: this._previewTemplate.matchSize,
+                    viewContainer: this._viewContainerRef
+                } : null;
+                ref.disabled = this.disabled;
+                ref.lockAxis = this.lockAxis;
+                ref.dragStartDelay = (typeof dragStartDelay === 'object' && dragStartDelay) ?
+                    dragStartDelay : coerceNumberProperty(dragStartDelay);
+                ref.constrainPosition = this.constrainPosition;
+                ref.previewClass = this.previewClass;
+                ref
+                    .withBoundaryElement(this._getBoundaryElement())
+                    .withPlaceholderTemplate(placeholder)
+                    .withPreviewTemplate(preview);
+                if (dir) {
+                    ref.withDirection(dir.value);
+                }
+            }
+        });
+    }
+    /** Handles the events from the underlying `DragRef`. */
+    _handleEvents(ref) {
+        ref.started.subscribe(() => {
+            this.started.emit({ source: this });
+            // Since all of these events run outside of change detection,
+            // we need to ensure that everything is marked correctly.
+            this._changeDetectorRef.markForCheck();
+        });
+        ref.released.subscribe(() => {
+            this.released.emit({ source: this });
+        });
+        ref.ended.subscribe(event => {
+            this.ended.emit({ source: this, distance: event.distance });
+            // Since all of these events run outside of change detection,
+            // we need to ensure that everything is marked correctly.
+            this._changeDetectorRef.markForCheck();
+        });
+        ref.entered.subscribe(event => {
+            this.entered.emit({
+                container: event.container.data,
+                item: this,
+                currentIndex: event.currentIndex
             });
-            ref.exited.subscribe(event => {
-                this.exited.emit({
-                    container: event.container.data,
-                    item: this
-                });
+        });
+        ref.exited.subscribe(event => {
+            this.exited.emit({
+                container: event.container.data,
+                item: this
             });
-            ref.dropped.subscribe(event => {
-                this.dropped.emit({
-                    previousIndex: event.previousIndex,
-                    currentIndex: event.currentIndex,
-                    previousContainer: event.previousContainer.data,
-                    container: event.container.data,
-                    isPointerOverContainer: event.isPointerOverContainer,
-                    item: this,
-                    distance: event.distance
-                });
+        });
+        ref.dropped.subscribe(event => {
+            this.dropped.emit({
+                previousIndex: event.previousIndex,
+                currentIndex: event.currentIndex,
+                previousContainer: event.previousContainer.data,
+                container: event.container.data,
+                isPointerOverContainer: event.isPointerOverContainer,
+                item: this,
+                distance: event.distance
             });
+        });
+    }
+    /** Assigns the default input values based on a provided config object. */
+    _assignDefaults(config) {
+        const { lockAxis, dragStartDelay, constrainPosition, previewClass, boundaryElement, draggingDisabled, rootElementSelector } = config;
+        this.disabled = draggingDisabled == null ? false : draggingDisabled;
+        this.dragStartDelay = dragStartDelay || 0;
+        if (lockAxis) {
+            this.lockAxis = lockAxis;
         }
-        /** Assigns the default input values based on a provided config object. */
-        _assignDefaults(config) {
-            const { lockAxis, dragStartDelay, constrainPosition, previewClass, boundaryElement, draggingDisabled, rootElementSelector } = config;
-            this.disabled = draggingDisabled == null ? false : draggingDisabled;
-            this.dragStartDelay = dragStartDelay || 0;
-            if (lockAxis) {
-                this.lockAxis = lockAxis;
-            }
-            if (constrainPosition) {
-                this.constrainPosition = constrainPosition;
-            }
-            if (previewClass) {
-                this.previewClass = previewClass;
-            }
-            if (boundaryElement) {
-                this.boundaryElement = boundaryElement;
-            }
-            if (rootElementSelector) {
-                this.rootElementSelector = rootElementSelector;
-            }
+        if (constrainPosition) {
+            this.constrainPosition = constrainPosition;
+        }
+        if (previewClass) {
+            this.previewClass = previewClass;
+        }
+        if (boundaryElement) {
+            this.boundaryElement = boundaryElement;
+        }
+        if (rootElementSelector) {
+            this.rootElementSelector = rootElementSelector;
         }
     }
-    CdkDrag.decorators = [
-        { type: Directive, args: [{
-                    selector: '[cdkDrag]',
-                    exportAs: 'cdkDrag',
-                    host: {
-                        'class': 'cdk-drag',
-                        '[class.cdk-drag-disabled]': 'disabled',
-                        '[class.cdk-drag-dragging]': '_dragRef.isDragging()',
-                    },
-                    providers: [{ provide: CDK_DRAG_PARENT, useExisting: CdkDrag }]
-                },] }
-    ];
-    CdkDrag.ctorParameters = () => [
-        { type: ElementRef },
-        { type: undefined, decorators: [{ type: Inject, args: [CDK_DROP_LIST,] }, { type: Optional }, { type: SkipSelf }] },
-        { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
-        { type: NgZone },
-        { type: ViewContainerRef },
-        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [CDK_DRAG_CONFIG,] }] },
-        { type: Directionality, decorators: [{ type: Optional }] },
-        { type: DragDrop },
-        { type: ChangeDetectorRef }
-    ];
-    CdkDrag.propDecorators = {
-        _handles: [{ type: ContentChildren, args: [CdkDragHandle, { descendants: true },] }],
-        _previewTemplate: [{ type: ContentChild, args: [CdkDragPreview,] }],
-        _placeholderTemplate: [{ type: ContentChild, args: [CdkDragPlaceholder,] }],
-        data: [{ type: Input, args: ['cdkDragData',] }],
-        lockAxis: [{ type: Input, args: ['cdkDragLockAxis',] }],
-        rootElementSelector: [{ type: Input, args: ['cdkDragRootElement',] }],
-        boundaryElement: [{ type: Input, args: ['cdkDragBoundary',] }],
-        dragStartDelay: [{ type: Input, args: ['cdkDragStartDelay',] }],
-        freeDragPosition: [{ type: Input, args: ['cdkDragFreeDragPosition',] }],
-        disabled: [{ type: Input, args: ['cdkDragDisabled',] }],
-        constrainPosition: [{ type: Input, args: ['cdkDragConstrainPosition',] }],
-        previewClass: [{ type: Input, args: ['cdkDragPreviewClass',] }],
-        started: [{ type: Output, args: ['cdkDragStarted',] }],
-        released: [{ type: Output, args: ['cdkDragReleased',] }],
-        ended: [{ type: Output, args: ['cdkDragEnded',] }],
-        entered: [{ type: Output, args: ['cdkDragEntered',] }],
-        exited: [{ type: Output, args: ['cdkDragExited',] }],
-        dropped: [{ type: Output, args: ['cdkDragDropped',] }],
-        moved: [{ type: Output, args: ['cdkDragMoved',] }]
-    };
-    return CdkDrag;
-})();
-export { CdkDrag };
+}
+CdkDrag.decorators = [
+    { type: Directive, args: [{
+                selector: '[cdkDrag]',
+                exportAs: 'cdkDrag',
+                host: {
+                    'class': 'cdk-drag',
+                    '[class.cdk-drag-disabled]': 'disabled',
+                    '[class.cdk-drag-dragging]': '_dragRef.isDragging()',
+                },
+                providers: [{ provide: CDK_DRAG_PARENT, useExisting: CdkDrag }]
+            },] }
+];
+CdkDrag.ctorParameters = () => [
+    { type: ElementRef },
+    { type: undefined, decorators: [{ type: Inject, args: [CDK_DROP_LIST,] }, { type: Optional }, { type: SkipSelf }] },
+    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
+    { type: NgZone },
+    { type: ViewContainerRef },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [CDK_DRAG_CONFIG,] }] },
+    { type: Directionality, decorators: [{ type: Optional }] },
+    { type: DragDrop },
+    { type: ChangeDetectorRef },
+    { type: CdkDragHandle, decorators: [{ type: Optional }, { type: Self }, { type: Inject, args: [CDK_DRAG_HANDLE,] }] }
+];
+CdkDrag.propDecorators = {
+    _handles: [{ type: ContentChildren, args: [CDK_DRAG_HANDLE, { descendants: true },] }],
+    _previewTemplate: [{ type: ContentChild, args: [CDK_DRAG_PREVIEW,] }],
+    _placeholderTemplate: [{ type: ContentChild, args: [CDK_DRAG_PLACEHOLDER,] }],
+    data: [{ type: Input, args: ['cdkDragData',] }],
+    lockAxis: [{ type: Input, args: ['cdkDragLockAxis',] }],
+    rootElementSelector: [{ type: Input, args: ['cdkDragRootElement',] }],
+    boundaryElement: [{ type: Input, args: ['cdkDragBoundary',] }],
+    dragStartDelay: [{ type: Input, args: ['cdkDragStartDelay',] }],
+    freeDragPosition: [{ type: Input, args: ['cdkDragFreeDragPosition',] }],
+    disabled: [{ type: Input, args: ['cdkDragDisabled',] }],
+    constrainPosition: [{ type: Input, args: ['cdkDragConstrainPosition',] }],
+    previewClass: [{ type: Input, args: ['cdkDragPreviewClass',] }],
+    started: [{ type: Output, args: ['cdkDragStarted',] }],
+    released: [{ type: Output, args: ['cdkDragReleased',] }],
+    ended: [{ type: Output, args: ['cdkDragEnded',] }],
+    entered: [{ type: Output, args: ['cdkDragEntered',] }],
+    exited: [{ type: Output, args: ['cdkDragExited',] }],
+    dropped: [{ type: Output, args: ['cdkDragDropped',] }],
+    moved: [{ type: Output, args: ['cdkDragMoved',] }]
+};
 /** Gets the closest ancestor of an element that matches a selector. */
 function getClosestMatchingAncestor(element, selector) {
     let currentElement = element.parentElement;
@@ -364,4 +358,4 @@ function getClosestMatchingAncestor(element, selector) {
     }
     return null;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag.js","sourceRoot":"","sources":["../../../../../../../src/cdk/drag-drop/directives/drag.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Directionality} from '@angular/cdk/bidi';\nimport {DOCUMENT} from '@angular/common';\nimport {\n  AfterViewInit,\n  ContentChild,\n  ContentChildren,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Inject,\n  InjectionToken,\n  Input,\n  NgZone,\n  OnDestroy,\n  Optional,\n  Output,\n  QueryList,\n  SkipSelf,\n  ViewContainerRef,\n  OnChanges,\n  SimpleChanges,\n  ChangeDetectorRef,\n  isDevMode,\n} from '@angular/core';\nimport {\n  coerceBooleanProperty,\n  coerceNumberProperty,\n  coerceElement,\n  BooleanInput\n} from '@angular/cdk/coercion';\nimport {Observable, Observer, Subject, merge} from 'rxjs';\nimport {startWith, take, map, takeUntil, switchMap, tap} from 'rxjs/operators';\nimport {\n  CdkDragDrop,\n  CdkDragEnd,\n  CdkDragEnter,\n  CdkDragExit,\n  CdkDragMove,\n  CdkDragStart,\n  CdkDragRelease,\n} from '../drag-events';\nimport {CdkDragHandle} from './drag-handle';\nimport {CdkDragPlaceholder} from './drag-placeholder';\nimport {CdkDragPreview} from './drag-preview';\nimport {CDK_DRAG_PARENT} from '../drag-parent';\nimport {DragRef, Point} from '../drag-ref';\nimport {CdkDropListInternal as CdkDropList} from './drop-list';\nimport {DragDrop} from '../drag-drop';\nimport {CDK_DRAG_CONFIG, DragDropConfig, DragStartDelay, DragAxis} from './config';\n\n/**\n * Injection token that is used to provide a CdkDropList instance to CdkDrag.\n * Used for avoiding circular imports.\n */\nexport const CDK_DROP_LIST = new InjectionToken<CdkDropList>('CDK_DROP_LIST');\n\n/** Element that can be moved inside a CdkDropList container. */\n@Directive({\n  selector: '[cdkDrag]',\n  exportAs: 'cdkDrag',\n  host: {\n    'class': 'cdk-drag',\n    '[class.cdk-drag-disabled]': 'disabled',\n    '[class.cdk-drag-dragging]': '_dragRef.isDragging()',\n  },\n  providers: [{provide: CDK_DRAG_PARENT, useExisting: CdkDrag}]\n})\nexport class CdkDrag<T = any> implements AfterViewInit, OnChanges, OnDestroy {\n  private _destroyed = new Subject<void>();\n\n  /** Reference to the underlying drag instance. */\n  _dragRef: DragRef<CdkDrag<T>>;\n\n  /** Elements that can be used to drag the draggable item. */\n  @ContentChildren(CdkDragHandle, {descendants: true}) _handles: QueryList<CdkDragHandle>;\n\n  /** Element that will be used as a template to create the draggable item's preview. */\n  @ContentChild(CdkDragPreview) _previewTemplate: CdkDragPreview;\n\n  /** Template for placeholder element rendered to show where a draggable would be dropped. */\n  @ContentChild(CdkDragPlaceholder) _placeholderTemplate: CdkDragPlaceholder;\n\n  /** Arbitrary data to attach to this drag instance. */\n  @Input('cdkDragData') data: T;\n\n  /** Locks the position of the dragged element along the specified axis. */\n  @Input('cdkDragLockAxis') lockAxis: DragAxis;\n\n  /**\n   * Selector that will be used to determine the root draggable element, starting from\n   * the `cdkDrag` element and going up the DOM. Passing an alternate root element is useful\n   * when trying to enable dragging on an element that you might not have access to.\n   */\n  @Input('cdkDragRootElement') rootElementSelector: string;\n\n  /**\n   * Node or selector that will be used to determine the element to which the draggable's\n   * position will be constrained. If a string is passed in, it'll be used as a selector that\n   * will be matched starting from the element's parent and going up the DOM until a match\n   * has been found.\n   */\n  @Input('cdkDragBoundary') boundaryElement: string | ElementRef<HTMLElement> | HTMLElement;\n\n  /**\n   * Amount of milliseconds to wait after the user has put their\n   * pointer down before starting to drag the element.\n   */\n  @Input('cdkDragStartDelay') dragStartDelay: DragStartDelay;\n\n  /**\n   * Sets the position of a `CdkDrag` that is outside of a drop container.\n   * Can be used to restore the element's position for a returning user.\n   */\n  @Input('cdkDragFreeDragPosition') freeDragPosition: {x: number, y: number};\n\n  /** Whether starting to drag this element is disabled. */\n  @Input('cdkDragDisabled')\n  get disabled(): boolean {\n    return this._disabled || (this.dropContainer && this.dropContainer.disabled);\n  }\n  set disabled(value: boolean) {\n    this._disabled = coerceBooleanProperty(value);\n    this._dragRef.disabled = this._disabled;\n  }\n  private _disabled: boolean;\n\n  /**\n   * Function that can be used to customize the logic of how the position of the drag item\n   * is limited while it's being dragged. Gets called with a point containing the current position\n   * of the user's pointer on the page and should return a point describing where the item should\n   * be rendered.\n   */\n  @Input('cdkDragConstrainPosition') constrainPosition?: (point: Point, dragRef: DragRef) => Point;\n\n  /** Class to be added to the preview element. */\n  @Input('cdkDragPreviewClass') previewClass: string | string[];\n\n  /** Emits when the user starts dragging the item. */\n  @Output('cdkDragStarted') started: EventEmitter<CdkDragStart> = new EventEmitter<CdkDragStart>();\n\n  /** Emits when the user has released a drag item, before any animations have started. */\n  @Output('cdkDragReleased') released: EventEmitter<CdkDragRelease> =\n      new EventEmitter<CdkDragRelease>();\n\n  /** Emits when the user stops dragging an item in the container. */\n  @Output('cdkDragEnded') ended: EventEmitter<CdkDragEnd> = new EventEmitter<CdkDragEnd>();\n\n  /** Emits when the user has moved the item into a new container. */\n  @Output('cdkDragEntered') entered: EventEmitter<CdkDragEnter<any>> =\n      new EventEmitter<CdkDragEnter<any>>();\n\n  /** Emits when the user removes the item its container by dragging it into another container. */\n  @Output('cdkDragExited') exited: EventEmitter<CdkDragExit<any>> =\n      new EventEmitter<CdkDragExit<any>>();\n\n  /** Emits when the user drops the item inside a container. */\n  @Output('cdkDragDropped') dropped: EventEmitter<CdkDragDrop<any>> =\n      new EventEmitter<CdkDragDrop<any>>();\n\n  /**\n   * Emits as the user is dragging the item. Use with caution,\n   * because this event will fire for every pixel that the user has dragged.\n   */\n  @Output('cdkDragMoved') moved: Observable<CdkDragMove<T>> =\n      new Observable((observer: Observer<CdkDragMove<T>>) => {\n        const subscription = this._dragRef.moved.pipe(map(movedEvent => ({\n          source: this,\n          pointerPosition: movedEvent.pointerPosition,\n          event: movedEvent.event,\n          delta: movedEvent.delta,\n          distance: movedEvent.distance\n        }))).subscribe(observer);\n\n        return () => {\n          subscription.unsubscribe();\n        };\n      });\n\n  constructor(\n      /** Element that the draggable is attached to. */\n      public element: ElementRef<HTMLElement>,\n      /** Droppable container that the draggable is a part of. */\n      @Inject(CDK_DROP_LIST) @Optional() @SkipSelf() public dropContainer: CdkDropList,\n      @Inject(DOCUMENT) private _document: any, private _ngZone: NgZone,\n      private _viewContainerRef: ViewContainerRef,\n      @Optional() @Inject(CDK_DRAG_CONFIG) config: DragDropConfig,\n      @Optional() private _dir: Directionality, dragDrop: DragDrop,\n      private _changeDetectorRef: ChangeDetectorRef) {\n    this._dragRef = dragDrop.createDrag(element, {\n      dragStartThreshold: config && config.dragStartThreshold != null ?\n          config.dragStartThreshold : 5,\n      pointerDirectionChangeThreshold: config && config.pointerDirectionChangeThreshold != null ?\n          config.pointerDirectionChangeThreshold : 5,\n      zIndex: config?.zIndex\n    });\n    this._dragRef.data = this;\n\n    if (config) {\n      this._assignDefaults(config);\n    }\n\n    // Note that usually the container is assigned when the drop list is picks up the item, but in\n    // some cases (mainly transplanted views with OnPush, see #18341) we may end up in a situation\n    // where there are no items on the first change detection pass, but the items get picked up as\n    // soon as the user triggers another pass by dragging. This is a problem, because the item would\n    // have to switch from standalone mode to drag mode in the middle of the dragging sequence which\n    // is too late since the two modes save different kinds of information. We work around it by\n    // assigning the drop container both from here and the list.\n    if (dropContainer) {\n      this._dragRef._withDropContainer(dropContainer._dropListRef);\n      dropContainer.addItem(this);\n    }\n\n    this._syncInputs(this._dragRef);\n    this._handleEvents(this._dragRef);\n  }\n\n  /**\n   * Returns the element that is being used as a placeholder\n   * while the current element is being dragged.\n   * @deprecated No longer being used to be removed.\n   * @breaking-change 11.0.0\n   */\n  getPlaceholderElement(): HTMLElement {\n    return this._dragRef.getPlaceholderElement();\n  }\n\n  /**\n   * Returns the root draggable element.\n   * @deprecated No longer being used to be removed.\n   * @breaking-change 11.0.0\n   */\n  getRootElement(): HTMLElement {\n    return this._dragRef.getRootElement();\n  }\n\n  /** Resets a standalone drag item to its initial position. */\n  reset(): void {\n    this._dragRef.reset();\n  }\n\n  /**\n   * Gets the pixel coordinates of the draggable outside of a drop container.\n   */\n  getFreeDragPosition(): {readonly x: number, readonly y: number} {\n    return this._dragRef.getFreeDragPosition();\n  }\n\n  ngAfterViewInit() {\n    // We need to wait for the zone to stabilize, in order for the reference\n    // element to be in the proper place in the DOM. This is mostly relevant\n    // for draggable elements inside portals since they get stamped out in\n    // their original DOM position and then they get transferred to the portal.\n    this._ngZone.onStable.asObservable()\n      .pipe(take(1), takeUntil(this._destroyed))\n      .subscribe(() => {\n        this._updateRootElement();\n\n        // Listen for any newly-added handles.\n        this._handles.changes.pipe(\n          startWith(this._handles),\n          // Sync the new handles with the DragRef.\n          tap((handles: QueryList<CdkDragHandle>) => {\n            const childHandleElements = handles\n              .filter(handle => handle._parentDrag === this)\n              .map(handle => handle.element);\n            this._dragRef.withHandles(childHandleElements);\n          }),\n          // Listen if the state of any of the handles changes.\n          switchMap((handles: QueryList<CdkDragHandle>) => {\n            return merge(...handles.map(item => {\n              return item._stateChanges.pipe(startWith(item));\n            })) as Observable<CdkDragHandle>;\n          }),\n          takeUntil(this._destroyed)\n        ).subscribe(handleInstance => {\n          // Enabled/disable the handle that changed in the DragRef.\n          const dragRef = this._dragRef;\n          const handle = handleInstance.element.nativeElement;\n          handleInstance.disabled ? dragRef.disableHandle(handle) : dragRef.enableHandle(handle);\n        });\n\n        if (this.freeDragPosition) {\n          this._dragRef.setFreeDragPosition(this.freeDragPosition);\n        }\n      });\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    const rootSelectorChange = changes['rootElementSelector'];\n    const positionChange = changes['freeDragPosition'];\n\n    // We don't have to react to the first change since it's being\n    // handled in `ngAfterViewInit` where it needs to be deferred.\n    if (rootSelectorChange && !rootSelectorChange.firstChange) {\n      this._updateRootElement();\n    }\n\n    // Skip the first change since it's being handled in `ngAfterViewInit`.\n    if (positionChange && !positionChange.firstChange && this.freeDragPosition) {\n      this._dragRef.setFreeDragPosition(this.freeDragPosition);\n    }\n  }\n\n  ngOnDestroy() {\n    if (this.dropContainer) {\n      this.dropContainer.removeItem(this);\n    }\n\n    this._destroyed.next();\n    this._destroyed.complete();\n    this._dragRef.dispose();\n  }\n\n  /** Syncs the root element with the `DragRef`. */\n  private _updateRootElement() {\n    const element = this.element.nativeElement;\n    const rootElement = this.rootElementSelector ?\n        getClosestMatchingAncestor(element, this.rootElementSelector) : element;\n\n    if (rootElement && rootElement.nodeType !== this._document.ELEMENT_NODE) {\n      throw Error(`cdkDrag must be attached to an element node. ` +\n                  `Currently attached to \"${rootElement.nodeName}\".`);\n    }\n\n    this._dragRef.withRootElement(rootElement || element);\n  }\n\n  /** Gets the boundary element, based on the `boundaryElement` value. */\n  private _getBoundaryElement() {\n    const boundary = this.boundaryElement;\n\n    if (!boundary) {\n      return null;\n    }\n\n    if (typeof boundary === 'string') {\n      return getClosestMatchingAncestor(this.element.nativeElement, boundary);\n    }\n\n    const element = coerceElement(boundary);\n\n    if (isDevMode() && !element.contains(this.element.nativeElement)) {\n      throw Error('Draggable element is not inside of the node passed into cdkDragBoundary.');\n    }\n\n    return element;\n  }\n\n  /** Syncs the inputs of the CdkDrag with the options of the underlying DragRef. */\n  private _syncInputs(ref: DragRef<CdkDrag<T>>) {\n    ref.beforeStarted.subscribe(() => {\n      if (!ref.isDragging()) {\n        const dir = this._dir;\n        const dragStartDelay = this.dragStartDelay;\n        const placeholder = this._placeholderTemplate ? {\n          template: this._placeholderTemplate.templateRef,\n          context: this._placeholderTemplate.data,\n          viewContainer: this._viewContainerRef\n        } : null;\n        const preview = this._previewTemplate ? {\n          template: this._previewTemplate.templateRef,\n          context: this._previewTemplate.data,\n          matchSize: this._previewTemplate.matchSize,\n          viewContainer: this._viewContainerRef\n        } : null;\n\n        ref.disabled = this.disabled;\n        ref.lockAxis = this.lockAxis;\n        ref.dragStartDelay = (typeof dragStartDelay === 'object' && dragStartDelay) ?\n            dragStartDelay : coerceNumberProperty(dragStartDelay);\n        ref.constrainPosition = this.constrainPosition;\n        ref.previewClass = this.previewClass;\n        ref\n          .withBoundaryElement(this._getBoundaryElement())\n          .withPlaceholderTemplate(placeholder)\n          .withPreviewTemplate(preview);\n\n        if (dir) {\n          ref.withDirection(dir.value);\n        }\n      }\n    });\n  }\n\n  /** Handles the events from the underlying `DragRef`. */\n  private _handleEvents(ref: DragRef<CdkDrag<T>>) {\n    ref.started.subscribe(() => {\n      this.started.emit({source: this});\n\n      // Since all of these events run outside of change detection,\n      // we need to ensure that everything is marked correctly.\n      this._changeDetectorRef.markForCheck();\n    });\n\n    ref.released.subscribe(() => {\n      this.released.emit({source: this});\n    });\n\n    ref.ended.subscribe(event => {\n      this.ended.emit({source: this, distance: event.distance});\n\n      // Since all of these events run outside of change detection,\n      // we need to ensure that everything is marked correctly.\n      this._changeDetectorRef.markForCheck();\n    });\n\n    ref.entered.subscribe(event => {\n      this.entered.emit({\n        container: event.container.data,\n        item: this,\n        currentIndex: event.currentIndex\n      });\n    });\n\n    ref.exited.subscribe(event => {\n      this.exited.emit({\n        container: event.container.data,\n        item: this\n      });\n    });\n\n    ref.dropped.subscribe(event => {\n      this.dropped.emit({\n        previousIndex: event.previousIndex,\n        currentIndex: event.currentIndex,\n        previousContainer: event.previousContainer.data,\n        container: event.container.data,\n        isPointerOverContainer: event.isPointerOverContainer,\n        item: this,\n        distance: event.distance\n      });\n    });\n  }\n\n  /** Assigns the default input values based on a provided config object. */\n  private _assignDefaults(config: DragDropConfig) {\n    const {\n      lockAxis, dragStartDelay, constrainPosition, previewClass,\n      boundaryElement, draggingDisabled, rootElementSelector\n    } = config;\n\n    this.disabled = draggingDisabled == null ? false : draggingDisabled;\n    this.dragStartDelay = dragStartDelay || 0;\n\n    if (lockAxis) {\n      this.lockAxis = lockAxis;\n    }\n\n    if (constrainPosition) {\n      this.constrainPosition = constrainPosition;\n    }\n\n    if (previewClass) {\n      this.previewClass = previewClass;\n    }\n\n    if (boundaryElement) {\n      this.boundaryElement = boundaryElement;\n    }\n\n    if (rootElementSelector) {\n      this.rootElementSelector = rootElementSelector;\n    }\n  }\n\n  static ngAcceptInputType_disabled: BooleanInput;\n}\n\n/** Gets the closest ancestor of an element that matches a selector. */\nfunction getClosestMatchingAncestor(element: HTMLElement, selector: string) {\n  let currentElement = element.parentElement as HTMLElement | null;\n\n  while (currentElement) {\n    // IE doesn't support `matches` so we have to fall back to `msMatchesSelector`.\n    if (currentElement.matches ? currentElement.matches(selector) :\n        (currentElement as any).msMatchesSelector(selector)) {\n      return currentElement;\n    }\n\n    currentElement = currentElement.parentElement;\n  }\n\n  return null;\n}\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag.js","sourceRoot":"","sources":["../../../../../../../src/cdk/drag-drop/directives/drag.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Directionality} from '@angular/cdk/bidi';\nimport {DOCUMENT} from '@angular/common';\nimport {\n  AfterViewInit,\n  ContentChild,\n  ContentChildren,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Inject,\n  Input,\n  NgZone,\n  OnDestroy,\n  Optional,\n  Output,\n  QueryList,\n  SkipSelf,\n  ViewContainerRef,\n  OnChanges,\n  SimpleChanges,\n  ChangeDetectorRef,\n  isDevMode,\n  Self,\n} from '@angular/core';\nimport {\n  coerceBooleanProperty,\n  coerceNumberProperty,\n  coerceElement,\n  BooleanInput\n} from '@angular/cdk/coercion';\nimport {Observable, Observer, Subject, merge} from 'rxjs';\nimport {startWith, take, map, takeUntil, switchMap, tap} from 'rxjs/operators';\nimport {\n  CdkDragDrop,\n  CdkDragEnd,\n  CdkDragEnter,\n  CdkDragExit,\n  CdkDragMove,\n  CdkDragStart,\n  CdkDragRelease,\n} from '../drag-events';\nimport {CDK_DRAG_HANDLE, CdkDragHandle} from './drag-handle';\nimport {CDK_DRAG_PLACEHOLDER, CdkDragPlaceholder} from './drag-placeholder';\nimport {CDK_DRAG_PREVIEW, CdkDragPreview} from './drag-preview';\nimport {CDK_DRAG_PARENT} from '../drag-parent';\nimport {DragRef, Point} from '../drag-ref';\nimport {CDK_DROP_LIST, CdkDropListInternal as CdkDropList} from './drop-list';\nimport {DragDrop} from '../drag-drop';\nimport {CDK_DRAG_CONFIG, DragDropConfig, DragStartDelay, DragAxis} from './config';\n\n/** Element that can be moved inside a CdkDropList container. */\n@Directive({\n  selector: '[cdkDrag]',\n  exportAs: 'cdkDrag',\n  host: {\n    'class': 'cdk-drag',\n    '[class.cdk-drag-disabled]': 'disabled',\n    '[class.cdk-drag-dragging]': '_dragRef.isDragging()',\n  },\n  providers: [{provide: CDK_DRAG_PARENT, useExisting: CdkDrag}]\n})\nexport class CdkDrag<T = any> implements AfterViewInit, OnChanges, OnDestroy {\n  private _destroyed = new Subject<void>();\n\n  /** Reference to the underlying drag instance. */\n  _dragRef: DragRef<CdkDrag<T>>;\n\n  // TODO: Remove cast once https://github.com/angular/angular/pull/37506 is available.\n  /** Elements that can be used to drag the draggable item. */\n  @ContentChildren(CDK_DRAG_HANDLE as any, {descendants: true}) _handles: QueryList<CdkDragHandle>;\n\n  // TODO: Remove cast once https://github.com/angular/angular/pull/37506 is available.\n  /** Element that will be used as a template to create the draggable item's preview. */\n  @ContentChild(CDK_DRAG_PREVIEW as any) _previewTemplate: CdkDragPreview;\n\n  // TODO: Remove cast once https://github.com/angular/angular/pull/37506 is available.\n  /** Template for placeholder element rendered to show where a draggable would be dropped. */\n  @ContentChild(CDK_DRAG_PLACEHOLDER as any) _placeholderTemplate: CdkDragPlaceholder;\n\n  /** Arbitrary data to attach to this drag instance. */\n  @Input('cdkDragData') data: T;\n\n  /** Locks the position of the dragged element along the specified axis. */\n  @Input('cdkDragLockAxis') lockAxis: DragAxis;\n\n  /**\n   * Selector that will be used to determine the root draggable element, starting from\n   * the `cdkDrag` element and going up the DOM. Passing an alternate root element is useful\n   * when trying to enable dragging on an element that you might not have access to.\n   */\n  @Input('cdkDragRootElement') rootElementSelector: string;\n\n  /**\n   * Node or selector that will be used to determine the element to which the draggable's\n   * position will be constrained. If a string is passed in, it'll be used as a selector that\n   * will be matched starting from the element's parent and going up the DOM until a match\n   * has been found.\n   */\n  @Input('cdkDragBoundary') boundaryElement: string | ElementRef<HTMLElement> | HTMLElement;\n\n  /**\n   * Amount of milliseconds to wait after the user has put their\n   * pointer down before starting to drag the element.\n   */\n  @Input('cdkDragStartDelay') dragStartDelay: DragStartDelay;\n\n  /**\n   * Sets the position of a `CdkDrag` that is outside of a drop container.\n   * Can be used to restore the element's position for a returning user.\n   */\n  @Input('cdkDragFreeDragPosition') freeDragPosition: {x: number, y: number};\n\n  /** Whether starting to drag this element is disabled. */\n  @Input('cdkDragDisabled')\n  get disabled(): boolean {\n    return this._disabled || (this.dropContainer && this.dropContainer.disabled);\n  }\n  set disabled(value: boolean) {\n    this._disabled = coerceBooleanProperty(value);\n    this._dragRef.disabled = this._disabled;\n  }\n  private _disabled: boolean;\n\n  /**\n   * Function that can be used to customize the logic of how the position of the drag item\n   * is limited while it's being dragged. Gets called with a point containing the current position\n   * of the user's pointer on the page and should return a point describing where the item should\n   * be rendered.\n   */\n  @Input('cdkDragConstrainPosition') constrainPosition?: (point: Point, dragRef: DragRef) => Point;\n\n  /** Class to be added to the preview element. */\n  @Input('cdkDragPreviewClass') previewClass: string | string[];\n\n  /** Emits when the user starts dragging the item. */\n  @Output('cdkDragStarted') started: EventEmitter<CdkDragStart> = new EventEmitter<CdkDragStart>();\n\n  /** Emits when the user has released a drag item, before any animations have started. */\n  @Output('cdkDragReleased') released: EventEmitter<CdkDragRelease> =\n      new EventEmitter<CdkDragRelease>();\n\n  /** Emits when the user stops dragging an item in the container. */\n  @Output('cdkDragEnded') ended: EventEmitter<CdkDragEnd> = new EventEmitter<CdkDragEnd>();\n\n  /** Emits when the user has moved the item into a new container. */\n  @Output('cdkDragEntered') entered: EventEmitter<CdkDragEnter<any>> =\n      new EventEmitter<CdkDragEnter<any>>();\n\n  /** Emits when the user removes the item its container by dragging it into another container. */\n  @Output('cdkDragExited') exited: EventEmitter<CdkDragExit<any>> =\n      new EventEmitter<CdkDragExit<any>>();\n\n  /** Emits when the user drops the item inside a container. */\n  @Output('cdkDragDropped') dropped: EventEmitter<CdkDragDrop<any>> =\n      new EventEmitter<CdkDragDrop<any>>();\n\n  /**\n   * Emits as the user is dragging the item. Use with caution,\n   * because this event will fire for every pixel that the user has dragged.\n   */\n  @Output('cdkDragMoved') moved: Observable<CdkDragMove<T>> =\n      new Observable((observer: Observer<CdkDragMove<T>>) => {\n        const subscription = this._dragRef.moved.pipe(map(movedEvent => ({\n          source: this,\n          pointerPosition: movedEvent.pointerPosition,\n          event: movedEvent.event,\n          delta: movedEvent.delta,\n          distance: movedEvent.distance\n        }))).subscribe(observer);\n\n        return () => {\n          subscription.unsubscribe();\n        };\n      });\n\n  constructor(\n      /** Element that the draggable is attached to. */\n      public element: ElementRef<HTMLElement>,\n      /** Droppable container that the draggable is a part of. */\n      @Inject(CDK_DROP_LIST) @Optional() @SkipSelf() public dropContainer: CdkDropList,\n      @Inject(DOCUMENT) private _document: any, private _ngZone: NgZone,\n      private _viewContainerRef: ViewContainerRef,\n      @Optional() @Inject(CDK_DRAG_CONFIG) config: DragDropConfig,\n      @Optional() private _dir: Directionality, dragDrop: DragDrop,\n      private _changeDetectorRef: ChangeDetectorRef,\n      @Optional() @Self() @Inject(CDK_DRAG_HANDLE) private _selfHandle?: CdkDragHandle) {\n    this._dragRef = dragDrop.createDrag(element, {\n      dragStartThreshold: config && config.dragStartThreshold != null ?\n          config.dragStartThreshold : 5,\n      pointerDirectionChangeThreshold: config && config.pointerDirectionChangeThreshold != null ?\n          config.pointerDirectionChangeThreshold : 5,\n      zIndex: config?.zIndex\n    });\n    this._dragRef.data = this;\n\n    if (config) {\n      this._assignDefaults(config);\n    }\n\n    // Note that usually the container is assigned when the drop list is picks up the item, but in\n    // some cases (mainly transplanted views with OnPush, see #18341) we may end up in a situation\n    // where there are no items on the first change detection pass, but the items get picked up as\n    // soon as the user triggers another pass by dragging. This is a problem, because the item would\n    // have to switch from standalone mode to drag mode in the middle of the dragging sequence which\n    // is too late since the two modes save different kinds of information. We work around it by\n    // assigning the drop container both from here and the list.\n    if (dropContainer) {\n      this._dragRef._withDropContainer(dropContainer._dropListRef);\n      dropContainer.addItem(this);\n    }\n\n    this._syncInputs(this._dragRef);\n    this._handleEvents(this._dragRef);\n  }\n\n  /**\n   * Returns the element that is being used as a placeholder\n   * while the current element is being dragged.\n   */\n  getPlaceholderElement(): HTMLElement {\n    return this._dragRef.getPlaceholderElement();\n  }\n\n  /** Returns the root draggable element. */\n  getRootElement(): HTMLElement {\n    return this._dragRef.getRootElement();\n  }\n\n  /** Resets a standalone drag item to its initial position. */\n  reset(): void {\n    this._dragRef.reset();\n  }\n\n  /**\n   * Gets the pixel coordinates of the draggable outside of a drop container.\n   */\n  getFreeDragPosition(): {readonly x: number, readonly y: number} {\n    return this._dragRef.getFreeDragPosition();\n  }\n\n  ngAfterViewInit() {\n    // We need to wait for the zone to stabilize, in order for the reference\n    // element to be in the proper place in the DOM. This is mostly relevant\n    // for draggable elements inside portals since they get stamped out in\n    // their original DOM position and then they get transferred to the portal.\n    this._ngZone.onStable.asObservable()\n      .pipe(take(1), takeUntil(this._destroyed))\n      .subscribe(() => {\n        this._updateRootElement();\n\n        // Listen for any newly-added handles.\n        this._handles.changes.pipe(\n          startWith(this._handles),\n          // Sync the new handles with the DragRef.\n          tap((handles: QueryList<CdkDragHandle>) => {\n            const childHandleElements = handles\n              .filter(handle => handle._parentDrag === this)\n              .map(handle => handle.element);\n\n            // Usually handles are only allowed to be a descendant of the drag element, but if\n            // the consumer defined a different drag root, we should allow the drag element\n            // itself to be a handle too.\n            if (this._selfHandle && this.rootElementSelector) {\n              childHandleElements.push(this.element);\n            }\n\n            this._dragRef.withHandles(childHandleElements);\n          }),\n          // Listen if the state of any of the handles changes.\n          switchMap((handles: QueryList<CdkDragHandle>) => {\n            return merge(...handles.map(item => {\n              return item._stateChanges.pipe(startWith(item));\n            })) as Observable<CdkDragHandle>;\n          }),\n          takeUntil(this._destroyed)\n        ).subscribe(handleInstance => {\n          // Enabled/disable the handle that changed in the DragRef.\n          const dragRef = this._dragRef;\n          const handle = handleInstance.element.nativeElement;\n          handleInstance.disabled ? dragRef.disableHandle(handle) : dragRef.enableHandle(handle);\n        });\n\n        if (this.freeDragPosition) {\n          this._dragRef.setFreeDragPosition(this.freeDragPosition);\n        }\n      });\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    const rootSelectorChange = changes['rootElementSelector'];\n    const positionChange = changes['freeDragPosition'];\n\n    // We don't have to react to the first change since it's being\n    // handled in `ngAfterViewInit` where it needs to be deferred.\n    if (rootSelectorChange && !rootSelectorChange.firstChange) {\n      this._updateRootElement();\n    }\n\n    // Skip the first change since it's being handled in `ngAfterViewInit`.\n    if (positionChange && !positionChange.firstChange && this.freeDragPosition) {\n      this._dragRef.setFreeDragPosition(this.freeDragPosition);\n    }\n  }\n\n  ngOnDestroy() {\n    if (this.dropContainer) {\n      this.dropContainer.removeItem(this);\n    }\n\n    this._destroyed.next();\n    this._destroyed.complete();\n    this._dragRef.dispose();\n  }\n\n  /** Syncs the root element with the `DragRef`. */\n  private _updateRootElement() {\n    const element = this.element.nativeElement;\n    const rootElement = this.rootElementSelector ?\n        getClosestMatchingAncestor(element, this.rootElementSelector) : element;\n\n    if (rootElement && rootElement.nodeType !== this._document.ELEMENT_NODE) {\n      throw Error(`cdkDrag must be attached to an element node. ` +\n                  `Currently attached to \"${rootElement.nodeName}\".`);\n    }\n\n    this._dragRef.withRootElement(rootElement || element);\n  }\n\n  /** Gets the boundary element, based on the `boundaryElement` value. */\n  private _getBoundaryElement() {\n    const boundary = this.boundaryElement;\n\n    if (!boundary) {\n      return null;\n    }\n\n    if (typeof boundary === 'string') {\n      return getClosestMatchingAncestor(this.element.nativeElement, boundary);\n    }\n\n    const element = coerceElement(boundary);\n\n    if (isDevMode() && !element.contains(this.element.nativeElement)) {\n      throw Error('Draggable element is not inside of the node passed into cdkDragBoundary.');\n    }\n\n    return element;\n  }\n\n  /** Syncs the inputs of the CdkDrag with the options of the underlying DragRef. */\n  private _syncInputs(ref: DragRef<CdkDrag<T>>) {\n    ref.beforeStarted.subscribe(() => {\n      if (!ref.isDragging()) {\n        const dir = this._dir;\n        const dragStartDelay = this.dragStartDelay;\n        const placeholder = this._placeholderTemplate ? {\n          template: this._placeholderTemplate.templateRef,\n          context: this._placeholderTemplate.data,\n          viewContainer: this._viewContainerRef\n        } : null;\n        const preview = this._previewTemplate ? {\n          template: this._previewTemplate.templateRef,\n          context: this._previewTemplate.data,\n          matchSize: this._previewTemplate.matchSize,\n          viewContainer: this._viewContainerRef\n        } : null;\n\n        ref.disabled = this.disabled;\n        ref.lockAxis = this.lockAxis;\n        ref.dragStartDelay = (typeof dragStartDelay === 'object' && dragStartDelay) ?\n            dragStartDelay : coerceNumberProperty(dragStartDelay);\n        ref.constrainPosition = this.constrainPosition;\n        ref.previewClass = this.previewClass;\n        ref\n          .withBoundaryElement(this._getBoundaryElement())\n          .withPlaceholderTemplate(placeholder)\n          .withPreviewTemplate(preview);\n\n        if (dir) {\n          ref.withDirection(dir.value);\n        }\n      }\n    });\n  }\n\n  /** Handles the events from the underlying `DragRef`. */\n  private _handleEvents(ref: DragRef<CdkDrag<T>>) {\n    ref.started.subscribe(() => {\n      this.started.emit({source: this});\n\n      // Since all of these events run outside of change detection,\n      // we need to ensure that everything is marked correctly.\n      this._changeDetectorRef.markForCheck();\n    });\n\n    ref.released.subscribe(() => {\n      this.released.emit({source: this});\n    });\n\n    ref.ended.subscribe(event => {\n      this.ended.emit({source: this, distance: event.distance});\n\n      // Since all of these events run outside of change detection,\n      // we need to ensure that everything is marked correctly.\n      this._changeDetectorRef.markForCheck();\n    });\n\n    ref.entered.subscribe(event => {\n      this.entered.emit({\n        container: event.container.data,\n        item: this,\n        currentIndex: event.currentIndex\n      });\n    });\n\n    ref.exited.subscribe(event => {\n      this.exited.emit({\n        container: event.container.data,\n        item: this\n      });\n    });\n\n    ref.dropped.subscribe(event => {\n      this.dropped.emit({\n        previousIndex: event.previousIndex,\n        currentIndex: event.currentIndex,\n        previousContainer: event.previousContainer.data,\n        container: event.container.data,\n        isPointerOverContainer: event.isPointerOverContainer,\n        item: this,\n        distance: event.distance\n      });\n    });\n  }\n\n  /** Assigns the default input values based on a provided config object. */\n  private _assignDefaults(config: DragDropConfig) {\n    const {\n      lockAxis, dragStartDelay, constrainPosition, previewClass,\n      boundaryElement, draggingDisabled, rootElementSelector\n    } = config;\n\n    this.disabled = draggingDisabled == null ? false : draggingDisabled;\n    this.dragStartDelay = dragStartDelay || 0;\n\n    if (lockAxis) {\n      this.lockAxis = lockAxis;\n    }\n\n    if (constrainPosition) {\n      this.constrainPosition = constrainPosition;\n    }\n\n    if (previewClass) {\n      this.previewClass = previewClass;\n    }\n\n    if (boundaryElement) {\n      this.boundaryElement = boundaryElement;\n    }\n\n    if (rootElementSelector) {\n      this.rootElementSelector = rootElementSelector;\n    }\n  }\n\n  static ngAcceptInputType_disabled: BooleanInput;\n}\n\n/** Gets the closest ancestor of an element that matches a selector. */\nfunction getClosestMatchingAncestor(element: HTMLElement, selector: string) {\n  let currentElement = element.parentElement as HTMLElement | null;\n\n  while (currentElement) {\n    // IE doesn't support `matches` so we have to fall back to `msMatchesSelector`.\n    if (currentElement.matches ? currentElement.matches(selector) :\n        (currentElement as any).msMatchesSelector(selector)) {\n      return currentElement;\n    }\n\n    currentElement = currentElement.parentElement;\n  }\n\n  return null;\n}\n\n"]}