/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
import { Directionality } from '@angular/cdk/bidi';
import { ViewportRuler } from '@angular/cdk/scrolling';
import { DOCUMENT } from '@angular/common';
import { ContentChild, ContentChildren, Directive, ElementRef, EventEmitter, Inject, InjectionToken, Input, NgZone, Optional, Output, QueryList, SkipSelf, ViewContainerRef, ChangeDetectorRef, } from '@angular/core';
import { coerceBooleanProperty } from '@angular/cdk/coercion';
import { Observable, Subject, merge } from 'rxjs';
import { startWith, take, map, takeUntil, switchMap, tap } from 'rxjs/operators';
import { DragDropRegistry } from '../drag-drop-registry';
import { CdkDragHandle } from './drag-handle';
import { CdkDragPlaceholder } from './drag-placeholder';
import { CdkDragPreview } from './drag-preview';
import { CDK_DROP_LIST } from '../drop-list-container';
import { CDK_DRAG_PARENT } from '../drag-parent';
import { DragRef } from '../drag-ref';
import { DragDrop } from '../drag-drop';
/**
 * Injection token that can be used to configure the behavior of `CdkDrag`.
 * @type {?}
 */
export const CDK_DRAG_CONFIG = new InjectionToken('CDK_DRAG_CONFIG', {
    providedIn: 'root',
    factory: CDK_DRAG_CONFIG_FACTORY
});
/**
 * \@docs-private
 * @return {?}
 */
export function CDK_DRAG_CONFIG_FACTORY() {
    return { dragStartThreshold: 5, pointerDirectionChangeThreshold: 5 };
}
/**
 * @ignore
 * Element that can be moved inside a CdkDropList container.
 *
 * @template T
 */
