ngx-pluto
Version:
858 lines • 84.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 { ElementRef } from '@angular/core';
import { Subject } from 'rxjs';
import { moveItemInArray } from './drag-utils';
/**
* Counter used to generate unique ids for drop refs.
* @type {?}
*/
let _uniqueIdCounter = 0;
/**
* Proximity, as a ratio to width/height, at which a
* dragged item will affect the drop container.
* @type {?}
*/
const DROP_PROXIMITY_THRESHOLD = 0.05;
/**
* @ignore
* Entry in the position cache for draggable items.
* \@docs-private
* @record
*/
function CachedItemPosition() { }
if (false) {
/**
* Instance of the drag item.
* @type {?}
*/
CachedItemPosition.prototype.drag;
/**
* Dimensions of the item.
* @type {?}
*/
CachedItemPosition.prototype.clientRect;
/**
* Amount by which the item has been moved since dragging started.
* @type {?}
*/
CachedItemPosition.prototype.offset;
}
/**
* @ignore
* Internal compile-time-only representation of a `DropListRef`.
* Used to avoid circular import issues between the `DropListRef` and the `DragRef`.
* \@docs-private
* @record
*/
export function DropListRefInternal() { }
/**
* @ignore
* Reference to a drop list. Used to manipulate or dispose of the container.
* \@docs-private
* @template T
*/
export class DropListRef {
/**
* @param {?} element
* @param {?} _dragDropRegistry
* @param {?} _document
*/
constructor(element, _dragDropRegistry, _document) {
this._dragDropRegistry = _dragDropRegistry;
/**
* Unique ID for the drop list.
* @deprecated No longer being used. To be removed.
* \@breaking-change 8.0.0
*/
this.id = `cdk-drop-list-ref-${_uniqueIdCounter++}`;
/**
* Whether starting a dragging sequence from this container is disabled.
*/
this.disabled = false;
/**
* Function that is used to determine whether an item
* is allowed to be moved into a drop container.
*/
this.enterPredicate = (/**
* @return {?}
*/
() => true);
/**
* Emits right before dragging has started.
*/
this.beforeStarted = new Subject();
/**
* Emits when the user has moved a new drag item into this container.
*/
this.entered = new Subject();
/**
* Emits when the user removes an item from the container
* by dragging it into another container.
*/
this.exited = new Subject();
/**
* Emits when the user drops an item inside the container.
*/
this.dropped = new Subject();
/**
* Emits as the user is swapping items while actively dragging.
*/
this.sorted = new Subject();
/**
* Whether an item in the list is being dragged.
*/
this._isDragging = false;
/**
* Cache of the dimensions of all the items inside the container.
*/
this._itemPositions = [];
/**
* Keeps track of the item that was last swapped with the dragged item, as
* well as what direction the pointer was moving in when the swap occured.
*/
this._previousSwap = { drag: (/** @type {?} */ (null)), delta: 0 };
/**
* Drop lists that are connected to the current one.
*/
this._siblings = [];
/**
* Direction in which the list is oriented.
*/
this._orientation = 'vertical';
/**
* Connected siblings that currently have a dragged item.
*/
this._activeSiblings = new Set();
/**
* Layout direction of the drop list.
*/
this._direction = 'ltr';
_dragDropRegistry.registerDropContainer(this);
this._document = _document;
this.element = element instanceof ElementRef ? element.nativeElement : element;
}
/**
* Removes the drop list functionality from the DOM element.
* @return {?}
*/
dispose() {
this.beforeStarted.complete();
this.entered.complete();
this.exited.complete();
this.dropped.complete();
this.sorted.complete();
this._activeSiblings.clear();
this._dragDropRegistry.removeDropContainer(this);
}
/**
* Whether an item from this list is currently being dragged.
* @return {?}
*/
isDragging() {
return this._isDragging;
}
/**
* Starts dragging an item.
* @return {?}
*/
start() {
this.beforeStarted.next();
this._isDragging = true;
this._activeDraggables = this._draggables.slice();
this._cacheOwnPosition();
this._cacheItemPositions();
this._siblings.forEach((/**
* @param {?} sibling
* @return {?}
*/
sibling => sibling._startReceiving(this)));
}
/**
* Emits an event to indicate that the user moved an item into the container.
* @param {?} item Item that was moved into the container.
* @param {?} pointerX Position of the item along the X axis.
* @param {?} pointerY Position of the item along the Y axis.
* @return {?}
*/
enter(item, pointerX, pointerY) {
this.entered.next({ item, container: this });
this.start();
// We use the coordinates of where the item entered the drop
// zone to figure out at which index it should be inserted.
/** @type {?} */
const newIndex = this._getItemIndexFromPointerPosition(item, pointerX, pointerY);
/** @type {?} */
const currentIndex = this._activeDraggables.indexOf(item);
/** @type {?} */
const newPositionReference = this._activeDraggables[newIndex];
/** @type {?} */
const placeholder = item.getPlaceholderElement();
// Since the item may be in the `activeDraggables` already (e.g. if the user dragged it
// into another container and back again), we have to ensure that it isn't duplicated.
if (currentIndex > -1) {
this._activeDraggables.splice(currentIndex, 1);
}
// Don't use items that are being dragged as a reference, because
// their element has been moved down to the bottom of the body.
if (newPositionReference && !this._dragDropRegistry.isDragging(newPositionReference)) {
/** @type {?} */
const element = newPositionReference.getRootElement();
(/** @type {?} */ (element.parentElement)).insertBefore(placeholder, element);
this._activeDraggables.splice(newIndex, 0, item);
}
else {
this.element.appendChild(placeholder);
this._activeDraggables.push(item);
}
// The transform needs to be cleared so it doesn't throw off the measurements.
placeholder.style.transform = '';
// Note that the positions were already cached when we called `start` above,
// but we need to refresh them since the amount of items has changed.
this._cacheItemPositions();
}
/**
* Removes an item from the container after it was dragged into another container by the user.
* @param {?} item Item that was dragged out.
* @return {?}
*/
exit(item) {
this._reset();
this.exited.next({ item, container: this });
}
/**
* Drops an item into this container.
* @param {?} item Item being dropped into the container.
* @param {?} currentIndex Index at which the item should be inserted.
* @param {?} previousContainer Container from which the item got dragged in.
* @param {?} isPointerOverContainer Whether the user's pointer was over the
* container when the item was dropped.
* @return {?}
*/
drop(item, currentIndex, previousContainer, isPointerOverContainer) {
this._reset();
this.dropped.next({
item,
currentIndex,
previousIndex: previousContainer.getItemIndex(item),
container: this,
previousContainer,
isPointerOverContainer
});
}
/**
* Sets the draggable items that are a part of this list.
* @template THIS
* @this {THIS}
* @param {?} items Items that are a part of this list.
* @return {THIS}
*/
withItems(items) {
(/** @type {?} */ (this))._draggables = items;
items.forEach((/**
* @param {?} item
* @return {?}
*/
item => item._withDropContainer((/** @type {?} */ (this)))));
return (/** @type {?} */ (this));
}
/**
* Sets the layout direction of the drop list.
* @template THIS
* @this {THIS}
* @param {?} direction
* @return {THIS}
*/
withDirection(direction) {
(/** @type {?} */ (this))._direction = direction;
return (/** @type {?} */ (this));
}
/**
* Sets the containers that are connected to this one. When two or more containers are
* connected, the user will be allowed to transfer items between them.
* @template THIS
* @this {THIS}
* @param {?} connectedTo Other containers that the current containers should be connected to.
* @return {THIS}
*/
connectedTo(connectedTo) {
(/** @type {?} */ (this))._siblings = connectedTo.slice();
return (/** @type {?} */ (this));
}
/**
* Sets the orientation of the container.
* @template THIS
* @this {THIS}
* @param {?} orientation New orientation for the container.
* @return {THIS}
*/
withOrientation(orientation) {
(/** @type {?} */ (this))._orientation = orientation;
return (/** @type {?} */ (this));
}
/**
* Figures out the index of an item in the container.
* @param {?} item Item whose index should be determined.
* @return {?}
*/
getItemIndex(item) {
if (!this._isDragging) {
return this._draggables.indexOf(item);
}
// Items are sorted always by top/left in the cache, however they flow differently in RTL.
// The rest of the logic still stands no matter what orientation we're in, however
// we need to invert the array when determining the index.
/** @type {?} */
const items = this._orientation === 'horizontal' && this._direction === 'rtl' ?
this._itemPositions.slice().reverse() : this._itemPositions;
return findIndex(items, (/**
* @param {?} currentItem
* @return {?}
*/
currentItem => currentItem.drag === item));
}
/**
* Whether the list is able to receive the item that
* is currently being dragged inside a connected drop list.
* @return {?}
*/
isReceiving() {
return this._activeSiblings.size > 0;
}
/**
* Sorts an item inside the container based on its position.
* @param {?} item Item to be sorted.
* @param {?} pointerX Position of the item along the X axis.
* @param {?} pointerY Position of the item along the Y axis.
* @param {?} pointerDelta Direction in which the pointer is moving along each axis.
* @return {?}
*/
_sortItem(item, pointerX, pointerY, pointerDelta) {
// Don't sort the item if it's out of range.
if (!this._isPointerNearDropContainer(pointerX, pointerY)) {
return;
}
/** @type {?} */
const siblings = this._itemPositions;
/** @type {?} */
const newIndex = this._getItemIndexFromPointerPosition(item, pointerX, pointerY, pointerDelta);
if (newIndex === -1 && siblings.length > 0) {
return;
}
/** @type {?} */
const isHorizontal = this._orientation === 'horizontal';
/** @type {?} */
const currentIndex = findIndex(siblings, (/**
* @param {?} currentItem
* @return {?}
*/
currentItem => currentItem.drag === item));
/** @type {?} */
const siblingAtNewPosition = siblings[newIndex];
/** @type {?} */
const currentPosition = siblings[currentIndex].clientRect;
/** @type {?} */
const newPosition = siblingAtNewPosition.clientRect;
/** @type {?} */
const delta = currentIndex > newIndex ? 1 : -1;
this._previousSwap.drag = siblingAtNewPosition.drag;
this._previousSwap.delta = isHorizontal ? pointerDelta.x : pointerDelta.y;
// How many pixels the item's placeholder should be offset.
/** @type {?} */
const itemOffset = this._getItemOffsetPx(currentPosition, newPosition, delta);
// How many pixels all the other items should be offset.
/** @type {?} */
const siblingOffset = this._getSiblingOffsetPx(currentIndex, siblings, delta);
// Save the previous order of the items before moving the item to its new index.
// We use this to check whether an item has been moved as a result of the sorting.
/** @type {?} */
const oldOrder = siblings.slice();
// Shuffle the array in place.
moveItemInArray(siblings, currentIndex, newIndex);
this.sorted.next({
previousIndex: currentIndex,
currentIndex: newIndex,
container: this,
item
});
siblings.forEach((/**
* @param {?} sibling
* @param {?} index
* @return {?}
*/
(sibling, index) => {
// Don't do anything if the position hasn't changed.
if (oldOrder[index] === sibling) {
return;
}
/** @type {?} */
const isDraggedItem = sibling.drag === item;
/** @type {?} */
const offset = isDraggedItem ? itemOffset : siblingOffset;
/** @type {?} */
const elementToOffset = isDraggedItem ? item.getPlaceholderElement() :
sibling.drag.getRootElement();
// Update the offset to reflect the new position.
sibling.offset += offset;
// Since we're moving the items with a `transform`, we need to adjust their cached
// client rects to reflect their new position, as well as swap their positions in the cache.
// Note that we shouldn't use `getBoundingClientRect` here to update the cache, because the
// elements may be mid-animation which will give us a wrong result.
if (isHorizontal) {
// Round the transforms since some browsers will
// blur the elements, for sub-pixel transforms.
elementToOffset.style.transform = `translate3d(${Math.round(sibling.offset)}px, 0, 0)`;
adjustClientRect(sibling.clientRect, 0, offset);
}
else {
elementToOffset.style.transform = `translate3d(0, ${Math.round(sibling.offset)}px, 0)`;
adjustClientRect(sibling.clientRect, offset, 0);
}
}));
}
/**
* Caches the position of the drop list.
* @private
* @return {?}
*/
_cacheOwnPosition() {
this._clientRect = this.element.getBoundingClientRect();
}
/**
* Refreshes the position cache of the items and sibling containers.
* @private
* @return {?}
*/
_cacheItemPositions() {
/** @type {?} */
const isHorizontal = this._orientation === 'horizontal';
this._itemPositions = this._activeDraggables.map((/**
* @param {?} drag
* @return {?}
*/
drag => {
/** @type {?} */
const elementToMeasure = this._dragDropRegistry.isDragging(drag) ?
// If the element is being dragged, we have to measure the
// placeholder, because the element is hidden.
drag.getPlaceholderElement() :
drag.getRootElement();
/** @type {?} */
const clientRect = elementToMeasure.getBoundingClientRect();
return {
drag,
offset: 0,
// We need to clone the `clientRect` here, because all the values on it are readonly
// and we need to be able to update them. Also we can't use a spread here, because
// the values on a `ClientRect` aren't own properties. See:
// https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect#Notes
clientRect: {
top: clientRect.top,
right: clientRect.right,
bottom: clientRect.bottom,
left: clientRect.left,
width: clientRect.width,
height: clientRect.height
}
};
})).sort((/**
* @param {?} a
* @param {?} b
* @return {?}
*/
(a, b) => {
return isHorizontal ? a.clientRect.left - b.clientRect.left :
a.clientRect.top - b.clientRect.top;
}));
}
/**
* Resets the container to its initial state.
* @private
* @return {?}
*/
_reset() {
this._isDragging = false;
// TODO(crisbeto): may have to wait for the animations to finish.
this._activeDraggables.forEach((/**
* @param {?} item
* @return {?}
*/
item => item.getRootElement().style.transform = ''));
this._siblings.forEach((/**
* @param {?} sibling
* @return {?}
*/
sibling => sibling._stopReceiving(this)));
this._activeDraggables = [];
this._itemPositions = [];
this._previousSwap.drag = null;
this._previousSwap.delta = 0;
}
/**
* Gets the offset in pixels by which the items that aren't being dragged should be moved.
* @private
* @param {?} currentIndex Index of the item currently being dragged.
* @param {?} siblings All of the items in the list.
* @param {?} delta Direction in which the user is moving.
* @return {?}
*/
_getSiblingOffsetPx(currentIndex, siblings, delta) {
/** @type {?} */
const isHorizontal = this._orientation === 'horizontal';
/** @type {?} */
const currentPosition = siblings[currentIndex].clientRect;
/** @type {?} */
const immediateSibling = siblings[currentIndex + delta * -1];
/** @type {?} */
let siblingOffset = currentPosition[isHorizontal ? 'width' : 'height'] * delta;
if (immediateSibling) {
/** @type {?} */
const start = isHorizontal ? 'left' : 'top';
/** @type {?} */
const end = isHorizontal ? 'right' : 'bottom';
// Get the spacing between the start of the current item and the end of the one immediately
// after it in the direction in which the user is dragging, or vice versa. We add it to the
// offset in order to push the element to where it will be when it's inline and is influenced
// by the `margin` of its siblings.
if (delta === -1) {
siblingOffset -= immediateSibling.clientRect[start] - currentPosition[end];
}
else {
siblingOffset += currentPosition[start] - immediateSibling.clientRect[end];
}
}
return siblingOffset;
}
/**
* Checks whether the pointer coordinates are close to the drop container.
* @private
* @param {?} pointerX Coordinates along the X axis.
* @param {?} pointerY Coordinates along the Y axis.
* @return {?}
*/
_isPointerNearDropContainer(pointerX, pointerY) {
const { top, right, bottom, left, width, height } = this._clientRect;
/** @type {?} */
const xThreshold = width * DROP_PROXIMITY_THRESHOLD;
/** @type {?} */
const yThreshold = height * DROP_PROXIMITY_THRESHOLD;
return pointerY > top - yThreshold && pointerY < bottom + yThreshold &&
pointerX > left - xThreshold && pointerX < right + xThreshold;
}
/**
* Gets the offset in pixels by which the item that is being dragged should be moved.
* @private
* @param {?} currentPosition Current position of the item.
* @param {?} newPosition Position of the item where the current item should be moved.
* @param {?} delta Direction in which the user is moving.
* @return {?}
*/
_getItemOffsetPx(currentPosition, newPosition, delta) {
/** @type {?} */
const isHorizontal = this._orientation === 'horizontal';
/** @type {?} */
let itemOffset = isHorizontal ? newPosition.left - currentPosition.left :
newPosition.top - currentPosition.top;
// Account for differences in the item width/height.
if (delta === -1) {
itemOffset += isHorizontal ? newPosition.width - currentPosition.width :
newPosition.height - currentPosition.height;
}
return itemOffset;
}
/**
* Gets the index of an item in the drop container, based on the position of the user's pointer.
* @private
* @param {?} item Item that is being sorted.
* @param {?} pointerX Position of the user's pointer along the X axis.
* @param {?} pointerY Position of the user's pointer along the Y axis.
* @param {?=} delta Direction in which the user is moving their pointer.
* @return {?}
*/
_getItemIndexFromPointerPosition(item, pointerX, pointerY, delta) {
/** @type {?} */
const isHorizontal = this._orientation === 'horizontal';
return findIndex(this._itemPositions, (/**
* @param {?} __0
* @param {?} _
* @param {?} array
* @return {?}
*/
({ drag, clientRect }, _, array) => {
if (drag === item) {
// If there's only one item left in the container, it must be
// the dragged item itself so we use it as a reference.
return array.length < 2;
}
if (delta) {
/** @type {?} */
const direction = isHorizontal ? delta.x : delta.y;
// If the user is still hovering over the same item as last time, and they didn't change
// the direction in which they're dragging, we don't consider it a direction swap.
if (drag === this._previousSwap.drag && direction === this._previousSwap.delta) {
return false;
}
}
return isHorizontal ?
// Round these down since most browsers report client rects with
// sub-pixel precision, whereas the pointer coordinates are rounded to pixels.
pointerX >= Math.floor(clientRect.left) && pointerX <= Math.floor(clientRect.right) :
pointerY >= Math.floor(clientRect.top) && pointerY <= Math.floor(clientRect.bottom);
}));
}
/**
* Checks whether the user's pointer is positioned over the container.
* @param {?} x Pointer position along the X axis.
* @param {?} y Pointer position along the Y axis.
* @return {?}
*/
_isOverContainer(x, y) {
return isInsideClientRect(this._clientRect, x, y);
}
/**
* Figures out whether an item should be moved into a sibling
* drop container, based on its current position.
* @param {?} item Drag item that is being moved.
* @param {?} x Position of the item along the X axis.
* @param {?} y Position of the item along the Y axis.
* @return {?}
*/
_getSiblingContainerFromPosition(item, x, y) {
return this._siblings.find((/**
* @param {?} sibling
* @return {?}
*/
sibling => sibling._canReceive(item, x, y)));
}
/**
* Checks whether the drop list can receive the passed-in item.
* @param {?} item Item that is being dragged into the list.
* @param {?} x Position of the item along the X axis.
* @param {?} y Position of the item along the Y axis.
* @return {?}
*/
_canReceive(item, x, y) {
if (!this.enterPredicate(item, this) || !isInsideClientRect(this._clientRect, x, y)) {
return false;
}
/** @type {?} */
const elementFromPoint = this._document.elementFromPoint(x, y);
// If there's no element at the pointer position, then
// the client rect is probably scrolled out of the view.
if (!elementFromPoint) {
return false;
}
// The `ClientRect`, that we're using to find the container over which the user is
// hovering, doesn't give us any information on whether the element has been scrolled
// out of the view or whether it's overlapping with other containers. This means that
// we could end up transferring the item into a container that's invisible or is positioned
// below another one. We use the result from `elementFromPoint` to get the top-most element
// at the pointer position and to find whether it's one of the intersecting drop containers.
return elementFromPoint === this.element || this.element.contains(elementFromPoint);
}
/**
* Called by one of the connected drop lists when a dragging sequence has started.
* @param {?} sibling Sibling in which dragging has started.
* @return {?}
*/
_startReceiving(sibling) {
/** @type {?} */
const activeSiblings = this._activeSiblings;
if (!activeSiblings.has(sibling)) {
activeSiblings.add(sibling);
this._cacheOwnPosition();
}
}
/**
* Called by a connected drop list when dragging has stopped.
* @param {?} sibling Sibling whose dragging has stopped.
* @return {?}
*/
_stopReceiving(sibling) {
this._activeSiblings.delete(sibling);
}
}
if (false) {
/**
* @type {?}
* @private
*/
DropListRef.prototype._document;
/**
* Element that the drop list is attached to.
* @type {?}
*/
DropListRef.prototype.element;
/**
* Unique ID for the drop list.
* @deprecated No longer being used. To be removed.
* \@breaking-change 8.0.0
* @type {?}
*/
DropListRef.prototype.id;
/**
* Whether starting a dragging sequence from this container is disabled.
* @type {?}
*/
DropListRef.prototype.disabled;
/**
* Locks the position of the draggable elements inside the container along the specified axis.
* @type {?}
*/
DropListRef.prototype.lockAxis;
/**
* Function that is used to determine whether an item
* is allowed to be moved into a drop container.
* @type {?}
*/
DropListRef.prototype.enterPredicate;
/**
* Emits right before dragging has started.
* @type {?}
*/
DropListRef.prototype.beforeStarted;
/**
* Emits when the user has moved a new drag item into this container.
* @type {?}
*/
DropListRef.prototype.entered;
/**
* Emits when the user removes an item from the container
* by dragging it into another container.
* @type {?}
*/
DropListRef.prototype.exited;
/**
* Emits when the user drops an item inside the container.
* @type {?}
*/
DropListRef.prototype.dropped;
/**
* Emits as the user is swapping items while actively dragging.
* @type {?}
*/
DropListRef.prototype.sorted;
/**
* Arbitrary data that can be attached to the drop list.
* @type {?}
*/
DropListRef.prototype.data;
/**
* Whether an item in the list is being dragged.
* @type {?}
* @private
*/
DropListRef.prototype._isDragging;
/**
* Cache of the dimensions of all the items inside the container.
* @type {?}
* @private
*/
DropListRef.prototype._itemPositions;
/**
* Cached `ClientRect` of the drop list.
* @type {?}
* @private
*/
DropListRef.prototype._clientRect;
/**
* Draggable items that are currently active inside the container. Includes the items
* from `_draggables`, as well as any items that have been dragged in, but haven't
* been dropped yet.
* @type {?}
* @private
*/
DropListRef.prototype._activeDraggables;
/**
* Keeps track of the item that was last swapped with the dragged item, as
* well as what direction the pointer was moving in when the swap occured.
* @type {?}
* @private
*/
DropListRef.prototype._previousSwap;
/**
* Draggable items in the container.
* @type {?}
* @private
*/
DropListRef.prototype._draggables;
/**
* Drop lists that are connected to the current one.
* @type {?}
* @private
*/
DropListRef.prototype._siblings;
/**
* Direction in which the list is oriented.
* @type {?}
* @private
*/
DropListRef.prototype._orientation;
/**
* Connected siblings that currently have a dragged item.
* @type {?}
* @private
*/
DropListRef.prototype._activeSiblings;
/**
* Layout direction of the drop list.
* @type {?}
* @private
*/
DropListRef.prototype._direction;
/**
* @type {?}
* @private
*/
DropListRef.prototype._dragDropRegistry;
}
/**
* Updates the top/left positions of a `ClientRect`, as well as their bottom/right counterparts.
* @param {?} clientRect `ClientRect` that should be updated.
* @param {?} top Amount to add to the `top` position.
* @param {?} left Amount to add to the `left` position.
* @return {?}
*/
function adjustClientRect(clientRect, top, left) {
clientRect.top += top;
clientRect.bottom = clientRect.top + clientRect.height;
clientRect.left += left;
clientRect.right = clientRect.left + clientRect.width;
}
/**
* Finds the index of an item that matches a predicate function. Used as an equivalent
* of `Array.prototype.find` which isn't part of the standard Google typings.
* @template T
* @param {?} array Array in which to look for matches.
* @param {?} predicate Function used to determine whether an item is a match.
* @return {?}
*/
function findIndex(array, predicate) {
for (let i = 0; i < array.length; i++) {
if (predicate(array[i], i, array)) {
return i;
}
}
return -1;
}
/**
* Checks whether some coordinates are within a `ClientRect`.
* @param {?} clientRect ClientRect that is being checked.
* @param {?} x Coordinates along the X axis.
* @param {?} y Coordinates along the Y axis.
* @return {?}
*/
function isInsideClientRect(clientRect, x, y) {
const { top, bottom, left, right } = clientRect;
return y >= top && y <= bottom && x >= left && x <= right;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drop-list-ref.js","sourceRoot":"ng://ngx-pluto/","sources":["lib/drag-drop/drop-list-ref.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 {ElementRef} from '@angular/core';\r\nimport {DragDropRegistry} from './drag-drop-registry';\r\nimport {Direction} from '@angular/cdk/bidi';\r\nimport {Subject} from 'rxjs';\r\nimport {moveItemInArray} from './drag-utils';\r\nimport {DragRefInternal as DragRef} from './drag-ref';\r\n\r\n\r\n/** Counter used to generate unique ids for drop refs. */\r\nlet _uniqueIdCounter = 0;\r\n\r\n/**\r\n * Proximity, as a ratio to width/height, at which a\r\n * dragged item will affect the drop container.\r\n */\r\nconst DROP_PROXIMITY_THRESHOLD = 0.05;\r\n\r\n/**\r\n * @ignore\r\n * Entry in the position cache for draggable items.\r\n * @docs-private\r\n */\r\ninterface CachedItemPosition {\r\n  /** Instance of the drag item. */\r\n  drag: DragRef;\r\n  /** Dimensions of the item. */\r\n  clientRect: ClientRect;\r\n  /** Amount by which the item has been moved since dragging started. */\r\n  offset: number;\r\n}\r\n\r\n/**\r\n * @ignore\r\n * Internal compile-time-only representation of a `DropListRef`.\r\n * Used to avoid circular import issues between the `DropListRef` and the `DragRef`.\r\n * @docs-private\r\n */\r\nexport interface DropListRefInternal extends DropListRef {}\r\n\r\n/**\r\n * @ignore\r\n * Reference to a drop list. Used to manipulate or dispose of the container.\r\n * @docs-private\r\n */\r\nexport class DropListRef<T = any> {\r\n  private _document: Document;\r\n\r\n  /** Element that the drop list is attached to. */\r\n  readonly element: HTMLElement;\r\n\r\n  /**\r\n   * Unique ID for the drop list.\r\n   * @deprecated No longer being used. To be removed.\r\n   * @breaking-change 8.0.0\r\n   */\r\n  id = `cdk-drop-list-ref-${_uniqueIdCounter++}`;\r\n\r\n  /** Whether starting a dragging sequence from this container is disabled. */\r\n  disabled: boolean = false;\r\n\r\n  /** Locks the position of the draggable elements inside the container along the specified axis. */\r\n  lockAxis: 'x' | 'y';\r\n\r\n  /**\r\n   * Function that is used to determine whether an item\r\n   * is allowed to be moved into a drop container.\r\n   */\r\n  enterPredicate: (drag: DragRef, drop: DropListRef) => boolean = () => true;\r\n\r\n  /** Emits right before dragging has started. */\r\n  beforeStarted = new Subject<void>();\r\n\r\n  /**\r\n   * Emits when the user has moved a new drag item into this container.\r\n   */\r\n  entered = new Subject<{item: DragRef, container: DropListRef}>();\r\n\r\n  /**\r\n   * Emits when the user removes an item from the container\r\n   * by dragging it into another container.\r\n   */\r\n  exited = new Subject<{item: DragRef, container: DropListRef}>();\r\n\r\n  /** Emits when the user drops an item inside the container. */\r\n  dropped = new Subject<{\r\n    item: DragRef,\r\n    currentIndex: number,\r\n    previousIndex: number,\r\n    container: DropListRef,\r\n    previousContainer: DropListRef,\r\n    isPointerOverContainer: boolean\r\n  }>();\r\n\r\n  /** Emits as the user is swapping items while actively dragging. */\r\n  sorted = new Subject<{\r\n    previousIndex: number,\r\n    currentIndex: number,\r\n    container: DropListRef,\r\n    item: DragRef\r\n  }>();\r\n\r\n  /** Arbitrary data that can be attached to the drop list. */\r\n  data: T;\r\n\r\n  /** Whether an item in the list is being dragged. */\r\n  private _isDragging = false;\r\n\r\n  /** Cache of the dimensions of all the items inside the container. */\r\n  private _itemPositions: CachedItemPosition[] = [];\r\n\r\n  /** Cached `ClientRect` of the drop list. */\r\n  private _clientRect: ClientRect;\r\n\r\n  /**\r\n   * Draggable items that are currently active inside the container. Includes the items\r\n   * from `_draggables`, as well as any items that have been dragged in, but haven't\r\n   * been dropped yet.\r\n   */\r\n  private _activeDraggables: DragRef[];\r\n\r\n  /**\r\n   * Keeps track of the item that was last swapped with the dragged item, as\r\n   * well as what direction the pointer was moving in when the swap occured.\r\n   */\r\n  private _previousSwap = {drag: null as DragRef | null, delta: 0};\r\n\r\n  /** Draggable items in the container. */\r\n  private _draggables: ReadonlyArray<DragRef>;\r\n\r\n  /** Drop lists that are connected to the current one. */\r\n  private _siblings: ReadonlyArray<DropListRef> = [];\r\n\r\n  /** Direction in which the list is oriented. */\r\n  private _orientation: 'horizontal' | 'vertical' = 'vertical';\r\n\r\n  /** Connected siblings that currently have a dragged item. */\r\n  private _activeSiblings = new Set<DropListRef>();\r\n\r\n  /** Layout direction of the drop list. */\r\n  private _direction: Direction = 'ltr';\r\n\r\n  constructor(\r\n    element: ElementRef<HTMLElement> | HTMLElement,\r\n    private _dragDropRegistry: DragDropRegistry<DragRef, DropListRef>,\r\n    _document: any) {\r\n    _dragDropRegistry.registerDropContainer(this);\r\n    this._document = _document;\r\n    this.element = element instanceof ElementRef ? element.nativeElement : element;\r\n  }\r\n\r\n  /** Removes the drop list functionality from the DOM element. */\r\n  dispose() {\r\n    this.beforeStarted.complete();\r\n    this.entered.complete();\r\n    this.exited.complete();\r\n    this.dropped.complete();\r\n    this.sorted.complete();\r\n    this._activeSiblings.clear();\r\n    this._dragDropRegistry.removeDropContainer(this);\r\n  }\r\n\r\n  /** Whether an item from this list is currently being dragged. */\r\n  isDragging() {\r\n    return this._isDragging;\r\n  }\r\n\r\n  /** Starts dragging an item. */\r\n  start(): void {\r\n    this.beforeStarted.next();\r\n    this._isDragging = true;\r\n    this._activeDraggables = this._draggables.slice();\r\n    this._cacheOwnPosition();\r\n    this._cacheItemPositions();\r\n    this._siblings.forEach(sibling => sibling._startReceiving(this));\r\n  }\r\n\r\n  /**\r\n   * Emits an event to indicate that the user moved an item into the container.\r\n   * @param item Item that was moved into the container.\r\n   * @param pointerX Position of the item along the X axis.\r\n   * @param pointerY Position of the item along the Y axis.\r\n   */\r\n  enter(item: DragRef, pointerX: number, pointerY: number): void {\r\n    this.entered.next({item, container: this});\r\n    this.start();\r\n\r\n    // We use the coordinates of where the item entered the drop\r\n    // zone to figure out at which index it should be inserted.\r\n    const newIndex = this._getItemIndexFromPointerPosition(item, pointerX, pointerY);\r\n    const currentIndex = this._activeDraggables.indexOf(item);\r\n    const newPositionReference = this._activeDraggables[newIndex];\r\n    const placeholder = item.getPlaceholderElement();\r\n\r\n    // Since the item may be in the `activeDraggables` already (e.g. if the user dragged it\r\n    // into another container and back again), we have to ensure that it isn't duplicated.\r\n    if (currentIndex > -1) {\r\n      this._activeDraggables.splice(currentIndex, 1);\r\n    }\r\n\r\n    // Don't use items that are being dragged as a reference, because\r\n    // their element has been moved down to the bottom of the body.\r\n    if (newPositionReference && !this._dragDropRegistry.isDragging(newPositionReference)) {\r\n      const element = newPositionReference.getRootElement();\r\n      element.parentElement!.insertBefore(placeholder, element);\r\n      this._activeDraggables.splice(newIndex, 0, item);\r\n    } else {\r\n      this.element.appendChild(placeholder);\r\n      this._activeDraggables.push(item);\r\n    }\r\n\r\n    // The transform needs to be cleared so it doesn't throw off the measurements.\r\n    placeholder.style.transform = '';\r\n\r\n    // Note that the positions were already cached when we called `start` above,\r\n    // but we need to refresh them since the amount of items has changed.\r\n    this._cacheItemPositions();\r\n  }\r\n\r\n  /**\r\n   * Removes an item from the container after it was dragged into another container by the user.\r\n   * @param item Item that was dragged out.\r\n   */\r\n  exit(item: DragRef): void {\r\n    this._reset();\r\n    this.exited.next({item, container: this});\r\n  }\r\n\r\n  /**\r\n   * Drops an item into this container.\r\n   * @param item Item being dropped into the container.\r\n   * @param currentIndex Index at which the item should be inserted.\r\n   * @param previousContainer Container from which the item got dragged in.\r\n   * @param isPointerOverContainer Whether the user's pointer was over the\r\n   *    container when the item was dropped.\r\n   */\r\n  drop(item: DragRef, currentIndex: number, previousContainer: DropListRef,\r\n    isPointerOverContainer: boolean): void {\r\n    this._reset();\r\n    this.dropped.next({\r\n      item,\r\n      currentIndex,\r\n      previousIndex: previousContainer.getItemIndex(item),\r\n      container: this,\r\n      previousContainer,\r\n      isPointerOverContainer\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Sets the draggable items that are a part of this list.\r\n   * @param items Items that are a part of this list.\r\n   */\r\n  withItems(items: DragRef[]): this {\r\n    this._draggables = items;\r\n    items.forEach(item => item._withDropContainer(this));\r\n    return this;\r\n  }\r\n\r\n  /** Sets the layout direction of the drop list. */\r\n  withDirection(direction: Direction): this {\r\n    this._direction = direction;\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Sets the containers that are connected to this one. When two or more containers are\r\n   * connected, the user will be allowed to transfer items between them.\r\n   * @param connectedTo Other containers that the current containers should be connected to.\r\n   */\r\n  connectedTo(connectedTo: DropListRef[]): this {\r\n    this._siblings = connectedTo.slice();\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Sets the orientation of the container.\r\n   * @param orientation New orientation for the container.\r\n   */\r\n  withOrientation(orientation: 'vertical' | 'horizontal'): this {\r\n    this._orientation = orientation;\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Figures out the index of an item in the container.\r\n   * @param item Item whose index should be determined.\r\n   */\r\n  getItemIndex(item: DragRef): number {\r\n    if (!this._isDragging) {\r\n      return this._draggables.indexOf(item);\r\n    }\r\n\r\n    // Items are sorted always by top/left in the cache, however they flow differently in RTL.\r\n    // The rest of the logic still stands no matter what orientation we're in, however\r\n    // we need to invert the array when determining the index.\r\n    const items = this._orientation === 'horizontal' && this._direction === 'rtl' ?\r\n        this._itemPositions.slice().reverse() : this._itemPositions;\r\n\r\n    return findIndex(items, currentItem => currentItem.drag === item);\r\n  }\r\n\r\n  /**\r\n   * Whether the list is able to receive the item that\r\n   * is currently being dragged inside a connected drop list.\r\n   */\r\n  isReceiving(): boolean {\r\n    return this._activeSiblings.size > 0;\r\n  }\r\n\r\n  /**\r\n   * Sorts an item inside the container based on its position.\r\n   * @param item Item to be sorted.\r\n   * @param pointerX Position of the item along the X axis.\r\n   * @param pointerY Position of the item along the Y axis.\r\n   * @param pointerDelta Direction in which the pointer is moving along each axis.\r\n   */\r\n  _sortItem(item: DragRef, pointerX: number, pointerY: number,\r\n            pointerDelta: {x: number, y: number}): void {\r\n    // Don't sort the item if it's out of range.\r\n    if (!this._isPointerNearDropContainer(pointerX, pointerY)) {\r\n      return;\r\n    }\r\n\r\n    const siblings = this._itemPositions;\r\n    const newIndex = this._getItemIndexFromPointerPosition(item, pointerX, pointerY, pointerDelta);\r\n\r\n    if (newIndex === -1 && siblings.length > 0) {\r\n      return;\r\n    }\r\n\r\n    const isHorizontal = this._orientation === 'horizontal';\r\n    const currentIndex = findIndex(siblings, currentItem => currentItem.drag === item);\r\n    const siblingAtNewPosition = siblings[newIndex];\r\n    const currentPosition = siblings[currentIndex].clientRect;\r\n    const newPosition = siblingAtNewPosition.clientRect;\r\n    const delta = currentIndex > newIndex ? 1 : -1;\r\n\r\n    this._previousSwap.drag = siblingAtNewPosition.drag;\r\n    this._previousSwap.delta = isHorizontal ? pointerDelta.x : pointerDelta.y;\r\n\r\n    // How many pixels the item's placeholder should be offset.\r\n    const itemOffset = this._getItemOffsetPx(currentPosition, newPosition, delta);\r\n\r\n    // How many pixels all the other items should be offset.\r\n    const siblingOffset = this._getSiblingOffsetPx(currentIndex, siblings, delta);\r\n\r\n    // Save the previous order of the items before moving the item to its new index.\r\n    // We use this to check whether an item has been moved as a result of the sorting.\r\n    const oldOrder = siblings.slice();\r\n\r\n    // Shuffle the array in place.\r\n    moveItemInArray(siblings, currentIndex, newIndex);\r\n\r\n    this.sorted.next({\r\n      previousIndex: currentIndex,\r\n      currentIndex: newIndex,\r\n      container: this,\r\n      item\r\n    });\r\n\r\n    siblings.forEach((sibling, index) => {\r\n      // Don't do anything if the position hasn't changed.\r\n      if (oldOrder[index] === sibling) {\r\n        return;\r\n      }\r\n\r\n      const isDraggedItem = sibling.drag === item;\r\n      const offset = isDraggedItem ? itemOffset : siblingOffset;\r\n      const elementToOffset = isDraggedItem ? item.getPlaceholderElement() :\r\n                                              sibling.drag.getRootElement();\r\n\r\n      // Update the offset to reflect the new position.\r\n      sibling.offset += offset;\r\n\r\n      // Since we're moving the items with a `transform`, we need to adjust their cached\r\n      // client rects to reflect their new position, as well as swap their positions in the cache.\r\n      // Note that we shouldn't use `getBoundingClientRect` here to update the cache, because the\r\n      // elements may be mid-animation which will give us a wrong result.\r\n      if (isHorizontal) {\r\n        // Round the transforms since some browsers will\r\n        // blur the elements, for sub-pixel transforms.\r\n        elementToOffset.style.transform = `translate3d(${Math.round(sibling.offset)}px, 0, 0)`;\r\n        adjustClientRect(sibling.clientRect, 0, offset);\r\n      } else {\r\n        elementToOffset.style.transform = `translate3d(0, ${Math.round(sibling.offset)}px, 0)`;\r\n        adjustClientRect(sibling.clientRect, offset, 0);\r\n      }\r\n    });\r\n  }\r\n\r\n  /** Caches the position of the drop list. */\r\n  private _cacheOwnPosition() {\r\n    this._clientRect = this.element.getBoundingClientRect();\r\n  }\r\n\r\n  /** Refreshes the position cache of the items and sibling containers. */\r\n  private _cacheItemPositions() {\r\n    const isHorizontal = this._orientation === 'horizontal';\r\n\r\n    this._itemPositions = this._activeDraggables.map(drag => {\r\n      const elementToMeasure = this._dragDropRegistry.isDragging(drag) ?\r\n          // If the element is being dragged, we have to measure the\r\n          // placeholder, because the element is hidden.\r\n          drag.getPlaceholderElement() :\r\n          drag.getRootElement();\r\n      const clientRect = elementToMeasure.getBoundingClientRect();\r\n\r\n      return {\r\n        drag,\r\n        offset: 0,\r\n        // We need to clone the `clientRect` here, because all the values on it are readonly\r\n        // and we need to be able to update them. Also we can't use a spread here, because\r\n        // the values on a `ClientRect` aren't own properties. See:\r\n        // https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect#Notes\r\n        clientRect: {\r\n          top: clientRect.top,\r\n          right: clientRect.right,\r\n          bottom: clientRect.bottom,\r\n          left: clientRect.left,\r\n          width: clientRect.width,\r\n          height: clientRect.height\r\n        }\r\n      };\r\n    }).sort((a, b) => {\r\n      return isHorizontal ? a.clientRect.left - b.clientRect.left :\r\n                            a.clientRect.top - b.clientRect.top;\r\n    });\r\n  }\r\n\r\n  /** Resets the container to its initial state. */\r\n  private _reset() {\r\n    this._isDragging = false;\r\n\r\n    // TODO(crisbeto): may have to wait for the animations to finish.\r\n    this._activeDraggables.forEach(item => item.getRootElement().style.transform = '');\r\n    this._siblings.forEach(sibling => sibling._stopReceiving(this));\r\n    this._activeDraggables = [];\r\n    this._itemPositions = [];\r\n    this._previousSwap.drag = null;\r\n    this._previousSwap.delta = 0;\r\n  }\r\n\r\n  /**\r\n   * Gets the offset in pixels by which the items that aren't being dragged should be moved.\r\n   * @param currentIndex Index of the item currently being dragged.\r\n   * @param siblings All of the items in the list.\r\n   * @param delta Direction in which the user is moving.\r\n   */\r\n  private _getSiblingOffsetPx(currentIndex: number,\r\n                              siblings: CachedItemPosition[],\r\n                              delta: 1 | -1) {\r\n\r\n    const isHorizontal = this._orientation === 'horizontal';\r\n    const currentPosition = siblings[currentIndex].clientRect;\r\n    const immediateSibling = siblings[currentIndex + delta * -1];\r\n    let siblingOffset = currentPosition[isHorizontal ? 'width' : 'height'] * delta;\r\n\r\n    if (immediateSibling) {\r\n      const start = isHorizontal ? 'left' : 'top';\r\n      const end = isHorizontal ? 'right' : 'bottom';\r\n\r\n      // Get the spacing between the start of the current item and the end of the one immediately\r\n      // after it in the direction in which the user is dragging, or vice versa. We add it to the\r\n      // offset in order to push the element to where it will be when it's inline and is influenced\r\n      // by the `margin` of its siblings.\r\n      if (delta === -1) {\r\n        siblingOffset -= immediateSibling.clientRect[start] - currentPosition[end];\r\n      } else {\r\n        siblingOffset += currentPosition[start] - immediateSibling.clientRect[end];\r\n      }\r\n    }\r\n\r\n    return siblingOffset;\r\n  }\r\n\r\n  /**\r\n   * Checks whether the pointer coordinates are close to the drop container.\r\n   * @param pointerX Coordinates along the X axis.\r\n   * @param pointerY Coordinates along the Y axis.\r\n   */\r\n  private _isPointerNearDropContainer(pointerX: number, pointerY: number): boolean {\r\n    const {top, right, bottom, left, width, height} = this._clientRect;\r\n    const xThreshold = width * DROP_PROXIMITY_THRESHOLD;\r\n    const yThreshold = height * DROP_PROXIMITY_THRESHOLD;\r\n\r\n    return pointerY > top - yThreshold && pointerY < bottom + yThreshold &&\r\n           pointerX > left - xThreshold && pointerX < right + xThreshold;\r\n  }\r\n\r\n  /**\r\n   * Gets the offset in pixels by which the item that is being dragged should be moved.\r\n   * @param currentPosition Current position of the item.\r\n   * @param newPosition Position of the item where the current item should be moved.\r\n   * @param delta Direction in which the user is moving.\r\n   */\r\n  private _getItemOffsetPx(currentPosition: ClientRect, newPosition: ClientRect, delta: 1 | -1) {\r\n    const isHorizontal = this._orientation === 'horizontal';\r\n    let itemOffset = isHorizontal ? newPosition.left - currentPosition.left :\r\n                                    newPosition.top - currentPosition.top;\r\n\r\n    // Account for differences in the item width/height.\r\n    if (delta === -1) {\r\n      itemOffset += isHorizontal ? newPosition.width - currentPosition.width :\r\n                                   newPosition.height - currentPosition.height;\r\n    }\r\n\r\n    return itemOffset;\r\n  }\r\n\r\n  /**\r\n   * Gets the index of an item in the drop container, based on the position of the user's pointer.\r\n   * @param item Item that is being sorted.\r\n   * @param pointerX Position of the user's pointer along the X axis.\r\n   * @param pointerY Position of the user's pointer along the Y axis.\r\n   * @param delta Direction in which the user is moving their pointer.\r\n   */\r\n  private _getItemIndexFromPointerPosition(item: DragRef, pointerX: number, pointerY: number,\r\n                                           delta?: {x: number, y: number}) {\r\n    const isHorizontal = this._orientation === 'horizontal';\r\n\r\n    return findIndex(this._itemPositions, ({drag, clientRect}, _, array) => {\r\n      if (drag === item) {\r\n        // If there's only one item left in the container, it must be\r\n        // the dragged item itself so we use it as a reference.\r\n        return array.length < 2;\r\n      }\r\n\r\n      if (delta) {\r\n        const direction = isHorizontal ? delta.x : delta.y;\r\n\r\n        // If the user is still hovering over the same item as last time, and they didn't change\r\n        // the direction in which they're dragging, we don't consider it a direction swap.\r\n        if (drag === this._previousSwap.drag && direction === this._previousSwap.delta) {\r\n          return false;\r\n        }\r\n      }\r\n\r\n      return isHorizontal ?\r\n          // Round these down since most browsers report client rects with\r\n          // sub-pixel precision, whereas the pointer coordinates are rounded to pixels.\r\n          pointerX >= Math.floor(clientRect.left) && pointerX <= Math.floor(clientRect.right) :\r\n          pointerY >= Math.floor(clientRect.top) && pointerY <= Math.floor(clientRect.bottom);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Checks whether the user's pointer is positioned over the container.\r\n   * @param x Pointer position along the X axis.\r\n   * @param y Pointer position along the Y axis.\r\n   */\r\n  _isOverContainer(x: number, y: number): boolean {\r\n    return isInsideClientRect(this._clientRect, x, y);\r\n  }\r\n\r\n  /**\r\n   * Figures out whether an item should be moved into a sibling\r\n   * drop container, based on its current position.\r\n   * @param item Drag item that is being moved.\r\n   * @param x Position of the item along the X axis.\r\n   * @param y Position of the item along the Y axis.\r\n   */\r\n  _getSiblingContainerFromPosition(item: DragRef, x: number, y: number): DropListRef | undefined {\r\n    return this._siblings.find(sibling => sibling._canReceive(item, x, y));\r\n  }\r\n\r\n  /**\r\n   * Checks whether the drop list can receive the passed-in item.\r\n   * @param item Item that is being dragged into the list.\r\n   * @param x Position of the item along the X axis.\r\n   * @param y Position of the item along the Y axis.\r\n   */\r\n  _canReceive(item: DragRef, x: number, y: number): boolean {\r\n    if (!this.enterPredicate(item, this) || !isInsideClientRect(this._clientRect, x, y)) {\r\n      return false;\r\n    }\r\n\r\n    const elementFromPoint = this._document.elementFromPoint(x, y);\r\n\r\n    // If there's no element at the pointer position, then\r\n    // the client rect is probably scrolled out of the view.\r\n    if (!elementFromPoint) {\r\n      return false;\r\n    }\r\n\r\n    // The `ClientRect`, that we're using to find the container over which the user is\r\n    // hovering, doesn't give us any information on whether the element has been scrolled\r\n    // out of the view or whether it's overlapping with other containers. This means that\r\n    // we could end up transferring the item into a container that's invisible or is positioned\r\n    // below another one. We use the result from `elementFromPoint` to get the top-most element\r\n    // at the pointer position and to find whether it's one of the intersecting drop containers.\r\n    return elementFromPoint === this.element || this.element.contains(elementFromPoint);\r\n  }\r\n\r\n  /**\r\n   * Called by one of the connected drop lists when a dragging sequence has started.\r\n   * @param sibling Sibling in which dragging has started.\r\n   */\r\n  _startReceiving(sibling: DropListRef) {\r\n    const activeSiblings = this._activeSiblings;\r\n\r\n    if (!activeSiblings.has(sibling)) {\r\n      activeSiblings.add(sibling);\r\n      this._cacheOwnPosition();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Called by a connected drop list when dragging has stopped.\r\n   * @param sibling Sibling whose dragging has stopped.\r\n   */\r\n  _stopReceiving(sibling: DropListRef) {\r\n    this._activeSiblings.delete(sibling);\r\n  }\r\n}\r\n\r\n\r\n/**\r\n * Updates the top/left positions of a `ClientRect`, as well as their bottom/right counterparts.\r\n * @param clientRect `ClientRect` that should be updated.\r\n * @param top Amount to add to the `top` position.\r\n * @param left Amount to add to the `left` position.\r\n */\r\nfunction adjustClientRect(clientRect: ClientRect, top: number, left: number) {\r\n  clientRect.top += top;\r\n  clientRect.bottom = clientRect.top + clientRect.height;\r\n\r\n  clientRect.left += left;\r\n  clientRect.right = clientRect.left + clientRect.width;\r\n}\r\n\r\n\r\n/**\r\n * Finds the index of an item that matches a predicate function. Used as an equivalent\r\n * of `Array.prototype.find` which isn't part of the standard Google typings.\r\n * @param array Array in which to look for matches.\r\n * @param predicate Function used to determine whether an item is a match.\r\n */\r\nfunction findIndex<T>(array: T[],\r\n                      predicate: (value: T, index: number, obj: T[]) => boolean): number {\r\n\r\n  for (let i = 0; i < array.length; i++) {\r\n    if (predicate(array[i], i, array)) {\r\n      return i;\r\n    }\r\n  }\r\n\r\n  return -1;\r\n}\r\n\r\n\r\n/**\r\n * Checks whether some coordinates are within a `ClientRect`.\r\n * @param clientRect ClientRect that is being checked.\r\n * @param x Coordinates along the X axis.\r\n * @param y Coordinates along the Y axis.\r\n */\r\nfunction isInsideClientRect(clientRect: ClientRect, x: number, y: number) {\r\n  const {top, bottom, left, right} = clientRect;\r\n  return y >= top && y <= bottom && x >= left && x <= right;\r\n}\r\n"]}