Function compactWrap

src/extras/wrapCompactor.ts:59–124

* Compact items in wrap order, filling gaps from left-to-right, top-to-bottom. * All items are assumed to be 1x1 for wrap mode to work correctly.

(layout: Layout, cols: number)

 * All items are assumed to be 1x1 for wrap mode to work correctly.
 */
function compactWrap(layout: Layout, cols: number): LayoutItem[] {
  if (layout.length === 0) return [];

  const sorted = sortByWrapOrder(layout);
  const out: LayoutItem[] = new Array(layout.length);
  const statics = sorted.filter(item => item.static);

  // Track which positions are occupied by static items
  const staticPositions = new Set<number>();
  for (const s of statics) {
    // For static items, mark all cells they occupy
    for (let dy = 0; dy < s.h; dy++) {
      for (let dx = 0; dx < s.w; dx++) {
        staticPositions.add((s.y + dy) * cols + (s.x + dx));
      }
    }
  }

  let nextPos = 0;

  for (let i = 0; i < sorted.length; i++) {
    const sortedItem = sorted[i];
    if (sortedItem === undefined) continue;

    const l = cloneLayoutItem(sortedItem);

    if (l.static) {
      // Static items stay in place
      const originalIndex = layout.indexOf(sortedItem);
      out[originalIndex] = l;
      l.moved = false;
      continue;
    }

    // Find next available position that doesn't conflict with statics
    while (staticPositions.has(nextPos)) {
      nextPos++;
    }

    // For items larger than 1x1, we need to check if the full item fits
    const { x, y } = fromWrapPosition(nextPos, cols);

    // Check if item would overflow the row
    if (x + l.w > cols) {
      // Move to start of next row
      nextPos = (y + 1) * cols;
      // Skip any static positions on the new row
      while (staticPositions.has(nextPos)) {
        nextPos++;
      }
    }

    const newCoords = fromWrapPosition(nextPos, cols);
    (l as Mutable<LayoutItem>).x = newCoords.x;
    (l as Mutable<LayoutItem>).y = newCoords.y;

    // Advance past this item
    nextPos += l.w;