export class CdkDrag {
    /**
     * @param {?} element
     * @param {?} dropContainer
     * @param {?} _document
     * @param {?} _ngZone
     * @param {?} _viewContainerRef
     * @param {?} viewportRuler
     * @param {?} dragDropRegistry
     * @param {?} config
     * @param {?} _dir
     * @param {?=} dragDrop
     * @param {?=} _changeDetectorRef
     */
    constructor(element, dropContainer, _document, _ngZone, _viewContainerRef, viewportRuler, dragDropRegistry, config, _dir, 
    /**
     * @deprecated `viewportRuler`, `dragDropRegistry` and `_changeDetectorRef` parameters
     * to be removed. Also `dragDrop` parameter to be made required.
     * @breaking-change 8.0.0.
     */
    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();
        this._disabled = false;
        /**
         * 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((/**
         * @param {?} observer
         * @return {?}
         */
        (observer) => {
            /** @type {?} */
            const subscription = this._dragRef.moved.pipe(map((/**
             * @param {?} movedEvent
             * @return {?}
             */
            movedEvent => ({
                source: this,
                pointerPosition: movedEvent.pointerPosition,
                event: movedEvent.event,
                delta: movedEvent.delta
            })))).subscribe(observer);
            return (/**
             * @return {?}
             */
            () => {
                subscription.unsubscribe();
            });
        }));
        // @breaking-change 8.0.0 Remove null check once the paramter is made required.
        if (dragDrop) {
            this._dragRef = dragDrop.createDrag(element, config);
        }
        else {
            this._dragRef = new DragRef(element, config, _document, _ngZone, viewportRuler, dragDropRegistry);
        }
        this._dragRef.data = this;
        this._syncInputs(this._dragRef);
        this._handleEvents(this._dragRef);
    }
    /**
     * Whether starting to drag this element is disabled.
     * @return {?}
     */
    get disabled() {
        return this._disabled || (this.dropContainer && this.dropContainer.disabled);
    }
    /**
     * @param {?} value
     * @return {?}
     */
    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.
     * @return {?}
     */
    getPlaceholderElement() {
        return this._dragRef.getPlaceholderElement();
    }
    /**
     * Returns the root draggable element.
     * @return {?}
     */
    getRootElement() {
        return this._dragRef.getRootElement();
    }
    /**
     * Resets a standalone drag item to its initial position.
     * @return {?}
     */
    reset() {
        this._dragRef.reset();
    }
    /**
     * @return {?}
     */
    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((/**
         * @return {?}
         */
        () => {
            this._updateRootElement();
            // Listen for any newly-added handles.
            this._handles.changes.pipe(startWith(this._handles), 
            // Sync the new handles with the DragRef.
            tap((/**
             * @param {?} handles
             * @return {?}
             */
            (handles) => {
                /** @type {?} */
                const childHandleElements = handles
                    .filter((/**
                 * @param {?} handle
                 * @return {?}
                 */
                handle => handle._parentDrag === this))
                    .map((/**
                 * @param {?} handle
                 * @return {?}
                 */
                handle => handle.element));
                this._dragRef.withHandles(childHandleElements);
            })), 
            // Listen if the state of any of the handles changes.
            switchMap((/**
             * @param {?} handles
             * @return {?}
             */
            (handles) => {
                return merge(...handles.map((/**
                 * @param {?} item
                 * @return {?}
                 */
                item => item._stateChanges)));
            })), takeUntil(this._destroyed)).subscribe((/**
             * @param {?} handleInstance
             * @return {?}
             */
            handleInstance => {
                // Enabled/disable the handle that changed in the DragRef.
                /** @type {?} */
                const dragRef = this._dragRef;
                /** @type {?} */
                const handle = handleInstance.element.nativeElement;
                handleInstance.disabled ? dragRef.disableHandle(handle) : dragRef.enableHandle(handle);
            }));
        }));
    }
    /**
     * @param {?} changes
     * @return {?}
     */
    ngOnChanges(changes) {
        /** @type {?} */
        const rootSelectorChange = changes['rootElementSelector'];
        // 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();
        }
    }
    /**
     * @return {?}
     */
    ngOnDestroy() {
        this._destroyed.next();
        this._destroyed.complete();
        this._dragRef.dispose();
    }
    /**
     * Syncs the root element with the `DragRef`.
     * @private
     * @return {?}
     */
    _updateRootElement() {
        /** @type {?} */
        const element = this.element.nativeElement;
        /** @type {?} */
        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);
    }
    /**
     * Gets the boundary element, based on the `boundaryElementSelector`.
     * @private
     * @return {?}
     */
    _getBoundaryElement() {
        /** @type {?} */
        const selector = this.boundaryElementSelector;
        return selector ? getClosestMatchingAncestor(this.element.nativeElement, selector) : null;
    }
    /**
     * Syncs the inputs of the CdkDrag with the options of the underlying DragRef.
     * @private
     * @param {?} ref
     * @return {?}
     */
    _syncInputs(ref) {
        ref.beforeStarted.subscribe((/**
         * @return {?}
         */
        () => {
            if (!ref.isDragging()) {
                /** @type {?} */
                const dir = this._dir;
                /** @type {?} */
                const placeholder = this._placeholderTemplate ? {
                    template: this._placeholderTemplate.templateRef,
                    context: this._placeholderTemplate.data,
                    viewContainer: this._viewContainerRef
                } : null;
                /** @type {?} */
                const preview = this._previewTemplate ? {
                    template: this._previewTemplate.templateRef,
                    context: this._previewTemplate.data,
                    viewContainer: this._viewContainerRef
                } : null;
                ref.disabled = this.disabled;
                ref.lockAxis = this.lockAxis;
                ref
                    .withBoundaryElement(this._getBoundaryElement())
                    .withPlaceholderTemplate(placeholder)
                    .withPreviewTemplate(preview);
                if (dir) {
                    ref.withDirection(dir.value);
                }
            }
        }));
    }
    /**
     * Handles the events from the underlying `DragRef`.
     * @private
     * @param {?} ref
     * @return {?}
     */
    _handleEvents(ref) {
        ref.started.subscribe((/**
         * @return {?}
         */
        () => {
            this.started.emit({ source: this });
            // Since all of these events run outside of change detection,
            // we need to ensure that everything is marked correctly.
            if (this._changeDetectorRef) {
                // @breaking-change 8.0.0 Remove null check for _changeDetectorRef
                this._changeDetectorRef.markForCheck();
            }
        }));
        ref.released.subscribe((/**
         * @return {?}
         */
        () => {
            this.released.emit({ source: this });
        }));
        ref.ended.subscribe((/**
         * @return {?}
         */
        () => {
            this.ended.emit({ source: this });
            // Since all of these events run outside of change detection,
            // we need to ensure that everything is marked correctly.
            if (this._changeDetectorRef) {
                // @breaking-change 8.0.0 Remove null check for _changeDetectorRef
                this._changeDetectorRef.markForCheck();
            }
        }));
        ref.entered.subscribe((/**
         * @param {?} event
         * @return {?}
         */
        event => {
            this.entered.emit({
                container: event.container.data,
                item: this
            });
        }));
        ref.exited.subscribe((/**
         * @param {?} event
         * @return {?}
         */
        event => {
            this.exited.emit({
                container: event.container.data,
                item: this
            });
        }));
        ref.dropped.subscribe((/**
         * @param {?} event
         * @return {?}
         */
        event => {
            this.dropped.emit({
                previousIndex: event.previousIndex,
                currentIndex: event.currentIndex,
                previousContainer: event.previousContainer.data,
                container: event.container.data,
                isPointerOverContainer: event.isPointerOverContainer,
                item: this
            });
        }));
    }
}
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 }]
            },] }
];
/** @nocollapse */
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: ViewportRuler },
    { type: DragDropRegistry },
    { type: undefined, decorators: [{ 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',] }],
    boundaryElementSelector: [{ type: Input, args: ['cdkDragBoundary',] }],
    disabled: [{ type: Input, args: ['cdkDragDisabled',] }],
    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',] }]
};
if (false) {
    /**
     * @type {?}
     * @private
     */
    CdkDrag.prototype._destroyed;
    /**
     * Reference to the underlying drag instance.
     * @type {?}
     */
    CdkDrag.prototype._dragRef;
    /**
     * Elements that can be used to drag the draggable item.
     * @type {?}
     */
    CdkDrag.prototype._handles;
    /**
     * Element that will be used as a template to create the draggable item's preview.
     * @type {?}
     */
    CdkDrag.prototype._previewTemplate;
    /**
     * Template for placeholder element rendered to show where a draggable would be dropped.
     * @type {?}
     */
    CdkDrag.prototype._placeholderTemplate;
    /**
     * Arbitrary data to attach to this drag instance.
     * @type {?}
     */
    CdkDrag.prototype.data;
    /**
     * Locks the position of the dragged element along the specified axis.
     * @type {?}
     */
    CdkDrag.prototype.lockAxis;
    /**
     * Selector that will be used to determine the root draggable element, starting from
     * the `cdkDrag` element and going up the DOM. Passing an alternate root element is useful
     * when trying to enable dragging on an element that you might not have access to.
     * @type {?}
     */
    CdkDrag.prototype.rootElementSelector;
    /**
     * Selector that will be used to determine the element to which the draggable's position will
     * be constrained. Matching starts from the element's parent and goes up the DOM until a matching
     * element has been found.
     * @type {?}
     */
    CdkDrag.prototype.boundaryElementSelector;
    /**
     * @type {?}
     * @private
     */
    CdkDrag.prototype._disabled;
    /**
     * Emits when the user starts dragging the item.
     * @type {?}
     */
    CdkDrag.prototype.started;
    /**
     * Emits when the user has released a drag item, before any animations have started.
     * @type {?}
     */
    CdkDrag.prototype.released;
    /**
     * Emits when the user stops dragging an item in the container.
     * @type {?}
     */
    CdkDrag.prototype.ended;
    /**
     * Emits when the user has moved the item into a new container.
     * @type {?}
     */
    CdkDrag.prototype.entered;
    /**
     * Emits when the user removes the item its container by dragging it into another container.
     * @type {?}
     */
    CdkDrag.prototype.exited;
    /**
     * Emits when the user drops the item inside a container.
     * @type {?}
     */
    CdkDrag.prototype.dropped;
    /**
     * Emits as the user is dragging the item. Use with caution,
     * because this event will fire for every pixel that the user has dragged.
     * @type {?}
     */
    CdkDrag.prototype.moved;
    /**
     * Element that the draggable is attached to.
     * @type {?}
     */
    CdkDrag.prototype.element;
    /**
     * Droppable container that the draggable is a part of.
     * @type {?}
     */
    CdkDrag.prototype.dropContainer;
    /**
     * @type {?}
     * @private
     */
    CdkDrag.prototype._document;
    /**
     * @type {?}
     * @private
     */
    CdkDrag.prototype._ngZone;
    /**
     * @type {?}
     * @private
     */
    CdkDrag.prototype._viewContainerRef;
    /**
     * @type {?}
     * @private
     */
    CdkDrag.prototype._dir;
    /**
     * @type {?}
     * @private
     */
    CdkDrag.prototype._changeDetectorRef;
}
/**
 * Gets the closest ancestor of an element that matches a selector.
 * @param {?} element
 * @param {?} selector
 * @return {?}
 */
function getClosestMatchingAncestor(element, selector) {
    /** @type {?} */
    let currentElement = (/** @type {?} */ (element.parentElement));
    while (currentElement) {
        // IE doesn't support `matches` so we have to fall back to `msMatchesSelector`.
        if (currentElement.matches ? currentElement.matches(selector) :
            ((/** @type {?} */ (currentElement))).msMatchesSelector(selector)) {
            return currentElement;
        }
        currentElement = currentElement.parentElement;
    }
    return null;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag.js","sourceRoot":"ng://ngx-pluto/","sources":["lib/drag-drop/directives/drag.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * @license\r\n * Copyright Google LLC All Rights Reserved.\r\n *\r\n * Use of this source code is governed by an MIT-style license that can be\r\n * found in the LICENSE file at https://angular.io/license\r\n */\r\n\r\nimport {Directionality} from '@angular/cdk/bidi';\r\nimport {ViewportRuler} from '@angular/cdk/scrolling';\r\nimport {DOCUMENT} from '@angular/common';\r\nimport {\r\n  AfterViewInit,\r\n  ContentChild,\r\n  ContentChildren,\r\n  Directive,\r\n  ElementRef,\r\n  EventEmitter,\r\n  Inject,\r\n  InjectionToken,\r\n  Input,\r\n  NgZone,\r\n  OnDestroy,\r\n  Optional,\r\n  Output,\r\n  QueryList,\r\n  SkipSelf,\r\n  ViewContainerRef,\r\n  OnChanges,\r\n  SimpleChanges,\r\n  ChangeDetectorRef,\r\n} from '@angular/core';\r\nimport {coerceBooleanProperty} from '@angular/cdk/coercion';\r\nimport {Observable, Observer, Subject, merge} from 'rxjs';\r\nimport {startWith, take, map, takeUntil, switchMap, tap} from 'rxjs/operators';\r\nimport {DragDropRegistry} from '../drag-drop-registry';\r\nimport {\r\n  CdkDragDrop,\r\n  CdkDragEnd,\r\n  CdkDragEnter,\r\n  CdkDragExit,\r\n  CdkDragMove,\r\n  CdkDragStart,\r\n  CdkDragRelease,\r\n} from '../drag-events';\r\nimport {CdkDragHandle} from './drag-handle';\r\nimport {CdkDragPlaceholder} from './drag-placeholder';\r\nimport {CdkDragPreview} from './drag-preview';\r\nimport {CDK_DROP_LIST} from '../drop-list-container';\r\nimport {CDK_DRAG_PARENT} from '../drag-parent';\r\nimport {DragRef, DragRefConfig} from '../drag-ref';\r\nimport {DropListRef} from '../drop-list-ref';\r\nimport {CdkDropListInternal as CdkDropList} from './drop-list';\r\nimport {DragDrop} from '../drag-drop';\r\n\r\n/** Injection token that can be used to configure the behavior of `CdkDrag`. */\r\nexport const CDK_DRAG_CONFIG = new InjectionToken<DragRefConfig>('CDK_DRAG_CONFIG', {\r\n  providedIn: 'root',\r\n  factory: CDK_DRAG_CONFIG_FACTORY\r\n});\r\n\r\n/** @docs-private */\r\nexport function CDK_DRAG_CONFIG_FACTORY(): DragRefConfig {\r\n  return {dragStartThreshold: 5, pointerDirectionChangeThreshold: 5};\r\n}\r\n\r\n/** \r\n * @ignore\r\n * Element that can be moved inside a CdkDropList container. \r\n * */\r\n@Directive({\r\n  selector: '[cdkDrag]',\r\n  exportAs: 'cdkDrag',\r\n  host: {\r\n    'class': 'cdk-drag',\r\n    '[class.cdk-drag-disabled]': 'disabled',\r\n    '[class.cdk-drag-dragging]': '_dragRef.isDragging()',\r\n  },\r\n  providers: [{provide: CDK_DRAG_PARENT, useExisting: CdkDrag}]\r\n})\r\nexport class CdkDrag<T = any> implements AfterViewInit, OnChanges, OnDestroy {\r\n  private _destroyed = new Subject<void>();\r\n\r\n  /** Reference to the underlying drag instance. */\r\n  _dragRef: DragRef<CdkDrag<T>>;\r\n\r\n  /** Elements that can be used to drag the draggable item. */\r\n  @ContentChildren(CdkDragHandle, {descendants: true}) _handles: QueryList<CdkDragHandle>;\r\n\r\n  /** Element that will be used as a template to create the draggable item's preview. */\r\n  @ContentChild(CdkDragPreview) _previewTemplate: CdkDragPreview;\r\n\r\n  /** Template for placeholder element rendered to show where a draggable would be dropped. */\r\n  @ContentChild(CdkDragPlaceholder) _placeholderTemplate: CdkDragPlaceholder;\r\n\r\n  /** Arbitrary data to attach to this drag instance. */\r\n  @Input('cdkDragData') data: T;\r\n\r\n  /** Locks the position of the dragged element along the specified axis. */\r\n  @Input('cdkDragLockAxis') lockAxis: 'x' | 'y';\r\n\r\n  /**\r\n   * Selector that will be used to determine the root draggable element, starting from\r\n   * the `cdkDrag` element and going up the DOM. Passing an alternate root element is useful\r\n   * when trying to enable dragging on an element that you might not have access to.\r\n   */\r\n  @Input('cdkDragRootElement') rootElementSelector: string;\r\n\r\n  /**\r\n   * Selector that will be used to determine the element to which the draggable's position will\r\n   * be constrained. Matching starts from the element's parent and goes up the DOM until a matching\r\n   * element has been found.\r\n   */\r\n  @Input('cdkDragBoundary') boundaryElementSelector: string;\r\n\r\n  /** Whether starting to drag this element is disabled. */\r\n  @Input('cdkDragDisabled')\r\n  get disabled(): boolean {\r\n    return this._disabled || (this.dropContainer && this.dropContainer.disabled);\r\n  }\r\n  set disabled(value: boolean) {\r\n    this._disabled = coerceBooleanProperty(value);\r\n    this._dragRef.disabled = this._disabled;\r\n  }\r\n  private _disabled = false;\r\n\r\n  /** Emits when the user starts dragging the item. */\r\n  @Output('cdkDragStarted') started: EventEmitter<CdkDragStart> = new EventEmitter<CdkDragStart>();\r\n\r\n  /** Emits when the user has released a drag item, before any animations have started. */\r\n  @Output('cdkDragReleased') released: EventEmitter<CdkDragRelease> =\r\n      new EventEmitter<CdkDragRelease>();\r\n\r\n  /** Emits when the user stops dragging an item in the container. */\r\n  @Output('cdkDragEnded') ended: EventEmitter<CdkDragEnd> = new EventEmitter<CdkDragEnd>();\r\n\r\n  /** Emits when the user has moved the item into a new container. */\r\n  @Output('cdkDragEntered') entered: EventEmitter<CdkDragEnter<any>> =\r\n      new EventEmitter<CdkDragEnter<any>>();\r\n\r\n  /** Emits when the user removes the item its container by dragging it into another container. */\r\n  @Output('cdkDragExited') exited: EventEmitter<CdkDragExit<any>> =\r\n      new EventEmitter<CdkDragExit<any>>();\r\n\r\n  /** Emits when the user drops the item inside a container. */\r\n  @Output('cdkDragDropped') dropped: EventEmitter<CdkDragDrop<any>> =\r\n      new EventEmitter<CdkDragDrop<any>>();\r\n\r\n  /**\r\n   * Emits as the user is dragging the item. Use with caution,\r\n   * because this event will fire for every pixel that the user has dragged.\r\n   */\r\n  @Output('cdkDragMoved') moved: Observable<CdkDragMove<T>> =\r\n      new Observable((observer: Observer<CdkDragMove<T>>) => {\r\n        const subscription = this._dragRef.moved.pipe(map(movedEvent => ({\r\n          source: this,\r\n          pointerPosition: movedEvent.pointerPosition,\r\n          event: movedEvent.event,\r\n          delta: movedEvent.delta\r\n        }))).subscribe(observer);\r\n\r\n        return () => {\r\n          subscription.unsubscribe();\r\n        };\r\n      });\r\n\r\n  constructor(\r\n    /** Element that the draggable is attached to. */\r\n    public element: ElementRef<HTMLElement>,\r\n    /** Droppable container that the draggable is a part of. */\r\n    @Inject(CDK_DROP_LIST) @Optional() @SkipSelf()\r\n    public dropContainer: CdkDropList,\r\n    @Inject(DOCUMENT) private _document: any,\r\n    private _ngZone: NgZone,\r\n    private _viewContainerRef: ViewContainerRef,\r\n    viewportRuler: ViewportRuler,\r\n    dragDropRegistry: DragDropRegistry<DragRef, DropListRef>,\r\n    @Inject(CDK_DRAG_CONFIG) config: DragRefConfig,\r\n    @Optional() private _dir: Directionality,\r\n\r\n    /**\r\n     * @deprecated `viewportRuler`, `dragDropRegistry` and `_changeDetectorRef` parameters\r\n     * to be removed. Also `dragDrop` parameter to be made required.\r\n     * @breaking-change 8.0.0.\r\n     */\r\n    dragDrop?: DragDrop,\r\n    private _changeDetectorRef?: ChangeDetectorRef) {\r\n\r\n\r\n    // @breaking-change 8.0.0 Remove null check once the paramter is made required.\r\n    if (dragDrop) {\r\n      this._dragRef = dragDrop.createDrag(element, config);\r\n    } else {\r\n      this._dragRef = new DragRef(element, config, _document, _ngZone, viewportRuler,\r\n          dragDropRegistry);\r\n    }\r\n\r\n    this._dragRef.data = this;\r\n    this._syncInputs(this._dragRef);\r\n    this._handleEvents(this._dragRef);\r\n  }\r\n\r\n  /**\r\n   * Returns the element that is being used as a placeholder\r\n   * while the current element is being dragged.\r\n   */\r\n  getPlaceholderElement(): HTMLElement {\r\n    return this._dragRef.getPlaceholderElement();\r\n  }\r\n\r\n  /** Returns the root draggable element. */\r\n  getRootElement(): HTMLElement {\r\n    return this._dragRef.getRootElement();\r\n  }\r\n\r\n  /** Resets a standalone drag item to its initial position. */\r\n  reset(): void {\r\n    this._dragRef.reset();\r\n  }\r\n\r\n  ngAfterViewInit() {\r\n    // We need to wait for the zone to stabilize, in order for the reference\r\n    // element to be in the proper place in the DOM. This is mostly relevant\r\n    // for draggable elements inside portals since they get stamped out in\r\n    // their original DOM position and then they get transferred to the portal.\r\n    this._ngZone.onStable.asObservable()\r\n      .pipe(take(1), takeUntil(this._destroyed))\r\n      .subscribe(() => {\r\n        this._updateRootElement();\r\n\r\n        // Listen for any newly-added handles.\r\n        this._handles.changes.pipe(\r\n          startWith(this._handles),\r\n          // Sync the new handles with the DragRef.\r\n          tap((handles: QueryList<CdkDragHandle>) => {\r\n            const childHandleElements = handles\r\n              .filter(handle => handle._parentDrag === this)\r\n              .map(handle => handle.element);\r\n            this._dragRef.withHandles(childHandleElements);\r\n          }),\r\n          // Listen if the state of any of the handles changes.\r\n          switchMap((handles: QueryList<CdkDragHandle>) => {\r\n            return merge(...handles.map(item => item._stateChanges));\r\n          }),\r\n          takeUntil(this._destroyed)\r\n        ).subscribe(handleInstance => {\r\n          // Enabled/disable the handle that changed in the DragRef.\r\n          const dragRef = this._dragRef;\r\n          const handle = handleInstance.element.nativeElement;\r\n          handleInstance.disabled ? dragRef.disableHandle(handle) : dragRef.enableHandle(handle);\r\n        });\r\n      });\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges) {\r\n    const rootSelectorChange = changes['rootElementSelector'];\r\n\r\n    // We don't have to react to the first change since it's being\r\n    // handled in `ngAfterViewInit` where it needs to be deferred.\r\n    if (rootSelectorChange && !rootSelectorChange.firstChange) {\r\n      this._updateRootElement();\r\n    }\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this._destroyed.next();\r\n    this._destroyed.complete();\r\n    this._dragRef.dispose();\r\n  }\r\n\r\n  /** Syncs the root element with the `DragRef`. */\r\n  private _updateRootElement() {\r\n    const element = this.element.nativeElement;\r\n    const rootElement = this.rootElementSelector ?\r\n        getClosestMatchingAncestor(element, this.rootElementSelector) : element;\r\n\r\n    if (rootElement && rootElement.nodeType !== this._document.ELEMENT_NODE) {\r\n      throw Error(`cdkDrag must be attached to an element node. ` +\r\n                  `Currently attached to \"${rootElement.nodeName}\".`);\r\n    }\r\n\r\n    this._dragRef.withRootElement(rootElement || element);\r\n  }\r\n\r\n  /** Gets the boundary element, based on the `boundaryElementSelector`. */\r\n  private _getBoundaryElement() {\r\n    const selector = this.boundaryElementSelector;\r\n    return selector ? getClosestMatchingAncestor(this.element.nativeElement, selector) : null;\r\n  }\r\n\r\n  /** Syncs the inputs of the CdkDrag with the options of the underlying DragRef. */\r\n  private _syncInputs(ref: DragRef<CdkDrag<T>>) {\r\n    ref.beforeStarted.subscribe(() => {\r\n      if (!ref.isDragging()) {\r\n        const dir = this._dir;\r\n        const placeholder = this._placeholderTemplate ? {\r\n          template: this._placeholderTemplate.templateRef,\r\n          context: this._placeholderTemplate.data,\r\n          viewContainer: this._viewContainerRef\r\n        } : null;\r\n        const preview = this._previewTemplate ? {\r\n          template: this._previewTemplate.templateRef,\r\n          context: this._previewTemplate.data,\r\n          viewContainer: this._viewContainerRef\r\n        } : null;\r\n\r\n        ref.disabled = this.disabled;\r\n        ref.lockAxis = this.lockAxis;\r\n        ref\r\n          .withBoundaryElement(this._getBoundaryElement())\r\n          .withPlaceholderTemplate(placeholder)\r\n          .withPreviewTemplate(preview);\r\n\r\n        if (dir) {\r\n          ref.withDirection(dir.value);\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  /** Handles the events from the underlying `DragRef`. */\r\n  private _handleEvents(ref: DragRef<CdkDrag<T>>) {\r\n    ref.started.subscribe(() => {\r\n      this.started.emit({source: this});\r\n\r\n      // Since all of these events run outside of change detection,\r\n      // we need to ensure that everything is marked correctly.\r\n      if (this._changeDetectorRef) {\r\n        // @breaking-change 8.0.0 Remove null check for _changeDetectorRef\r\n        this._changeDetectorRef.markForCheck();\r\n      }\r\n    });\r\n\r\n    ref.released.subscribe(() => {\r\n      this.released.emit({source: this});\r\n    });\r\n\r\n    ref.ended.subscribe(() => {\r\n      this.ended.emit({source: this});\r\n\r\n      // Since all of these events run outside of change detection,\r\n      // we need to ensure that everything is marked correctly.\r\n      if (this._changeDetectorRef) {\r\n        // @breaking-change 8.0.0 Remove null check for _changeDetectorRef\r\n        this._changeDetectorRef.markForCheck();\r\n      }\r\n    });\r\n\r\n    ref.entered.subscribe(event => {\r\n      this.entered.emit({\r\n        container: event.container.data,\r\n        item: this\r\n      });\r\n    });\r\n\r\n    ref.exited.subscribe(event => {\r\n      this.exited.emit({\r\n        container: event.container.data,\r\n        item: this\r\n      });\r\n    });\r\n\r\n    ref.dropped.subscribe(event => {\r\n      this.dropped.emit({\r\n        previousIndex: event.previousIndex,\r\n        currentIndex: event.currentIndex,\r\n        previousContainer: event.previousContainer.data,\r\n        container: event.container.data,\r\n        isPointerOverContainer: event.isPointerOverContainer,\r\n        item: this\r\n      });\r\n    });\r\n  }\r\n}\r\n\r\n/** Gets the closest ancestor of an element that matches a selector. */\r\nfunction getClosestMatchingAncestor(element: HTMLElement, selector: string) {\r\n  let currentElement = element.parentElement as HTMLElement | null;\r\n\r\n  while (currentElement) {\r\n    // IE doesn't support `matches` so we have to fall back to `msMatchesSelector`.\r\n    if (currentElement.matches ? currentElement.matches(selector) :\r\n        (currentElement as any).msMatchesSelector(selector)) {\r\n      return currentElement;\r\n    }\r\n\r\n    currentElement = currentElement.parentElement;\r\n  }\r\n\r\n  return null;\r\n}\r\n\r\n"]}