@witchcraft/layout 0.3.1 → 0.4.1

package/dist/runtime/layout/getFrameCollapseInfo.js

@@ -2,11 +2,16 @@ import { pushIfNotIn } from "@alanscodelog/utils/pushIfNotIn";
 import { walk } from "@alanscodelog/utils/walk";
 import { applyFrameChanges } from "./applyFrameChanges.js";
 import { getFramesRedistributeInfo } from "./getFramesRedistributeInfo.js";
+import { framesRedistributeFix } from "../helpers/framesRedistributeFix.js";
+import { getPinnedEdgesForCollapsedFrames } from "../helpers/getPinnedEdgesForCollapsedFrames.js";
 import { oppositeSide } from "../helpers/oppositeSide.js";
 import { settings } from "../settings.js";
 import { LAYOUT_ERROR } from "../types/index.js";
 import { KnownError } from "../utils/KnownError.js";
-export function getFrameCollapseInfo(win, frameId) {
+export function getFrameCollapseInfo(win, frameId, {
+  collapseSizeScaled
+} = {}) {
+  collapseSizeScaled = collapseSizeScaled ?? settings.getCollapseSizeScaled(win);
   win = walk(win, void 0, { save: true });
   const frame = win.frames[frameId];
   if (!frame) throw new Error(`Unknown frame ${frameId}`);
@@ -25,42 +30,17 @@ export function getFrameCollapseInfo(win, frameId) {
   const posKey = isVertical ? "x" : "y";
   const oppositePosKey = isVertical ? "y" : "x";
   const oppositeSizeKey = isVertical ? "height" : "width";
-  const collapseSize = settings.collapseSizeScaled;
   const currentSize = frame[sizeKey];
-  const collapseAmount = collapseSize[sizeKey];
+  const collapseAmount = collapseSizeScaled[sizeKey];
   const shrinkAmount = currentSize - collapseAmount;
   const dockedSide = frame.docked;
-  const framesToFix = [];
-  const opposite = oppositeSide(dockedSide);
-  for (const other of Object.values(win.frames)) {
-    if (frame.id === other.id || !other.docked) continue;
-    if (other.docked === opposite) continue;
-    if (dockedSide === "left" || dockedSide === "top") {
-      if (other[posKey] !== 0) continue;
-      other[posKey] = frame[posKey] + frame[sizeKey];
-      other[sizeKey] -= frame[sizeKey];
-      framesToFix.push({
-        id: other.id,
-        posKey,
-        sizeKey,
-        type: "start"
-      });
-    } else {
-      if (other[posKey] + other[sizeKey] !== settings.maxInt) continue;
-      other[sizeKey] -= frame[sizeKey];
-      framesToFix.push({
-        id: other.id,
-        posKey,
-        sizeKey,
-        type: "end"
-      });
-    }
-  }
+  const { applyFixes, toFix } = framesRedistributeFix(win, frame, dockedSide, posKey, sizeKey, "shrink");
   const otherFrameIds = Object.keys(win.frames).filter((id) => id !== frameId);
   const redistributeSide = oppositeSide(dockedSide);
-  const changes = getFramesRedistributeInfo(win, redistributeSide, otherFrameIds, -shrinkAmount, true);
+  const pinnedEdgeCoordinates = getPinnedEdgesForCollapsedFrames(win, frame, dockedSide, posKey, sizeKey);
+  const changes = getFramesRedistributeInfo(win, redistributeSide, otherFrameIds, -shrinkAmount, { allowOutOfBounds: true, pinnedEdgeCoordinates });
   if (changes instanceof KnownError) {
-    if (changes.code === LAYOUT_ERROR.REDISTRIBUTE_OUT_OF_BOUNDS || LAYOUT_ERROR.NO_SPACE_TO_REDISTRIBUTE) {
+    if (changes.code === LAYOUT_ERROR.REDISTRIBUTE_OUT_OF_BOUNDS || changes.code === LAYOUT_ERROR.NO_SPACE_TO_REDISTRIBUTE) {
       changes.message = `This error should never happen, please file a bug report: ${changes.message}`;
       throw changes;
     }
@@ -68,24 +48,14 @@ export function getFrameCollapseInfo(win, frameId) {
   }
   applyFrameChanges(win, changes);
   pushIfNotIn(toExtract, changes.modified.map((_) => _.id));
-  for (const fix of framesToFix) {
-    const other = win.frames[fix.id];
-    if (fix.type === "start") {
-      const sizeDiff = other[fix.posKey];
-      other[fix.posKey] = 0;
-      other[fix.sizeKey] += sizeDiff;
-    } else {
-      const sizeDiff = settings.maxInt - (other[fix.posKey] + other[fix.sizeKey]);
-      other[fix.sizeKey] += sizeDiff;
-    }
-  }
-  pushIfNotIn(toExtract, framesToFix.map((_) => _.id));
+  applyFixes();
+  pushIfNotIn(toExtract, toFix);
   if (frame.docked === "right" || frame.docked === "bottom") {
-    frame[posKey] = frame[posKey] + (frame[sizeKey] - collapseSize[sizeKey]);
+    frame[posKey] = frame[posKey] + (frame[sizeKey] - collapseSizeScaled[sizeKey]);
   }
-  frame[sizeKey] = collapseSize[sizeKey];
+  frame[sizeKey] = collapseSizeScaled[sizeKey];
   frame.collapsed = currentSize;
-  if (collapseSize[sizeKey] === 0) {
+  if (collapseSizeScaled[sizeKey] === 0) {
     frame[oppositePosKey] = 0;
     frame[oppositeSizeKey] = settings.maxInt;
   }

package/dist/runtime/layout/getFrameDockInfo.d.ts

@@ -6,4 +6,4 @@ import { KnownError } from "../utils/KnownError.js";
  *
  * Changes can be applied to a window with {@link applyFrameChanges}.
  */
-export declare function getFrameDockInfo(win: LayoutWindow, frameId: string, side: EdgeSide, maxPerpendicularLength?: number): LayoutChange | KnownError<typeof LAYOUT_ERROR.REDISTRIBUTE_OUT_OF_BOUNDS> | KnownError<typeof LAYOUT_ERROR.NO_SPACE_TO_REDISTRIBUTE> | KnownError<typeof LAYOUT_ERROR.CANT_LEAVE_NO_UNDOCKED_FRAMES> | KnownError<typeof LAYOUT_ERROR.FRAME_ALREADY_DOCKED_ON_SIDE> | KnownError<typeof LAYOUT_ERROR.CANT_UNDOCK_COLLAPSED_FRAME> | KnownError<typeof LAYOUT_ERROR.NO_FILL_CANDIDATES>;
+export declare function getFrameDockInfo(win: LayoutWindow, frameId: string, side: EdgeSide, maxPerpendicularLength?: number): LayoutChange | KnownError<typeof LAYOUT_ERROR.REDISTRIBUTE_OUT_OF_BOUNDS> | KnownError<typeof LAYOUT_ERROR.NO_SPACE_TO_REDISTRIBUTE> | KnownError<typeof LAYOUT_ERROR.REDISTRIBUTE_WOULD_RESULT_IN_INVALID_FRAMES> | KnownError<typeof LAYOUT_ERROR.CANT_LEAVE_NO_UNDOCKED_FRAMES> | KnownError<typeof LAYOUT_ERROR.FRAME_ALREADY_DOCKED_ON_SIDE> | KnownError<typeof LAYOUT_ERROR.CANT_UNDOCK_COLLAPSED_FRAME> | KnownError<typeof LAYOUT_ERROR.NO_FILL_CANDIDATES>;

package/dist/runtime/layout/getFrameDockInfo.js

@@ -6,6 +6,7 @@ import { getFramesRedistributeInfo } from "./getFramesRedistributeInfo.js";
 import { getFrameUndockInfo } from "./getFrameUndockInfo.js";
 import { cloneFrame } from "../helpers/cloneFrame.js";
 import { getDockBoundaries } from "../helpers/getDockBoundaries.js";
+import { getPinnedEdgesForCollapsedFrames } from "../helpers/getPinnedEdgesForCollapsedFrames.js";
 import { oppositeSide } from "../helpers/oppositeSide.js";
 import { settings } from "../settings.js";
 import { LAYOUT_ERROR } from "../types/index.js";
@@ -44,7 +45,10 @@ export function getFrameDockInfo(win, frameId, side, maxPerpendicularLength) {
   applyFrameChanges(win, changes);
   pushIfNotIn(toExtract, changes.modified.map((_) => _.id));
   const sideToPushTowards = oppositeSide(side);
-  const redistributeChanges = getFramesRedistributeInfo(win, sideToPushTowards, nonDockedFrameIds, perpendicularLength);
+  const posKey = isHorizontal ? "x" : "y";
+  const sizeKey = isHorizontal ? "width" : "height";
+  const pinnedEdgeCoordinates = getPinnedEdgesForCollapsedFrames(win, frame, side, posKey, sizeKey);
+  const redistributeChanges = getFramesRedistributeInfo(win, sideToPushTowards, nonDockedFrameIds, perpendicularLength, { pinnedEdgeCoordinates });
   if (redistributeChanges instanceof KnownError) {
     return redistributeChanges;
   }

package/dist/runtime/layout/getFrameUncollapseInfo.d.ts

@@ -1,4 +1,4 @@
-import type { LayoutChange, LayoutWindow } from "../types/index.js";
+import type { LayoutChange, LayoutWindow, Size } from "../types/index.js";
 import { LAYOUT_ERROR } from "../types/index.js";
 import { KnownError } from "../utils/KnownError.js";
 /**
@@ -9,4 +9,7 @@ import { KnownError } from "../utils/KnownError.js";
  * Uncollapsing restores the frame to its pre-collapse size, shrinking neighboring
  * frames to make room.
  */
-export declare function getFrameUncollapseInfo(win: LayoutWindow, frameId: string): LayoutChange | KnownError<typeof LAYOUT_ERROR.CANT_UNCOLLAPSE_NOT_COLLAPSED> | KnownError<typeof LAYOUT_ERROR.REDISTRIBUTE_OUT_OF_BOUNDS> | KnownError<typeof LAYOUT_ERROR.NO_SPACE_TO_REDISTRIBUTE>;
+export declare function getFrameUncollapseInfo(win: LayoutWindow, frameId: string, { restoreSize }?: {
+    /** Override the size to restore the frame to. */
+    restoreSize?: Size;
+}): LayoutChange | KnownError<typeof LAYOUT_ERROR.CANT_UNCOLLAPSE_NOT_COLLAPSED> | KnownError<typeof LAYOUT_ERROR.REDISTRIBUTE_OUT_OF_BOUNDS> | KnownError<typeof LAYOUT_ERROR.NO_SPACE_TO_REDISTRIBUTE> | KnownError<typeof LAYOUT_ERROR.REDISTRIBUTE_WOULD_RESULT_IN_INVALID_FRAMES>;

package/dist/runtime/layout/getFrameUncollapseInfo.js

@@ -2,11 +2,14 @@ import { pushIfNotIn } from "@alanscodelog/utils/pushIfNotIn";
 import { walk } from "@alanscodelog/utils/walk";
 import { applyFrameChanges } from "./applyFrameChanges.js";
 import { getFramesRedistributeInfo } from "./getFramesRedistributeInfo.js";
+import { framesRedistributeFix } from "../helpers/framesRedistributeFix.js";
+import { getPinnedEdgesForCollapsedFrames } from "../helpers/getPinnedEdgesForCollapsedFrames.js";
 import { oppositeSide } from "../helpers/oppositeSide.js";
-import { settings } from "../settings.js";
 import { LAYOUT_ERROR } from "../types/index.js";
 import { KnownError } from "../utils/KnownError.js";
-export function getFrameUncollapseInfo(win, frameId) {
+export function getFrameUncollapseInfo(win, frameId, {
+  restoreSize
+} = {}) {
   win = walk(win, void 0, { save: true });
   const frame = win.frames[frameId];
   if (!frame) {
@@ -16,69 +19,32 @@ export function getFrameUncollapseInfo(win, frameId) {
     throw new Error(`Frame ${frameId} is not docked.`);
   }
   const toExtract = [frame.id];
-  const storedSize = frame.collapsed;
-  if (storedSize === void 0) {
+  const isVertical = frame.docked === "left" || frame.docked === "right";
+  const sizeKey = isVertical ? "width" : "height";
+  const posKey = isVertical ? "x" : "y";
+  const currentSize = frame[sizeKey];
+  const storedSize = restoreSize !== void 0 ? restoreSize[sizeKey] : frame.collapsed;
+  if (frame.collapsed === void 0) {
     return new KnownError(
       LAYOUT_ERROR.CANT_UNCOLLAPSE_NOT_COLLAPSED,
       `Frame ${frameId} is not collapsed.`,
       { frame }
     );
   }
-  const isVertical = frame.docked === "left" || frame.docked === "right";
-  const sizeKey = isVertical ? "width" : "height";
-  const posKey = isVertical ? "x" : "y";
-  const currentSize = frame[sizeKey];
   const expandAmount = storedSize - currentSize;
   const dockedSide = frame.docked;
-  const framesToFix = [];
-  const opposite = oppositeSide(dockedSide);
-  if (frame[sizeKey] !== 0) {
-    for (const other of Object.values(win.frames)) {
-      if (frame.id === other.id || !other.docked) continue;
-      if (other.width === 0 || other.height === 0) continue;
-      if (other.docked === opposite) continue;
-      if (dockedSide === "left" || dockedSide === "top") {
-        if (other[posKey] !== 0) continue;
-        other[posKey] = frame[posKey] + frame[sizeKey];
-        other[sizeKey] -= frame[sizeKey];
-        framesToFix.push({
-          id: other.id,
-          posKey,
-          sizeKey,
-          type: "start"
-        });
-      } else {
-        if (other[posKey] + other[sizeKey] !== settings.maxInt) continue;
-        other[sizeKey] -= frame[sizeKey];
-        framesToFix.push({
-          id: other.id,
-          posKey,
-          sizeKey,
-          type: "end"
-        });
-      }
-    }
-  }
+  const { applyFixes, toFix } = framesRedistributeFix(win, frame, dockedSide, posKey, sizeKey, "expand");
   const otherFrameIds = Object.keys(win.frames).filter((id) => id !== frameId);
   const redistributeSide = oppositeSide(frame.docked);
-  const changes = getFramesRedistributeInfo(win, redistributeSide, otherFrameIds, expandAmount);
+  const pinnedEdgeCoordinates = getPinnedEdgesForCollapsedFrames(win, frame, dockedSide, posKey, sizeKey);
+  const changes = getFramesRedistributeInfo(win, redistributeSide, otherFrameIds, expandAmount, { pinnedEdgeCoordinates });
   if (changes instanceof KnownError) {
     return changes;
   }
   applyFrameChanges(win, changes);
   pushIfNotIn(toExtract, changes.modified.map((_) => _.id));
-  for (const fix of framesToFix) {
-    const other = win.frames[fix.id];
-    if (fix.type === "start") {
-      const sizeDiff = other[fix.posKey];
-      other[fix.posKey] = 0;
-      other[fix.sizeKey] += sizeDiff;
-    } else {
-      const sizeDiff = settings.maxInt - (other[fix.posKey] + other[fix.sizeKey]);
-      other[fix.sizeKey] += sizeDiff;
-    }
-  }
-  pushIfNotIn(toExtract, framesToFix.map((_) => _.id));
+  applyFixes();
+  pushIfNotIn(toExtract, toFix);
   frame[sizeKey] = storedSize;
   frame.collapsed = void 0;
   if (frame.docked === "right" || frame.docked === "bottom") {

package/dist/runtime/layout/getFrameUndockInfo.js

@@ -34,6 +34,7 @@ export function getFrameUndockInfo(win, frameId) {
   const adjustmentKey = frameSide === "left" ? "x" : frameSide === "top" ? "y" : frameSide === "right" ? "width" : "height";
   const secondaryAdjustmentKey = frameSide === "left" ? "width" : frameSide === "top" ? "height" : frameSide === "right" ? "x" : "y";
   const adjustmentValue = frameSide === "left" || frameSide === "top" ? 0 : maxInt;
+  const perpendicularSizeKey = isVertical ? "width" : "height";
   const otherChanges = otherDockedFramesToResize.map((other) => {
     if (other.docked === shrinkStartKey) {
       frameClone[posKey] += other[sizeKey];
@@ -41,10 +42,12 @@ export function getFrameUndockInfo(win, frameId) {
     } else if (other.docked === shrinkEndKey) {
       frameClone[sizeKey] -= other[sizeKey];
     }
+    const otherIsVertical = other.docked === "left" || other.docked === "right";
+    const isSameAxis = isVertical === otherIsVertical;
     return {
       ...other,
       [adjustmentKey]: adjustmentValue,
-      [secondaryAdjustmentKey]: other[secondaryAdjustmentKey] + other[adjustmentKey]
+      ...isSameAxis ? { [secondaryAdjustmentKey]: other[secondaryAdjustmentKey] + other[adjustmentKey] } : { [perpendicularSizeKey]: maxInt }
     };
   });
   return { modified: [frameClone, ...otherChanges], created: [], deleted: [] };

package/dist/runtime/layout/getFramesRedistributeInfo.d.ts

@@ -10,7 +10,7 @@ import { KnownError } from "../utils/KnownError.js";
  *
  * If you try to resize a layout like this to the right, you will get issues with frame edges not lining up as frame B would be resized less than A. If you had a frame at the empty space that you excluded, it's right edge would no longer align with B's.
  *
- * See {@link getFrameCollapseInfo} and {@link getFrameUncollapseInfo} for how to work around this (you must move frames like A to share the edge then move them back). Excluding them from the calcuation usually leads to subtler errors. Such as if there are frames after A and B to the right, excluding A would mean A's right edge would stop aligning with those other frames.
+ * See {@link framesRedistributeFix} for the helper that is used internally to get around this.
  *
  * ┌────────────┐
  * │A           │
@@ -19,11 +19,27 @@ import { KnownError } from "../utils/KnownError.js";
  *    └─────────┘
  *
  * Also note that it automatically excludes all collapsed frames without an area (height or width === 0).
+ *
+ * ## Pinned Edges
+ *
+ * Pinned edges will not be moved, space will be redistributed amongst remaining space. If doing this would cause edges to get "flipped", function will return {@link LAYOUT_ERROR.REDISTRIBUTE_WOULD_RESULT_IN_INVALID_FRAMES}.
+ *
+ * ┌──┬──────────────┐
+ * │  │              │
+ * │  ├──────────┬───┤
+ * │  │          │   │
+ * │  │          │   │
+ * └──┴──────────┴───┘
  */
 export declare function getFramesRedistributeInfo(win: LayoutWindow, 
 /** Side to expand/shrink to. */
 side: EdgeSide, frameIds: string[], 
 /** This can be negative to expand the frames instead (e.g. when collapsing a docked frame). */
-amountScaled: number, 
-/** Allow the resize span to exceed window bounds. */
-allowOutOfBounds?: boolean): LayoutChange | KnownError<typeof LAYOUT_ERROR.REDISTRIBUTE_OUT_OF_BOUNDS> | KnownError<typeof LAYOUT_ERROR.NO_SPACE_TO_REDISTRIBUTE>;
+amountScaled: number, { allowOutOfBounds, pinnedEdgeCoordinates, skipMinSizeCheck }?: {
+    /** Allow the resize span to exceed window bounds. */
+    allowOutOfBounds?: boolean;
+    /** Frame IDs whose position and size must not change. Must be a subset of frameIds. */
+    pinnedEdgeCoordinates?: number[];
+    /** Skip the per-frame min size check. Frames may shrink very small but not to 0 or below. */
+    skipMinSizeCheck?: boolean;
+}): LayoutChange | KnownError<typeof LAYOUT_ERROR.REDISTRIBUTE_OUT_OF_BOUNDS> | KnownError<typeof LAYOUT_ERROR.NO_SPACE_TO_REDISTRIBUTE> | KnownError<typeof LAYOUT_ERROR.REDISTRIBUTE_WOULD_RESULT_IN_INVALID_FRAMES>;

package/dist/runtime/layout/getFramesRedistributeInfo.js

@@ -1,12 +1,22 @@
 import { settings } from "../settings.js";
 import { LAYOUT_ERROR } from "../types/index.js";
 import { KnownError } from "../utils/KnownError.js";
-export function getFramesRedistributeInfo(win, side, frameIds, amountScaled, allowOutOfBounds = false) {
+export function getFramesRedistributeInfo(win, side, frameIds, amountScaled, {
+  allowOutOfBounds = false,
+  pinnedEdgeCoordinates,
+  skipMinSizeCheck = false
+} = {}) {
   const isLeftOrTop = side === "left" || side === "top";
   const isHorizontalSide = side === "left" || side === "right";
   const posKey = isHorizontalSide ? "x" : "y";
   const sizeKey = isHorizontalSide ? "width" : "height";
   const frames = frameIds.map((id) => win.frames[id]);
+  const pinnedEdges = /* @__PURE__ */ new Set();
+  if (pinnedEdgeCoordinates) {
+    for (const coord of pinnedEdgeCoordinates) {
+      pinnedEdges.add(coord);
+    }
+  }
   const edgeSet = /* @__PURE__ */ new Set();
   for (const frame of frames) {
     edgeSet.add(frame[posKey]);
@@ -31,7 +41,26 @@ export function getFramesRedistributeInfo(win, side, frameIds, amountScaled, all
   }
   const oppositeEdgeIndex = isLeftOrTop ? uniqueEdges.length - 1 : 0;
   newEdges[oppositeEdgeIndex] = isLeftOrTop ? anchorEdge + newSpan : anchorEdge - newSpan;
-  const minSize = settings.minSizeScaled[sizeKey];
+  if (pinnedEdges.size > 0) {
+    for (let i = 0; i < uniqueEdges.length; i++) {
+      if (pinnedEdges.has(uniqueEdges[i])) {
+        newEdges[i] = uniqueEdges[i];
+      }
+    }
+    for (let i = 0; i < uniqueEdges.length - 1; i++) {
+      const startEdge = uniqueEdges[i];
+      const endEdge = uniqueEdges[i + 1];
+      const newStart = newEdges[i];
+      const newEnd = newEdges[i + 1];
+      if (newStart > newEnd) {
+        const hasPinnedEdge = pinnedEdges.has(startEdge) || pinnedEdges.has(endEdge);
+        if (hasPinnedEdge) {
+          return new KnownError(LAYOUT_ERROR.REDISTRIBUTE_WOULD_RESULT_IN_INVALID_FRAMES, `Redistribution would cause frames to cross pinned edge at ${pinnedEdges.has(startEdge) ? startEdge : endEdge}.`, { problemEdgeCoordinates: [startEdge, endEdge] });
+        }
+      }
+    }
+  }
+  const minSize = skipMinSizeCheck ? 0 : settings.minSizeScaled[sizeKey];
   const result = [];
   for (const frame of frames) {
     if (frame.collapsed && (frame.width === 0 || frame.height === 0)) continue;

package/dist/runtime/layout/getRelaxFramesInfo.d.ts

@@ -0,0 +1,7 @@
+import type { LayoutChange, LayoutWindow } from "../types/index.js";
+/**
+ * Experimental frame "relaxation" algorithm.
+ *
+ * Useful for expanding frames that have gotten too small. Used internally by {@link getUpdateWindowSizeInfo}
+ */
+export declare function getRelaxFramesInfo(win: LayoutWindow, passes?: number): LayoutChange<any>;

package/dist/runtime/layout/getRelaxFramesInfo.js

@@ -0,0 +1,91 @@
+import { pushIfNotIn } from "@alanscodelog/utils/pushIfNotIn";
+import { walk } from "@alanscodelog/utils/walk";
+import { getMoveEdgeInfo } from "../helpers/getMoveEdgeInfo.js";
+import { settings } from "../settings.js";
+import { KnownError } from "../utils/KnownError.js";
+export function getRelaxFramesInfo(win, passes = 2) {
+  win = walk(win, void 0, { save: true });
+  const toExtract = [];
+  const framesSortedHorizontal = Object.values(win.frames).filter((f) => f.width > 0 && f.width < settings.minSizeScaled.width && !f.collapsed).sort((a, b) => a.x - b.x);
+  const framesSortedVertical = Object.values(win.frames).filter((f) => f.height > 0 && f.height < settings.minSizeScaled.height && !f.collapsed).sort((a, b) => a.y - b.y);
+  for (let pass = 0; pass < passes; pass++) {
+    let anyChanged = false;
+    for (const orientation of ["horizontal", "vertical"]) {
+      const sizeKey = orientation === "horizontal" ? "width" : "height";
+      const posKey = orientation === "horizontal" ? "x" : "y";
+      const minSize = settings.minSizeScaled[sizeKey];
+      const frames = orientation === "horizontal" ? framesSortedHorizontal : framesSortedVertical;
+      if (frames.length === 0) {
+        continue;
+      }
+      for (const frame of frames) {
+        const deficit = minSize - frame[sizeKey];
+        if (deficit <= 0) continue;
+        const endEdge = {
+          startX: frame.x + frame.width,
+          startY: frame.y + frame.height,
+          endX: frame.x + frame.width,
+          endY: frame.y + frame.height
+        };
+        const touchingEnd = Object.values(win.frames).filter(
+          (f) => f.id !== frame.id && f[posKey] === frame[posKey] + frame[sizeKey] && !f.collapsed
+        );
+        if (touchingEnd.length > 0) {
+          const targetPos = {
+            x: orientation === "horizontal" ? frame.x + frame.width + deficit : frame.x,
+            y: orientation === "vertical" ? frame.y + frame.height + deficit : frame.y
+          };
+          const result = getMoveEdgeInfo(touchingEnd, endEdge, targetPos, settings.minSizeScaled, true, true);
+          if (!(result instanceof KnownError) && result.distance > 0) {
+            const expandBy = Math.min(deficit, result.distance);
+            frame[sizeKey] += expandBy;
+            for (const f of touchingEnd) {
+              f[posKey] += expandBy;
+              f[sizeKey] -= expandBy;
+            }
+            pushIfNotIn(toExtract, [frame.id, ...touchingEnd.map((f) => f.id)]);
+            anyChanged = true;
+            if (frame[sizeKey] >= minSize) continue;
+          }
+        }
+        if (frame[sizeKey] < minSize) {
+          const remainingDeficit = minSize - frame[sizeKey];
+          const startEdge = {
+            startX: frame.x,
+            startY: frame.y,
+            endX: frame.x,
+            endY: frame.y
+          };
+          const touchingStart = Object.values(win.frames).filter(
+            (f) => f.id !== frame.id && f[posKey] + f[sizeKey] === frame[posKey] && !f.collapsed
+          );
+          if (touchingStart.length > 0) {
+            const targetPos = {
+              x: orientation === "horizontal" ? frame.x - remainingDeficit : frame.x,
+              y: orientation === "vertical" ? frame.y - remainingDeficit : frame.y
+            };
+            const result = getMoveEdgeInfo(touchingStart, startEdge, targetPos, settings.minSizeScaled, true, true);
+            if (!(result instanceof KnownError) && result.distance > 0) {
+              const expandBy = Math.min(remainingDeficit, result.distance);
+              frame[posKey] -= expandBy;
+              frame[sizeKey] += expandBy;
+              for (const f of touchingStart) {
+                f[sizeKey] -= expandBy;
+              }
+              pushIfNotIn(toExtract, [frame.id, ...touchingStart.map((f) => f.id)]);
+              anyChanged = true;
+            }
+          }
+        }
+      }
+    }
+    if (!anyChanged) {
+      break;
+    }
+  }
+  return {
+    modified: toExtract.map((id) => win.frames[id]),
+    created: [],
+    deleted: []
+  };
+}

package/dist/runtime/layout/getUpdateWindowSizeInfo.d.ts

@@ -0,0 +1,13 @@
+import type { LayoutChange, LayoutWindow, PxSize } from "../types/index.js";
+/**
+ * Returns info to update the window size, keeping non-0 collapsed frames the same pixel size IF possible. Never returns an error.
+ *
+ * This sacrifices the min (percentage) size of other frames if needed, although not to the point of making them 0 size (which would break the layout).
+ *
+ * If there is absolutely no space, it will leave things as they are. This just means that the collapsed frame will shrink further than your ideal pixel width, but percentage size will stay the same.
+ *
+ * @experimental
+ */
+export declare function getUpdateWindowSizeInfo(win: LayoutWindow, event: PxSize, { relaxPasses }?: {
+    relaxPasses?: number;
+}): LayoutChange<any>;

package/dist/runtime/layout/getUpdateWindowSizeInfo.js

@@ -0,0 +1,65 @@
+import { pushIfNotIn } from "@alanscodelog/utils/pushIfNotIn";
+import { walk } from "@alanscodelog/utils/walk";
+import { applyFrameChanges } from "../layout/applyFrameChanges.js";
+import { getFrameCollapseInfo } from "../layout/getFrameCollapseInfo.js";
+import { getFrameUncollapseInfo } from "../layout/getFrameUncollapseInfo.js";
+import { getRelaxFramesInfo } from "../layout/getRelaxFramesInfo.js";
+import { settings } from "../settings.js";
+import { KnownError } from "../utils/KnownError.js";
+export function getUpdateWindowSizeInfo(win, event, { relaxPasses = 2 } = {}) {
+  win = walk(win, void 0, { save: true });
+  win.pxWidth = event.pxWidth;
+  win.pxHeight = event.pxHeight;
+  const maxInt = settings.maxInt;
+  const frames = Object.values(win.frames);
+  const dockedFrameIds = frames.filter((f) => f.collapsed).map((f) => f.id);
+  if (dockedFrameIds.length === 0) {
+    return {
+      modified: [],
+      created: [],
+      deleted: [],
+      window: { pxWidth: event.pxWidth, pxHeight: event.pxHeight }
+    };
+  }
+  const toExtract = [];
+  for (const frameId of dockedFrameIds) {
+    const frame = win.frames[frameId];
+    const orientation = frame.docked === "left" || frame.docked === "right" ? "horizontal" : "vertical";
+    const sizeKey = orientation === "horizontal" ? "width" : "height";
+    const targetPxSize = settings.collapseSizePx[sizeKey];
+    const targetScaled = Math.round(targetPxSize / (orientation === "horizontal" ? win.pxWidth : win.pxHeight) * maxInt);
+    if (frame[sizeKey] === targetScaled) continue;
+    if (frame[sizeKey] === 0) continue;
+    let result;
+    const wasCollapsed = frame.collapsed;
+    const wasMinSize = { ...settings.minSize };
+    settings.minSize = 1;
+    if (targetScaled < frame[sizeKey]) {
+      frame.collapsed = void 0;
+      result = getFrameCollapseInfo(win, frame.id, { collapseSizeScaled: { width: targetScaled, height: targetScaled } });
+    } else {
+      frame.collapsed = Infinity;
+      result = getFrameUncollapseInfo(win, frame.id, { restoreSize: { width: targetScaled, height: targetScaled } });
+    }
+    if (!(result instanceof KnownError)) {
+      applyFrameChanges(win, result);
+      pushIfNotIn(toExtract, result.modified.map((f) => f.id));
+    }
+    frame.collapsed = wasCollapsed;
+    settings.minSize = wasMinSize;
+    const result2 = getRelaxFramesInfo(win, relaxPasses);
+    if (!(result2 instanceof KnownError)) {
+      applyFrameChanges(win, result2);
+      pushIfNotIn(toExtract, result2.modified.map((f) => f.id));
+    }
+  }
+  return {
+    modified: toExtract.map((id) => win.frames[id]),
+    created: [],
+    deleted: [],
+    window: {
+      pxWidth: event.pxWidth,
+      pxHeight: event.pxHeight
+    }
+  };
+}

package/dist/runtime/layout/index.d.ts

@@ -19,6 +19,7 @@ export { getFrameSwapInfo } from "./getFrameSwapInfo.js";
 export { getFrameTo } from "./getFrameTo.js";
 export { getFrameUncollapseInfo } from "./getFrameUncollapseInfo.js";
 export { getFrameUndockInfo } from "./getFrameUndockInfo.js";
+export { getUpdateWindowSizeInfo } from "./getUpdateWindowSizeInfo.js";
 export { getWindowDragZones } from "./getWindowDragZones.js";
 export { isPointInRect } from "./isPointInRect.js";
 export { layoutAddWindow } from "./layoutAddWindow.js";

package/dist/runtime/layout/index.js

@@ -19,6 +19,7 @@ export { getFrameSwapInfo } from "./getFrameSwapInfo.js";
 export { getFrameTo } from "./getFrameTo.js";
 export { getFrameUncollapseInfo } from "./getFrameUncollapseInfo.js";
 export { getFrameUndockInfo } from "./getFrameUndockInfo.js";
+export { getUpdateWindowSizeInfo } from "./getUpdateWindowSizeInfo.js";
 export { getWindowDragZones } from "./getWindowDragZones.js";
 export { isPointInRect } from "./isPointInRect.js";
 export { layoutAddWindow } from "./layoutAddWindow.js";

package/dist/runtime/layout/resizeFrame.js

@@ -1,5 +1,5 @@
+import { clampNumber } from "@alanscodelog/utils/clampNumber";
 import { findFramesTouchingEdge } from "./findFramesTouchingEdge.js";
-import { clampNumber } from "../helpers/clampNumber.js";
 import { frameToEdges } from "../helpers/frameToEdges.js";
 import { getEdgeOrientation } from "../helpers/getEdgeOrientation.js";
 import { getResizeLimit } from "../helpers/getResizeLimit.js";
@@ -8,7 +8,6 @@ import { isWindowEdge } from "../helpers/isWindowEdge.js";
 import { resizeByEdge } from "../helpers/resizeByEdge.js";
 import { settings } from "../settings.js";
 export function resizeFrame(win, frame, dir, distance, minSize = settings.minSizeScaled) {
-  const originalDistance = distance;
   const frameEdges = frameToEdges(frame);
   const resizeEdges = dir === "up" ? [frameEdges.top] : dir === "down" ? [frameEdges.bottom] : dir === "vertical" ? [frameEdges.top, frameEdges.bottom] : dir === "left" ? [frameEdges.left] : dir === "right" ? [frameEdges.right] : [frameEdges.left, frameEdges.right];
   let divideDistance = false;
@@ -52,7 +51,6 @@ export function resizeFrame(win, frame, dir, distance, minSize = settings.minSiz
       }
     }
     if (!foundEdge) {
-      distance = originalDistance;
       continue;
     }
     const touchingFrames = findFramesTouchingEdge(foundEdge, Object.values(win.frames))?.map((_) => _.frame);

package/dist/runtime/settings.d.ts

@@ -1,5 +1,20 @@
 import type { Point, Size } from "./types/index.js";
 export declare class Settings {
+    private initialized;
+    constructor();
+    resetToDefaults(): void;
+    _zoneSizes: {
+        frameEdgePx: number;
+        windowEdgePx: number;
+    };
+    get zoneSizes(): {
+        frameEdgePx: number;
+        windowEdgePx: number;
+    };
+    set zoneSizes(v: number | {
+        frameEdgePx: number;
+        windowEdgePx: number;
+    });
     private _scale;
     private _maxInt;
     get scale(): number;
@@ -7,7 +22,7 @@ export declare class Settings {
     get maxInt(): number;
     private _snapPoint;
     private _snapPointScaled;
-    get snapPoint(): number | Point;
+    get snapPoint(): Point;
     set snapPoint(v: number | Point);
     get snapPointScaled(): {
         x: number;
@@ -15,23 +30,19 @@ export declare class Settings {
     };
     private _minSize;
     private _minSizeScaled;
-    get minSize(): number | Size;
+    get minSize(): Size;
     set minSize(v: number | Size);
-    get minSizeScaled(): {
-        width: number;
-        height: number;
-    };
-    private _collapseSize;
-    private _collapseSizeScaled;
-    get collapseSize(): number | Size;
-    set collapseSize(v: number | Size);
-    get collapseSizeScaled(): {
-        width: number;
-        height: number;
-    };
+    get minSizeScaled(): Size;
+    private _collapseSizePx;
+    get collapseSizePx(): Size;
+    set collapseSizePx(v: number | Size);
+    getCollapseSizeScaled(win: {
+        pxWidth: number;
+        pxHeight: number;
+    }): Size;
     private _maxPerpendicularLength;
     private _maxPerpendicularLengthScaled;
-    get maxPerpendicularLength(): number | Size;
+    get maxPerpendicularLength(): Size;
     set maxPerpendicularLength(v: number | Size);
     get maxPerpendicularLengthScaled(): {
         width: number;
@@ -40,9 +51,5 @@ export declare class Settings {
     private _scalePoint;
     private _scaleSize;
     private _recalcAll;
-    zoneSizes: {
-        frameEdgePx: number;
-        windowEdgePx: number;
-    };
 }
 export declare const settings: Settings;