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.
238 lines
34 KiB
238 lines
34 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 { Injectable, NgZone, Inject } from '@angular/core';
|
|
import { DOCUMENT } from '@angular/common';
|
|
import { normalizePassiveListenerOptions } from '@angular/cdk/platform';
|
|
import { merge, Observable, Subject } from 'rxjs';
|
|
import * as i0 from "@angular/core";
|
|
import * as i1 from "@angular/common";
|
|
/** Event options that can be used to bind an active, capturing event. */
|
|
import * as ɵngcc0 from '@angular/core';
|
|
const activeCapturingEventOptions = normalizePassiveListenerOptions({
|
|
passive: false,
|
|
capture: true
|
|
});
|
|
/**
|
|
* Service that keeps track of all the drag item and drop container
|
|
* instances, and manages global event listeners on the `document`.
|
|
* @docs-private
|
|
*/
|
|
// Note: this class is generic, rather than referencing CdkDrag and CdkDropList directly, in order
|
|
// to avoid circular imports. If we were to reference them here, importing the registry into the
|
|
// classes that are registering themselves will introduce a circular import.
|
|
export class DragDropRegistry {
|
|
constructor(_ngZone, _document) {
|
|
this._ngZone = _ngZone;
|
|
/** Registered drop container instances. */
|
|
this._dropInstances = new Set();
|
|
/** Registered drag item instances. */
|
|
this._dragInstances = new Set();
|
|
/** Drag item instances that are currently being dragged. */
|
|
this._activeDragInstances = [];
|
|
/** Keeps track of the event listeners that we've bound to the `document`. */
|
|
this._globalListeners = new Map();
|
|
/**
|
|
* Predicate function to check if an item is being dragged. Moved out into a property,
|
|
* because it'll be called a lot and we don't want to create a new function every time.
|
|
*/
|
|
this._draggingPredicate = (item) => item.isDragging();
|
|
/**
|
|
* Emits the `touchmove` or `mousemove` events that are dispatched
|
|
* while the user is dragging a drag item instance.
|
|
*/
|
|
this.pointerMove = new Subject();
|
|
/**
|
|
* Emits the `touchend` or `mouseup` events that are dispatched
|
|
* while the user is dragging a drag item instance.
|
|
*/
|
|
this.pointerUp = new Subject();
|
|
/**
|
|
* Emits when the viewport has been scrolled while the user is dragging an item.
|
|
* @deprecated To be turned into a private member. Use the `scrolled` method instead.
|
|
* @breaking-change 13.0.0
|
|
*/
|
|
this.scroll = new Subject();
|
|
/**
|
|
* Event listener that will prevent the default browser action while the user is dragging.
|
|
* @param event Event whose default action should be prevented.
|
|
*/
|
|
this._preventDefaultWhileDragging = (event) => {
|
|
if (this._activeDragInstances.length > 0) {
|
|
event.preventDefault();
|
|
}
|
|
};
|
|
/** Event listener for `touchmove` that is bound even if no dragging is happening. */
|
|
this._persistentTouchmoveListener = (event) => {
|
|
if (this._activeDragInstances.length > 0) {
|
|
// Note that we only want to prevent the default action after dragging has actually started.
|
|
// Usually this is the same time at which the item is added to the `_activeDragInstances`,
|
|
// but it could be pushed back if the user has set up a drag delay or threshold.
|
|
if (this._activeDragInstances.some(this._draggingPredicate)) {
|
|
event.preventDefault();
|
|
}
|
|
this.pointerMove.next(event);
|
|
}
|
|
};
|
|
this._document = _document;
|
|
}
|
|
/** Adds a drop container to the registry. */
|
|
registerDropContainer(drop) {
|
|
if (!this._dropInstances.has(drop)) {
|
|
this._dropInstances.add(drop);
|
|
}
|
|
}
|
|
/** Adds a drag item instance to the registry. */
|
|
registerDragItem(drag) {
|
|
this._dragInstances.add(drag);
|
|
// The `touchmove` event gets bound once, ahead of time, because WebKit
|
|
// won't preventDefault on a dynamically-added `touchmove` listener.
|
|
// See https://bugs.webkit.org/show_bug.cgi?id=184250.
|
|
if (this._dragInstances.size === 1) {
|
|
this._ngZone.runOutsideAngular(() => {
|
|
// The event handler has to be explicitly active,
|
|
// because newer browsers make it passive by default.
|
|
this._document.addEventListener('touchmove', this._persistentTouchmoveListener, activeCapturingEventOptions);
|
|
});
|
|
}
|
|
}
|
|
/** Removes a drop container from the registry. */
|
|
removeDropContainer(drop) {
|
|
this._dropInstances.delete(drop);
|
|
}
|
|
/** Removes a drag item instance from the registry. */
|
|
removeDragItem(drag) {
|
|
this._dragInstances.delete(drag);
|
|
this.stopDragging(drag);
|
|
if (this._dragInstances.size === 0) {
|
|
this._document.removeEventListener('touchmove', this._persistentTouchmoveListener, activeCapturingEventOptions);
|
|
}
|
|
}
|
|
/**
|
|
* Starts the dragging sequence for a drag instance.
|
|
* @param drag Drag instance which is being dragged.
|
|
* @param event Event that initiated the dragging.
|
|
*/
|
|
startDragging(drag, event) {
|
|
// Do not process the same drag twice to avoid memory leaks and redundant listeners
|
|
if (this._activeDragInstances.indexOf(drag) > -1) {
|
|
return;
|
|
}
|
|
this._activeDragInstances.push(drag);
|
|
if (this._activeDragInstances.length === 1) {
|
|
const isTouchEvent = event.type.startsWith('touch');
|
|
// We explicitly bind __active__ listeners here, because newer browsers will default to
|
|
// passive ones for `mousemove` and `touchmove`. The events need to be active, because we
|
|
// use `preventDefault` to prevent the page from scrolling while the user is dragging.
|
|
this._globalListeners
|
|
.set(isTouchEvent ? 'touchend' : 'mouseup', {
|
|
handler: (e) => this.pointerUp.next(e),
|
|
options: true
|
|
})
|
|
.set('scroll', {
|
|
handler: (e) => this.scroll.next(e),
|
|
// Use capturing so that we pick up scroll changes in any scrollable nodes that aren't
|
|
// the document. See https://github.com/angular/components/issues/17144.
|
|
options: true
|
|
})
|
|
// Preventing the default action on `mousemove` isn't enough to disable text selection
|
|
// on Safari so we need to prevent the selection event as well. Alternatively this can
|
|
// be done by setting `user-select: none` on the `body`, however it has causes a style
|
|
// recalculation which can be expensive on pages with a lot of elements.
|
|
.set('selectstart', {
|
|
handler: this._preventDefaultWhileDragging,
|
|
options: activeCapturingEventOptions
|
|
});
|
|
// We don't have to bind a move event for touch drag sequences, because
|
|
// we already have a persistent global one bound from `registerDragItem`.
|
|
if (!isTouchEvent) {
|
|
this._globalListeners.set('mousemove', {
|
|
handler: (e) => this.pointerMove.next(e),
|
|
options: activeCapturingEventOptions
|
|
});
|
|
}
|
|
this._ngZone.runOutsideAngular(() => {
|
|
this._globalListeners.forEach((config, name) => {
|
|
this._document.addEventListener(name, config.handler, config.options);
|
|
});
|
|
});
|
|
}
|
|
}
|
|
/** Stops dragging a drag item instance. */
|
|
stopDragging(drag) {
|
|
const index = this._activeDragInstances.indexOf(drag);
|
|
if (index > -1) {
|
|
this._activeDragInstances.splice(index, 1);
|
|
if (this._activeDragInstances.length === 0) {
|
|
this._clearGlobalListeners();
|
|
}
|
|
}
|
|
}
|
|
/** Gets whether a drag item instance is currently being dragged. */
|
|
isDragging(drag) {
|
|
return this._activeDragInstances.indexOf(drag) > -1;
|
|
}
|
|
/**
|
|
* Gets a stream that will emit when any element on the page is scrolled while an item is being
|
|
* dragged.
|
|
* @param shadowRoot Optional shadow root that the current dragging sequence started from.
|
|
* Top-level listeners won't pick up events coming from the shadow DOM so this parameter can
|
|
* be used to include an additional top-level listener at the shadow root level.
|
|
*/
|
|
scrolled(shadowRoot) {
|
|
const streams = [this.scroll];
|
|
if (shadowRoot && shadowRoot !== this._document) {
|
|
// Note that this is basically the same as `fromEvent` from rjxs, but we do it ourselves,
|
|
// because we want to guarantee that the event is bound outside of the `NgZone`. With
|
|
// `fromEvent` it'll only happen if the subscription is outside the `NgZone`.
|
|
streams.push(new Observable((observer) => {
|
|
return this._ngZone.runOutsideAngular(() => {
|
|
const eventOptions = true;
|
|
const callback = (event) => {
|
|
if (this._activeDragInstances.length) {
|
|
observer.next(event);
|
|
}
|
|
};
|
|
shadowRoot.addEventListener('scroll', callback, eventOptions);
|
|
return () => {
|
|
shadowRoot.removeEventListener('scroll', callback, eventOptions);
|
|
};
|
|
});
|
|
}));
|
|
}
|
|
return merge(...streams);
|
|
}
|
|
ngOnDestroy() {
|
|
this._dragInstances.forEach(instance => this.removeDragItem(instance));
|
|
this._dropInstances.forEach(instance => this.removeDropContainer(instance));
|
|
this._clearGlobalListeners();
|
|
this.pointerMove.complete();
|
|
this.pointerUp.complete();
|
|
}
|
|
/** Clears out the global event listeners from the `document`. */
|
|
_clearGlobalListeners() {
|
|
this._globalListeners.forEach((config, name) => {
|
|
this._document.removeEventListener(name, config.handler, config.options);
|
|
});
|
|
this._globalListeners.clear();
|
|
}
|
|
}
|
|
DragDropRegistry.ɵfac = function DragDropRegistry_Factory(t) { return new (t || DragDropRegistry)(ɵngcc0.ɵɵinject(ɵngcc0.NgZone), ɵngcc0.ɵɵinject(DOCUMENT)); };
|
|
DragDropRegistry.ɵprov = i0.ɵɵdefineInjectable({ factory: function DragDropRegistry_Factory() { return new DragDropRegistry(i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i1.DOCUMENT)); }, token: DragDropRegistry, providedIn: "root" });
|
|
DragDropRegistry.ctorParameters = () => [
|
|
{ type: NgZone },
|
|
{ type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
|
|
];
|
|
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(DragDropRegistry, [{
|
|
type: Injectable,
|
|
args: [{ providedIn: 'root' }]
|
|
}], function () { return [{ type: ɵngcc0.NgZone }, { type: undefined, decorators: [{
|
|
type: Inject,
|
|
args: [DOCUMENT]
|
|
}] }]; }, null); })();
|
|
|
|
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"drag-drop-registry.js","sources":["../../../../../../src/cdk/drag-drop/drag-drop-registry.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 {Injectable, NgZone, OnDestroy, Inject} from '@angular/core';\nimport {DOCUMENT} from '@angular/common';\nimport {normalizePassiveListenerOptions} from '@angular/cdk/platform';\nimport {merge, Observable, Observer, Subject} from 'rxjs';\n\n/** Event options that can be used to bind an active, capturing event. */\nconst activeCapturingEventOptions = normalizePassiveListenerOptions({\n  passive: false,\n  capture: true\n});\n\n/**\n * Service that keeps track of all the drag item and drop container\n * instances, and manages global event listeners on the `document`.\n * @docs-private\n */\n// Note: this class is generic, rather than referencing CdkDrag and CdkDropList directly, in order\n// to avoid circular imports. If we were to reference them here, importing the registry into the\n// classes that are registering themselves will introduce a circular import.\n@Injectable({providedIn: 'root'})\nexport class DragDropRegistry<I extends {isDragging(): boolean}, C> implements OnDestroy {\n  private _document: Document;\n\n  /** Registered drop container instances. */\n  private _dropInstances = new Set<C>();\n\n  /** Registered drag item instances. */\n  private _dragInstances = new Set<I>();\n\n  /** Drag item instances that are currently being dragged. */\n  private _activeDragInstances: I[] = [];\n\n  /** Keeps track of the event listeners that we've bound to the `document`. */\n  private _globalListeners = new Map<string, {\n    handler: (event: Event) => void,\n    options?: AddEventListenerOptions | boolean\n  }>();\n\n  /**\n   * Predicate function to check if an item is being dragged.  Moved out into a property,\n   * because it'll be called a lot and we don't want to create a new function every time.\n   */\n  private _draggingPredicate = (item: I) => item.isDragging();\n\n  /**\n   * Emits the `touchmove` or `mousemove` events that are dispatched\n   * while the user is dragging a drag item instance.\n   */\n  readonly pointerMove: Subject<TouchEvent | MouseEvent> = new Subject<TouchEvent | MouseEvent>();\n\n  /**\n   * Emits the `touchend` or `mouseup` events that are dispatched\n   * while the user is dragging a drag item instance.\n   */\n  readonly pointerUp: Subject<TouchEvent | MouseEvent> = new Subject<TouchEvent | MouseEvent>();\n\n  /**\n   * Emits when the viewport has been scrolled while the user is dragging an item.\n   * @deprecated To be turned into a private member. Use the `scrolled` method instead.\n   * @breaking-change 13.0.0\n   */\n  readonly scroll: Subject<Event> = new Subject<Event>();\n\n  constructor(\n    private _ngZone: NgZone,\n    @Inject(DOCUMENT) _document: any) {\n    this._document = _document;\n  }\n\n  /** Adds a drop container to the registry. */\n  registerDropContainer(drop: C) {\n    if (!this._dropInstances.has(drop)) {\n      this._dropInstances.add(drop);\n    }\n  }\n\n  /** Adds a drag item instance to the registry. */\n  registerDragItem(drag: I) {\n    this._dragInstances.add(drag);\n\n    // The `touchmove` event gets bound once, ahead of time, because WebKit\n    // won't preventDefault on a dynamically-added `touchmove` listener.\n    // See https://bugs.webkit.org/show_bug.cgi?id=184250.\n    if (this._dragInstances.size === 1) {\n      this._ngZone.runOutsideAngular(() => {\n        // The event handler has to be explicitly active,\n        // because newer browsers make it passive by default.\n        this._document.addEventListener('touchmove', this._persistentTouchmoveListener,\n            activeCapturingEventOptions);\n      });\n    }\n  }\n\n  /** Removes a drop container from the registry. */\n  removeDropContainer(drop: C) {\n    this._dropInstances.delete(drop);\n  }\n\n  /** Removes a drag item instance from the registry. */\n  removeDragItem(drag: I) {\n    this._dragInstances.delete(drag);\n    this.stopDragging(drag);\n\n    if (this._dragInstances.size === 0) {\n      this._document.removeEventListener('touchmove', this._persistentTouchmoveListener,\n          activeCapturingEventOptions);\n    }\n  }\n\n  /**\n   * Starts the dragging sequence for a drag instance.\n   * @param drag Drag instance which is being dragged.\n   * @param event Event that initiated the dragging.\n   */\n  startDragging(drag: I, event: TouchEvent | MouseEvent) {\n    // Do not process the same drag twice to avoid memory leaks and redundant listeners\n    if (this._activeDragInstances.indexOf(drag) > -1) {\n      return;\n    }\n\n    this._activeDragInstances.push(drag);\n\n    if (this._activeDragInstances.length === 1) {\n      const isTouchEvent = event.type.startsWith('touch');\n\n      // We explicitly bind __active__ listeners here, because newer browsers will default to\n      // passive ones for `mousemove` and `touchmove`. The events need to be active, because we\n      // use `preventDefault` to prevent the page from scrolling while the user is dragging.\n      this._globalListeners\n        .set(isTouchEvent ? 'touchend' : 'mouseup', {\n          handler: (e: Event) => this.pointerUp.next(e as TouchEvent | MouseEvent),\n          options: true\n        })\n        .set('scroll', {\n          handler: (e: Event) => this.scroll.next(e),\n          // Use capturing so that we pick up scroll changes in any scrollable nodes that aren't\n          // the document. See https://github.com/angular/components/issues/17144.\n          options: true\n        })\n        // Preventing the default action on `mousemove` isn't enough to disable text selection\n        // on Safari so we need to prevent the selection event as well. Alternatively this can\n        // be done by setting `user-select: none` on the `body`, however it has causes a style\n        // recalculation which can be expensive on pages with a lot of elements.\n        .set('selectstart', {\n          handler: this._preventDefaultWhileDragging,\n          options: activeCapturingEventOptions\n        });\n\n      // We don't have to bind a move event for touch drag sequences, because\n      // we already have a persistent global one bound from `registerDragItem`.\n      if (!isTouchEvent) {\n        this._globalListeners.set('mousemove', {\n          handler: (e: Event) => this.pointerMove.next(e as MouseEvent),\n          options: activeCapturingEventOptions\n        });\n      }\n\n      this._ngZone.runOutsideAngular(() => {\n        this._globalListeners.forEach((config, name) => {\n          this._document.addEventListener(name, config.handler, config.options);\n        });\n      });\n    }\n  }\n\n  /** Stops dragging a drag item instance. */\n  stopDragging(drag: I) {\n    const index = this._activeDragInstances.indexOf(drag);\n\n    if (index > -1) {\n      this._activeDragInstances.splice(index, 1);\n\n      if (this._activeDragInstances.length === 0) {\n        this._clearGlobalListeners();\n      }\n    }\n  }\n\n  /** Gets whether a drag item instance is currently being dragged. */\n  isDragging(drag: I) {\n    return this._activeDragInstances.indexOf(drag) > -1;\n  }\n\n  /**\n   * Gets a stream that will emit when any element on the page is scrolled while an item is being\n   * dragged.\n   * @param shadowRoot Optional shadow root that the current dragging sequence started from.\n   *   Top-level listeners won't pick up events coming from the shadow DOM so this parameter can\n   *   be used to include an additional top-level listener at the shadow root level.\n   */\n  scrolled(shadowRoot?: DocumentOrShadowRoot | null): Observable<Event> {\n    const streams: Observable<Event>[] = [this.scroll];\n\n    if (shadowRoot && shadowRoot !== this._document) {\n      // Note that this is basically the same as `fromEvent` from rjxs, but we do it ourselves,\n      // because we want to guarantee that the event is bound outside of the `NgZone`. With\n      // `fromEvent` it'll only happen if the subscription is outside the `NgZone`.\n      streams.push(new Observable((observer: Observer<Event>) => {\n        return this._ngZone.runOutsideAngular(() => {\n          const eventOptions = true;\n          const callback = (event: Event) => {\n            if (this._activeDragInstances.length) {\n              observer.next(event);\n            }\n          };\n\n          (shadowRoot as ShadowRoot).addEventListener('scroll', callback, eventOptions);\n\n          return () => {\n            (shadowRoot as ShadowRoot).removeEventListener('scroll', callback, eventOptions);\n          };\n        });\n      }));\n    }\n\n    return merge(...streams);\n  }\n\n  ngOnDestroy() {\n    this._dragInstances.forEach(instance => this.removeDragItem(instance));\n    this._dropInstances.forEach(instance => this.removeDropContainer(instance));\n    this._clearGlobalListeners();\n    this.pointerMove.complete();\n    this.pointerUp.complete();\n  }\n\n  /**\n   * Event listener that will prevent the default browser action while the user is dragging.\n   * @param event Event whose default action should be prevented.\n   */\n  private _preventDefaultWhileDragging = (event: Event) => {\n    if (this._activeDragInstances.length > 0) {\n      event.preventDefault();\n    }\n  }\n\n  /** Event listener for `touchmove` that is bound even if no dragging is happening. */\n  private _persistentTouchmoveListener = (event: TouchEvent) => {\n    if (this._activeDragInstances.length > 0) {\n      // Note that we only want to prevent the default action after dragging has actually started.\n      // Usually this is the same time at which the item is added to the `_activeDragInstances`,\n      // but it could be pushed back if the user has set up a drag delay or threshold.\n      if (this._activeDragInstances.some(this._draggingPredicate)) {\n        event.preventDefault();\n      }\n\n      this.pointerMove.next(event);\n    }\n  }\n\n  /** Clears out the global event listeners from the `document`. */\n  private _clearGlobalListeners() {\n    this._globalListeners.forEach((config, name) => {\n      this._document.removeEventListener(name, config.handler, config.options);\n    });\n\n    this._globalListeners.clear();\n  }\n}\n"]}
|