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