@mark1russell7/packing 0.2.15 → 0.2.16

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/packing",
-  "version": "0.2.15",
+  "version": "0.2.16",
   "description": "Rectangle packing: shelf, guillotine and skyline strategies, push cascades and measures of a layout.",
   "keywords": [
     "rectangle-packing",

package/src/pack.ts

@@ -40,11 +40,13 @@ export interface PackLayoutOptions extends PackOptions {
 /** The depth of the calls of `packInto`. Only the outer gap fill counts its rectangles as moves. */
 let fillDepth = 0;
 
-function packInto<T>(rects: Rect<T>[], region: Rect<T>, offset: Vector, order: SortOrder): void {
-  const unpacked = Rect.unpacked(rects);
+function packInto<T>(byOrder: Rect<T>[], region: Rect<T>, offset: Vector, order: SortOrder): void {
+  // A filter keeps the order of the sort, thus the region needs no sort again
+  const unpacked = Rect.unpacked(byOrder);
   fillDepth++;
   try {
-    pack(unpacked, region, { sortOrder: order });
+    // The region has a fixed size, thus `pack` only calls the row packing
+    packSortedRows(unpacked, region, order);
   } finally {
     fillDepth--;
   }
@@ -53,17 +55,15 @@ function packInto<T>(rects: Rect<T>[], region: Rect<T>, offset: Vector, order: S
   for (const r of placed) r.translateBy(offset);
 }
 
-function packRow<T>(rects: Rect<T>[], outer: Rect<T>, order: SortOrder): boolean {
+function packRow<T>(byOrder: Rect<T>[], outer: Rect<T>, order: SortOrder): boolean {
   const row: Rect<T>[] = [];
-  // toSorted gives a sorted copy, thus the order of the array of the caller stays
-  const byHeight = rects.toSorted(compareRects(order));
   // A gap fill puts a later rect before an earlier one, thus the order `input` fills no gaps
   const fillGaps = order !== "input";
 
   const rowRect = new Rect<T>();
   rowRect.size.set(outer.size.x, 0);
 
-  for (const rect of byHeight) {
+  for (const rect of byOrder) {
     if (rect.wasPacked) continue;
 
     if (rect.size.x > rowRect.size.x) {
@@ -73,7 +73,7 @@ function packRow<T>(rects: Rect<T>[], outer: Rect<T>, order: SortOrder): boolean
       outerLeft.position.setTo(rowRect.position);
       outerLeft.size.set(outer.size.x - rowRect.position.x, rowRect.size.y);
       outerLeft.fixedSize = true;
-      if (fillGaps) packInto(rects, outerLeft, outer.position, order);
+      if (fillGaps) packInto(byOrder, outerLeft, outer.position, order);
 
       rowRect.position.set(0, rowRect.bottom());
       rowRect.size.set(outer.size.x, 0);
@@ -84,7 +84,7 @@ function packRow<T>(rects: Rect<T>[], outer: Rect<T>, order: SortOrder): boolean
       if (outer.fixedSize) continue;
       outer.size.y += rect.size.y;
       if (!outer.fixedWidth && !outer.size.x) outer.size.x = rect.size.x;
-      Rect.resetPacked(rects);
+      Rect.resetPacked(byOrder);
       return false;
     }
 
@@ -103,12 +103,22 @@ function packRow<T>(rects: Rect<T>[], outer: Rect<T>, order: SortOrder): boolean
       outerLeft.size.set(rectInRow.size.x, rowRect.size.y - rectInRow.size.y);
       outerLeft.fixedWidth = true;
       outerLeft.fixedSize = true;
-      packInto(rects, outerLeft, outer.position, order);
+      packInto(byOrder, outerLeft, outer.position, order);
     }
   }
   return true;
 }
 
+/**
+ * This function packs rows of rectangles that are in the order `order` already. A stable sort orders by the key and then
+ * by the position in the input, and a filter keeps that order. Thus a gap fill gives the layout of a sort again.
+ */
+function packSortedRows<T>(byOrder: Rect<T>[], outer: Rect<T>, order: SortOrder): void {
+  for (const r of byOrder) if (r.locked) r.wasPacked = true;
+  // A row that does not fit grows the height and starts again, thus the gap fills of the try before do not count
+  while (!packRow(byOrder, outer, order)) if (fillDepth === 0) clearMoves(MOVES.rows);
+}
+
 /**
  * This function packs rectangles into an outer rectangle of a given width with a guillotine row packing. It does
  * not change the width. Without `fixedSize`, the height grows until all rectangles fit. A `locked` rectangle keeps
@@ -121,9 +131,8 @@ export function packRows<T>(rects: Rect<T>[], outer: Rect<T>, options: PackOptio
   const order = options.sortOrder ?? "height-desc";
   const space = options.space;
   if (space !== undefined && (!space.plain || rects.some((r) => r.locked))) return packRowsInSpace(rects, outer, order, space);
-  for (const r of rects) if (r.locked) r.wasPacked = true;
-  // A row that does not fit grows the height and starts again, thus the gap fills of the try before do not count
-  while (!packRow(rects, outer, order)) if (fillDepth === 0) clearMoves(MOVES.rows);
+  // toSorted gives a sorted copy, thus the order of the array of the caller stays. The sort happens once for each call.
+  packSortedRows(rects.toSorted(compareRects(order)), outer, order);
   return outer;
 }