Function compactItemInternal

src/core/compact-compat.ts:77–142

* Compact a single item in the layout. * * This is the exact algorithm from lib/utils.js compactItem.

(
  compareWith: Layout,
  l: LayoutItem,
  compactType: CompactType,
  cols: number,
  fullLayout: Layout,
  allowOverlap: boolean | undefined,
  b: number | undefined
)

 * This is the exact algorithm from lib/utils.js compactItem.
 */
function compactItemInternal(
  compareWith: Layout,
  l: LayoutItem,
  compactType: CompactType,
  cols: number,
  fullLayout: Layout,
  allowOverlap: boolean | undefined,
  b: number | undefined
): LayoutItem {
  const compactV = compactType === "vertical";
  const compactH = compactType === "horizontal";

  // When allowOverlap is true, skip all compaction movement.
  // Items stay where they are placed.
  if (!allowOverlap) {
    if (compactV) {
      // Bottom 'y' possible is the bottom of the layout.
      // This allows you to do nice stuff like specify {y: Infinity}
      if (typeof b === "number") {
        (l as Mutable<LayoutItem>).y = Math.min(b, l.y);
      } else {
        (l as Mutable<LayoutItem>).y = Math.min(bottom(compareWith), l.y);
      }
      // Move the element up as far as it can go without colliding.
      while (l.y > 0 && !getFirstCollision(compareWith, l)) {
        (l as Mutable<LayoutItem>).y--;
      }
    } else if (compactH) {
      // Move the element left as far as it can go without colliding.
      while (l.x > 0 && !getFirstCollision(compareWith, l)) {
        (l as Mutable<LayoutItem>).x--;
      }
    }
  }

  // Move it down/right, and keep moving if it's colliding.
  let collision: LayoutItem | undefined;
  // When allowOverlap is true, skip collision resolution entirely.
  while (
    (collision = getFirstCollision(compareWith, l)) !== undefined &&
    !allowOverlap
  ) {
    if (compactH) {
      resolveCompactionCollision(fullLayout, l, collision.x + collision.w, "x");
    } else {
      resolveCompactionCollision(fullLayout, l, collision.y + collision.h, "y");
    }

    // Since we can't grow without bounds horizontally, if we've overflown,
    // let's move it down and try again.
    if (compactH && l.x + l.w > cols) {
      (l as Mutable<LayoutItem>).x = cols - l.w;
      (l as Mutable<LayoutItem>).y++;
      // Also move element as left as we can
      while (l.x > 0 && !getFirstCollision(compareWith, l)) {
        (l as Mutable<LayoutItem>).x--;
      }
    }