You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
531 lines
72 KiB
531 lines
72 KiB
/**
|
|
* @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, Input, NgZone, Optional, Output, QueryList, SkipSelf, ViewContainerRef, ChangeDetectorRef, Self, } 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 { CDK_DRAG_HANDLE, CdkDragHandle } from './drag-handle';
|
|
import { CDK_DRAG_PLACEHOLDER, CdkDragPlaceholder } from './drag-placeholder';
|
|
import { CDK_DRAG_PREVIEW, CdkDragPreview } from './drag-preview';
|
|
import { CDK_DRAG_PARENT } from '../drag-parent';
|
|
import { CDK_DROP_LIST } from './drop-list';
|
|
import { DragDrop } from '../drag-drop';
|
|
import { CDK_DRAG_CONFIG } from './config';
|
|
import { assertElementNode } from './assertions';
|
|
import * as ɵngcc0 from '@angular/core';
|
|
import * as ɵngcc1 from '@angular/cdk/bidi';
|
|
import * as ɵngcc2 from '../drag-drop';
|
|
import * as ɵngcc3 from './drag-handle';
|
|
const DRAG_HOST_CLASS = 'cdk-drag';
|
|
/** Element that can be moved inside a CdkDropList container. */
|
|
export class CdkDrag {
|
|
constructor(
|
|
/** Element that the draggable is attached to. */
|
|
element,
|
|
/** Droppable container that the draggable is a part of. */
|
|
dropContainer,
|
|
/**
|
|
* @deprecated `_document` parameter no longer being used and will be removed.
|
|
* @breaking-change 12.0.0
|
|
*/
|
|
_document, _ngZone, _viewContainerRef, config, _dir, dragDrop, _changeDetectorRef, _selfHandle, _parentDrag) {
|
|
this.element = element;
|
|
this.dropContainer = dropContainer;
|
|
this._ngZone = _ngZone;
|
|
this._viewContainerRef = _viewContainerRef;
|
|
this._dir = _dir;
|
|
this._changeDetectorRef = _changeDetectorRef;
|
|
this._selfHandle = _selfHandle;
|
|
this._parentDrag = _parentDrag;
|
|
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((observer) => {
|
|
const subscription = this._dragRef.moved.pipe(map(movedEvent => ({
|
|
source: this,
|
|
pointerPosition: movedEvent.pointerPosition,
|
|
event: movedEvent.event,
|
|
delta: movedEvent.delta,
|
|
distance: movedEvent.distance
|
|
}))).subscribe(observer);
|
|
return () => {
|
|
subscription.unsubscribe();
|
|
};
|
|
});
|
|
this._dragRef = dragDrop.createDrag(element, {
|
|
dragStartThreshold: config && config.dragStartThreshold != null ?
|
|
config.dragStartThreshold : 5,
|
|
pointerDirectionChangeThreshold: config && config.pointerDirectionChangeThreshold != null ?
|
|
config.pointerDirectionChangeThreshold : 5,
|
|
zIndex: config === null || config === void 0 ? void 0 : config.zIndex,
|
|
});
|
|
this._dragRef.data = this;
|
|
// We have to keep track of the drag instances in order to be able to match an element to
|
|
// a drag instance. We can't go through the global registry of `DragRef`, because the root
|
|
// element could be different.
|
|
CdkDrag._dragInstances.push(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. */
|
|
get disabled() {
|
|
return this._disabled || (this.dropContainer && this.dropContainer.disabled);
|
|
}
|
|
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.
|
|
*/
|
|
getPlaceholderElement() {
|
|
return this._dragRef.getPlaceholderElement();
|
|
}
|
|
/** Returns the root draggable element. */
|
|
getRootElement() {
|
|
return this._dragRef.getRootElement();
|
|
}
|
|
/** Resets a standalone drag item to its initial position. */
|
|
reset() {
|
|
this._dragRef.reset();
|
|
}
|
|
/**
|
|
* Gets the pixel coordinates of the draggable outside of a drop container.
|
|
*/
|
|
getFreeDragPosition() {
|
|
return this._dragRef.getFreeDragPosition();
|
|
}
|
|
ngAfterViewInit() {
|
|
// Normally this isn't in the zone, but it can cause major performance regressions for apps
|
|
// using `zone-patch-rxjs` because it'll trigger a change detection when it unsubscribes.
|
|
this._ngZone.runOutsideAngular(() => {
|
|
// 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
|
|
.pipe(take(1), takeUntil(this._destroyed))
|
|
.subscribe(() => {
|
|
this._updateRootElement();
|
|
this._setupHandlesListener();
|
|
if (this.freeDragPosition) {
|
|
this._dragRef.setFreeDragPosition(this.freeDragPosition);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
ngOnChanges(changes) {
|
|
const rootSelectorChange = changes['rootElementSelector'];
|
|
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);
|
|
}
|
|
}
|
|
ngOnDestroy() {
|
|
if (this.dropContainer) {
|
|
this.dropContainer.removeItem(this);
|
|
}
|
|
const index = CdkDrag._dragInstances.indexOf(this);
|
|
if (index > -1) {
|
|
CdkDrag._dragInstances.splice(index, 1);
|
|
}
|
|
// Unnecessary in most cases, but used to avoid extra change detections with `zone-paths-rxjs`.
|
|
this._ngZone.runOutsideAngular(() => {
|
|
this._destroyed.next();
|
|
this._destroyed.complete();
|
|
this._dragRef.dispose();
|
|
});
|
|
}
|
|
/** Syncs the root element with the `DragRef`. */
|
|
_updateRootElement() {
|
|
const element = this.element.nativeElement;
|
|
const rootElement = this.rootElementSelector ?
|
|
getClosestMatchingAncestor(element, this.rootElementSelector) : element;
|
|
if (rootElement && (typeof ngDevMode === 'undefined' || ngDevMode)) {
|
|
assertElementNode(rootElement, 'cdkDrag');
|
|
}
|
|
this._dragRef.withRootElement(rootElement || element);
|
|
}
|
|
/** Gets the boundary element, based on the `boundaryElement` value. */
|
|
_getBoundaryElement() {
|
|
const boundary = this.boundaryElement;
|
|
if (!boundary) {
|
|
return null;
|
|
}
|
|
if (typeof boundary === 'string') {
|
|
return getClosestMatchingAncestor(this.element.nativeElement, boundary);
|
|
}
|
|
const element = coerceElement(boundary);
|
|
if ((typeof ngDevMode === 'undefined' || ngDevMode) &&
|
|
!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. */
|
|
_syncInputs(ref) {
|
|
ref.beforeStarted.subscribe(() => {
|
|
if (!ref.isDragging()) {
|
|
const dir = this._dir;
|
|
const dragStartDelay = this.dragStartDelay;
|
|
const placeholder = this._placeholderTemplate ? {
|
|
template: this._placeholderTemplate.templateRef,
|
|
context: this._placeholderTemplate.data,
|
|
viewContainer: this._viewContainerRef
|
|
} : null;
|
|
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)
|
|
.withPreviewContainer(this.previewContainer || 'global');
|
|
if (dir) {
|
|
ref.withDirection(dir.value);
|
|
}
|
|
}
|
|
});
|
|
// This only needs to be resolved once.
|
|
ref.beforeStarted.pipe(take(1)).subscribe(() => {
|
|
var _a, _b;
|
|
// If we managed to resolve a parent through DI, use it.
|
|
if (this._parentDrag) {
|
|
ref.withParent(this._parentDrag._dragRef);
|
|
return;
|
|
}
|
|
// Otherwise fall back to resolving the parent by looking up the DOM. This can happen if
|
|
// the item was projected into another item by something like `ngTemplateOutlet`.
|
|
let parent = this.element.nativeElement.parentElement;
|
|
while (parent) {
|
|
// `classList` needs to be null checked, because IE doesn't have it on some elements.
|
|
if ((_a = parent.classList) === null || _a === void 0 ? void 0 : _a.contains(DRAG_HOST_CLASS)) {
|
|
ref.withParent(((_b = CdkDrag._dragInstances.find(drag => {
|
|
return drag.element.nativeElement === parent;
|
|
})) === null || _b === void 0 ? void 0 : _b._dragRef) || null);
|
|
break;
|
|
}
|
|
parent = parent.parentElement;
|
|
}
|
|
});
|
|
}
|
|
/** Handles the events from the underlying `DragRef`. */
|
|
_handleEvents(ref) {
|
|
ref.started.subscribe(() => {
|
|
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(() => {
|
|
this.released.emit({ source: this });
|
|
});
|
|
ref.ended.subscribe(event => {
|
|
this.ended.emit({
|
|
source: this,
|
|
distance: event.distance,
|
|
dropPoint: event.dropPoint
|
|
});
|
|
// 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(event => {
|
|
this.entered.emit({
|
|
container: event.container.data,
|
|
item: this,
|
|
currentIndex: event.currentIndex
|
|
});
|
|
});
|
|
ref.exited.subscribe(event => {
|
|
this.exited.emit({
|
|
container: event.container.data,
|
|
item: this
|
|
});
|
|
});
|
|
ref.dropped.subscribe(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,
|
|
dropPoint: event.dropPoint
|
|
});
|
|
});
|
|
}
|
|
/** Assigns the default input values based on a provided config object. */
|
|
_assignDefaults(config) {
|
|
const { lockAxis, dragStartDelay, constrainPosition, previewClass, boundaryElement, draggingDisabled, rootElementSelector, previewContainer } = 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;
|
|
}
|
|
if (previewContainer) {
|
|
this.previewContainer = previewContainer;
|
|
}
|
|
}
|
|
/** Sets up the listener that syncs the handles with the drag ref. */
|
|
_setupHandlesListener() {
|
|
// Listen for any newly-added handles.
|
|
this._handles.changes.pipe(startWith(this._handles),
|
|
// Sync the new handles with the DragRef.
|
|
tap((handles) => {
|
|
const childHandleElements = handles
|
|
.filter(handle => handle._parentDrag === this)
|
|
.map(handle => handle.element);
|
|
// Usually handles are only allowed to be a descendant of the drag element, but if
|
|
// the consumer defined a different drag root, we should allow the drag element
|
|
// itself to be a handle too.
|
|
if (this._selfHandle && this.rootElementSelector) {
|
|
childHandleElements.push(this.element);
|
|
}
|
|
this._dragRef.withHandles(childHandleElements);
|
|
}),
|
|
// Listen if the state of any of the handles changes.
|
|
switchMap((handles) => {
|
|
return merge(...handles.map(item => {
|
|
return item._stateChanges.pipe(startWith(item));
|
|
}));
|
|
}), takeUntil(this._destroyed)).subscribe(handleInstance => {
|
|
// Enabled/disable the handle that changed in the DragRef.
|
|
const dragRef = this._dragRef;
|
|
const handle = handleInstance.element.nativeElement;
|
|
handleInstance.disabled ? dragRef.disableHandle(handle) : dragRef.enableHandle(handle);
|
|
});
|
|
}
|
|
}
|
|
CdkDrag.ɵfac = function CdkDrag_Factory(t) { return new (t || CdkDrag)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(CDK_DROP_LIST, 12), ɵngcc0.ɵɵdirectiveInject(DOCUMENT), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ViewContainerRef), ɵngcc0.ɵɵdirectiveInject(CDK_DRAG_CONFIG, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc1.Directionality, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.DragDrop), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(CDK_DRAG_HANDLE, 10), ɵngcc0.ɵɵdirectiveInject(CDK_DRAG_PARENT, 12)); };
|
|
CdkDrag.ɵdir = /*@__PURE__*/ ɵngcc0.ɵɵdefineDirective({ type: CdkDrag, selectors: [["", "cdkDrag", ""]], contentQueries: function CdkDrag_ContentQueries(rf, ctx, dirIndex) { if (rf & 1) {
|
|
ɵngcc0.ɵɵcontentQuery(dirIndex, CDK_DRAG_PREVIEW, 5);
|
|
ɵngcc0.ɵɵcontentQuery(dirIndex, CDK_DRAG_PLACEHOLDER, 5);
|
|
ɵngcc0.ɵɵcontentQuery(dirIndex, CDK_DRAG_HANDLE, 5);
|
|
} if (rf & 2) {
|
|
let _t;
|
|
ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._previewTemplate = _t.first);
|
|
ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._placeholderTemplate = _t.first);
|
|
ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._handles = _t);
|
|
} }, hostAttrs: [1, "cdk-drag"], hostVars: 4, hostBindings: function CdkDrag_HostBindings(rf, ctx) { if (rf & 2) {
|
|
ɵngcc0.ɵɵclassProp("cdk-drag-disabled", ctx.disabled)("cdk-drag-dragging", ctx._dragRef.isDragging());
|
|
} }, inputs: { disabled: ["cdkDragDisabled", "disabled"], dragStartDelay: ["cdkDragStartDelay", "dragStartDelay"], lockAxis: ["cdkDragLockAxis", "lockAxis"], constrainPosition: ["cdkDragConstrainPosition", "constrainPosition"], previewClass: ["cdkDragPreviewClass", "previewClass"], boundaryElement: ["cdkDragBoundary", "boundaryElement"], rootElementSelector: ["cdkDragRootElement", "rootElementSelector"], previewContainer: ["cdkDragPreviewContainer", "previewContainer"], data: ["cdkDragData", "data"], freeDragPosition: ["cdkDragFreeDragPosition", "freeDragPosition"] }, outputs: { started: "cdkDragStarted", released: "cdkDragReleased", ended: "cdkDragEnded", entered: "cdkDragEntered", exited: "cdkDragExited", dropped: "cdkDragDropped", moved: "cdkDragMoved" }, exportAs: ["cdkDrag"], features: [ɵngcc0.ɵɵProvidersFeature([{ provide: CDK_DRAG_PARENT, useExisting: CdkDrag }]), ɵngcc0.ɵɵNgOnChangesFeature] });
|
|
CdkDrag._dragInstances = [];
|
|
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 },
|
|
{ type: CdkDragHandle, decorators: [{ type: Optional }, { type: Self }, { type: Inject, args: [CDK_DRAG_HANDLE,] }] },
|
|
{ type: CdkDrag, decorators: [{ type: Optional }, { type: SkipSelf }, { type: Inject, args: [CDK_DRAG_PARENT,] }] }
|
|
];
|
|
CdkDrag.propDecorators = {
|
|
_handles: [{ type: ContentChildren, args: [CDK_DRAG_HANDLE, { descendants: true },] }],
|
|
_previewTemplate: [{ type: ContentChild, args: [CDK_DRAG_PREVIEW,] }],
|
|
_placeholderTemplate: [{ type: ContentChild, args: [CDK_DRAG_PLACEHOLDER,] }],
|
|
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',] }],
|
|
previewContainer: [{ type: Input, args: ['cdkDragPreviewContainer',] }],
|
|
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',] }]
|
|
};
|
|
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(CdkDrag, [{
|
|
type: Directive,
|
|
args: [{
|
|
selector: '[cdkDrag]',
|
|
exportAs: 'cdkDrag',
|
|
host: {
|
|
'class': DRAG_HOST_CLASS,
|
|
'[class.cdk-drag-disabled]': 'disabled',
|
|
'[class.cdk-drag-dragging]': '_dragRef.isDragging()'
|
|
},
|
|
providers: [{ provide: CDK_DRAG_PARENT, useExisting: CdkDrag }]
|
|
}]
|
|
}], function () { return [{ type: ɵngcc0.ElementRef }, { type: undefined, decorators: [{
|
|
type: Inject,
|
|
args: [CDK_DROP_LIST]
|
|
}, {
|
|
type: Optional
|
|
}, {
|
|
type: SkipSelf
|
|
}] }, { type: undefined, decorators: [{
|
|
type: Inject,
|
|
args: [DOCUMENT]
|
|
}] }, { type: ɵngcc0.NgZone }, { type: ɵngcc0.ViewContainerRef }, { type: undefined, decorators: [{
|
|
type: Optional
|
|
}, {
|
|
type: Inject,
|
|
args: [CDK_DRAG_CONFIG]
|
|
}] }, { type: ɵngcc1.Directionality, decorators: [{
|
|
type: Optional
|
|
}] }, { type: ɵngcc2.DragDrop }, { type: ɵngcc0.ChangeDetectorRef }, { type: ɵngcc3.CdkDragHandle, decorators: [{
|
|
type: Optional
|
|
}, {
|
|
type: Self
|
|
}, {
|
|
type: Inject,
|
|
args: [CDK_DRAG_HANDLE]
|
|
}] }, { type: CdkDrag, decorators: [{
|
|
type: Optional
|
|
}, {
|
|
type: SkipSelf
|
|
}, {
|
|
type: Inject,
|
|
args: [CDK_DRAG_PARENT]
|
|
}] }]; }, { 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']
|
|
}], disabled: [{
|
|
type: Input,
|
|
args: ['cdkDragDisabled']
|
|
}], dragStartDelay: [{
|
|
type: Input,
|
|
args: ['cdkDragStartDelay']
|
|
}], lockAxis: [{
|
|
type: Input,
|
|
args: ['cdkDragLockAxis']
|
|
}], constrainPosition: [{
|
|
type: Input,
|
|
args: ['cdkDragConstrainPosition']
|
|
}], previewClass: [{
|
|
type: Input,
|
|
args: ['cdkDragPreviewClass']
|
|
}], boundaryElement: [{
|
|
type: Input,
|
|
args: ['cdkDragBoundary']
|
|
}], rootElementSelector: [{
|
|
type: Input,
|
|
args: ['cdkDragRootElement']
|
|
}], previewContainer: [{
|
|
type: Input,
|
|
args: ['cdkDragPreviewContainer']
|
|
}], _handles: [{
|
|
type: ContentChildren,
|
|
args: [CDK_DRAG_HANDLE, { descendants: true }]
|
|
}], _previewTemplate: [{
|
|
type: ContentChild,
|
|
args: [CDK_DRAG_PREVIEW]
|
|
}], _placeholderTemplate: [{
|
|
type: ContentChild,
|
|
args: [CDK_DRAG_PLACEHOLDER]
|
|
}], data: [{
|
|
type: Input,
|
|
args: ['cdkDragData']
|
|
}], freeDragPosition: [{
|
|
type: Input,
|
|
args: ['cdkDragFreeDragPosition']
|
|
}] }); })();
|
|
/** Gets the closest ancestor of an element that matches a selector. */
|
|
function getClosestMatchingAncestor(element, selector) {
|
|
let currentElement = element.parentElement;
|
|
while (currentElement) {
|
|
// IE doesn't support `matches` so we have to fall back to `msMatchesSelector`.
|
|
if (currentElement.matches ? currentElement.matches(selector) :
|
|
currentElement.msMatchesSelector(selector)) {
|
|
return currentElement;
|
|
}
|
|
currentElement = currentElement.parentElement;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"drag.js","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  Input,\n  NgZone,\n  OnDestroy,\n  Optional,\n  Output,\n  QueryList,\n  SkipSelf,\n  ViewContainerRef,\n  OnChanges,\n  SimpleChanges,\n  ChangeDetectorRef,\n  Self,\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 {CDK_DRAG_HANDLE, CdkDragHandle} from './drag-handle';\nimport {CDK_DRAG_PLACEHOLDER, CdkDragPlaceholder} from './drag-placeholder';\nimport {CDK_DRAG_PREVIEW, CdkDragPreview} from './drag-preview';\nimport {CDK_DRAG_PARENT} from '../drag-parent';\nimport {DragRef, Point, PreviewContainer} from '../drag-ref';\nimport {CDK_DROP_LIST, CdkDropListInternal as CdkDropList} from './drop-list';\nimport {DragDrop} from '../drag-drop';\nimport {CDK_DRAG_CONFIG, DragDropConfig, DragStartDelay, DragAxis} from './config';\nimport {assertElementNode} from './assertions';\n\nconst DRAG_HOST_CLASS = 'cdk-drag';\n\n/** Element that can be moved inside a CdkDropList container. */\n@Directive({\n  selector: '[cdkDrag]',\n  exportAs: 'cdkDrag',\n  host: {\n    'class': DRAG_HOST_CLASS,\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 readonly _destroyed = new Subject<void>();\n  private static _dragInstances: CdkDrag[] = [];\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(CDK_DRAG_HANDLE, {descendants: true}) _handles: QueryList<CdkDragHandle>;\n\n  /** Element that will be used as a template to create the draggable item's preview. */\n  @ContentChild(CDK_DRAG_PREVIEW) _previewTemplate: CdkDragPreview;\n\n  /** Template for placeholder element rendered to show where a draggable would be dropped. */\n  @ContentChild(CDK_DRAG_PLACEHOLDER) _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  /**\n   * Configures the place into which the preview of the item will be inserted. Can be configured\n   * globally through `CDK_DROP_LIST`. Possible values:\n   * - `global` - Preview will be inserted at the bottom of the `<body>`. The advantage is that\n   * you don't have to worry about `overflow: hidden` or `z-index`, but the item won't retain\n   * its inherited styles.\n   * - `parent` - Preview will be inserted into the parent of the drag item. The advantage is that\n   * inherited styles will be preserved, but it may be clipped by `overflow: hidden` or not be\n   * visible due to `z-index`. Furthermore, the preview is going to have an effect over selectors\n   * like `:nth-child` and some flexbox configurations.\n   * - `ElementRef<HTMLElement> | HTMLElement` - Preview will be inserted into a specific element.\n   * Same advantages and disadvantages as `parent`.\n   */\n  @Input('cdkDragPreviewContainer') previewContainer: PreviewContainer;\n\n  /** Emits when the user starts dragging the item. */\n  @Output('cdkDragStarted') readonly started: EventEmitter<CdkDragStart> =\n      new EventEmitter<CdkDragStart>();\n\n  /** Emits when the user has released a drag item, before any animations have started. */\n  @Output('cdkDragReleased') readonly released: EventEmitter<CdkDragRelease> =\n      new EventEmitter<CdkDragRelease>();\n\n  /** Emits when the user stops dragging an item in the container. */\n  @Output('cdkDragEnded') readonly ended: EventEmitter<CdkDragEnd> = new EventEmitter<CdkDragEnd>();\n\n  /** Emits when the user has moved the item into a new container. */\n  @Output('cdkDragEntered') readonly 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') readonly exited: EventEmitter<CdkDragExit<any>> =\n      new EventEmitter<CdkDragExit<any>>();\n\n  /** Emits when the user drops the item inside a container. */\n  @Output('cdkDragDropped') readonly 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')\n  readonly 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      /**\n       * @deprecated `_document` parameter no longer being used and will be removed.\n       * @breaking-change 12.0.0\n       */\n      @Inject(DOCUMENT) _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      @Optional() @Self() @Inject(CDK_DRAG_HANDLE) private _selfHandle?: CdkDragHandle,\n      @Optional() @SkipSelf() @Inject(CDK_DRAG_PARENT) private _parentDrag?: CdkDrag) {\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      zIndex: config?.zIndex,\n    });\n    this._dragRef.data = this;\n\n    // We have to keep track of the drag instances in order to be able to match an element to\n    // a drag instance. We can't go through the global registry of `DragRef`, because the root\n    // element could be different.\n    CdkDrag._dragInstances.push(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 by\n    // assigning the drop container both from here and the list.\n    if (dropContainer) {\n      this._dragRef._withDropContainer(dropContainer._dropListRef);\n      dropContainer.addItem(this);\n    }\n\n    this._syncInputs(this._dragRef);\n    this._handleEvents(this._dragRef);\n  }\n\n  /**\n   * Returns the element that is being used as a placeholder\n   * while the current element is being dragged.\n   */\n  getPlaceholderElement(): HTMLElement {\n    return this._dragRef.getPlaceholderElement();\n  }\n\n  /** Returns the root draggable element. */\n  getRootElement(): HTMLElement {\n    return this._dragRef.getRootElement();\n  }\n\n  /** Resets a standalone drag item to its initial position. */\n  reset(): void {\n    this._dragRef.reset();\n  }\n\n  /**\n   * Gets the pixel coordinates of the draggable outside of a drop container.\n   */\n  getFreeDragPosition(): {readonly x: number, readonly y: number} {\n    return this._dragRef.getFreeDragPosition();\n  }\n\n  ngAfterViewInit() {\n    // Normally this isn't in the zone, but it can cause major performance regressions for apps\n    // using `zone-patch-rxjs` because it'll trigger a change detection when it unsubscribes.\n    this._ngZone.runOutsideAngular(() => {\n      // We need to wait for the zone to stabilize, in order for the reference\n      // element to be in the proper place in the DOM. This is mostly relevant\n      // for draggable elements inside portals since they get stamped out in\n      // their original DOM position and then they get transferred to the portal.\n      this._ngZone.onStable\n        .pipe(take(1), takeUntil(this._destroyed))\n        .subscribe(() => {\n          this._updateRootElement();\n          this._setupHandlesListener();\n\n          if (this.freeDragPosition) {\n            this._dragRef.setFreeDragPosition(this.freeDragPosition);\n          }\n        });\n    });\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    const rootSelectorChange = changes['rootElementSelector'];\n    const positionChange = changes['freeDragPosition'];\n\n    // We don't have to react to the first change since it's being\n    // handled in `ngAfterViewInit` where it needs to be deferred.\n    if (rootSelectorChange && !rootSelectorChange.firstChange) {\n      this._updateRootElement();\n    }\n\n    // Skip the first change since it's being handled in `ngAfterViewInit`.\n    if (positionChange && !positionChange.firstChange && this.freeDragPosition) {\n      this._dragRef.setFreeDragPosition(this.freeDragPosition);\n    }\n  }\n\n  ngOnDestroy() {\n    if (this.dropContainer) {\n      this.dropContainer.removeItem(this);\n    }\n\n    const index = CdkDrag._dragInstances.indexOf(this);\n    if (index > -1) {\n      CdkDrag._dragInstances.splice(index, 1);\n    }\n\n    // Unnecessary in most cases, but used to avoid extra change detections with `zone-paths-rxjs`.\n    this._ngZone.runOutsideAngular(() => {\n      this._destroyed.next();\n      this._destroyed.complete();\n      this._dragRef.dispose();\n    });\n  }\n\n  /** Syncs the root element with the `DragRef`. */\n  private _updateRootElement() {\n    const element = this.element.nativeElement;\n    const rootElement = this.rootElementSelector ?\n        getClosestMatchingAncestor(element, this.rootElementSelector) : element;\n\n    if (rootElement && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      assertElementNode(rootElement, 'cdkDrag');\n    }\n\n    this._dragRef.withRootElement(rootElement || element);\n  }\n\n  /** Gets the boundary element, based on the `boundaryElement` value. */\n  private _getBoundaryElement() {\n    const boundary = this.boundaryElement;\n\n    if (!boundary) {\n      return null;\n    }\n\n    if (typeof boundary === 'string') {\n      return getClosestMatchingAncestor(this.element.nativeElement, boundary);\n    }\n\n    const element = coerceElement(boundary);\n\n    if ((typeof ngDevMode === 'undefined' || ngDevMode) &&\n      !element.contains(this.element.nativeElement)) {\n      throw Error('Draggable element is not inside of the node passed into cdkDragBoundary.');\n    }\n\n    return element;\n  }\n\n  /** Syncs the inputs of the CdkDrag with the options of the underlying DragRef. */\n  private _syncInputs(ref: DragRef<CdkDrag<T>>) {\n    ref.beforeStarted.subscribe(() => {\n      if (!ref.isDragging()) {\n        const dir = this._dir;\n        const dragStartDelay = this.dragStartDelay;\n        const placeholder = this._placeholderTemplate ? {\n          template: this._placeholderTemplate.templateRef,\n          context: this._placeholderTemplate.data,\n          viewContainer: this._viewContainerRef\n        } : null;\n        const preview = this._previewTemplate ? {\n          template: this._previewTemplate.templateRef,\n          context: this._previewTemplate.data,\n          matchSize: this._previewTemplate.matchSize,\n          viewContainer: this._viewContainerRef\n        } : null;\n\n        ref.disabled = this.disabled;\n        ref.lockAxis = this.lockAxis;\n        ref.dragStartDelay = (typeof dragStartDelay === 'object' && dragStartDelay) ?\n            dragStartDelay : coerceNumberProperty(dragStartDelay);\n        ref.constrainPosition = this.constrainPosition;\n        ref.previewClass = this.previewClass;\n        ref\n          .withBoundaryElement(this._getBoundaryElement())\n          .withPlaceholderTemplate(placeholder)\n          .withPreviewTemplate(preview)\n          .withPreviewContainer(this.previewContainer || 'global');\n\n        if (dir) {\n          ref.withDirection(dir.value);\n        }\n      }\n    });\n\n    // This only needs to be resolved once.\n    ref.beforeStarted.pipe(take(1)).subscribe(() => {\n      // If we managed to resolve a parent through DI, use it.\n      if (this._parentDrag) {\n        ref.withParent(this._parentDrag._dragRef);\n        return;\n      }\n\n      // Otherwise fall back to resolving the parent by looking up the DOM. This can happen if\n      // the item was projected into another item by something like `ngTemplateOutlet`.\n      let parent = this.element.nativeElement.parentElement;\n      while (parent) {\n        // `classList` needs to be null checked, because IE doesn't have it on some elements.\n        if (parent.classList?.contains(DRAG_HOST_CLASS)) {\n          ref.withParent(CdkDrag._dragInstances.find(drag => {\n            return drag.element.nativeElement === parent;\n          })?._dragRef || null);\n          break;\n        }\n        parent = parent.parentElement;\n      }\n    });\n  }\n\n  /** Handles the events from the underlying `DragRef`. */\n  private _handleEvents(ref: DragRef<CdkDrag<T>>) {\n    ref.started.subscribe(() => {\n      this.started.emit({source: this});\n\n      // Since all of these events run outside of change detection,\n      // we need to ensure that everything is marked correctly.\n      this._changeDetectorRef.markForCheck();\n    });\n\n    ref.released.subscribe(() => {\n      this.released.emit({source: this});\n    });\n\n    ref.ended.subscribe(event => {\n      this.ended.emit({\n        source: this,\n        distance: event.distance,\n        dropPoint: event.dropPoint\n      });\n\n      // Since all of these events run outside of change detection,\n      // we need to ensure that everything is marked correctly.\n      this._changeDetectorRef.markForCheck();\n    });\n\n    ref.entered.subscribe(event => {\n      this.entered.emit({\n        container: event.container.data,\n        item: this,\n        currentIndex: event.currentIndex\n      });\n    });\n\n    ref.exited.subscribe(event => {\n      this.exited.emit({\n        container: event.container.data,\n        item: this\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        isPointerOverContainer: event.isPointerOverContainer,\n        item: this,\n        distance: event.distance,\n        dropPoint: event.dropPoint\n      });\n    });\n  }\n\n  /** Assigns the default input values based on a provided config object. */\n  private _assignDefaults(config: DragDropConfig) {\n    const {\n      lockAxis, dragStartDelay, constrainPosition, previewClass, boundaryElement, draggingDisabled,\n      rootElementSelector, previewContainer\n    } = config;\n\n    this.disabled = draggingDisabled == null ? false : draggingDisabled;\n    this.dragStartDelay = dragStartDelay || 0;\n\n    if (lockAxis) {\n      this.lockAxis = lockAxis;\n    }\n\n    if (constrainPosition) {\n      this.constrainPosition = constrainPosition;\n    }\n\n    if (previewClass) {\n      this.previewClass = previewClass;\n    }\n\n    if (boundaryElement) {\n      this.boundaryElement = boundaryElement;\n    }\n\n    if (rootElementSelector) {\n      this.rootElementSelector = rootElementSelector;\n    }\n\n    if (previewContainer) {\n      this.previewContainer = previewContainer;\n    }\n  }\n\n  /** Sets up the listener that syncs the handles with the drag ref. */\n  private _setupHandlesListener() {\n    // Listen for any newly-added handles.\n    this._handles.changes.pipe(\n      startWith(this._handles),\n      // Sync the new handles with the DragRef.\n      tap((handles: QueryList<CdkDragHandle>) => {\n        const childHandleElements = handles\n          .filter(handle => handle._parentDrag === this)\n          .map(handle => handle.element);\n\n        // Usually handles are only allowed to be a descendant of the drag element, but if\n        // the consumer defined a different drag root, we should allow the drag element\n        // itself to be a handle too.\n        if (this._selfHandle && this.rootElementSelector) {\n          childHandleElements.push(this.element);\n        }\n\n        this._dragRef.withHandles(childHandleElements);\n      }),\n      // Listen if the state of any of the handles changes.\n      switchMap((handles: QueryList<CdkDragHandle>) => {\n        return merge(...handles.map(item => {\n          return item._stateChanges.pipe(startWith(item));\n        })) as Observable<CdkDragHandle>;\n      }),\n      takeUntil(this._destroyed)\n    ).subscribe(handleInstance => {\n      // Enabled/disable the handle that changed in the DragRef.\n      const dragRef = this._dragRef;\n      const handle = handleInstance.element.nativeElement;\n      handleInstance.disabled ? dragRef.disableHandle(handle) : dragRef.enableHandle(handle);\n    });\n  }\n\n  static ngAcceptInputType_disabled: BooleanInput;\n}\n\n/** Gets the closest ancestor of an element that matches a selector. */\nfunction getClosestMatchingAncestor(element: HTMLElement, selector: string) {\n  let currentElement = element.parentElement as HTMLElement | null;\n\n  while (currentElement) {\n    // IE doesn't support `matches` so we have to fall back to `msMatchesSelector`.\n    if (currentElement.matches ? currentElement.matches(selector) :\n        (currentElement as any).msMatchesSelector(selector)) {\n      return currentElement;\n    }\n\n    currentElement = currentElement.parentElement;\n  }\n\n  return null;\n}\n"]}
|