@angular/cdk 10.0.0-rc.3 → 10.1.0

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

@@ -6,281 +6,282 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { coerceArray, coerceBooleanProperty } from '@angular/cdk/coercion';
-import { ElementRef, EventEmitter, Input, Output, Optional, Directive, ChangeDetectorRef, SkipSelf, Inject, } from '@angular/core';
+import { ElementRef, EventEmitter, Input, Output, Optional, Directive, ChangeDetectorRef, SkipSelf, Inject, InjectionToken, } from '@angular/core';
 import { Directionality } from '@angular/cdk/bidi';
 import { ScrollDispatcher } from '@angular/cdk/scrolling';
-import { CDK_DROP_LIST } from './drag';
-import { CdkDropListGroup } from './drop-list-group';
+import { CDK_DROP_LIST_GROUP, CdkDropListGroup } from './drop-list-group';
 import { DragDrop } from '../drag-drop';
 import { CDK_DRAG_CONFIG } from './config';
 import { Subject } from 'rxjs';
 import { startWith, takeUntil } from 'rxjs/operators';
 /** Counter used to generate unique ids for drop zones. */
 let _uniqueIdCounter = 0;
+/**
+ * Injection token that can be used to reference instances of `CdkDropList`. It serves as
+ * alternative token to the actual `CdkDropList` class which could cause unnecessary
+ * retention of the class and its directive metadata.
+ */
+export const CDK_DROP_LIST = new InjectionToken('CdkDropList');
 const ɵ0 = undefined;
 /** Container that wraps a set of draggable items. */
