/**
 * @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 { coerceArray, coerceBooleanProperty } from '@angular/cdk/coercion';
import { ContentChildren, ElementRef, EventEmitter, forwardRef, Input, Output, QueryList, Optional, Directive, ChangeDetectorRef, SkipSelf, Inject, } from '@angular/core';
import { DOCUMENT } from '@angular/common';
import { Directionality } from '@angular/cdk/bidi';
import { CdkDrag } from './drag';
import { DragDropRegistry } from '../drag-drop-registry';
import { CDK_DROP_LIST_CONTAINER } from '../drop-list-container';
import { CdkDropListGroup } from './drop-list-group';
import { DropListRef } from '../drop-list-ref';
import { DragDrop } from '../drag-drop';
import { Subject } from 'rxjs';
import { startWith, takeUntil } from 'rxjs/operators';
/**
 * Counter used to generate unique ids for drop zones.
 * @type {?}
 */
var _uniqueIdCounter = 0;
/**
 * @ignore
 * Internal compile-time-only representation of a `CdkDropList`.
 * Used to avoid circular import issues between the `CdkDropList` and the `CdkDrag`.
 * \@docs-private
 * @record
 */
export function CdkDropListInternal() { }
var ɵ0 = undefined;
// @breaking-change 8.0.0 `CdkDropList` implements `CdkDropListContainer` for backwards
// compatiblity. The implements clause, as well as all the methods that it enforces can
// be removed when `CdkDropListContainer` is deleted.
/**
 * @ignore
 * Container that wraps a set of draggable items.
 *
 * @template T
 */
