ngx-pluto
Version:
336 lines • 28.7 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,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 { Injectable, NgZone, Inject } from '@angular/core';
import { DOCUMENT } from '@angular/common';
import { Subject } from 'rxjs';
import { normalizePassiveListenerOptions } from './utils/passive-listeners';
import * as i0 from "@angular/core";
import * as i1 from "@angular/common";
/**
* Event options that can be used to bind an active, capturing event.
* @type {?}
*/
const activeCapturingEventOptions = normalizePassiveListenerOptions({
passive: false,
capture: true
});
/**
* @ignore
* Service that keeps track of all the drag item and drop container
* instances, and manages global event listeners on the `document`.
* \@docs-private
* @template I, C
*/
// 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 {
/**
* @param {?} _ngZone
* @param {?} _document
*/
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 = new Set();
/**
* Keeps track of the event listeners that we've bound to the `document`.
*/
this._globalListeners = new Map();
/**
* 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();
/**
* 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 = (/**
* @param {?} event
* @return {?}
*/
(event) => {
if (this._activeDragInstances.size) {
event.preventDefault();
}
});
this._document = _document;
}
/**
* Adds a drop container to the registry.
* @param {?} drop
* @return {?}
*/
registerDropContainer(drop) {
if (!this._dropInstances.has(drop)) {
if (this.getDropContainer(drop.id)) {
throw Error(`Drop instance with id "${drop.id}" has already been registered.`);
}
this._dropInstances.add(drop);
}
}
/**
* Adds a drag item instance to the registry.
* @param {?} drag
* @return {?}
*/
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((/**
* @return {?}
*/
() => {
// The event handler has to be explicitly active,
// because newer browsers make it passive by default.
this._document.addEventListener('touchmove', this._preventDefaultWhileDragging, activeCapturingEventOptions);
}));
}
}
/**
* Removes a drop container from the registry.
* @param {?} drop
* @return {?}
*/
removeDropContainer(drop) {
this._dropInstances.delete(drop);
}
/**
* Removes a drag item instance from the registry.
* @param {?} drag
* @return {?}
*/
removeDragItem(drag) {
this._dragInstances.delete(drag);
this.stopDragging(drag);
if (this._dragInstances.size === 0) {
this._document.removeEventListener('touchmove', this._preventDefaultWhileDragging, activeCapturingEventOptions);
}
}
/**
* Starts the dragging sequence for a drag instance.
* @param {?} drag Drag instance which is being dragged.
* @param {?} event Event that initiated the dragging.
* @return {?}
*/
startDragging(drag, event) {
this._activeDragInstances.add(drag);
if (this._activeDragInstances.size === 1) {
/** @type {?} */
const isTouchEvent = event.type.startsWith('touch');
/** @type {?} */
const moveEvent = isTouchEvent ? 'touchmove' : 'mousemove';
/** @type {?} */
const upEvent = isTouchEvent ? 'touchend' : 'mouseup';
// 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(moveEvent, {
handler: (/**
* @param {?} e
* @return {?}
*/
(e) => this.pointerMove.next((/** @type {?} */ (e)))),
options: activeCapturingEventOptions
})
.set(upEvent, {
handler: (/**
* @param {?} e
* @return {?}
*/
(e) => this.pointerUp.next((/** @type {?} */ (e)))),
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
});
// TODO(crisbeto): prevent mouse wheel scrolling while
// dragging until we've set up proper scroll handling.
if (!isTouchEvent) {
this._globalListeners.set('wheel', {
handler: this._preventDefaultWhileDragging,
options: activeCapturingEventOptions
});
}
this._ngZone.runOutsideAngular((/**
* @return {?}
*/
() => {
this._globalListeners.forEach((/**
* @param {?} config
* @param {?} name
* @return {?}
*/
(config, name) => {
this._document.addEventListener(name, config.handler, config.options);
}));
}));
}
}
/**
* Stops dragging a drag item instance.
* @param {?} drag
* @return {?}
*/
stopDragging(drag) {
this._activeDragInstances.delete(drag);
if (this._activeDragInstances.size === 0) {
this._clearGlobalListeners();
}
}
/**
* Gets whether a drag item instance is currently being dragged.
* @param {?} drag
* @return {?}
*/
isDragging(drag) {
return this._activeDragInstances.has(drag);
}
/**
* Gets a drop container by its id.
* @deprecated No longer being used. To be removed.
* \@breaking-change 8.0.0
* @param {?} id
* @return {?}
*/
getDropContainer(id) {
return Array.from(this._dropInstances).find((/**
* @param {?} instance
* @return {?}
*/
instance => instance.id === id));
}
/**
* @return {?}
*/
ngOnDestroy() {
this._dragInstances.forEach((/**
* @param {?} instance
* @return {?}
*/
instance => this.removeDragItem(instance)));
this._dropInstances.forEach((/**
* @param {?} instance
* @return {?}
*/
instance => this.removeDropContainer(instance)));
this._clearGlobalListeners();
this.pointerMove.complete();
this.pointerUp.complete();
}
/**
* Clears out the global event listeners from the `document`.
* @private
* @return {?}
*/
_clearGlobalListeners() {
this._globalListeners.forEach((/**
* @param {?} config
* @param {?} name
* @return {?}
*/
(config, name) => {
this._document.removeEventListener(name, config.handler, config.options);
}));
this._globalListeners.clear();
}
}
DragDropRegistry.decorators = [
{ type: Injectable, args: [{ providedIn: 'root' },] }
];
/** @nocollapse */
DragDropRegistry.ctorParameters = () => [
{ type: NgZone },
{ type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
];
/** @nocollapse */ DragDropRegistry.ngInjectableDef = i0.defineInjectable({ factory: function DragDropRegistry_Factory() { return new DragDropRegistry(i0.inject(i0.NgZone), i0.inject(i1.DOCUMENT)); }, token: DragDropRegistry, providedIn: "root" });
if (false) {
/**
* @type {?}
* @private
*/
DragDropRegistry.prototype._document;
/**
* Registered drop container instances.
* @type {?}
* @private
*/
DragDropRegistry.prototype._dropInstances;
/**
* Registered drag item instances.
* @type {?}
* @private
*/
DragDropRegistry.prototype._dragInstances;
/**
* Drag item instances that are currently being dragged.
* @type {?}
* @private
*/
DragDropRegistry.prototype._activeDragInstances;
/**
* Keeps track of the event listeners that we've bound to the `document`.
* @type {?}
* @private
*/
DragDropRegistry.prototype._globalListeners;
/**
* Emits the `touchmove` or `mousemove` events that are dispatched
* while the user is dragging a drag item instance.
* @type {?}
*/
DragDropRegistry.prototype.pointerMove;
/**
* Emits the `touchend` or `mouseup` events that are dispatched
* while the user is dragging a drag item instance.
* @type {?}
*/
DragDropRegistry.prototype.pointerUp;
/**
* Event listener that will prevent the default browser action while the user is dragging.
* \@param event Event whose default action should be prevented.
* @type {?}
* @private
*/
DragDropRegistry.prototype._preventDefaultWhileDragging;
/**
* @type {?}
* @private
*/
DragDropRegistry.prototype._ngZone;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag-drop-registry.js","sourceRoot":"ng://ngx-pluto/","sources":["lib/drag-drop/drag-drop-registry.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * @license\r\n * Copyright Google LLC All Rights Reserved.\r\n *\r\n * Use of this source code is governed by an MIT-style license that can be\r\n * found in the LICENSE file at https://angular.io/license\r\n */\r\n\r\nimport {Injectable, NgZone, OnDestroy, Inject} from '@angular/core';\r\nimport {DOCUMENT} from '@angular/common';\r\nimport {Subject} from 'rxjs';\r\nimport { normalizePassiveListenerOptions } from './utils/passive-listeners';\r\n\r\n/** Event options that can be used to bind an active, capturing event. */\r\nconst activeCapturingEventOptions = normalizePassiveListenerOptions({\r\n  passive: false,\r\n  capture: true\r\n});\r\n\r\n/**\r\n * @ignore\r\n * Service that keeps track of all the drag item and drop container\r\n * instances, and manages global event listeners on the `document`.\r\n * @docs-private\r\n */\r\n// Note: this class is generic, rather than referencing CdkDrag and CdkDropList directly, in order\r\n// to avoid circular imports. If we were to reference them here, importing the registry into the\r\n// classes that are registering themselves will introduce a circular import.\r\n@Injectable({providedIn: 'root'})\r\nexport class DragDropRegistry<I, C extends {id: string}> implements OnDestroy {\r\n  private _document: Document;\r\n\r\n  /** Registered drop container instances. */\r\n  private _dropInstances = new Set<C>();\r\n\r\n  /** Registered drag item instances. */\r\n  private _dragInstances = new Set<I>();\r\n\r\n  /** Drag item instances that are currently being dragged. */\r\n  private _activeDragInstances = new Set<I>();\r\n\r\n  /** Keeps track of the event listeners that we've bound to the `document`. */\r\n  private _globalListeners = new Map<string, {\r\n    handler: (event: Event) => void,\r\n    options?: AddEventListenerOptions | boolean\r\n  }>();\r\n\r\n  /**\r\n   * Emits the `touchmove` or `mousemove` events that are dispatched\r\n   * while the user is dragging a drag item instance.\r\n   */\r\n  readonly pointerMove: Subject<TouchEvent | MouseEvent> = new Subject<TouchEvent | MouseEvent>();\r\n\r\n  /**\r\n   * Emits the `touchend` or `mouseup` events that are dispatched\r\n   * while the user is dragging a drag item instance.\r\n   */\r\n  readonly pointerUp: Subject<TouchEvent | MouseEvent> = new Subject<TouchEvent | MouseEvent>();\r\n\r\n  constructor(\r\n    private _ngZone: NgZone,\r\n    @Inject(DOCUMENT) _document: any) {\r\n    this._document = _document;\r\n  }\r\n\r\n  /** Adds a drop container to the registry. */\r\n  registerDropContainer(drop: C) {\r\n    if (!this._dropInstances.has(drop)) {\r\n      if (this.getDropContainer(drop.id)) {\r\n        throw Error(`Drop instance with id \"${drop.id}\" has already been registered.`);\r\n      }\r\n\r\n      this._dropInstances.add(drop);\r\n    }\r\n  }\r\n\r\n  /** Adds a drag item instance to the registry. */\r\n  registerDragItem(drag: I) {\r\n    this._dragInstances.add(drag);\r\n\r\n    // The `touchmove` event gets bound once, ahead of time, because WebKit\r\n    // won't preventDefault on a dynamically-added `touchmove` listener.\r\n    // See https://bugs.webkit.org/show_bug.cgi?id=184250.\r\n    if (this._dragInstances.size === 1) {\r\n      this._ngZone.runOutsideAngular(() => {\r\n        // The event handler has to be explicitly active,\r\n        // because newer browsers make it passive by default.\r\n        this._document.addEventListener('touchmove', this._preventDefaultWhileDragging,\r\n            activeCapturingEventOptions);\r\n      });\r\n    }\r\n  }\r\n\r\n  /** Removes a drop container from the registry. */\r\n  removeDropContainer(drop: C) {\r\n    this._dropInstances.delete(drop);\r\n  }\r\n\r\n  /** Removes a drag item instance from the registry. */\r\n  removeDragItem(drag: I) {\r\n    this._dragInstances.delete(drag);\r\n    this.stopDragging(drag);\r\n\r\n    if (this._dragInstances.size === 0) {\r\n      this._document.removeEventListener('touchmove', this._preventDefaultWhileDragging,\r\n          activeCapturingEventOptions);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Starts the dragging sequence for a drag instance.\r\n   * @param drag Drag instance which is being dragged.\r\n   * @param event Event that initiated the dragging.\r\n   */\r\n  startDragging(drag: I, event: TouchEvent | MouseEvent) {\r\n    this._activeDragInstances.add(drag);\r\n\r\n    if (this._activeDragInstances.size === 1) {\r\n      const isTouchEvent = event.type.startsWith('touch');\r\n      const moveEvent = isTouchEvent ? 'touchmove' : 'mousemove';\r\n      const upEvent = isTouchEvent ? 'touchend' : 'mouseup';\r\n\r\n      // We explicitly bind __active__ listeners here, because newer browsers will default to\r\n      // passive ones for `mousemove` and `touchmove`. The events need to be active, because we\r\n      // use `preventDefault` to prevent the page from scrolling while the user is dragging.\r\n      this._globalListeners\r\n        .set(moveEvent, {\r\n          handler: (e: Event) => this.pointerMove.next(e as TouchEvent | MouseEvent),\r\n          options: activeCapturingEventOptions\r\n        })\r\n        .set(upEvent, {\r\n          handler: (e: Event) => this.pointerUp.next(e as TouchEvent | MouseEvent),\r\n          options: true\r\n        })\r\n        // Preventing the default action on `mousemove` isn't enough to disable text selection\r\n        // on Safari so we need to prevent the selection event as well. Alternatively this can\r\n        // be done by setting `user-select: none` on the `body`, however it has causes a style\r\n        // recalculation which can be expensive on pages with a lot of elements.\r\n        .set('selectstart', {\r\n          handler: this._preventDefaultWhileDragging,\r\n          options: activeCapturingEventOptions\r\n        });\r\n\r\n      // TODO(crisbeto): prevent mouse wheel scrolling while\r\n      // dragging until we've set up proper scroll handling.\r\n      if (!isTouchEvent) {\r\n        this._globalListeners.set('wheel', {\r\n          handler: this._preventDefaultWhileDragging,\r\n          options: activeCapturingEventOptions\r\n        });\r\n      }\r\n\r\n      this._ngZone.runOutsideAngular(() => {\r\n        this._globalListeners.forEach((config, name) => {\r\n          this._document.addEventListener(name, config.handler, config.options);\r\n        });\r\n      });\r\n    }\r\n  }\r\n\r\n  /** Stops dragging a drag item instance. */\r\n  stopDragging(drag: I) {\r\n    this._activeDragInstances.delete(drag);\r\n\r\n    if (this._activeDragInstances.size === 0) {\r\n      this._clearGlobalListeners();\r\n    }\r\n  }\r\n\r\n  /** Gets whether a drag item instance is currently being dragged. */\r\n  isDragging(drag: I) {\r\n    return this._activeDragInstances.has(drag);\r\n  }\r\n\r\n  /**\r\n   * Gets a drop container by its id.\r\n   * @deprecated No longer being used. To be removed.\r\n   * @breaking-change 8.0.0\r\n   */\r\n  getDropContainer(id: string): C | undefined {\r\n    return Array.from(this._dropInstances).find(instance => instance.id === id);\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this._dragInstances.forEach(instance => this.removeDragItem(instance));\r\n    this._dropInstances.forEach(instance => this.removeDropContainer(instance));\r\n    this._clearGlobalListeners();\r\n    this.pointerMove.complete();\r\n    this.pointerUp.complete();\r\n  }\r\n\r\n  /**\r\n   * Event listener that will prevent the default browser action while the user is dragging.\r\n   * @param event Event whose default action should be prevented.\r\n   */\r\n  private _preventDefaultWhileDragging = (event: Event) => {\r\n    if (this._activeDragInstances.size) {\r\n      event.preventDefault();\r\n    }\r\n  }\r\n\r\n  /** Clears out the global event listeners from the `document`. */\r\n  private _clearGlobalListeners() {\r\n    this._globalListeners.forEach((config, name) => {\r\n      this._document.removeEventListener(name, config.handler, config.options);\r\n    });\r\n\r\n    this._globalListeners.clear();\r\n  }\r\n}\r\n"]}