@angular/cdk
Version:
Angular Material Component Development Kit
290 lines • 38.8 kB
JavaScript
/**
* @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, Input, Output, QueryList, Optional, Directive, ChangeDetectorRef, SkipSelf, } from '@angular/core';
import { Directionality } from '@angular/cdk/bidi';
import { CdkDrag, CDK_DROP_LIST } from './drag';
import { CdkDropListGroup } from './drop-list-group';
import { DragDrop } from '../drag-drop';
import { Subject } from 'rxjs';
import { startWith, takeUntil } from 'rxjs/operators';
/** Counter used to generate unique ids for drop zones. */
var _uniqueIdCounter = 0;
var ɵ0 = undefined;
/** Container that wraps a set of draggable items. */
var CdkDropList = /** @class */ (function () {
function CdkDropList(
/** Element that the drop list is attached to. */
element, dragDrop, _changeDetectorRef, _dir, _group) {
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;
/** Whether sorting within this drop list is disabled. */
this.sortingDisabled = false;
/**
* Function that is used to determine whether an item
* is allowed to be moved into a drop container.
*/
this.enterPredicate = function () { return true; };
/** Whether to auto-scroll the view when the user moves their pointer close to the edges. */
this.autoScrollDisabled = false;
/** 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();
this._dropListRef = dragDrop.createDropList(element);
this._dropListRef.data = this;
this._dropListRef.enterPredicate = function (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);
}
}
Object.defineProperty(CdkDropList.prototype, "disabled", {
/** Whether starting a dragging sequence from this container is disabled. */
get: function () {
return this._disabled || (!!this._group && this._group.disabled);
},
set: function (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);
},
enumerable: true,
configurable: true
});
CdkDropList.prototype.ngAfterContentInit = function () {
var _this = this;
this._draggables.changes
.pipe(startWith(this._draggables), takeUntil(this._destroyed))
.subscribe(function (items) {
_this._dropListRef.withItems(items.reduce(function (filteredItems, drag) {
if (drag.dropContainer === _this) {
filteredItems.push(drag._dragRef);
}
return filteredItems;
}, []));
});
};
CdkDropList.prototype.ngOnDestroy = function () {
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.
* @deprecated No longer being used. To be removed.
* @breaking-change 10.0.0
*/
CdkDropList.prototype.start = 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.
*
* @deprecated No longer being used. To be removed.
* @breaking-change 10.0.0
*/
CdkDropList.prototype.drop = function (item, currentIndex, previousContainer, isPointerOverContainer) {
this._dropListRef.drop(item._dragRef, currentIndex, previousContainer._dropListRef, isPointerOverContainer, { x: 0, y: 0 });
};
/**
* 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.
* @deprecated No longer being used. To be removed.
* @breaking-change 10.0.0
*/
CdkDropList.prototype.enter = 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.
* @deprecated No longer being used. To be removed.
* @breaking-change 10.0.0
*/
CdkDropList.prototype.exit = 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.
* @deprecated No longer being used. To be removed.
* @breaking-change 10.0.0
*/
CdkDropList.prototype.getItemIndex = function (item) {
return this._dropListRef.getItemIndex(item._dragRef);
};
/** Syncs the inputs of the CdkDropList with the options of the underlying DropListRef. */
CdkDropList.prototype._setupInputSyncSubscription = function (ref) {
var _this = this;
if (this._dir) {
this._dir.change
.pipe(startWith(this._dir.value), takeUntil(this._destroyed))
.subscribe(function (value) { return ref.withDirection(value); });
}
ref.beforeStarted.subscribe(function () {
var siblings = coerceArray(_this.connectedTo).map(function (drop) {
return typeof drop === 'string' ?
CdkDropList._dropLists.find(function (list) { return list.id === drop; }) : drop;
});
if (_this._group) {
_this._group._items.forEach(function (drop) {
if (siblings.indexOf(drop) === -1) {
siblings.push(drop);
}
});
}
ref.disabled = _this.disabled;
ref.lockAxis = _this.lockAxis;
ref.sortingDisabled = coerceBooleanProperty(_this.sortingDisabled);
ref.autoScrollDisabled = coerceBooleanProperty(_this.autoScrollDisabled);
ref
.connectedTo(siblings.filter(function (drop) { return drop && drop !== _this; }).map(function (list) { return list._dropListRef; }))
.withOrientation(_this.orientation);
});
};
/** Handles events from the underlying DropListRef. */
CdkDropList.prototype._handleEvents = function (ref) {
var _this = this;
ref.beforeStarted.subscribe(function () {
_this._changeDetectorRef.markForCheck();
});
ref.entered.subscribe(function (event) {
_this.entered.emit({
container: _this,
item: event.item.data,
currentIndex: event.currentIndex
});
});
ref.exited.subscribe(function (event) {
_this.exited.emit({
container: _this,
item: event.item.data
});
_this._changeDetectorRef.markForCheck();
});
ref.sorted.subscribe(function (event) {
_this.sorted.emit({
previousIndex: event.previousIndex,
currentIndex: event.currentIndex,
container: _this,
item: event.item.data
});
});
ref.dropped.subscribe(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,
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();
});
};
/** 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()',
}
},] }
];
/** @nocollapse */
CdkDropList.ctorParameters = function () { return [
{ type: ElementRef },
{ type: DragDrop },
{ type: ChangeDetectorRef },
{ type: Directionality, decorators: [{ type: Optional }] },
{ type: CdkDropListGroup, decorators: [{ type: Optional }, { type: SkipSelf }] }
]; };
CdkDropList.propDecorators = {
_draggables: [{ type: ContentChildren, args: [CdkDrag, { descendants: true },] }],
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 };
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  ContentChildren,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  Output,\n  QueryList,\n  Optional,\n  Directive,\n  ChangeDetectorRef,\n  SkipSelf,\n  AfterContentInit,\n} from '@angular/core';\nimport {Directionality} from '@angular/cdk/bidi';\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 {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 AfterContentInit, OnDestroy {\n  /** Emits when the list has been destroyed. */\n  private _destroyed = new Subject<void>();\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  /** Draggable items in the container. */\n  @ContentChildren(CdkDrag, {descendants: true}) _draggables: QueryList<CdkDrag>;\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: 'horizontal' | 'vertical' = 'vertical';\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: 'x' | 'y';\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 = false;\n\n  /** Whether sorting within this drop list is disabled. */\n  @Input('cdkDropListSortingDisabled')\n  sortingDisabled: boolean = false;\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 = false;\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  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    this._dropListRef = dragDrop.createDropList(element);\n    this._dropListRef.data = this;\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  ngAfterContentInit() {\n    this._draggables.changes\n      .pipe(startWith(this._draggables), takeUntil(this._destroyed))\n      .subscribe((items: QueryList<CdkDrag>) => {\n        this._dropListRef.withItems(items.reduce((filteredItems, drag) => {\n          if (drag.dropContainer === this) {\n            filteredItems.push(drag._dragRef);\n          }\n\n          return filteredItems;\n        }, [] as DragRef[]));\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._dropListRef.dispose();\n    this._destroyed.next();\n    this._destroyed.complete();\n  }\n\n  /**\n   * Starts dragging an item.\n   * @deprecated No longer being used. To be removed.\n   * @breaking-change 10.0.0\n   */\n  start(): void {\n    this._dropListRef.start();\n  }\n\n  /**\n   * Drops an item into this container.\n   * @param item Item being dropped into the container.\n   * @param currentIndex Index at which the item should be inserted.\n   * @param previousContainer Container from which the item got dragged in.\n   * @param isPointerOverContainer Whether the user's pointer was over the\n   *    container when the item was dropped.\n   *\n   * @deprecated No longer being used. To be removed.\n   * @breaking-change 10.0.0\n   */\n  drop(item: CdkDrag, currentIndex: number, previousContainer: CdkDropList,\n    isPointerOverContainer: boolean): void {\n    this._dropListRef.drop(item._dragRef, currentIndex, previousContainer._dropListRef,\n        isPointerOverContainer, {x: 0, y: 0});\n  }\n\n  /**\n   * Emits an event to indicate that the user moved an item into the container.\n   * @param item Item that was moved into the container.\n   * @param pointerX Position of the item along the X axis.\n   * @param pointerY Position of the item along the Y axis.\n   * @deprecated No longer being used. To be removed.\n   * @breaking-change 10.0.0\n   */\n  enter(item: CdkDrag, pointerX: number, pointerY: number): void {\n    this._dropListRef.enter(item._dragRef, pointerX, pointerY);\n  }\n\n  /**\n   * Removes an item from the container after it was dragged into another container by the user.\n   * @param item Item that was dragged out.\n   * @deprecated No longer being used. To be removed.\n   * @breaking-change 10.0.0\n   */\n  exit(item: CdkDrag): void {\n    this._dropListRef.exit(item._dragRef);\n  }\n\n  /**\n   * Figures out the index of an item in the container.\n   * @param item Item whose index should be determined.\n   * @deprecated No longer being used. To be removed.\n   * @breaking-change 10.0.0\n   */\n  getItemIndex(item: CdkDrag): number {\n    return this._dropListRef.getItemIndex(item._dragRef);\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      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._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  static ngAcceptInputType_disabled: BooleanInput;\n  static ngAcceptInputType_sortingDisabled: BooleanInput;\n  static ngAcceptInputType_autoScrollDisabled: BooleanInput;\n}\n"]}