Function moveElement

src/core/layout.ts:258–349

(
  layout: Layout,
  l: LayoutItem,
  x: number | undefined,
  y: number | undefined,
  isUserAction: boolean | undefined,
  preventCollision: boolean | undefined,
  compactType: CompactType,
  cols: number,
  allowOverlap?: boolean
)

 * @returns The updated layout
 */
export function moveElement(
  layout: Layout,
  l: LayoutItem,
  x: number | undefined,
  y: number | undefined,
  isUserAction: boolean | undefined,
  preventCollision: boolean | undefined,
  compactType: CompactType,
  cols: number,
  allowOverlap?: boolean
): LayoutItem[] {
  // Static items can't be moved unless explicitly draggable
  if (l.static && l.isDraggable !== true) {
    return [...layout];
  }

  // Short-circuit if position unchanged
  if (l.y === y && l.x === x) {
    return [...layout];
  }

  const oldX = l.x;
  const oldY = l.y;

  // Update position (mutates l directly - see JSDoc note)
  if (typeof x === "number") (l as Mutable<LayoutItem>).x = x;
  if (typeof y === "number") (l as Mutable<LayoutItem>).y = y;
  (l as Mutable<LayoutItem>).moved = true;

  // Sort for proper collision detection order
  let sorted = sortLayoutItems(layout, compactType);
  const movingUp =
    compactType === "vertical" && typeof y === "number"
      ? oldY >= y
      : compactType === "horizontal" && typeof x === "number"
        ? oldX >= x
        : false;

  if (movingUp) {
    sorted = sorted.reverse();
  }

  const collisions = getAllCollisions(sorted, l);
  const hasCollisions = collisions.length > 0;

  // Handle overlap mode - just clone and return
  if (hasCollisions && allowOverlap) {
    return cloneLayout(layout);
  }

  // Handle prevent collision mode - revert position
  // Return same reference to signal no change occurred
  if (hasCollisions && preventCollision) {
    (l as Mutable<LayoutItem>).x = oldX;
    (l as Mutable<LayoutItem>).y = oldY;
    (l as Mutable<LayoutItem>).moved = false;
    return layout as LayoutItem[];
  }