@witchcraft/layout 0.3.1 → 0.4.1

package/src/runtime/layout/getFrameUncollapseInfo.ts

@@ -4,9 +4,10 @@ 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 type { EdgeSide, LayoutChange, LayoutWindow } from "../types/index.js"
+import type { EdgeSide, LayoutChange, LayoutWindow, Size } from "../types/index.js"
 import { LAYOUT_ERROR } from "../types/index.js"
 import { KnownError } from "../utils/KnownError.js"
 
@@ -20,19 +21,33 @@ import { KnownError } from "../utils/KnownError.js"
  */
 export function getFrameUncollapseInfo(
 	win: LayoutWindow,
-	frameId: string
+	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.NO_SPACE_TO_REDISTRIBUTE>
+	| KnownError<typeof LAYOUT_ERROR.REDISTRIBUTE_WOULD_RESULT_IN_INVALID_FRAMES> {
 	win = walk(win, undefined, { save: true })
 	const frame = win.frames[frameId]
 	if (!frame) { throw new Error(`Unknown frame ${frameId}`) }
 	if (!frame.docked) { throw new Error(`Frame ${frameId} is not docked.`) }
 	const toExtract = [frame.id]
 
-	const storedSize = frame.collapsed
-	if (storedSize === undefined) {
+
+	const isVertical = frame.docked === "left" || frame.docked === "right"
+	const sizeKey = isVertical ? "width" : "height" as const
+	const posKey = isVertical ? "x" : "y"
+	const currentSize = frame[sizeKey]
+
+	const storedSize = (restoreSize !== undefined ? restoreSize[sizeKey] : frame.collapsed)!
+
+	if (frame.collapsed === undefined) {
 		return new KnownError(
 			LAYOUT_ERROR.CANT_UNCOLLAPSE_NOT_COLLAPSED,
 			`Frame ${frameId} is not collapsed.`,
@@ -40,93 +55,21 @@ export function getFrameUncollapseInfo(
 		)
 	}
 
-	const isVertical = frame.docked === "left" || frame.docked === "right"
-	const sizeKey = isVertical ? "width" : "height" as const
-	const posKey = isVertical ? "x" : "y"
-	const currentSize = frame[sizeKey]
 	const expandAmount = storedSize - currentSize
 
+
 	const dockedSide = frame.docked as EdgeSide
 
-	/**
-	 * Mirrors the framesToFix logic in getFrameCollapseInfo:
-	 *
-	 * The only difference being we can skip the fixes if the frame was fully collapsed to 0.
-	 *
-	 * Why is this? Well take this example where A is docked and collapsed and B is docked, in the following two cases we would have no problems expanding as B ends where A begins, but if B shares the edge and A is not fully collapsed it is no longer aligned with the "end" of A.
-	 *
-	 * Ok:
-	 * A - fully collapsed to 0
-	 * ~ ┌──────────┐
-	 * │ │B*        │
-	 * │ ├──────────┤
-	 * │ │          │
-	 * │ │          │
-	 * │ └──────────┘
-	 *
-	 * Ok:
-	 * A collapsed to non-zero size
-	 * Note B still shares A's right edge
-	 * ┌──┬─────────┐
-	 * │A~│B*       │
-	 * │  ├─────────┤
-	 * │  │         │
-	 * │  │         │
-	 * └──┴─────────┘
-	 *
-	 * Causes issues:
-	 * A collapsed to non-zero size with B docked first
-	 * B looses alignment with A causing issues when redistributing
-	 * ┌────────────┐
-	 * │B*          │
-	 * ├──┬─────────┤
-	 * │A~│         │
-	 * │  │         │
-	 * └──┴─────────┘
-	 */
-	const framesToFix: ({
-		id: string
-		posKey: "x" | "y"
-		sizeKey: "width" | "height"
-		type: "start" | "end"
-	})[] = []
-
-	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] // this is collapsed size
-				framesToFix.push({
-					id: other.id,
-					posKey: posKey,
-					sizeKey: sizeKey,
-					type: "start"
-				})
-			} else {
-				if (other[posKey] + other[sizeKey] !== settings.maxInt) continue
-				other[sizeKey] -= frame[sizeKey]
-				framesToFix.push({
-					id: other.id,
-					posKey: posKey,
-					sizeKey: sizeKey,
-					type: "end"
-				})
-			}
-		}
-	}
+	const { applyFixes, toFix } = framesRedistributeFix(win, frame, dockedSide, posKey, sizeKey, "expand")
 
 	// note fully collapsed frames without an area are already excluded by getFramesRedistributeInfo
 	const otherFrameIds = Object.keys(win.frames).filter(id => id !== frameId)
 
 	const redistributeSide = oppositeSide(frame.docked)
 