var CdkDropList = /** @class */ (function () {
    function CdkDropList(element, dragDropRegistry, _changeDetectorRef, _dir, _group, _document, 
    /**
     * @deprecated `dragDropRegistry` and `_document` parameters to be removed.
     * Also `dragDrop` parameter to be made required.
     * @breaking-change 8.0.0.
     */
    dragDrop) {
        var _this = this;
        this.element = element;
        this._changeDetectorRef = _changeDetectorRef;
        this._dir = _dir;
        this._group = _group;
        /**
         * Emits when the list has been destroyed.
         */
        this._destroyed = new Subject();
        /**
         * Other draggable containers that this container is connected to and into which the
         * container's items can be transferred. Can either be references to other drop containers,
         * or their unique IDs.
         */
        this.connectedTo = [];
        /**
         * Direction in which the list is oriented.
         */
        this.orientation = 'vertical';
        /**
         * Unique ID for the drop zone. Can be used as a reference
         * in the `connectedTo` of another `CdkDropList`.
         */
        this.id = "cdk-drop-list-" + _uniqueIdCounter++;
        this._disabled = false;
        /**
         * Function that is used to determine whether an item
         * is allowed to be moved into a drop container.
         */
        this.enterPredicate = (/**
         * @return {?}
         */
        function () { return true; });
        /**
         * Emits when the user drops an item inside the container.
         */
        this.dropped = new EventEmitter();
        /**
         * Emits when the user has moved a new drag item into this container.
         */
        this.entered = new EventEmitter();
        /**
         * Emits when the user removes an item from the container
         * by dragging it into another container.
         */
        this.exited = new EventEmitter();
        /**
         * Emits as the user is swapping items while actively dragging.
         */
        this.sorted = new EventEmitter();
        // @breaking-change 8.0.0 Remove null check once `dragDrop` parameter is made required.
        if (dragDrop) {
            this._dropListRef = dragDrop.createDropList(element);
        }
        else {
            this._dropListRef = new DropListRef(element, dragDropRegistry, _document || document);
        }
        this._dropListRef.data = this;
        this._dropListRef.enterPredicate = (/**
         * @param {?} drag
         * @param {?} drop
         * @return {?}
         */
        function (drag, drop) {
            return _this.enterPredicate(drag.data, drop.data);
        });
        this._syncInputs(this._dropListRef);
        this._handleEvents(this._dropListRef);
        CdkDropList._dropLists.push(this);
        if (_group) {
            _group._items.add(this);
        }
    }
    Object.defineProperty(CdkDropList.prototype, "disabled", {
        /** Whether starting a dragging sequence from this container is disabled. */
        get: /**
         * Whether starting a dragging sequence from this container is disabled.
         * @return {?}
         */
        function () {
            return this._disabled || (!!this._group && this._group.disabled);
        },
        set: /**
         * @param {?} value
         * @return {?}
         */
        function (value) {
            this._disabled = coerceBooleanProperty(value);
        },
        enumerable: true,
        configurable: true
    });
    /**
     * @return {?}
     */
    CdkDropList.prototype.ngAfterContentInit = /**
     * @return {?}
     */
    function () {
        var _this = this;
        this._draggables.changes
            .pipe(startWith(this._draggables), takeUntil(this._destroyed))
            .subscribe((/**
         * @param {?} items
         * @return {?}
         */
        function (items) {
            _this._dropListRef.withItems(items.map((/**
             * @param {?} drag
             * @return {?}
             */
            function (drag) { return drag._dragRef; })));
        }));
    };
    /**
     * @return {?}
     */
    CdkDropList.prototype.ngOnDestroy = /**
     * @return {?}
     */
    function () {
        /** @type {?} */
        var index = CdkDropList._dropLists.indexOf(this);
        if (index > -1) {
            CdkDropList._dropLists.splice(index, 1);
        }
        if (this._group) {
            this._group._items.delete(this);
        }
        this._dropListRef.dispose();
        this._destroyed.next();
        this._destroyed.complete();
    };
    /** Starts dragging an item. */
    /**
     * Starts dragging an item.
     * @return {?}
     */
    CdkDropList.prototype.start = /**
     * Starts dragging an item.
     * @return {?}
     */
    function () {
        this._dropListRef.start();
    };
    /**
     * Drops an item into this container.
     * @param item Item being dropped into the container.
     * @param currentIndex Index at which the item should be inserted.
     * @param previousContainer Container from which the item got dragged in.
     * @param isPointerOverContainer Whether the user's pointer was over the
     *    container when the item was dropped.
     */
    /**
     * Drops an item into this container.
     * @param {?} item Item being dropped into the container.
     * @param {?} currentIndex Index at which the item should be inserted.
     * @param {?} previousContainer Container from which the item got dragged in.
     * @param {?} isPointerOverContainer Whether the user's pointer was over the
     *    container when the item was dropped.
     * @return {?}
     */
    CdkDropList.prototype.drop = /**
     * Drops an item into this container.
     * @param {?} item Item being dropped into the container.
     * @param {?} currentIndex Index at which the item should be inserted.
     * @param {?} previousContainer Container from which the item got dragged in.
     * @param {?} isPointerOverContainer Whether the user's pointer was over the
     *    container when the item was dropped.
     * @return {?}
     */
    function (item, currentIndex, previousContainer, isPointerOverContainer) {
        this._dropListRef.drop(item._dragRef, currentIndex, ((/** @type {?} */ (previousContainer)))._dropListRef, isPointerOverContainer);
    };
    /**
     * Emits an event to indicate that the user moved an item into the container.
     * @param item Item that was moved into the container.
     * @param pointerX Position of the item along the X axis.
     * @param pointerY Position of the item along the Y axis.
     */
    /**
     * Emits an event to indicate that the user moved an item into the container.
     * @param {?} item Item that was moved into the container.
     * @param {?} pointerX Position of the item along the X axis.
     * @param {?} pointerY Position of the item along the Y axis.
     * @return {?}
     */
    CdkDropList.prototype.enter = /**
     * Emits an event to indicate that the user moved an item into the container.
     * @param {?} item Item that was moved into the container.
     * @param {?} pointerX Position of the item along the X axis.
     * @param {?} pointerY Position of the item along the Y axis.
     * @return {?}
     */
    function (item, pointerX, pointerY) {
        this._dropListRef.enter(item._dragRef, pointerX, pointerY);
    };
    /**
     * Removes an item from the container after it was dragged into another container by the user.
     * @param item Item that was dragged out.
     */
    /**
     * Removes an item from the container after it was dragged into another container by the user.
     * @param {?} item Item that was dragged out.
     * @return {?}
     */
    CdkDropList.prototype.exit = /**
     * Removes an item from the container after it was dragged into another container by the user.
     * @param {?} item Item that was dragged out.
     * @return {?}
     */
    function (item) {
        this._dropListRef.exit(item._dragRef);
    };
    /**
     * Figures out the index of an item in the container.
     * @param item Item whose index should be determined.
     */
    /**
     * Figures out the index of an item in the container.
     * @param {?} item Item whose index should be determined.
     * @return {?}
     */
    CdkDropList.prototype.getItemIndex = /**
     * Figures out the index of an item in the container.
     * @param {?} item Item whose index should be determined.
     * @return {?}
     */
    function (item) {
        return this._dropListRef.getItemIndex(item._dragRef);
    };
    /**
     * Sorts an item inside the container based on its position.
     * @param item Item to be sorted.
     * @param pointerX Position of the item along the X axis.
     * @param pointerY Position of the item along the Y axis.
     * @param pointerDelta Direction in which the pointer is moving along each axis.
     */
    /**
     * Sorts an item inside the container based on its position.
     * @param {?} item Item to be sorted.
     * @param {?} pointerX Position of the item along the X axis.
     * @param {?} pointerY Position of the item along the Y axis.
     * @param {?} pointerDelta Direction in which the pointer is moving along each axis.
     * @return {?}
     */
    CdkDropList.prototype._sortItem = /**
     * Sorts an item inside the container based on its position.
     * @param {?} item Item to be sorted.
     * @param {?} pointerX Position of the item along the X axis.
     * @param {?} pointerY Position of the item along the Y axis.
     * @param {?} pointerDelta Direction in which the pointer is moving along each axis.
     * @return {?}
     */
    function (item, pointerX, pointerY, pointerDelta) {
        return this._dropListRef._sortItem(item._dragRef, pointerX, pointerY, pointerDelta);
    };
    /**
     * Figures out whether an item should be moved into a sibling
     * drop container, based on its current position.
     * @param item Drag item that is being moved.
     * @param x Position of the item along the X axis.
     * @param y Position of the item along the Y axis.
     */
    /**
     * Figures out whether an item should be moved into a sibling
     * drop container, based on its current position.
     * @param {?} item Drag item that is being moved.
     * @param {?} x Position of the item along the X axis.
     * @param {?} y Position of the item along the Y axis.
     * @return {?}
     */
    CdkDropList.prototype._getSiblingContainerFromPosition = /**
     * Figures out whether an item should be moved into a sibling
     * drop container, based on its current position.
     * @param {?} item Drag item that is being moved.
     * @param {?} x Position of the item along the X axis.
     * @param {?} y Position of the item along the Y axis.
     * @return {?}
     */
    function (item, x, y) {
        /** @type {?} */
        var result = this._dropListRef._getSiblingContainerFromPosition(item._dragRef, x, y);
        return result ? result.data : null;
    };
    /**
     * Checks whether the user's pointer is positioned over the container.
     * @param x Pointer position along the X axis.
     * @param y Pointer position along the Y axis.
     */
    /**
     * Checks whether the user's pointer is positioned over the container.
     * @param {?} x Pointer position along the X axis.
     * @param {?} y Pointer position along the Y axis.
     * @return {?}
     */
    CdkDropList.prototype._isOverContainer = /**
     * Checks whether the user's pointer is positioned over the container.
     * @param {?} x Pointer position along the X axis.
     * @param {?} y Pointer position along the Y axis.
     * @return {?}
     */
    function (x, y) {
        return this._dropListRef._isOverContainer(x, y);
    };
    /** Syncs the inputs of the CdkDropList with the options of the underlying DropListRef. */
    /**
     * Syncs the inputs of the CdkDropList with the options of the underlying DropListRef.
     * @private
     * @param {?} ref
     * @return {?}
     */
    CdkDropList.prototype._syncInputs = /**
     * Syncs the inputs of the CdkDropList with the options of the underlying DropListRef.
     * @private
     * @param {?} ref
     * @return {?}
     */
    function (ref) {
        var _this = this;
        if (this._dir) {
            this._dir.change
                .pipe(startWith(this._dir.value), takeUntil(this._destroyed))
                .subscribe((/**
             * @param {?} value
             * @return {?}
             */
            function (value) { return ref.withDirection(value); }));
        }
        ref.beforeStarted.subscribe((/**
         * @return {?}
         */
        function () {
            /** @type {?} */
            var siblings = coerceArray(_this.connectedTo).map((/**
             * @param {?} drop
             * @return {?}
             */
            function (drop) {
                return typeof drop === 'string' ?
                    (/** @type {?} */ (CdkDropList._dropLists.find((/**
                     * @param {?} list
                     * @return {?}
                     */
                    function (list) { return list.id === drop; })))) : drop;
            }));
            if (_this._group) {
                _this._group._items.forEach((/**
                 * @param {?} drop
                 * @return {?}
                 */
                function (drop) {
                    if (siblings.indexOf(drop) === -1) {
                        siblings.push(drop);
                    }
                }));
            }
            ref.lockAxis = _this.lockAxis;
            ref
                .connectedTo(siblings.filter((/**
             * @param {?} drop
             * @return {?}
             */
            function (drop) { return drop && drop !== _this; })).map((/**
             * @param {?} list
             * @return {?}
             */
            function (list) { return list._dropListRef; })))
                .withOrientation(_this.orientation);
        }));
    };
    /** Handles events from the underlying DropListRef. */
    /**
     * Handles events from the underlying DropListRef.
     * @private
     * @param {?} ref
     * @return {?}
     */
    CdkDropList.prototype._handleEvents = /**
     * Handles events from the underlying DropListRef.
     * @private
     * @param {?} ref
     * @return {?}
     */
    function (ref) {
        var _this = this;
        ref.beforeStarted.subscribe((/**
         * @return {?}
         */
        function () {
            _this._changeDetectorRef.markForCheck();
        }));
        ref.entered.subscribe((/**
         * @param {?} event
         * @return {?}
         */
        function (event) {
            _this.entered.emit({
                container: _this,
                item: event.item.data
            });
        }));
        ref.exited.subscribe((/**
         * @param {?} event
         * @return {?}
         */
        function (event) {
            _this.exited.emit({
                container: _this,
                item: event.item.data
            });
        }));
        ref.sorted.subscribe((/**
         * @param {?} event
         * @return {?}
         */
        function (event) {
            _this.sorted.emit({
                previousIndex: event.previousIndex,
                currentIndex: event.currentIndex,
                container: _this,
                item: event.item.data
            });
        }));
        ref.dropped.subscribe((/**
         * @param {?} event
         * @return {?}
         */
        function (event) {
            _this.dropped.emit({
                previousIndex: event.previousIndex,
                currentIndex: event.currentIndex,
                previousContainer: event.previousContainer.data,
                container: event.container.data,
                item: event.item.data,
                isPointerOverContainer: event.isPointerOverContainer
            });
            // Mark for check since all of these events run outside of change
            // detection and we're not guaranteed for something else to have triggered it.
            _this._changeDetectorRef.markForCheck();
        }));
    };
    /**
     * Keeps track of the drop lists that are currently on the page.
     */
    CdkDropList._dropLists = [];
    CdkDropList.decorators = [
        { type: Directive, args: [{
                    selector: '[cdkDropList], cdk-drop-list',
                    exportAs: 'cdkDropList',
                    providers: [
                        // Prevent child drop lists from picking up the same group as their parent.
                        { provide: CdkDropListGroup, useValue: ɵ0 },
                        { provide: CDK_DROP_LIST_CONTAINER, useExisting: CdkDropList },
                    ],
                    host: {
                        'class': 'cdk-drop-list',
                        '[id]': 'id',
                        '[class.cdk-drop-list-disabled]': 'disabled',
                        '[class.cdk-drop-list-dragging]': '_dropListRef.isDragging()',
                        '[class.cdk-drop-list-receiving]': '_dropListRef.isReceiving()',
                    }
                },] }
    ];
    /** @nocollapse */
    CdkDropList.ctorParameters = function () { return [
        { type: ElementRef },
        { type: DragDropRegistry },
        { type: ChangeDetectorRef },
        { type: Directionality, decorators: [{ type: Optional }] },
        { type: CdkDropListGroup, decorators: [{ type: Optional }, { type: SkipSelf }] },
        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] },
        { type: DragDrop }
    ]; };
    CdkDropList.propDecorators = {
        _draggables: [{ type: ContentChildren, args: [forwardRef((/**
                     * @return {?}
                     */
                    function () { return CdkDrag; })), {
                        // Explicitly set to false since some of the logic below makes assumptions about it.
                        // The `.withItems` call below should be updated if we ever need to switch this to `true`.
                        descendants: false
                    },] }],
        connectedTo: [{ type: Input, args: ['cdkDropListConnectedTo',] }],
        data: [{ type: Input, args: ['cdkDropListData',] }],
        orientation: [{ type: Input, args: ['cdkDropListOrientation',] }],
        id: [{ type: Input }],
        lockAxis: [{ type: Input, args: ['cdkDropListLockAxis',] }],
        disabled: [{ type: Input, args: ['cdkDropListDisabled',] }],
        enterPredicate: [{ type: Input, args: ['cdkDropListEnterPredicate',] }],
        dropped: [{ type: Output, args: ['cdkDropListDropped',] }],
        entered: [{ type: Output, args: ['cdkDropListEntered',] }],
        exited: [{ type: Output, args: ['cdkDropListExited',] }],
        sorted: [{ type: Output, args: ['cdkDropListSorted',] }]
    };
    return CdkDropList;
}());
export { CdkDropList };
if (false) {
    /**
     * Keeps track of the drop lists that are currently on the page.
     * @type {?}
     * @private
     */
    CdkDropList._dropLists;
    /**
     * Emits when the list has been destroyed.
     * @type {?}
     * @private
     */
    CdkDropList.prototype._destroyed;
    /**
     * Reference to the underlying drop list instance.
     * @type {?}
     */
    CdkDropList.prototype._dropListRef;
    /**
     * Draggable items in the container.
     * @type {?}
     */
    CdkDropList.prototype._draggables;
    /**
     * Other draggable containers that this container is connected to and into which the
     * container's items can be transferred. Can either be references to other drop containers,
     * or their unique IDs.
     * @type {?}
     */
    CdkDropList.prototype.connectedTo;
    /**
     * Arbitrary data to attach to this container.
     * @type {?}
     */
    CdkDropList.prototype.data;
    /**
     * Direction in which the list is oriented.
     * @type {?}
     */
    CdkDropList.prototype.orientation;
    /**
     * Unique ID for the drop zone. Can be used as a reference
     * in the `connectedTo` of another `CdkDropList`.
     * @type {?}
     */
    CdkDropList.prototype.id;
    /**
     * Locks the position of the draggable elements inside the container along the specified axis.
     * @type {?}
     */
    CdkDropList.prototype.lockAxis;
    /**
     * @type {?}
     * @private
     */
    CdkDropList.prototype._disabled;
    /**
     * Function that is used to determine whether an item
     * is allowed to be moved into a drop container.
     * @type {?}
     */
    CdkDropList.prototype.enterPredicate;
    /**
     * Emits when the user drops an item inside the container.
     * @type {?}
     */
    CdkDropList.prototype.dropped;
    /**
     * Emits when the user has moved a new drag item into this container.
     * @type {?}
     */
    CdkDropList.prototype.entered;
    /**
     * Emits when the user removes an item from the container
     * by dragging it into another container.
     * @type {?}
     */
    CdkDropList.prototype.exited;
    /**
     * Emits as the user is swapping items while actively dragging.
     * @type {?}
     */
    CdkDropList.prototype.sorted;
    /**
     * Element that the drop list is attached to.
     * @type {?}
     */
    CdkDropList.prototype.element;
    /**
     * @type {?}
     * @private
     */
    CdkDropList.prototype._changeDetectorRef;
    /**
     * @type {?}
     * @private
     */
    CdkDropList.prototype._dir;
    /**
     * @type {?}
     * @private
     */
    CdkDropList.prototype._group;
}
export { ɵ0 };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drop-list.js","sourceRoot":"ng://ngx-pluto/","sources":["lib/drag-drop/directives/drop-list.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 {coerceArray, coerceBooleanProperty} from '@angular/cdk/coercion';\r\nimport {\r\n  ContentChildren,\r\n  ElementRef,\r\n  EventEmitter,\r\n  forwardRef,\r\n  Input,\r\n  OnDestroy,\r\n  Output,\r\n  QueryList,\r\n  Optional,\r\n  Directive,\r\n  ChangeDetectorRef,\r\n  SkipSelf,\r\n  Inject,\r\n  AfterContentInit,\r\n} from '@angular/core';\r\nimport {DOCUMENT} from '@angular/common';\r\nimport {Directionality} from '@angular/cdk/bidi';\r\nimport {CdkDrag} from './drag';\r\nimport {DragDropRegistry} from '../drag-drop-registry';\r\nimport {CdkDragDrop, CdkDragEnter, CdkDragExit, CdkDragSortEvent} from '../drag-events';\r\nimport {CDK_DROP_LIST_CONTAINER, CdkDropListContainer} from '../drop-list-container';\r\nimport {CdkDropListGroup} from './drop-list-group';\r\nimport {DropListRef} from '../drop-list-ref';\r\nimport {DragRef} from '../drag-ref';\r\nimport {DragDrop} from '../drag-drop';\r\nimport {Subject} from 'rxjs';\r\nimport {startWith, takeUntil} from 'rxjs/operators';\r\n\r\n/** Counter used to generate unique ids for drop zones. */\r\nlet _uniqueIdCounter = 0;\r\n\r\n/**\r\n * @ignore\r\n * Internal compile-time-only representation of a `CdkDropList`.\r\n * Used to avoid circular import issues between the `CdkDropList` and the `CdkDrag`.\r\n * @docs-private\r\n */\r\nexport interface CdkDropListInternal extends CdkDropList {}\r\n\r\n// @breaking-change 8.0.0 `CdkDropList` implements `CdkDropListContainer` for backwards\r\n// compatiblity. The implements clause, as well as all the methods that it enforces can\r\n// be removed when `CdkDropListContainer` is deleted.\r\n\r\n/** \r\n * @ignore\r\n * Container that wraps a set of draggable items. \r\n * */\r\n@Directive({\r\n  selector: '[cdkDropList], cdk-drop-list',\r\n  exportAs: 'cdkDropList',\r\n  providers: [\r\n    // Prevent child drop lists from picking up the same group as their parent.\r\n    {provide: CdkDropListGroup, useValue: undefined},\r\n    {provide: CDK_DROP_LIST_CONTAINER, useExisting: CdkDropList},\r\n  ],\r\n  host: {\r\n    'class': 'cdk-drop-list',\r\n    '[id]': 'id',\r\n    '[class.cdk-drop-list-disabled]': 'disabled',\r\n    '[class.cdk-drop-list-dragging]': '_dropListRef.isDragging()',\r\n    '[class.cdk-drop-list-receiving]': '_dropListRef.isReceiving()',\r\n  }\r\n})\r\nexport class CdkDropList<T = any> implements CdkDropListContainer, AfterContentInit, OnDestroy {\r\n  /** Emits when the list has been destroyed. */\r\n  private _destroyed = new Subject<void>();\r\n\r\n  /** Keeps track of the drop lists that are currently on the page. */\r\n  private static _dropLists: CdkDropList[] = [];\r\n\r\n  /** Reference to the underlying drop list instance. */\r\n  _dropListRef: DropListRef<CdkDropList<T>>;\r\n\r\n  /** Draggable items in the container. */\r\n  @ContentChildren(forwardRef(() => CdkDrag), {\r\n    // Explicitly set to false since some of the logic below makes assumptions about it.\r\n    // The `.withItems` call below should be updated if we ever need to switch this to `true`.\r\n    descendants: false\r\n  }) _draggables: QueryList<CdkDrag>;\r\n\r\n  /**\r\n   * Other draggable containers that this container is connected to and into which the\r\n   * container's items can be transferred. Can either be references to other drop containers,\r\n   * or their unique IDs.\r\n   */\r\n  @Input('cdkDropListConnectedTo')\r\n  connectedTo: (CdkDropList | string)[] | CdkDropList | string = [];\r\n\r\n  /** Arbitrary data to attach to this container. */\r\n  @Input('cdkDropListData') data: T;\r\n\r\n  /** Direction in which the list is oriented. */\r\n  @Input('cdkDropListOrientation') orientation: 'horizontal' | 'vertical' = 'vertical';\r\n\r\n  /**\r\n   * Unique ID for the drop zone. Can be used as a reference\r\n   * in the `connectedTo` of another `CdkDropList`.\r\n   */\r\n  @Input() id: string = `cdk-drop-list-${_uniqueIdCounter++}`;\r\n\r\n  /** Locks the position of the draggable elements inside the container along the specified axis. */\r\n  @Input('cdkDropListLockAxis') lockAxis: 'x' | 'y';\r\n\r\n  /** Whether starting a dragging sequence from this container is disabled. */\r\n  @Input('cdkDropListDisabled')\r\n  get disabled(): boolean {\r\n    return this._disabled || (!!this._group && this._group.disabled);\r\n  }\r\n  set disabled(value: boolean) {\r\n    this._disabled = coerceBooleanProperty(value);\r\n  }\r\n  private _disabled = false;\r\n\r\n  /**\r\n   * Function that is used to determine whether an item\r\n   * is allowed to be moved into a drop container.\r\n   */\r\n  @Input('cdkDropListEnterPredicate')\r\n  enterPredicate: (drag: CdkDrag, drop: CdkDropList) => boolean = () => true\r\n\r\n  /** Emits when the user drops an item inside the container. */\r\n  @Output('cdkDropListDropped')\r\n  dropped: EventEmitter<CdkDragDrop<T, any>> = new EventEmitter<CdkDragDrop<T, any>>();\r\n\r\n  /**\r\n   * Emits when the user has moved a new drag item into this container.\r\n   */\r\n  @Output('cdkDropListEntered')\r\n  entered: EventEmitter<CdkDragEnter<T>> = new EventEmitter<CdkDragEnter<T>>();\r\n\r\n  /**\r\n   * Emits when the user removes an item from the container\r\n   * by dragging it into another container.\r\n   */\r\n  @Output('cdkDropListExited')\r\n  exited: EventEmitter<CdkDragExit<T>> = new EventEmitter<CdkDragExit<T>>();\r\n\r\n  /** Emits as the user is swapping items while actively dragging. */\r\n  @Output('cdkDropListSorted')\r\n  sorted: EventEmitter<CdkDragSortEvent<T>> = new EventEmitter<CdkDragSortEvent<T>>();\r\n\r\n  constructor(\r\n    /** Element that the drop list is attached to. */\r\n    public element: ElementRef<HTMLElement>,\r\n    dragDropRegistry: DragDropRegistry<DragRef, DropListRef>,\r\n    private _changeDetectorRef: ChangeDetectorRef,\r\n    @Optional() private _dir?: Directionality,\r\n    @Optional() @SkipSelf() private _group?: CdkDropListGroup<CdkDropList>,\r\n    @Optional() @Inject(DOCUMENT) _document?: any,\r\n\r\n    /**\r\n     * @deprecated `dragDropRegistry` and `_document` parameters to be removed.\r\n     * Also `dragDrop` parameter to be made required.\r\n     * @breaking-change 8.0.0.\r\n     */\r\n    dragDrop?: DragDrop) {\r\n\r\n    // @breaking-change 8.0.0 Remove null check once `dragDrop` parameter is made required.\r\n    if (dragDrop) {\r\n      this._dropListRef = dragDrop.createDropList(element);\r\n    } else {\r\n      this._dropListRef = new DropListRef(element, dragDropRegistry, _document || document);\r\n    }\r\n\r\n    this._dropListRef.data = this;\r\n    this._dropListRef.enterPredicate = (drag: DragRef<CdkDrag>, drop: DropListRef<CdkDropList>) => {\r\n      return this.enterPredicate(drag.data, drop.data);\r\n    };\r\n\r\n    this._syncInputs(this._dropListRef);\r\n    this._handleEvents(this._dropListRef);\r\n    CdkDropList._dropLists.push(this);\r\n\r\n    if (_group) {\r\n      _group._items.add(this);\r\n    }\r\n  }\r\n\r\n  ngAfterContentInit() {\r\n    this._draggables.changes\r\n      .pipe(startWith(this._draggables), takeUntil(this._destroyed))\r\n      .subscribe((items: QueryList<CdkDrag>) => {\r\n        this._dropListRef.withItems(items.map(drag => drag._dragRef));\r\n      });\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    const index = CdkDropList._dropLists.indexOf(this);\r\n\r\n    if (index > -1) {\r\n      CdkDropList._dropLists.splice(index, 1);\r\n    }\r\n\r\n    if (this._group) {\r\n      this._group._items.delete(this);\r\n    }\r\n\r\n    this._dropListRef.dispose();\r\n    this._destroyed.next();\r\n    this._destroyed.complete();\r\n  }\r\n\r\n  /** Starts dragging an item. */\r\n  start(): void {\r\n    this._dropListRef.start();\r\n  }\r\n\r\n  /**\r\n   * Drops an item into this container.\r\n   * @param item Item being dropped into the container.\r\n   * @param currentIndex Index at which the item should be inserted.\r\n   * @param previousContainer Container from which the item got dragged in.\r\n   * @param isPointerOverContainer Whether the user's pointer was over the\r\n   *    container when the item was dropped.\r\n   */\r\n  drop(item: CdkDrag, currentIndex: number, previousContainer: Partial<CdkDropListContainer>,\r\n    isPointerOverContainer: boolean): void {\r\n    this._dropListRef.drop(item._dragRef, currentIndex,\r\n      (previousContainer as CdkDropList)._dropListRef, isPointerOverContainer);\r\n  }\r\n\r\n  /**\r\n   * Emits an event to indicate that the user moved an item into the container.\r\n   * @param item Item that was moved into the container.\r\n   * @param pointerX Position of the item along the X axis.\r\n   * @param pointerY Position of the item along the Y axis.\r\n   */\r\n  enter(item: CdkDrag, pointerX: number, pointerY: number): void {\r\n    this._dropListRef.enter(item._dragRef, pointerX, pointerY);\r\n  }\r\n\r\n  /**\r\n   * Removes an item from the container after it was dragged into another container by the user.\r\n   * @param item Item that was dragged out.\r\n   */\r\n  exit(item: CdkDrag): void {\r\n    this._dropListRef.exit(item._dragRef);\r\n  }\r\n\r\n  /**\r\n   * Figures out the index of an item in the container.\r\n   * @param item Item whose index should be determined.\r\n   */\r\n  getItemIndex(item: CdkDrag): number {\r\n    return this._dropListRef.getItemIndex(item._dragRef);\r\n  }\r\n\r\n  /**\r\n   * Sorts an item inside the container based on its position.\r\n   * @param item Item to be sorted.\r\n   * @param pointerX Position of the item along the X axis.\r\n   * @param pointerY Position of the item along the Y axis.\r\n   * @param pointerDelta Direction in which the pointer is moving along each axis.\r\n   */\r\n  _sortItem(item: CdkDrag, pointerX: number, pointerY: number,\r\n            pointerDelta: {x: number, y: number}): void {\r\n    return this._dropListRef._sortItem(item._dragRef, pointerX, pointerY, pointerDelta);\r\n  }\r\n\r\n  /**\r\n   * Figures out whether an item should be moved into a sibling\r\n   * drop container, based on its current position.\r\n   * @param item Drag item that is being moved.\r\n   * @param x Position of the item along the X axis.\r\n   * @param y Position of the item along the Y axis.\r\n   */\r\n  _getSiblingContainerFromPosition(item: CdkDrag, x: number, y: number):\r\n    CdkDropListContainer | null {\r\n    const result = this._dropListRef._getSiblingContainerFromPosition(item._dragRef, x, y);\r\n    return result ? result.data : null;\r\n  }\r\n\r\n  /**\r\n   * Checks whether the user's pointer is positioned over the container.\r\n   * @param x Pointer position along the X axis.\r\n   * @param y Pointer position along the Y axis.\r\n   */\r\n  _isOverContainer(x: number, y: number): boolean {\r\n    return this._dropListRef._isOverContainer(x, y);\r\n  }\r\n\r\n  /** Syncs the inputs of the CdkDropList with the options of the underlying DropListRef. */\r\n  private _syncInputs(ref: DropListRef<CdkDropList>) {\r\n    if (this._dir) {\r\n      this._dir.change\r\n        .pipe(startWith(this._dir.value), takeUntil(this._destroyed))\r\n        .subscribe(value => ref.withDirection(value));\r\n    }\r\n\r\n    ref.beforeStarted.subscribe(() => {\r\n      const siblings = coerceArray(this.connectedTo).map(drop => {\r\n        return typeof drop === 'string' ?\r\n            CdkDropList._dropLists.find(list => list.id === drop)! : drop;\r\n      });\r\n\r\n      if (this._group) {\r\n        this._group._items.forEach(drop => {\r\n          if (siblings.indexOf(drop) === -1) {\r\n            siblings.push(drop);\r\n          }\r\n        });\r\n      }\r\n\r\n      ref.lockAxis = this.lockAxis;\r\n      ref\r\n        .connectedTo(siblings.filter(drop => drop && drop !== this).map(list => list._dropListRef))\r\n        .withOrientation(this.orientation);\r\n    });\r\n  }\r\n\r\n  /** Handles events from the underlying DropListRef. */\r\n  private _handleEvents(ref: DropListRef<CdkDropList>) {\r\n    ref.beforeStarted.subscribe(() => {\r\n      this._changeDetectorRef.markForCheck();\r\n    });\r\n\r\n    ref.entered.subscribe(event => {\r\n      this.entered.emit({\r\n        container: this,\r\n        item: event.item.data\r\n      });\r\n    });\r\n\r\n    ref.exited.subscribe(event => {\r\n      this.exited.emit({\r\n        container: this,\r\n        item: event.item.data\r\n      });\r\n    });\r\n\r\n    ref.sorted.subscribe(event => {\r\n      this.sorted.emit({\r\n        previousIndex: event.previousIndex,\r\n        currentIndex: event.currentIndex,\r\n        container: this,\r\n        item: event.item.data\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        item: event.item.data,\r\n        isPointerOverContainer: event.isPointerOverContainer\r\n      });\r\n\r\n      // Mark for check since all of these events run outside of change\r\n      // detection and we're not guaranteed for something else to have triggered it.\r\n      this._changeDetectorRef.markForCheck();\r\n    });\r\n  }\r\n\r\n}\r\n"]}