@recruitler/drag-drop
Version:
A forked version of Angular/'s drag-drop CDK.
433 lines • 65.6 kB
JavaScript
/**
* @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 { coerceElement } from '@angular/cdk/coercion';
import { adjustClientRect, getMutableClientRect, isInsideClientRect, } from '../dom/client-rect';
import { combineTransforms } from '../dom/styling';
import { moveItemInArray } from '../drag-utils';
/**
* Strategy that only supports sorting along a single axis.
* Items are reordered using CSS transforms which allows for sorting to be animated.
* @docs-private
*/
export class SingleAxisSortStrategy {
_element;
_dragDropRegistry;
/** Function used to determine if an item can be sorted into a specific index. */
_sortPredicate;
/** Cache of the dimensions of all the items inside the container. */
_itemPositions = [];
/**
* Draggable items that are currently active inside the container. Includes the items
* that were there at the start of the sequence, as well as any items that have been dragged
* in, but haven't been dropped yet.
*/
_activeDraggables;
/** Direction in which the list is oriented. */
orientation = 'vertical';
/** Layout direction of the drop list. */
direction;
constructor(_element, _dragDropRegistry) {
this._element = _element;
this._dragDropRegistry = _dragDropRegistry;
}
/**
* 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 occurred and whether the user's pointer continued to
* overlap with the swapped item after the swapping occurred.
*/
_previousSwap = {
drag: null,
delta: 0,
overlaps: false,
};
/**
* To be called when the drag sequence starts.
* @param items Items that are currently in the list.
*/
start(items) {
this.withItems(items);
}
/**
* To be called when an item is being sorted.
* @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.
*/
sort(item, pointerX, pointerY, pointerDelta) {
const siblings = this._itemPositions;
const newIndex = this._getItemIndexFromPointerPosition(item, pointerX, pointerY, pointerDelta);
if (newIndex === -1 && siblings.length > 0) {
return null;
}
const isHorizontal = this.orientation === 'horizontal';
const currentIndex = siblings.findIndex((currentItem) => currentItem.drag === item);
const siblingAtNewPosition = siblings[newIndex];
const currentPosition = siblings[currentIndex].clientRect;
const newPosition = siblingAtNewPosition.clientRect;
const delta = currentIndex > newIndex ? 1 : -1;
// How many pixels the item's placeholder should be offset.
const itemOffset = this._getItemOffsetPx(currentPosition, newPosition, delta);
// How many pixels all the other items should be offset.
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.
const oldOrder = siblings.slice();
// Shuffle the array in place.
moveItemInArray(siblings, currentIndex, newIndex);
siblings.forEach((sibling, index) => {
// Don't do anything if the position hasn't changed.
if (oldOrder[index] === sibling) {
return;
}
const isDraggedItem = sibling.drag === item;
const offset = isDraggedItem ? itemOffset : siblingOffset;
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 = combineTransforms(`translate3d(${Math.round(sibling.offset)}px, 0, 0)`, sibling.initialTransform);
adjustClientRect(sibling.clientRect, 0, offset);
}
else {
// elementToOffset.style.backgroundColor = 'green';
elementToOffset.style.transform = combineTransforms(`translate3d(0, ${Math.round(sibling.offset)}px, 0)`, sibling.initialTransform);
adjustClientRect(sibling.clientRect, offset, 0);
}
});
// Note that it's important that we do this after the client rects have been adjusted.
this._previousSwap.overlaps = isInsideClientRect(newPosition, pointerX, pointerY);
this._previousSwap.drag = siblingAtNewPosition.drag;
this._previousSwap.delta = isHorizontal ? pointerDelta.x : pointerDelta.y;
return { previousIndex: currentIndex, currentIndex: newIndex };
}
getActiveItem(index) {
return this._itemPositions[index].drag;
}
/**
* Called when an item is being moved 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.
* @param index Index at which the item entered. If omitted, the container will try to figure it
* out automatically.
*/
enter(item, pointerX, pointerY, index) {
const newIndex = index == null || index < 0
? // We use the coordinates of where the item entered the drop
// zone to figure out at which index it should be inserted.
this._getItemIndexFromPointerPosition(item, pointerX, pointerY)
: index;
const activeDraggables = this._activeDraggables;
const currentIndex = activeDraggables.indexOf(item);
const placeholder = item.getPlaceholderElement();
let newPositionReference = activeDraggables[newIndex];
// If the item at the new position is the same as the item that is being dragged,
// it means that we're trying to restore the item to its initial position. In this
// case we should use the next item from the list as the reference.
if (newPositionReference === item) {
newPositionReference = activeDraggables[newIndex + 1];
}
// If we didn't find a new position reference, it means that either the item didn't start off
// in this container, or that the item requested to be inserted at the end of the list.
if (!newPositionReference &&
(newIndex == null ||
newIndex === -1 ||
newIndex < activeDraggables.length - 1) &&
this._shouldEnterAsFirstChild(pointerX, pointerY)) {
newPositionReference = activeDraggables[0];
}
// 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) {
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)) {
const element = newPositionReference.getRootElement();
element.parentElement.insertBefore(placeholder, element);
activeDraggables.splice(newIndex, 0, item);
}
else {
coerceElement(this._element).appendChild(placeholder);
activeDraggables.push(item);
}
// The transform needs to be cleared so it doesn't throw off the measurements.
placeholder.style.transform = '';
// Note that usually `start` is called together with `enter` when an item goes into a new
// container. This will cache item positions, but we need to refresh them since the amount
// of items has changed.
this._cacheItemPositions();
}
/**
* Called when an item is being nested into the another item.
* @param item Item that was nested into the target item.
* @param pointerX Position of the item along the X axis.
* @param pointerY Position of the item along the Y axis.
* @param nestIndex Target Index at which the item will be neste. If omitted, the container will try to figure it
* out automatically.
*/
nest(item, nestIndex, currentNestIndex) {
if (nestIndex == currentNestIndex)
return;
let nestPositionReference = this._itemPositions[nestIndex].drag;
if (nestPositionReference === item) {
return;
}
if (currentNestIndex >= 0) {
// this.unnest(item, currentNestIndex);
}
const placeholder = item.getPlaceholderElement();
// 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 (nestPositionReference &&
!this._dragDropRegistry.isDragging(nestPositionReference)) {
const element = nestPositionReference.getRootElement();
element.appendChild(placeholder);
this._itemPositions.forEach((item, index) => {
item.drag.getRootElement().style.transform = "";
});
}
placeholder.style.transform = '';
}
unnest(item, nestIndex) {
// const activeDraggables = this.getItemIndex(item);
if (nestIndex >= this._itemPositions.length || nestIndex < 0)
return;
const currentIndex = this.getItemIndex(item);
const placeholder = item.getPlaceholderElement();
let nestPositionReference = this._itemPositions[nestIndex].drag;
let parent = nestPositionReference.getRootElement().parentElement;
if (nestPositionReference === item) {
return;
}
// 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 (nestPositionReference &&
!this._dragDropRegistry.isDragging(nestPositionReference)) {
const element = nestPositionReference.getRootElement();
element.removeChild(element.lastChild);
if (parent) {
parent.insertBefore(placeholder, parent.children[currentIndex]);
}
}
// The transform needs to be cleared so it doesn't throw off the measurements.
placeholder.style.transform = '';
// Note that usually `start` is called together with `enter` when an item goes into a new
// container. This will cache item positions, but we need to refresh them since the amount
// of items has changed.
}
/** Sets the items that are currently part of the list. */
withItems(items) {
this._activeDraggables = items.slice();
this._cacheItemPositions();
}
/** Assigns a sort predicate to the strategy. */
withSortPredicate(predicate) {
this._sortPredicate = predicate;
}
/** Resets the strategy to its initial state before dragging was started. */
reset() {
// TODO(crisbeto): may have to wait for the animations to finish.
this._activeDraggables.forEach((item) => {
const rootElement = item.getRootElement();
if (rootElement) {
const initialTransform = this._itemPositions.find((p) => p.drag === item)?.initialTransform;
rootElement.style.transform = initialTransform || '';
}
});
this._itemPositions = [];
this._activeDraggables = [];
this._previousSwap.drag = null;
this._previousSwap.delta = 0;
this._previousSwap.overlaps = false;
}
/**
* Gets a snapshot of items currently in the list.
* Can include items that we dragged in from another list.
*/
getActiveItemsSnapshot() {
return this._activeDraggables;
}
/** Gets the index of a specific item. */
getItemIndex(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.
const items = this.orientation === 'horizontal' && this.direction === 'rtl'
? this._itemPositions.slice().reverse()
: this._itemPositions;
return items.findIndex((currentItem) => currentItem.drag === item);
}
/** Used to notify the strategy that the scroll position has changed. */
updateOnScroll(topDifference, leftDifference) {
// Since we know the amount that the user has scrolled we can shift all of the
// client rectangles ourselves. This is cheaper than re-measuring everything and
// we can avoid inconsistent behavior where we might be measuring the element before
// its position has changed.
this._itemPositions.forEach(({ clientRect }) => {
adjustClientRect(clientRect, topDifference, leftDifference);
});
// We need two loops for this, because we want all of the cached
// positions to be up-to-date before we re-sort the item.
this._itemPositions.forEach(({ drag }) => {
if (this._dragDropRegistry.isDragging(drag)) {
// We need to re-sort the item manually, because the pointer move
// events won't be dispatched while the user is scrolling.
drag._sortFromLastPointerPosition();
}
});
}
/** Refreshes the position cache of the items and sibling containers. */
_cacheItemPositions() {
const isHorizontal = this.orientation === 'horizontal';
this._itemPositions = this._activeDraggables
.map((drag) => {
const elementToMeasure = drag.getVisibleElement();
return {
drag,
offset: 0,
initialTransform: elementToMeasure.style.transform || '',
clientRect: getMutableClientRect(elementToMeasure),
};
})
.sort((a, b) => {
return isHorizontal
? a.clientRect.left - b.clientRect.left
: a.clientRect.top - b.clientRect.top;
});
}
/**
* Gets the offset in pixels by which the item that is being dragged should be moved.
* @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.
*/
_getItemOffsetPx(currentPosition, newPosition, delta) {
const isHorizontal = this.orientation === 'horizontal';
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 offset in pixels by which the items that aren't being dragged should be moved.
* @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.
*/
_getSiblingOffsetPx(currentIndex, siblings, delta) {
const isHorizontal = this.orientation === 'horizontal';
const currentPosition = siblings[currentIndex].clientRect;
const immediateSibling = siblings[currentIndex + delta * -1];
let siblingOffset = currentPosition[isHorizontal ? 'width' : 'height'] * delta;
if (immediateSibling) {
const start = isHorizontal ? 'left' : 'top';
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 if pointer is entering in the first position
* @param pointerX Position of the user's pointer along the X axis.
* @param pointerY Position of the user's pointer along the Y axis.
*/
_shouldEnterAsFirstChild(pointerX, pointerY) {
if (!this._activeDraggables.length) {
return false;
}
const itemPositions = this._itemPositions;
const isHorizontal = this.orientation === 'horizontal';
// `itemPositions` are sorted by position while `activeDraggables` are sorted by child index
// check if container is using some sort of "reverse" ordering (eg: flex-direction: row-reverse)
const reversed = itemPositions[0].drag !== this._activeDraggables[0];
if (reversed) {
const lastItemRect = itemPositions[itemPositions.length - 1].clientRect;
return isHorizontal
? pointerX >= lastItemRect.right
: pointerY >= lastItemRect.bottom;
}
else {
const firstItemRect = itemPositions[0].clientRect;
return isHorizontal
? pointerX <= firstItemRect.left
: pointerY <= firstItemRect.top;
}
}
/**
*
* @returns ClientRect values of all items
*/
getItemBoundaries() {
return this._itemPositions.map(({ drag, clientRect }) => clientRect);
}
/**
* Gets the index of an item in the drop container, based on the position of the user's pointer.
* @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.
*/
_getItemIndexFromPointerPosition(item, pointerX, pointerY, delta) {
const isHorizontal = this.orientation === 'horizontal';
const index = this._itemPositions.findIndex(({ drag, clientRect }) => {
// Skip the item itself.
if (drag === item) {
return false;
}
if (delta) {
const direction = isHorizontal ? delta.x : delta.y;
// If the user is still hovering over the same item as last time, their cursor hasn't left
// the item after we made the swap, 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 &&
this._previousSwap.overlaps &&
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);
});
return index === -1 || !this._sortPredicate(index, item) ? -1 : index;
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"single-axis-sort-strategy.js","sourceRoot":"","sources":["../../../../../projects/sortable/src/lib/drag-drop/sorting/single-axis-sort-strategy.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 { Direction } from '@angular/cdk/bidi';\nimport { coerceElement } from '@angular/cdk/coercion';\nimport { ElementRef } from '@angular/core';\nimport {\n  adjustClientRect,\n  getMutableClientRect,\n  isInsideClientRect,\n} from '../dom/client-rect';\nimport { combineTransforms } from '../dom/styling';\nimport { DragDropRegistry } from '../drag-drop-registry';\nimport { moveItemInArray } from '../drag-utils';\nimport {\n  DropListSortStrategy,\n  DropListSortStrategyItem,\n  SortPredicate,\n} from './drop-list-sort-strategy';\n\n/**\n * Entry in the position cache for draggable items.\n * @docs-private\n */\ninterface CachedItemPosition<T> {\n  /** Instance of the drag item. */\n  drag: T;\n  /** Dimensions of the item. */\n  clientRect: ClientRect;\n  /** Amount by which the item has been moved since dragging started. */\n  offset: number;\n  /** Inline transform that the drag item had when dragging started. */\n  initialTransform: string;\n}\n\n/**\n * Strategy that only supports sorting along a single axis.\n * Items are reordered using CSS transforms which allows for sorting to be animated.\n * @docs-private\n */\nexport class SingleAxisSortStrategy<T extends DropListSortStrategyItem>\n  implements DropListSortStrategy<T>\n{\n  /** Function used to determine if an item can be sorted into a specific index. */\n  private _sortPredicate: SortPredicate<T>;\n\n  /** Cache of the dimensions of all the items inside the container. */\n  private _itemPositions: CachedItemPosition<T>[] = [];\n\n  /**\n   * Draggable items that are currently active inside the container. Includes the items\n   * that were there at the start of the sequence, as well as any items that have been dragged\n   * in, but haven't been dropped yet.\n   */\n  private _activeDraggables: T[];\n\n  /** Direction in which the list is oriented. */\n  orientation: 'vertical' | 'horizontal' = 'vertical';\n\n  /** Layout direction of the drop list. */\n  direction: Direction;\n\n  constructor(\n    private _element: HTMLElement | ElementRef<HTMLElement>,\n    private _dragDropRegistry: DragDropRegistry<T, unknown>\n  ) { }\n\n  /**\n   * Keeps track of the item that was last swapped with the dragged item, as well as what direction\n   * the pointer was moving in when the swap occurred and whether the user's pointer continued to\n   * overlap with the swapped item after the swapping occurred.\n   */\n  private _previousSwap = {\n    drag: null as T | null,\n    delta: 0,\n    overlaps: false,\n  };\n\n  /**\n   * To be called when the drag sequence starts.\n   * @param items Items that are currently in the list.\n   */\n  start(items: readonly T[]) {\n    this.withItems(items);\n  }\n\n  /**\n   * To be called when an item is being sorted.\n   * @param item Item to be sorted.\n   * @param pointerX Position of the item along the X axis.\n   * @param pointerY Position of the item along the Y axis.\n   * @param pointerDelta Direction in which the pointer is moving along each axis.\n   */\n  sort(\n    item: T,\n    pointerX: number,\n    pointerY: number,\n    pointerDelta: { x: number; y: number }\n  ) {\n    const siblings = this._itemPositions;\n    const newIndex = this._getItemIndexFromPointerPosition(\n      item,\n      pointerX,\n      pointerY,\n      pointerDelta\n    );\n\n    if (newIndex === -1 && siblings.length > 0) {\n      return null;\n    }\n\n    const isHorizontal = this.orientation === 'horizontal';\n    const currentIndex = siblings.findIndex(\n      (currentItem) => currentItem.drag === item\n    );\n\n    const siblingAtNewPosition = siblings[newIndex];\n    const currentPosition = siblings[currentIndex].clientRect;\n    const newPosition = siblingAtNewPosition.clientRect;\n    const delta = currentIndex > newIndex ? 1 : -1;\n\n    // How many pixels the item's placeholder should be offset.\n    const itemOffset = this._getItemOffsetPx(\n      currentPosition,\n      newPosition,\n      delta\n    );\n\n    // How many pixels all the other items should be offset.\n    const siblingOffset = this._getSiblingOffsetPx(\n      currentIndex,\n      siblings,\n      delta\n    );\n\n    // Save the previous order of the items before moving the item to its new index.\n    // We use this to check whether an item has been moved as a result of the sorting.\n    const oldOrder = siblings.slice();\n\n    // Shuffle the array in place.\n    moveItemInArray(siblings, currentIndex, newIndex);\n\n    siblings.forEach((sibling, index) => {\n      // Don't do anything if the position hasn't changed.\n      if (oldOrder[index] === sibling) {\n        return;\n      }\n\n      const isDraggedItem = sibling.drag === item;\n      const offset = isDraggedItem ? itemOffset : siblingOffset;\n      const elementToOffset = isDraggedItem\n        ? item.getPlaceholderElement()\n        : sibling.drag.getRootElement();\n\n      // Update the offset to reflect the new position.\n      sibling.offset += offset;\n\n      // Since we're moving the items with a `transform`, we need to adjust their cached\n      // client rects to reflect their new position, as well as swap their positions in the cache.\n      // Note that we shouldn't use `getBoundingClientRect` here to update the cache, because the\n      // elements may be mid-animation which will give us a wrong result.\n      if (isHorizontal) {\n        // Round the transforms since some browsers will\n        // blur the elements, for sub-pixel transforms.\n        elementToOffset.style.transform = combineTransforms(\n          `translate3d(${Math.round(sibling.offset)}px, 0, 0)`,\n          sibling.initialTransform\n        );\n        adjustClientRect(sibling.clientRect, 0, offset);\n      } else {\n        // elementToOffset.style.backgroundColor = 'green';\n        elementToOffset.style.transform = combineTransforms(\n          `translate3d(0, ${Math.round(sibling.offset)}px, 0)`,\n          sibling.initialTransform\n        );\n        adjustClientRect(sibling.clientRect, offset, 0);\n      }\n\n    });\n\n    // Note that it's important that we do this after the client rects have been adjusted.\n    this._previousSwap.overlaps = isInsideClientRect(\n      newPosition,\n      pointerX,\n      pointerY\n    );\n    this._previousSwap.drag = siblingAtNewPosition.drag;\n    this._previousSwap.delta = isHorizontal ? pointerDelta.x : pointerDelta.y;\n\n    return { previousIndex: currentIndex, currentIndex: newIndex };\n  }\n\n  getActiveItem(index: number): T {\n    return this._itemPositions[index].drag;\n  }\n\n  /**\n   * Called when an item is being moved into the container.\n   * @param item Item that was moved into the container.\n   * @param pointerX Position of the item along the X axis.\n   * @param pointerY Position of the item along the Y axis.\n   * @param index Index at which the item entered. If omitted, the container will try to figure it\n   *   out automatically.\n   */\n  enter(item: T, pointerX: number, pointerY: number, index?: number): void {\n    const newIndex =\n      index == null || index < 0\n        ? // We use the coordinates of where the item entered the drop\n        // zone to figure out at which index it should be inserted.\n        this._getItemIndexFromPointerPosition(item, pointerX, pointerY)\n        : index;\n\n    const activeDraggables = this._activeDraggables;\n    const currentIndex = activeDraggables.indexOf(item);\n    const placeholder = item.getPlaceholderElement();\n    let newPositionReference: T | undefined = activeDraggables[newIndex];\n\n    // If the item at the new position is the same as the item that is being dragged,\n    // it means that we're trying to restore the item to its initial position. In this\n    // case we should use the next item from the list as the reference.\n    if (newPositionReference === item) {\n      newPositionReference = activeDraggables[newIndex + 1];\n    }\n\n    // If we didn't find a new position reference, it means that either the item didn't start off\n    // in this container, or that the item requested to be inserted at the end of the list.\n    if (\n      !newPositionReference &&\n      (newIndex == null ||\n        newIndex === -1 ||\n        newIndex < activeDraggables.length - 1) &&\n      this._shouldEnterAsFirstChild(pointerX, pointerY)\n    ) {\n      newPositionReference = activeDraggables[0];\n    }\n\n    // Since the item may be in the `activeDraggables` already (e.g. if the user dragged it\n    // into another container and back again), we have to ensure that it isn't duplicated.\n    if (currentIndex > -1) {\n      activeDraggables.splice(currentIndex, 1);\n    }\n\n    // Don't use items that are being dragged as a reference, because\n    // their element has been moved down to the bottom of the body.\n    if (\n      newPositionReference &&\n      !this._dragDropRegistry.isDragging(newPositionReference)\n    ) {\n\n      const element = newPositionReference.getRootElement();\n      element.parentElement!.insertBefore(placeholder, element);\n      activeDraggables.splice(newIndex, 0, item);\n    } else {\n      coerceElement(this._element).appendChild(placeholder);\n      activeDraggables.push(item);\n    }\n\n    // The transform needs to be cleared so it doesn't throw off the measurements.\n    placeholder.style.transform = '';\n\n    // Note that usually `start` is called together with `enter` when an item goes into a new\n    // container. This will cache item positions, but we need to refresh them since the amount\n    // of items has changed.\n    this._cacheItemPositions();\n  }\n\n  /**\n   * Called when an item is being nested into the another item.\n  