-	const changes = getFramesRedistributeInfo(win, redistributeSide, otherFrameIds, expandAmount)
+	const pinnedEdgeCoordinates: number[] = getPinnedEdgesForCollapsedFrames(win, frame, dockedSide, posKey, sizeKey)
+
+	const changes = getFramesRedistributeInfo(win, redistributeSide, otherFrameIds, expandAmount, { pinnedEdgeCoordinates })
 
 	if (changes instanceof KnownError) {
 		return changes
@@ -135,19 +78,8 @@ export function getFrameUncollapseInfo(
 	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 = undefined
@@ -158,3 +90,4 @@ export function getFrameUncollapseInfo(
 
 	return { modified: toExtract.map(_ => win.frames[_]), created: [], deleted: [] }
 }
+

package/src/runtime/layout/getFrameUndockInfo.ts

@@ -78,6 +78,9 @@ export function getFrameUndockInfo(
 				: "y"
 
 	const adjustmentValue = frameSide === "left" || frameSide === "top" ? 0 : maxInt
+	// for perpendicular frames (e.g. top/bottom when undocking left/right),
+	// expand along the dimension perpendicular to the undock axis
+	const perpendicularSizeKey = isVertical ? "width" : "height" as const
 	const otherChanges = otherDockedFramesToResize.map(other => {
 		// shrink the ends of the undocking frame
 		if (other.docked === shrinkStartKey) {
@@ -86,10 +89,13 @@ export function getFrameUndockInfo(
 		} else if (other.docked === shrinkEndKey) {
 			frameClone[sizeKey] -= other[sizeKey]
 		}
+		// same-axis frames shift their position; perpendicular frames expand their dimension to fill the space
+		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 })
 		}
 	})
 

package/src/runtime/layout/getFramesRedistributeInfo.ts

@@ -13,7 +13,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           │
@@ -22,7 +22,19 @@ 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 function getFramesRedistributeInfo(
 	win: LayoutWindow,
 	/** Side to expand/shrink to. */
@@ -30,11 +42,22 @@ export function getFramesRedistributeInfo(
 	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 = false
+	{
+		allowOutOfBounds = false,
+		pinnedEdgeCoordinates,
+		skipMinSizeCheck = false
+	}: {
+		/** 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.NO_SPACE_TO_REDISTRIBUTE>
+	| KnownError<typeof LAYOUT_ERROR.REDISTRIBUTE_WOULD_RESULT_IN_INVALID_FRAMES> {
 	const isLeftOrTop = side === "left" || side === "top"
 	const isHorizontalSide = side === "left" || side === "right"
 	const posKey = isHorizontalSide ? "x" : "y" as const
@@ -42,6 +65,13 @@ export function getFramesRedistributeInfo(
 
 	const frames = frameIds.map(id => win.frames[id])
 
+	const pinnedEdges = new Set<number>()
+	if (pinnedEdgeCoordinates) {
+		for (const coord of pinnedEdgeCoordinates) {
+			pinnedEdges.add(coord)
+		}
+	}
+
 	const edgeSet = new Set<number>()
 	for (const frame of frames) {
 		edgeSet.add(frame[posKey])
@@ -59,6 +89,7 @@ export function getFramesRedistributeInfo(
 	const anchorEdge = isLeftOrTop ? uniqueEdges[0] : uniqueEdges[uniqueEdges.length - 1]
 	const dirMultiplier = isLeftOrTop ? -1 : 1
 
+	// calculate new edges using proportional algo
 	const newEdges: number[] = []
 	for (let i = 0; i < uniqueEdges.length; i++) {
 		const edge = uniqueEdges[i]
@@ -72,8 +103,31 @@ export function getFramesRedistributeInfo(
 	const oppositeEdgeIndex = isLeftOrTop ? uniqueEdges.length - 1 : 0
 	newEdges[oppositeEdgeIndex] = isLeftOrTop ? anchorEdge + newSpan : anchorEdge - newSpan
 
+	// if we have pinned edges, force them back to their original positions
+	if (pinnedEdges.size > 0) {
+		for (let i = 0; i < uniqueEdges.length; i++) {
+			if (pinnedEdges.has(uniqueEdges[i])) {
+				newEdges[i] = uniqueEdges[i]
+			}
+		}
+
+		// check for flipped frames - a non-pinned edge should not cross a pinned edge
+		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 = settings.minSizeScaled[sizeKey]
+	const minSize = skipMinSizeCheck ? 0 : settings.minSizeScaled[sizeKey]
 	const result: LayoutFrame[] = []
 	for (const frame of frames) {
 		if (frame.collapsed && (frame.width === 0 || frame.height === 0)) continue
@@ -83,6 +137,7 @@ export function getFramesRedistributeInfo(
 		const newEnd = newEdges[uniqueEdges.indexOf(endEdge)]
 		const newSize = newEnd - newStart
 
+
 		if (newSize < minSize) {
 			return new KnownError(LAYOUT_ERROR.NO_SPACE_TO_REDISTRIBUTE, `Redistribute would cause frame ${frame.id} to shrink to ${newSize} which is below minimum ${minSize}.`, { frameSizeNeeded: newSize, minFrameSize: minSize })
 		}

package/src/runtime/layout/getRelaxFramesInfo.ts

@@ -0,0 +1,139 @@
+import { pushIfNotIn } from "@alanscodelog/utils/pushIfNotIn"
+import { walk } from "@alanscodelog/utils/walk"
+
+import { getMoveEdgeInfo } from "../helpers/getMoveEdgeInfo.js"
+import { settings } from "../settings.js"
+import type { LayoutChange, LayoutWindow } from "../types/index.js"
+import { KnownError } from "../utils/KnownError.js"
+
+
+/**
+ * Experimental frame "relaxation" algorithm.
+ *
+ * Useful for expanding frames that have gotten too small. Used internally by {@link getUpdateWindowSizeInfo}
+ */
+export function getRelaxFramesInfo(
+	win: LayoutWindow,
+	passes: number = 2
+): LayoutChange<any> {
+	win = walk(win, undefined, { save: true })
+
+	const toExtract: string[] = []
+	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"] as const) {
+			const sizeKey = orientation === "horizontal" ? "width" : "height" as const
+			const posKey = orientation === "horizontal" ? "x" : "y" as const
+			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
+
+				// try expanding the right/bottom edge first
+				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 still too small, try expanding the left/top edge
+				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/src/runtime/layout/getUpdateWindowSizeInfo.ts

@@ -0,0 +1,105 @@
+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 type { LayoutChange, LayoutWindow, PxSize } from "../types/index.js"
+import { KnownError } from "../utils/KnownError.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 function getUpdateWindowSizeInfo(
+	win: LayoutWindow,
+	event: PxSize,
+	{ relaxPasses = 2 }: { relaxPasses?: number } = {}
+): LayoutChange<any> {
+	win = walk(win, undefined, { save: true }) as LayoutWindow
+
+	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: string[] = []
+	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" as const
+		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: LayoutChange | KnownError<any>
+
+		// the logic needed to do this is nearly identical to the collapse/uncollapse logic
+		// so we abuse the functions a bit, in future might allow a more flexible collapse/uncollapse function
+		const wasCollapsed = frame.collapsed
+		const wasMinSize = { ...settings.minSize }
+		settings.minSize = 1
+		if (targetScaled < frame[sizeKey]) {
+			// clear temporarily so collapse doesn't error
+			frame.collapsed = undefined
+			result = getFrameCollapseInfo(win, frame.id, { collapseSizeScaled: { width: targetScaled, height: targetScaled } })
+		} else {
+			// set to something, could be anything
+			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))
+		}
+
+		// restore original collapsed value
+		frame.collapsed = wasCollapsed
+		settings.minSize = wasMinSize
+
+
+		// attempt relaxation
+		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/src/runtime/layout/index.ts

@@ -21,6 +21,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/src/runtime/layout/resizeFrame.ts

@@ -1,6 +1,7 @@
+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"
@@ -19,7 +20,7 @@ export function resizeFrame(
 	/** Scaled */
 	minSize: Size = settings.minSizeScaled
 ): boolean {
-	const originalDistance = distance
+	// const originalDistance = distance
 	const frameEdges = frameToEdges(frame)
 	const resizeEdges = dir === "up"
 		? [frameEdges.top]
@@ -85,7 +86,7 @@ export function resizeFrame(
 		}
 
 		if (!foundEdge) {
-			distance = originalDistance
+			// distance = originalDistance
 			continue
 		}