-let CdkDropList = /** @class */ (() => {
-    class CdkDropList {
-        constructor(
-        /** Element that the drop list is attached to. */
-        element, dragDrop, _changeDetectorRef, _dir, _group, 
+export class CdkDropList {
+    constructor(
+    /** Element that the drop list is attached to. */
+    element, dragDrop, _changeDetectorRef, _dir, _group, 
+    /**
+     * @deprecated _scrollDispatcher parameter to become required.
+     * @breaking-change 11.0.0
+     */
+    _scrollDispatcher, config) {
+        this.element = element;
+        this._changeDetectorRef = _changeDetectorRef;
+        this._dir = _dir;
+        this._group = _group;
+        this._scrollDispatcher = _scrollDispatcher;
+        /** Emits when the list has been destroyed. */
+        this._destroyed = new Subject();
         /**
-         * @deprecated _scrollDispatcher parameter to become required.
-         * @breaking-change 11.0.0
+         * 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.
          */
-        _scrollDispatcher, config) {
-            this.element = element;
-            this._changeDetectorRef = _changeDetectorRef;
-            this._dir = _dir;
-            this._group = _group;
-            this._scrollDispatcher = _scrollDispatcher;
-            /** 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 = [];
-            /**
-             * Unique ID for the drop zone. Can be used as a reference
-             * in the `connectedTo` of another `CdkDropList`.
-             */
-            this.id = `cdk-drop-list-${_uniqueIdCounter++}`;
-            /**
-             * Function that is used to determine whether an item
-             * is allowed to be moved into a drop container.
-             */
-            this.enterPredicate = () => 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();
-            /**
-             * Keeps track of the items that are registered with this container. Historically we used to
-             * do this with a `ContentChildren` query, however queries don't handle transplanted views very
-             * well which means that we can't handle cases like dragging the headers of a `mat-table`
-             * correctly. What we do instead is to have the items register themselves with the container
-             * and then we sort them based on their position in the DOM.
-             */
-            this._unsortedItems = new Set();
-            this._dropListRef = dragDrop.createDropList(element);
-            this._dropListRef.data = this;
-            if (config) {
-                this._assignDefaults(config);
-            }
-            this._dropListRef.enterPredicate = (drag, drop) => {
-                return this.enterPredicate(drag.data, drop.data);
-            };
-            this._setupInputSyncSubscription(this._dropListRef);
-            this._handleEvents(this._dropListRef);
-            CdkDropList._dropLists.push(this);
-            if (_group) {
-                _group._items.add(this);
-            }
-        }
-        /** Whether starting a dragging sequence from this container is disabled. */
-        get disabled() {
-            return this._disabled || (!!this._group && this._group.disabled);
+        this.connectedTo = [];
+        /**
+         * Unique ID for the drop zone. Can be used as a reference
+         * in the `connectedTo` of another `CdkDropList`.
+         */
+        this.id = `cdk-drop-list-${_uniqueIdCounter++}`;
+        /**
+         * Function that is used to determine whether an item
+         * is allowed to be moved into a drop container.
+         */
+        this.enterPredicate = () => 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();
+        /**
+         * Keeps track of the items that are registered with this container. Historically we used to
+         * do this with a `ContentChildren` query, however queries don't handle transplanted views very
+         * well which means that we can't handle cases like dragging the headers of a `mat-table`
+         * correctly. What we do instead is to have the items register themselves with the container
+         * and then we sort them based on their position in the DOM.
+         */
+        this._unsortedItems = new Set();
+        this._dropListRef = dragDrop.createDropList(element);
+        this._dropListRef.data = this;
+        if (config) {
+            this._assignDefaults(config);
         }
-        set disabled(value) {
-            // Usually we sync the directive and ref state right before dragging starts, in order to have
-            // a single point of failure and to avoid having to use setters for everything. `disabled` is
-            // a special case, because it can prevent the `beforeStarted` event from firing, which can lock
-            // the user in a disabled state, so we also need to sync it as it's being set.
-            this._dropListRef.disabled = this._disabled = coerceBooleanProperty(value);
+        this._dropListRef.enterPredicate = (drag, drop) => {
+            return this.enterPredicate(drag.data, drop.data);
+        };
+        this._setupInputSyncSubscription(this._dropListRef);
+        this._handleEvents(this._dropListRef);
+        CdkDropList._dropLists.push(this);
+        if (_group) {
+            _group._items.add(this);
         }
-        /** Registers an items with the drop list. */
-        addItem(item) {
-            this._unsortedItems.add(item);
-            if (this._dropListRef.isDragging()) {
-                this._syncItemsWithRef();
-            }
+    }
+    /** Whether starting a dragging sequence from this container is disabled. */
+    get disabled() {
+        return this._disabled || (!!this._group && this._group.disabled);
+    }
+    set disabled(value) {
+        // Usually we sync the directive and ref state right before dragging starts, in order to have
+        // a single point of failure and to avoid having to use setters for everything. `disabled` is
+        // a special case, because it can prevent the `beforeStarted` event from firing, which can lock
+        // the user in a disabled state, so we also need to sync it as it's being set.
+        this._dropListRef.disabled = this._disabled = coerceBooleanProperty(value);
+    }
+    /** Registers an items with the drop list. */
+    addItem(item) {
+        this._unsortedItems.add(item);
+        if (this._dropListRef.isDragging()) {
+            this._syncItemsWithRef();
         }
-        /** Removes an item from the drop list. */
-        removeItem(item) {
-            this._unsortedItems.delete(item);
-            if (this._dropListRef.isDragging()) {
-                this._syncItemsWithRef();
-            }
+    }
+    /** Removes an item from the drop list. */
+    removeItem(item) {
+        this._unsortedItems.delete(item);
+        if (this._dropListRef.isDragging()) {
+            this._syncItemsWithRef();
         }
-        /** Gets the registered items in the list, sorted by their position in the DOM. */
-        getSortedItems() {
-            return Array.from(this._unsortedItems).sort((a, b) => {
-                const documentPosition = a._dragRef.getVisibleElement().compareDocumentPosition(b._dragRef.getVisibleElement());
-                // `compareDocumentPosition` returns a bitmask so we have to use a bitwise operator.
-                // https://developer.mozilla.org/en-US/docs/Web/API/Node/compareDocumentPosition
-                // tslint:disable-next-line:no-bitwise
-                return documentPosition & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1;
-            });
+    }
+    /** Gets the registered items in the list, sorted by their position in the DOM. */
+    getSortedItems() {
+        return Array.from(this._unsortedItems).sort((a, b) => {
+            const documentPosition = a._dragRef.getVisibleElement().compareDocumentPosition(b._dragRef.getVisibleElement());
+            // `compareDocumentPosition` returns a bitmask so we have to use a bitwise operator.
+            // https://developer.mozilla.org/en-US/docs/Web/API/Node/compareDocumentPosition
+            // tslint:disable-next-line:no-bitwise
+            return documentPosition & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1;
+        });
+    }
+    ngOnDestroy() {
+        const index = CdkDropList._dropLists.indexOf(this);
+        if (index > -1) {
+            CdkDropList._dropLists.splice(index, 1);
         }
-        ngOnDestroy() {
-            const index = CdkDropList._dropLists.indexOf(this);
-            if (index > -1) {
-                CdkDropList._dropLists.splice(index, 1);
-            }
-            if (this._group) {
-                this._group._items.delete(this);
-            }
-            this._unsortedItems.clear();
-            this._dropListRef.dispose();
-            this._destroyed.next();
-            this._destroyed.complete();
+        if (this._group) {
+            this._group._items.delete(this);
         }
-        /** Syncs the inputs of the CdkDropList with the options of the underlying DropListRef. */
-        _setupInputSyncSubscription(ref) {
-            if (this._dir) {
-                this._dir.change
-                    .pipe(startWith(this._dir.value), takeUntil(this._destroyed))
-                    .subscribe(value => ref.withDirection(value));
-            }
-            ref.beforeStarted.subscribe(() => {
-                const siblings = coerceArray(this.connectedTo).map(drop => {
-                    return typeof drop === 'string' ?
-                        CdkDropList._dropLists.find(list => list.id === drop) : drop;
-                });
-                if (this._group) {
-                    this._group._items.forEach(drop => {
-                        if (siblings.indexOf(drop) === -1) {
-                            siblings.push(drop);
-                        }
-                    });
-                }
-                // Note that we resolve the scrollable parents here so that we delay the resolution
-                // as long as possible, ensuring that the element is in its final place in the DOM.
-                // @breaking-change 11.0.0 Remove null check for _scrollDispatcher once it's required.
-                if (!this._scrollableParentsResolved && this._scrollDispatcher) {
-                    const scrollableParents = this._scrollDispatcher
-                        .getAncestorScrollContainers(this.element)
-                        .map(scrollable => scrollable.getElementRef().nativeElement);
-                    this._dropListRef.withScrollableParents(scrollableParents);
-                    // Only do this once since it involves traversing the DOM and the parents
-                    // shouldn't be able to change without the drop list being destroyed.
-                    this._scrollableParentsResolved = true;
-                }
-                ref.disabled = this.disabled;
-                ref.lockAxis = this.lockAxis;
-                ref.sortingDisabled = coerceBooleanProperty(this.sortingDisabled);
-                ref.autoScrollDisabled = coerceBooleanProperty(this.autoScrollDisabled);
-                ref
-                    .connectedTo(siblings.filter(drop => drop && drop !== this).map(list => list._dropListRef))
-                    .withOrientation(this.orientation);
-            });
+        this._unsortedItems.clear();
+        this._dropListRef.dispose();
+        this._destroyed.next();
+        this._destroyed.complete();
+    }
+    /** Syncs the inputs of the CdkDropList with the options of the underlying DropListRef. */
+    _setupInputSyncSubscription(ref) {
+        if (this._dir) {
+            this._dir.change
+                .pipe(startWith(this._dir.value), takeUntil(this._destroyed))
+                .subscribe(value => ref.withDirection(value));
         }
-        /** Handles events from the underlying DropListRef. */
-        _handleEvents(ref) {
-            ref.beforeStarted.subscribe(() => {
-                this._syncItemsWithRef();
-                this._changeDetectorRef.markForCheck();
+        ref.beforeStarted.subscribe(() => {
+            const siblings = coerceArray(this.connectedTo).map(drop => {
+                return typeof drop === 'string' ?
+                    CdkDropList._dropLists.find(list => list.id === drop) : drop;
             });
-            ref.entered.subscribe(event => {
-                this.entered.emit({
-                    container: this,
-                    item: event.item.data,
-                    currentIndex: event.currentIndex
+            if (this._group) {
+                this._group._items.forEach(drop => {
+                    if (siblings.indexOf(drop) === -1) {
+                        siblings.push(drop);
+                    }
                 });
+            }
+            // Note that we resolve the scrollable parents here so that we delay the resolution
+            // as long as possible, ensuring that the element is in its final place in the DOM.
+            // @breaking-change 11.0.0 Remove null check for _scrollDispatcher once it's required.
+            if (!this._scrollableParentsResolved && this._scrollDispatcher) {
+                const scrollableParents = this._scrollDispatcher
+                    .getAncestorScrollContainers(this.element)
+                    .map(scrollable => scrollable.getElementRef().nativeElement);
+                this._dropListRef.withScrollableParents(scrollableParents);
+                // Only do this once since it involves traversing the DOM and the parents
+                // shouldn't be able to change without the drop list being destroyed.
+                this._scrollableParentsResolved = true;
+            }
+            ref.disabled = this.disabled;
+            ref.lockAxis = this.lockAxis;
+            ref.sortingDisabled = coerceBooleanProperty(this.sortingDisabled);
+            ref.autoScrollDisabled = coerceBooleanProperty(this.autoScrollDisabled);
+            ref
+                .connectedTo(siblings.filter(drop => drop && drop !== this).map(list => list._dropListRef))
+                .withOrientation(this.orientation);
+        });
+    }
+    /** Handles events from the underlying DropListRef. */
+    _handleEvents(ref) {
+        ref.beforeStarted.subscribe(() => {
+            this._syncItemsWithRef();
+            this._changeDetectorRef.markForCheck();
+        });
+        ref.entered.subscribe(event => {
+            this.entered.emit({
+                container: this,
+                item: event.item.data,
+                currentIndex: event.currentIndex
             });
-            ref.exited.subscribe(event => {
-                this.exited.emit({
-                    container: this,
-                    item: event.item.data
-                });
-                this._changeDetectorRef.markForCheck();
+        });
+        ref.exited.subscribe(event => {
+            this.exited.emit({
+                container: this,
+                item: event.item.data
             });
-            ref.sorted.subscribe(event => {
-                this.sorted.emit({
-                    previousIndex: event.previousIndex,
-                    currentIndex: event.currentIndex,
-                    container: this,
-                    item: event.item.data
-                });
+            this._changeDetectorRef.markForCheck();
+        });
+        ref.sorted.subscribe(event => {
+            this.sorted.emit({
+                previousIndex: event.previousIndex,
+                currentIndex: event.currentIndex,
+                container: this,
+                item: event.item.data
             });
-            ref.dropped.subscribe(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,
-                    distance: event.distance
-                });
-                // 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();
+        });
+        ref.dropped.subscribe(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,
+                distance: event.distance
             });
-        }
-        /** Assigns the default input values based on a provided config object. */
-        _assignDefaults(config) {
-            const { lockAxis, draggingDisabled, sortingDisabled, listAutoScrollDisabled, listOrientation } = config;
-            this.disabled = draggingDisabled == null ? false : draggingDisabled;
-            this.sortingDisabled = sortingDisabled == null ? false : sortingDisabled;
-            this.autoScrollDisabled = listAutoScrollDisabled == null ? false : listAutoScrollDisabled;
-            this.orientation = listOrientation || 'vertical';
-            if (lockAxis) {
-                this.lockAxis = lockAxis;
-            }
-        }
-        /** Syncs up the registered drag items with underlying drop list ref. */
-        _syncItemsWithRef() {
-            this._dropListRef.withItems(this.getSortedItems().map(item => item._dragRef));
+            // 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();
+        });
+    }
+    /** Assigns the default input values based on a provided config object. */
+    _assignDefaults(config) {
+        const { lockAxis, draggingDisabled, sortingDisabled, listAutoScrollDisabled, listOrientation } = config;
+        this.disabled = draggingDisabled == null ? false : draggingDisabled;
+        this.sortingDisabled = sortingDisabled == null ? false : sortingDisabled;
+        this.autoScrollDisabled = listAutoScrollDisabled == null ? false : listAutoScrollDisabled;
+        this.orientation = listOrientation || 'vertical';
+        if (lockAxis) {
+            this.lockAxis = lockAxis;
         }
     }
-    /** 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, 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()',
-                    }
-                },] }
-    ];
-    CdkDropList.ctorParameters = () => [
-        { type: ElementRef },
-        { type: DragDrop },
-        { type: ChangeDetectorRef },
-        { type: Directionality, decorators: [{ type: Optional }] },
-        { type: CdkDropListGroup, decorators: [{ type: Optional }, { type: SkipSelf }] },
-        { type: ScrollDispatcher },
-        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [CDK_DRAG_CONFIG,] }] }
-    ];
-    CdkDropList.propDecorators = {
-        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',] }],
-        sortingDisabled: [{ type: Input, args: ['cdkDropListSortingDisabled',] }],
-        enterPredicate: [{ type: Input, args: ['cdkDropListEnterPredicate',] }],
-        autoScrollDisabled: [{ type: Input, args: ['cdkDropListAutoScrollDisabled',] }],
-        dropped: [{ type: Output, args: ['cdkDropListDropped',] }],
-        entered: [{ type: Output, args: ['cdkDropListEntered',] }],
-        exited: [{ type: Output, args: ['cdkDropListExited',] }],
-        sorted: [{ type: Output, args: ['cdkDropListSorted',] }]
-    };
-    return CdkDropList;
-})();
-export { CdkDropList };
+    /** Syncs up the registered drag items with underlying drop list ref. */
+    _syncItemsWithRef() {
+        this._dropListRef.withItems(this.getSortedItems().map(item => item._dragRef));
+    }
+}
+/** 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: CDK_DROP_LIST_GROUP, useValue: ɵ0 },
+                    { provide: CDK_DROP_LIST, 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()',
+                }
+            },] }
+];
+CdkDropList.ctorParameters = () => [
+    { type: ElementRef },
+    { type: DragDrop },
+    { type: ChangeDetectorRef },
+    { type: Directionality, decorators: [{ type: Optional }] },
+    { type: CdkDropListGroup, decorators: [{ type: Optional }, { type: Inject, args: [CDK_DROP_LIST_GROUP,] }, { type: SkipSelf }] },
+    { type: ScrollDispatcher },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [CDK_DRAG_CONFIG,] }] }
+];
+CdkDropList.propDecorators = {
+    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',] }],
+    sortingDisabled: [{ type: Input, args: ['cdkDropListSortingDisabled',] }],
+    enterPredicate: [{ type: Input, args: ['cdkDropListEnterPredicate',] }],
+    autoScrollDisabled: [{ type: Input, args: ['cdkDropListAutoScrollDisabled',] }],
+    dropped: [{ type: Output, args: ['cdkDropListDropped',] }],
+    entered: [{ type: Output, args: ['cdkDropListEntered',] }],
+    exited: [{ type: Output, args: ['cdkDropListExited',] }],
+    sorted: [{ type: Output, args: ['cdkDropListSorted',] }]
+};
 export { ɵ0 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drop-list.js","sourceRoot":"","sources":["../../../../../../../src/cdk/drag-drop/directives/drop-list.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 {BooleanInput, coerceArray, coerceBooleanProperty} from '@angular/cdk/coercion';\nimport {\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  Output,\n  Optional,\n  Directive,\n  ChangeDetectorRef,\n  SkipSelf,\n  Inject,\n} from '@angular/core';\nimport {Directionality} from '@angular/cdk/bidi';\nimport {ScrollDispatcher} from '@angular/cdk/scrolling';\nimport {CdkDrag, CDK_DROP_LIST} from './drag';\nimport {CdkDragDrop, CdkDragEnter, CdkDragExit, CdkDragSortEvent} from '../drag-events';\nimport {CdkDropListGroup} from './drop-list-group';\nimport {DropListRef} from '../drop-list-ref';\nimport {DragRef} from '../drag-ref';\nimport {DragDrop} from '../drag-drop';\nimport {DropListOrientation, DragAxis, DragDropConfig, CDK_DRAG_CONFIG} from './config';\nimport {Subject} from 'rxjs';\nimport {startWith, takeUntil} from 'rxjs/operators';\n\n/** Counter used to generate unique ids for drop zones. */\nlet _uniqueIdCounter = 0;\n\n/**\n * Internal compile-time-only representation of a `CdkDropList`.\n * Used to avoid circular import issues between the `CdkDropList` and the `CdkDrag`.\n * @docs-private\n */\nexport interface CdkDropListInternal extends CdkDropList {}\n\n/** Container that wraps a set of draggable items. */\n@Directive({\n  selector: '[cdkDropList], cdk-drop-list',\n  exportAs: 'cdkDropList',\n  providers: [\n    // Prevent child drop lists from picking up the same group as their parent.\n    {provide: CdkDropListGroup, useValue: undefined},\n    {provide: CDK_DROP_LIST, useExisting: CdkDropList},\n  ],\n  host: {\n    'class': 'cdk-drop-list',\n    '[id]': 'id',\n    '[class.cdk-drop-list-disabled]': 'disabled',\n    '[class.cdk-drop-list-dragging]': '_dropListRef.isDragging()',\n    '[class.cdk-drop-list-receiving]': '_dropListRef.isReceiving()',\n  }\n})\nexport class CdkDropList<T = any> implements OnDestroy {\n  /** Emits when the list has been destroyed. */\n  private _destroyed = new Subject<void>();\n\n  /** Whether the element's scrollable parents have been resolved. */\n  private _scrollableParentsResolved: boolean;\n\n  /** Keeps track of the drop lists that are currently on the page. */\n  private static _dropLists: CdkDropList[] = [];\n\n  /** Reference to the underlying drop list instance. */\n  _dropListRef: DropListRef<CdkDropList<T>>;\n\n  /**\n   * Other draggable containers that this container is connected to and into which the\n   * container's items can be transferred. Can either be references to other drop containers,\n   * or their unique IDs.\n   */\n  @Input('cdkDropListConnectedTo')\n  connectedTo: (CdkDropList | string)[] | CdkDropList | string = [];\n\n  /** Arbitrary data to attach to this container. */\n  @Input('cdkDropListData') data: T;\n\n  /** Direction in which the list is oriented. */\n  @Input('cdkDropListOrientation') orientation: DropListOrientation;\n\n  /**\n   * Unique ID for the drop zone. Can be used as a reference\n   * in the `connectedTo` of another `CdkDropList`.\n   */\n  @Input() id: string = `cdk-drop-list-${_uniqueIdCounter++}`;\n\n  /** Locks the position of the draggable elements inside the container along the specified axis. */\n  @Input('cdkDropListLockAxis') lockAxis: DragAxis;\n\n  /** Whether starting a dragging sequence from this container is disabled. */\n  @Input('cdkDropListDisabled')\n  get disabled(): boolean {\n    return this._disabled || (!!this._group && this._group.disabled);\n  }\n  set disabled(value: boolean) {\n    // Usually we sync the directive and ref state right before dragging starts, in order to have\n    // a single point of failure and to avoid having to use setters for everything. `disabled` is\n    // a special case, because it can prevent the `beforeStarted` event from firing, which can lock\n    // the user in a disabled state, so we also need to sync it as it's being set.\n    this._dropListRef.disabled = this._disabled = coerceBooleanProperty(value);\n  }\n  private _disabled: boolean;\n\n  /** Whether sorting within this drop list is disabled. */\n  @Input('cdkDropListSortingDisabled')\n  sortingDisabled: boolean;\n\n  /**\n   * Function that is used to determine whether an item\n   * is allowed to be moved into a drop container.\n   */\n  @Input('cdkDropListEnterPredicate')\n  enterPredicate: (drag: CdkDrag, drop: CdkDropList) => boolean = () => true\n\n  /** Whether to auto-scroll the view when the user moves their pointer close to the edges. */\n  @Input('cdkDropListAutoScrollDisabled')\n  autoScrollDisabled: boolean;\n\n  /** Emits when the user drops an item inside the container. */\n  @Output('cdkDropListDropped')\n  dropped: EventEmitter<CdkDragDrop<T, any>> = new EventEmitter<CdkDragDrop<T, any>>();\n\n  /**\n   * Emits when the user has moved a new drag item into this container.\n   */\n  @Output('cdkDropListEntered')\n  entered: EventEmitter<CdkDragEnter<T>> = new EventEmitter<CdkDragEnter<T>>();\n\n  /**\n   * Emits when the user removes an item from the container\n   * by dragging it into another container.\n   */\n  @Output('cdkDropListExited')\n  exited: EventEmitter<CdkDragExit<T>> = new EventEmitter<CdkDragExit<T>>();\n\n  /** Emits as the user is swapping items while actively dragging. */\n  @Output('cdkDropListSorted')\n  sorted: EventEmitter<CdkDragSortEvent<T>> = new EventEmitter<CdkDragSortEvent<T>>();\n\n  /**\n   * Keeps track of the items that are registered with this container. Historically we used to\n   * do this with a `ContentChildren` query, however queries don't handle transplanted views very\n   * well which means that we can't handle cases like dragging the headers of a `mat-table`\n   * correctly. What we do instead is to have the items register themselves with the container\n   * and then we sort them based on their position in the DOM.\n   */\n  private _unsortedItems = new Set<CdkDrag>();\n\n  constructor(\n      /** Element that the drop list is attached to. */\n      public element: ElementRef<HTMLElement>, dragDrop: DragDrop,\n      private _changeDetectorRef: ChangeDetectorRef, @Optional() private _dir?: Directionality,\n      @Optional() @SkipSelf() private _group?: CdkDropListGroup<CdkDropList>,\n\n      /**\n       * @deprecated _scrollDispatcher parameter to become required.\n       * @breaking-change 11.0.0\n       */\n      private _scrollDispatcher?: ScrollDispatcher,\n      @Optional() @Inject(CDK_DRAG_CONFIG) config?: DragDropConfig) {\n    this._dropListRef = dragDrop.createDropList(element);\n    this._dropListRef.data = this;\n\n    if (config) {\n      this._assignDefaults(config);\n    }\n\n    this._dropListRef.enterPredicate = (drag: DragRef<CdkDrag>, drop: DropListRef<CdkDropList>) => {\n      return this.enterPredicate(drag.data, drop.data);\n    };\n\n    this._setupInputSyncSubscription(this._dropListRef);\n    this._handleEvents(this._dropListRef);\n    CdkDropList._dropLists.push(this);\n\n    if (_group) {\n      _group._items.add(this);\n    }\n  }\n\n  /** Registers an items with the drop list. */\n  addItem(item: CdkDrag): void {\n    this._unsortedItems.add(item);\n\n    if (this._dropListRef.isDragging()) {\n      this._syncItemsWithRef();\n    }\n  }\n\n  /** Removes an item from the drop list. */\n  removeItem(item: CdkDrag): void {\n    this._unsortedItems.delete(item);\n\n    if (this._dropListRef.isDragging()) {\n      this._syncItemsWithRef();\n    }\n  }\n\n  /** Gets the registered items in the list, sorted by their position in the DOM. */\n  getSortedItems(): CdkDrag[] {\n    return Array.from(this._unsortedItems).sort((a: CdkDrag, b: CdkDrag) => {\n      const documentPosition =\n          a._dragRef.getVisibleElement().compareDocumentPosition(b._dragRef.getVisibleElement());\n\n      // `compareDocumentPosition` returns a bitmask so we have to use a bitwise operator.\n      // https://developer.mozilla.org/en-US/docs/Web/API/Node/compareDocumentPosition\n      // tslint:disable-next-line:no-bitwise\n      return documentPosition & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1;\n    });\n  }\n\n  ngOnDestroy() {\n    const index = CdkDropList._dropLists.indexOf(this);\n\n    if (index > -1) {\n      CdkDropList._dropLists.splice(index, 1);\n    }\n\n    if (this._group) {\n      this._group._items.delete(this);\n    }\n\n    this._unsortedItems.clear();\n    this._dropListRef.dispose();\n    this._destroyed.next();\n    this._destroyed.complete();\n  }\n\n  /** Syncs the inputs of the CdkDropList with the options of the underlying DropListRef. */\n  private _setupInputSyncSubscription(ref: DropListRef<CdkDropList>) {\n    if (this._dir) {\n      this._dir.change\n        .pipe(startWith(this._dir.value), takeUntil(this._destroyed))\n        .subscribe(value => ref.withDirection(value));\n    }\n\n    ref.beforeStarted.subscribe(() => {\n      const siblings = coerceArray(this.connectedTo).map(drop => {\n        return typeof drop === 'string' ?\n            CdkDropList._dropLists.find(list => list.id === drop)! : drop;\n      });\n\n      if (this._group) {\n        this._group._items.forEach(drop => {\n          if (siblings.indexOf(drop) === -1) {\n            siblings.push(drop);\n          }\n        });\n      }\n\n      // Note that we resolve the scrollable parents here so that we delay the resolution\n      // as long as possible, ensuring that the element is in its final place in the DOM.\n      // @breaking-change 11.0.0 Remove null check for _scrollDispatcher once it's required.\n      if (!this._scrollableParentsResolved && this._scrollDispatcher) {\n        const scrollableParents = this._scrollDispatcher\n          .getAncestorScrollContainers(this.element)\n          .map(scrollable => scrollable.getElementRef().nativeElement);\n        this._dropListRef.withScrollableParents(scrollableParents);\n\n        // Only do this once since it involves traversing the DOM and the parents\n        // shouldn't be able to change without the drop list being destroyed.\n        this._scrollableParentsResolved = true;\n      }\n\n      ref.disabled = this.disabled;\n      ref.lockAxis = this.lockAxis;\n      ref.sortingDisabled = coerceBooleanProperty(this.sortingDisabled);\n      ref.autoScrollDisabled = coerceBooleanProperty(this.autoScrollDisabled);\n      ref\n        .connectedTo(siblings.filter(drop => drop && drop !== this).map(list => list._dropListRef))\n        .withOrientation(this.orientation);\n    });\n  }\n\n  /** Handles events from the underlying DropListRef. */\n  private _handleEvents(ref: DropListRef<CdkDropList>) {\n    ref.beforeStarted.subscribe(() => {\n      this._syncItemsWithRef();\n      this._changeDetectorRef.markForCheck();\n    });\n\n    ref.entered.subscribe(event => {\n      this.entered.emit({\n        container: this,\n        item: event.item.data,\n        currentIndex: event.currentIndex\n      });\n    });\n\n    ref.exited.subscribe(event => {\n      this.exited.emit({\n        container: this,\n        item: event.item.data\n      });\n      this._changeDetectorRef.markForCheck();\n    });\n\n    ref.sorted.subscribe(event => {\n      this.sorted.emit({\n        previousIndex: event.previousIndex,\n        currentIndex: event.currentIndex,\n        container: this,\n        item: event.item.data\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        item: event.item.data,\n        isPointerOverContainer: event.isPointerOverContainer,\n        distance: event.distance\n      });\n\n      // Mark for check since all of these events run outside of change\n      // detection and we're not guaranteed for something else to have triggered it.\n      this._changeDetectorRef.markForCheck();\n    });\n  }\n\n  /** Assigns the default input values based on a provided config object. */\n  private _assignDefaults(config: DragDropConfig) {\n    const {\n      lockAxis, draggingDisabled, sortingDisabled, listAutoScrollDisabled, listOrientation\n    } = config;\n\n    this.disabled = draggingDisabled == null ? false : draggingDisabled;\n    this.sortingDisabled = sortingDisabled == null ? false : sortingDisabled;\n    this.autoScrollDisabled = listAutoScrollDisabled == null ? false : listAutoScrollDisabled;\n    this.orientation = listOrientation || 'vertical';\n\n    if (lockAxis) {\n      this.lockAxis = lockAxis;\n    }\n  }\n\n  /** Syncs up the registered drag items with underlying drop list ref. */\n  private _syncItemsWithRef() {\n    this._dropListRef.withItems(this.getSortedItems().map(item => item._dragRef));\n  }\n\n  static ngAcceptInputType_disabled: BooleanInput;\n  static ngAcceptInputType_sortingDisabled: BooleanInput;\n  static ngAcceptInputType_autoScrollDisabled: BooleanInput;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drop-list.js","sourceRoot":"","sources":["../../../../../../../src/cdk/drag-drop/directives/drop-list.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 {BooleanInput, coerceArray, coerceBooleanProperty} from '@angular/cdk/coercion';\nimport {\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  Output,\n  Optional,\n  Directive,\n  ChangeDetectorRef,\n  SkipSelf,\n  Inject,\n  InjectionToken,\n} from '@angular/core';\nimport {Directionality} from '@angular/cdk/bidi';\nimport {ScrollDispatcher} from '@angular/cdk/scrolling';\nimport {CdkDrag} from './drag';\nimport {CdkDragDrop, CdkDragEnter, CdkDragExit, CdkDragSortEvent} from '../drag-events';\nimport {CDK_DROP_LIST_GROUP, CdkDropListGroup} from './drop-list-group';\nimport {DropListRef} from '../drop-list-ref';\nimport {DragRef} from '../drag-ref';\nimport {DragDrop} from '../drag-drop';\nimport {DropListOrientation, DragAxis, DragDropConfig, CDK_DRAG_CONFIG} from './config';\nimport {Subject} from 'rxjs';\nimport {startWith, takeUntil} from 'rxjs/operators';\n\n/** Counter used to generate unique ids for drop zones. */\nlet _uniqueIdCounter = 0;\n\n/**\n * Internal compile-time-only representation of a `CdkDropList`.\n * Used to avoid circular import issues between the `CdkDropList` and the `CdkDrag`.\n * @docs-private\n */\nexport interface CdkDropListInternal extends CdkDropList {}\n\n/**\n * Injection token that can be used to reference instances of `CdkDropList`. It serves as\n * alternative token to the actual `CdkDropList` class which could cause unnecessary\n * retention of the class and its directive metadata.\n */\nexport const CDK_DROP_LIST = new InjectionToken<CdkDropList>('CdkDropList');\n\n/** Container that wraps a set of draggable items. */\n@Directive({\n  selector: '[cdkDropList], cdk-drop-list',\n  exportAs: 'cdkDropList',\n  providers: [\n    // Prevent child drop lists from picking up the same group as their parent.\n    {provide: CDK_DROP_LIST_GROUP, useValue: undefined},\n    {provide: CDK_DROP_LIST, useExisting: CdkDropList},\n  ],\n  host: {\n    'class': 'cdk-drop-list',\n    '[id]': 'id',\n    '[class.cdk-drop-list-disabled]': 'disabled',\n    '[class.cdk-drop-list-dragging]': '_dropListRef.isDragging()',\n    '[class.cdk-drop-list-receiving]': '_dropListRef.isReceiving()',\n  }\n})\nexport class CdkDropList<T = any> implements OnDestroy {\n  /** Emits when the list has been destroyed. */\n  private _destroyed = new Subject<void>();\n\n  /** Whether the element's scrollable parents have been resolved. */\n  private _scrollableParentsResolved: boolean;\n\n  /** Keeps track of the drop lists that are currently on the page. */\n  private static _dropLists: CdkDropList[] = [];\n\n  /** Reference to the underlying drop list instance. */\n  _dropListRef: DropListRef<CdkDropList<T>>;\n\n  /**\n   * Other draggable containers that this container is connected to and into which the\n   * container's items can be transferred. Can either be references to other drop containers,\n   * or their unique IDs.\n   */\n  @Input('cdkDropListConnectedTo')\n  connectedTo: (CdkDropList | string)[] | CdkDropList | string = [];\n\n  /** Arbitrary data to attach to this container. */\n  @Input('cdkDropListData') data: T;\n\n  /** Direction in which the list is oriented. */\n  @Input('cdkDropListOrientation') orientation: DropListOrientation;\n\n  /**\n   * Unique ID for the drop zone. Can be used as a reference\n   * in the `connectedTo` of another `CdkDropList`.\n   */\n  @Input() id: string = `cdk-drop-list-${_uniqueIdCounter++}`;\n\n  /** Locks the position of the draggable elements inside the container along the specified axis. */\n  @Input('cdkDropListLockAxis') lockAxis: DragAxis;\n\n  /** Whether starting a dragging sequence from this container is disabled. */\n  @Input('cdkDropListDisabled')\n  get disabled(): boolean {\n    return this._disabled || (!!this._group && this._group.disabled);\n  }\n  set disabled(value: boolean) {\n    // Usually we sync the directive and ref state right before dragging starts, in order to have\n    // a single point of failure and to avoid having to use setters for everything. `disabled` is\n    // a special case, because it can prevent the `beforeStarted` event from firing, which can lock\n    // the user in a disabled state, so we also need to sync it as it's being set.\n    this._dropListRef.disabled = this._disabled = coerceBooleanProperty(value);\n  }\n  private _disabled: boolean;\n\n  /** Whether sorting within this drop list is disabled. */\n  @Input('cdkDropListSortingDisabled')\n  sortingDisabled: boolean;\n\n  /**\n   * Function that is used to determine whether an item\n   * is allowed to be moved into a drop container.\n   */\n  @Input('cdkDropListEnterPredicate')\n  enterPredicate: (drag: CdkDrag, drop: CdkDropList) => boolean = () => true\n\n  /** Whether to auto-scroll the view when the user moves their pointer close to the edges. */\n  @Input('cdkDropListAutoScrollDisabled')\n  autoScrollDisabled: boolean;\n\n  /** Emits when the user drops an item inside the container. */\n  @Output('cdkDropListDropped')\n  dropped: EventEmitter<CdkDragDrop<T, any>> = new EventEmitter<CdkDragDrop<T, any>>();\n\n  /**\n   * Emits when the user has moved a new drag item into this container.\n   */\n  @Output('cdkDropListEntered')\n  entered: EventEmitter<CdkDragEnter<T>> = new EventEmitter<CdkDragEnter<T>>();\n\n  /**\n   * Emits when the user removes an item from the container\n   * by dragging it into another container.\n   */\n  @Output('cdkDropListExited')\n  exited: EventEmitter<CdkDragExit<T>> = new EventEmitter<CdkDragExit<T>>();\n\n  /** Emits as the user is swapping items while actively dragging. */\n  @Output('cdkDropListSorted')\n  sorted: EventEmitter<CdkDragSortEvent<T>> = new EventEmitter<CdkDragSortEvent<T>>();\n\n  /**\n   * Keeps track of the items that are registered with this container. Historically we used to\n   * do this with a `ContentChildren` query, however queries don't handle transplanted views very\n   * well which means that we can't handle cases like dragging the headers of a `mat-table`\n   * correctly. What we do instead is to have the items register themselves with the container\n   * and then we sort them based on their position in the DOM.\n   */\n  private _unsortedItems = new Set<CdkDrag>();\n\n  constructor(\n      /** Element that the drop list is attached to. */\n      public element: ElementRef<HTMLElement>, dragDrop: DragDrop,\n      private _changeDetectorRef: ChangeDetectorRef, @Optional() private _dir?: Directionality,\n      @Optional() @Inject(CDK_DROP_LIST_GROUP) @SkipSelf()\n      private _group?: CdkDropListGroup<CdkDropList>,\n\n      /**\n       * @deprecated _scrollDispatcher parameter to become required.\n       * @breaking-change 11.0.0\n       */\n      private _scrollDispatcher?: ScrollDispatcher,\n      @Optional() @Inject(CDK_DRAG_CONFIG) config?: DragDropConfig) {\n    this._dropListRef = dragDrop.createDropList(element);\n    this._dropListRef.data = this;\n\n    if (config) {\n      this._assignDefaults(config);\n    }\n\n    this._dropListRef.enterPredicate = (drag: DragRef<CdkDrag>, drop: DropListRef<CdkDropList>) => {\n      return this.enterPredicate(drag.data, drop.data);\n    };\n\n    this._setupInputSyncSubscription(this._dropListRef);\n    this._handleEvents(this._dropListRef);\n    CdkDropList._dropLists.push(this);\n\n    if (_group) {\n      _group._items.add(this);\n    }\n  }\n\n  /** Registers an items with the drop list. */\n  addItem(item: CdkDrag): void {\n    this._unsortedItems.add(item);\n\n    if (this._dropListRef.isDragging()) {\n      this._syncItemsWithRef();\n    }\n  }\n\n  /** Removes an item from the drop list. */\n  removeItem(item: CdkDrag): void {\n    this._unsortedItems.delete(item);\n\n    if (this._dropListRef.isDragging()) {\n      this._syncItemsWithRef();\n    }\n  }\n\n  /** Gets the registered items in the list, sorted by their position in the DOM. */\n  getSortedItems(): CdkDrag[] {\n    return Array.from(this._unsortedItems).sort((a: CdkDrag, b: CdkDrag) => {\n      const documentPosition =\n          a._dragRef.getVisibleElement().compareDocumentPosition(b._dragRef.getVisibleElement());\n\n      // `compareDocumentPosition` returns a bitmask so we have to use a bitwise operator.\n      // https://developer.mozilla.org/en-US/docs/Web/API/Node/compareDocumentPosition\n      // tslint:disable-next-line:no-bitwise\n      return documentPosition & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1;\n    });\n  }\n\n  ngOnDestroy() {\n    const index = CdkDropList._dropLists.indexOf(this);\n\n    if (index > -1) {\n      CdkDropList._dropLists.splice(index, 1);\n    }\n\n    if (this._group) {\n      this._group._items.delete(this);\n    }\n\n    this._unsortedItems.clear();\n    this._dropListRef.dispose();\n    this._destroyed.next();\n    this._destroyed.complete();\n  }\n\n  /** Syncs the inputs of the CdkDropList with the options of the underlying DropListRef. */\n  private _setupInputSyncSubscription(ref: DropListRef<CdkDropList>) {\n    if (this._dir) {\n      this._dir.change\n        .pipe(startWith(this._dir.value), takeUntil(this._destroyed))\n        .subscribe(value => ref.withDirection(value));\n    }\n\n    ref.beforeStarted.subscribe(() => {\n      const siblings = coerceArray(this.connectedTo).map(drop => {\n        return typeof drop === 'string' ?\n            CdkDropList._dropLists.find(list => list.id === drop)! : drop;\n      });\n\n      if (this._group) {\n        this._group._items.forEach(drop => {\n          if (siblings.indexOf(drop) === -1) {\n            siblings.push(drop);\n          }\n        });\n      }\n\n      // Note that we resolve the scrollable parents here so that we delay the resolution\n      // as long as possible, ensuring that the element is in its final place in the DOM.\n      // @breaking-change 11.0.0 Remove null check for _scrollDispatcher once it's required.\n      if (!this._scrollableParentsResolved && this._scrollDispatcher) {\n        const scrollableParents = this._scrollDispatcher\n          .getAncestorScrollContainers(this.element)\n          .map(scrollable => scrollable.getElementRef().nativeElement);\n        this._dropListRef.withScrollableParents(scrollableParents);\n\n        // Only do this once since it involves traversing the DOM and the parents\n        // shouldn't be able to change without the drop list being destroyed.\n        this._scrollableParentsResolved = true;\n      }\n\n      ref.disabled = this.disabled;\n      ref.lockAxis = this.lockAxis;\n      ref.sortingDisabled = coerceBooleanProperty(this.sortingDisabled);\n      ref.autoScrollDisabled = coerceBooleanProperty(this.autoScrollDisabled);\n      ref\n        .connectedTo(siblings.filter(drop => drop && drop !== this).map(list => list._dropListRef))\n        .withOrientation(this.orientation);\n    });\n  }\n\n  /** Handles events from the underlying DropListRef. */\n  private _handleEvents(ref: DropListRef<CdkDropList>) {\n    ref.beforeStarted.subscribe(() => {\n      this._syncItemsWithRef();\n      this._changeDetectorRef.markForCheck();\n    });\n\n    ref.entered.subscribe(event => {\n      this.entered.emit({\n        container: this,\n        item: event.item.data,\n        currentIndex: event.currentIndex\n      });\n    });\n\n    ref.exited.subscribe(event => {\n      this.exited.emit({\n        container: this,\n        item: event.item.data\n      });\n      this._changeDetectorRef.markForCheck();\n    });\n\n    ref.sorted.subscribe(event => {\n      this.sorted.emit({\n        previousIndex: event.previousIndex,\n        currentIndex: event.currentIndex,\n        container: this,\n        item: event.item.data\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        item: event.item.data,\n        isPointerOverContainer: event.isPointerOverContainer,\n        distance: event.distance\n      });\n\n      // Mark for check since all of these events run outside of change\n      // detection and we're not guaranteed for something else to have triggered it.\n      this._changeDetectorRef.markForCheck();\n    });\n  }\n\n  /** Assigns the default input values based on a provided config object. */\n  private _assignDefaults(config: DragDropConfig) {\n    const {\n      lockAxis, draggingDisabled, sortingDisabled, listAutoScrollDisabled, listOrientation\n    } = config;\n\n    this.disabled = draggingDisabled == null ? false : draggingDisabled;\n    this.sortingDisabled = sortingDisabled == null ? false : sortingDisabled;\n    this.autoScrollDisabled = listAutoScrollDisabled == null ? false : listAutoScrollDisabled;\n    this.orientation = listOrientation || 'vertical';\n\n    if (lockAxis) {\n      this.lockAxis = lockAxis;\n    }\n  }\n\n  /** Syncs up the registered drag items with underlying drop list ref. */\n  private _syncItemsWithRef() {\n    this._dropListRef.withItems(this.getSortedItems().map(item => item._dragRef));\n  }\n\n  static ngAcceptInputType_disabled: BooleanInput;\n  static ngAcceptInputType_sortingDisabled: BooleanInput;\n  static ngAcceptInputType_autoScrollDisabled: BooleanInput;\n}\n"]}