@witchcraft/layout 0.4.2 → 0.4.4

package/src/runtime/drag/FrameDragAction.ts

@@ -13,6 +13,9 @@ import type { KnownError } from "../utils/KnownError.js"
 
 export class FrameDragAction implements IDragAction {
 	name = "frameDrag" as const
+
+	minDragDistance = 5
+
 	state: {
 		lastReturn?: LayoutChange<"split" | "swap" | "rearrange" | "dock"> | KnownError
 	} = {
@@ -52,12 +55,15 @@ export class FrameDragAction implements IDragAction {
 		hooks: FrameDragAction["hooks"] = {},
 		config?: {
 			debug?: boolean | string
+			/** Minimum pixel distance the user must drag before the action is allowed (decos shown and action applied). Defaults to 5. */
+			minDragDistance?: number
 		}
 	) {
 		if (handleEvent !== undefined) this.handleEvent = handleEvent
 		if (modifyDecos !== undefined) this.modifyDecos = modifyDecos
 		this.hooks = hooks
 		if (config?.debug) this.debug = true
+		if (config?.minDragDistance !== undefined) this.minDragDistance = config.minDragDistance
 
 		this.reset()
 	}
@@ -149,6 +155,9 @@ export class FrameDragAction implements IDragAction {
 		_e: PointerEvent | undefined,
 		state: DragState
 	): ActionDragChangeResult {
+		if (state.dragDistance <= this.minDragDistance) {
+			return { updateEdges: false, shapes: [], showDragging: false }
+		}
 		const { win, draggingFrameId, dragHoveredFrame } = state
 		const matchedZone = getDragZones(state, settings.zoneSizes)
 

package/src/runtime/drag/SplitAction.ts

@@ -16,6 +16,7 @@ export type DragChangeType = "start" | "move" | "end"
 
 export class SplitAction implements IDragAction {
 	name = "split" as const
+	minDragDistance = 5
 
 	state: {
 		allowed: true
@@ -57,6 +58,8 @@ export class SplitAction implements IDragAction {
 		config?: {
 			debug?: boolean | string
 			splitHints?: Partial<SplitAction["splitHints"]>
+			/** Minimum pixel distance the user must drag before the action is allowed (decos shown and action applied). Defaults to 5. */
+			minDragDistance?: number
 		}
 	) {
 		if (handleEvent !== undefined) this.handleEvent = handleEvent
@@ -65,6 +68,7 @@ export class SplitAction implements IDragAction {
 		this.hooks = hooks
 		this.reset()
 		if (config?.debug) this.debug = true
+		if (config?.minDragDistance !== undefined) this.minDragDistance = config.minDragDistance
 		if (config?.splitHints?.actions) this.splitHints.actions = config.splitHints.actions
 		if (config?.splitHints?.transformError) this.splitHints.transformError = config.splitHints.transformError
 	}
@@ -106,7 +110,8 @@ export class SplitAction implements IDragAction {
 	canHandleRequest(e: PointerEvent | KeyboardEvent, state: DragState): boolean {
 		const { draggingEdges } = state
 		if (draggingEdges.length !== 1) return false
-		this.setTextHints(state.isDragging === "edge" ? true : undefined)
+		// hint should not be shown when dragging from window edge but we should still handle the event
+		this.setTextHints(state.isDragging === "edge" && !state.isDraggingFromWindowEdge ? true : undefined)
 		if (this.handleEvent(e, state)) {
 			this.hooks.onStart?.()
 			return true
@@ -154,7 +159,7 @@ export class SplitAction implements IDragAction {
 			dragDirections[oppositeOrientation]!,
 			dragPoint!
 		)
-		this.setTextHints(canSplit)
+		this.setTextHints(state.isDragging === "edge" && !state.isDraggingFromWindowEdge ? canSplit : undefined)
 		if (!(canSplit instanceof Error)) {
 			this.state.allowed = true
 			this.state.res = canSplit
@@ -173,7 +178,10 @@ export class SplitAction implements IDragAction {
 		_e: PointerEvent | undefined,
 		state: DragState
 	): ActionDragChangeResult {
-		const { dragHoveredFrame } = state
+		const { dragHoveredFrame, dragDistance } = state
+		if (dragDistance <= this.minDragDistance) {
+			return { updateEdges: false, shapes: [], showDragging: false }
+		}
 		let ok = false
 		if (dragHoveredFrame) {
 			if (this.state.lastPoint?.x === state.dragPoint?.x && this.state.lastPoint?.y === state.dragPoint?.y && this.state.lastReturn) {

package/src/runtime/helpers/findEdgesTouchingWindow.ts

@@ -0,0 +1,30 @@
+import { settings } from "../settings.js"
+import type { EdgeSide, LayoutFrame } from "../types/index.js"
+
+/**
+ * Checks which window edges a frame touches and how.
+ *
+ * @returns Record mapping touched sides to `"full"` (spans the entire edge) or `"partial"` (touches but doesn't span fully). Only touched sides are included as keys.
+ */
+export function findEdgesTouchingWindow(frame: LayoutFrame): Partial<Record<EdgeSide, "full" | "partial">> {
+	const maxInt = settings.maxInt
+	const result: Partial<Record<EdgeSide, "full" | "partial">> = {}
+
+	const spansVertical = frame.y === 0 && frame.y + frame.height === maxInt
+	const spansHorizontal = frame.x === 0 && frame.x + frame.width === maxInt
+
+	if (frame.x === 0) {
+		result.left = spansVertical ? "full" : "partial"
+	}
+	if (frame.x + frame.width === maxInt) {
+		result.right = spansVertical ? "full" : "partial"
+	}
+	if (frame.y === 0) {
+		result.top = spansHorizontal ? "full" : "partial"
+	}
+	if (frame.y + frame.height === maxInt) {
+		result.bottom = spansHorizontal ? "full" : "partial"
+	}
+
+	return result
+}

package/src/runtime/helpers/index.ts

@@ -12,6 +12,7 @@ export { assertValidWinAndFrameIds } from "./assertValidWinAndFrameIds.js"
 export { assertWindowHasActiveFrame } from "./assertWindowHasActiveFrame.js"
 export { cloneFrame } from "./cloneFrame.js"
 export { cloneFrames } from "./cloneFrames.js"
+export { consoleDebugWindow } from "./consoleDebugWindow.js"
 export { containsEdge } from "./containsEdge.js"
 export { convertLayoutWindowToWorkspace } from "./convertLayoutWindowToWorkspace.js"
 export { copySize } from "./copySize.js"
@@ -24,17 +25,21 @@ export { doesEdgeContinueEdge } from "./doesEdgeContinueEdge.js"
 export { edgeToPoints } from "./edgeToPoints.js"
 export { findDraggableEdge } from "./findDraggableEdge.js"
 export { findFrameDraggableEdges } from "./findFrameDraggableEdges.js"
+export { framesRedistributeFix } from "./framesRedistributeFix.js"
 export { frameToEdges } from "./frameToEdges.js"
 export { frameToPoints } from "./frameToPoints.js"
+export { getDockBoundaries } from "./getDockBoundaries.js"
 export { getEdgeLength } from "./getEdgeLength.js"
 export { getEdgeOrientation } from "./getEdgeOrientation.js"
 export { getEdgeSharedDirection } from "./getEdgeSharedDirection.js"
 export { getEdgeSide } from "./getEdgeSide.js"
 export { getFrameById } from "./getFrameById.js"
 export { getFrameConstant } from "./getFrameConstant.js"
+export { findEdgesTouchingWindow } from "./findEdgesTouchingWindow.js"
 export { getIntersections } from "./getIntersections.js"
 export { getIntersectionsCss } from "./getIntersectionsCss.js"
 export { getMoveEdgeInfo } from "./getMoveEdgeInfo.js"
+export { getPinnedEdgesForCollapsedFrames } from "./getPinnedEdgesForCollapsedFrames.js"
 export { getResizeLimit } from "./getResizeLimit.js"
 export { getShapeRectCss } from "./getShapeRectCss.js"
 export { getSideTouching } from "./getSideTouching.js"
@@ -55,9 +60,10 @@ export { isWindowEdge } from "./isWindowEdge.js"
 export { isWindowEdgePoint } from "./isWindowEdgePoint.js"
 export { moveEdge } from "./moveEdge.js"
 export { numberToScaledPercent } from "./numberToScaledPercent.js"
-export { pxSizeToScaledSize } from "./pxSizeToScaledSize.js"
 export { oppositeSide } from "./oppositeSide.js"
+export { pxSizeToScaledSize } from "./pxSizeToScaledSize.js"
 export { resizeByEdge } from "./resizeByEdge.js"
+export { rotateLayout } from "./rotateFrames.js"
 export { scaledPointToPx } from "./scaledPointToPx.js"
 export { sideToDirection } from "./sideToDirection.js"
 export { sideToOrientation } from "./sideToOrientation.js"
@@ -67,3 +73,4 @@ export { toId } from "./toId.js"
 export { toWindowCoord } from "./toWindowCoord.js"
 export { unionEdges } from "./unionEdges.js"
 export { updateWindowWithEvent } from "./updateWindowSizeWithEvent.js"
+export { validateLayoutShape } from "./validateLayoutShape.js"

package/src/runtime/layout/debugFrame.ts

@@ -1,6 +1,11 @@
+import { keys } from "@alanscodelog/utils/keys"
+
 import type { LayoutFrame } from "../types/index.js"
 
+const builtinProperties = ["id", "x", "y", "width", "height", "docked", "collapsed"]
 export function debugFrame(frame: LayoutFrame): string {
 	const f = frame
-	return `id: ${f.id.slice(0, 4)}, x:  ${f.x}, y: ${f.y}, w: ${f.width}, h: ${f.height}\ndocked: ${f.docked}, collapsed: ${f.collapsed}`
+	const otherProperties = keys(f).filter(k => !builtinProperties.includes(k)).map(k => `${k}: ${f[k]}`)
+	const otherPropertiesString = otherProperties.length > 0 ? `, ${otherProperties.join(", ")}` : ""
+	return `id: ${f.id.slice(0, 4)}, x:  ${f.x}, y: ${f.y}, w: ${f.width}, h: ${f.height}\ndocked: ${f.docked}, collapsed: ${f.collapsed}${otherPropertiesString}`
 }

package/src/runtime/layout/getFrameCollapseInfo.ts

@@ -2,13 +2,10 @@ import { pushIfNotIn } from "@alanscodelog/utils/pushIfNotIn"
 import { walk } from "@alanscodelog/utils/walk"
 
 import { applyFrameChanges } from "./applyFrameChanges.js"
-import { getFramesRedistributeInfo } from "./getFramesRedistributeInfo.js"
+import { getFrameShrinkInfo } from "./getFrameShrinkInfo.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, Size } 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"
 
@@ -32,7 +29,8 @@ export function getFrameCollapseInfo(
 	} = {}
 ): LayoutChange
 	| KnownError<typeof LAYOUT_ERROR.CANT_COLLAPSE_NOT_DOCKED>
-	| KnownError<typeof LAYOUT_ERROR.REDISTRIBUTE_WOULD_RESULT_IN_INVALID_FRAMES> {
+	| KnownError<typeof LAYOUT_ERROR.REDISTRIBUTE_WOULD_RESULT_IN_INVALID_FRAMES>
+	| KnownError<typeof LAYOUT_ERROR.CANT_RESIZE_SINGLE_FRAME> {
 	collapseSizeScaled = collapseSizeScaled ?? settings.getCollapseSizeScaled(win)
 	win = walk(win, undefined, { save: true }) as typeof win
 	const frame = win.frames[frameId]
@@ -51,55 +49,28 @@ export function getFrameCollapseInfo(
 
 	const isVertical = frame.docked === "left" || frame.docked === "right"
 	const sizeKey = isVertical ? "width" : "height" as const
-	const posKey = isVertical ? "x" : "y"
-	const oppositePosKey = isVertical ? "y" : "x"
-	const oppositeSizeKey = isVertical ? "height" : "width"
-
 
 	const currentSize = frame[sizeKey]
-	const collapseAmount = collapseSizeScaled[sizeKey]
-	const shrinkAmount = currentSize - collapseAmount
-
-	const dockedSide = frame.docked as EdgeSide
-
-	const { applyFixes, toFix } = framesRedistributeFix(win, frame, dockedSide, posKey, sizeKey, "shrink")
-
-	// 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(dockedSide)
+	const shrinkAmount = currentSize - collapseSizeScaled[sizeKey]
 
-	const pinnedEdgeCoordinates: number[] = getPinnedEdgesForCollapsedFrames(win, frame, dockedSide, posKey, sizeKey)
+	const shrinkResult = getFrameShrinkInfo(win, frameId, shrinkAmount, frame.docked, { allowOutOfBounds: true })
 
-	const changes = getFramesRedistributeInfo(win, redistributeSide, otherFrameIds, -shrinkAmount, { allowOutOfBounds: true, pinnedEdgeCoordinates })
-
-	if (changes instanceof KnownError) {
-		// we should never get out of bounds and because this is a collapse there should always be space
-		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
-		}
-		return changes
+	if (shrinkResult instanceof KnownError) {
+		return shrinkResult
 	}
-	applyFrameChanges(win, changes)
-	pushIfNotIn(toExtract, changes.modified.map(_ => _.id))
-
 
-	applyFixes()
-	pushIfNotIn(toExtract, toFix)
+	applyFrameChanges(win, shrinkResult)
+	pushIfNotIn(toExtract, shrinkResult.modified.map(_ => _.id))
 
-	if (frame.docked === "right" || frame.docked === "bottom") {
-		frame[posKey] = frame[posKey] + (frame[sizeKey] - collapseSizeScaled[sizeKey])
-	}
-	frame[sizeKey] = collapseSizeScaled[sizeKey]
 	frame.collapsed = currentSize
 	// when we collapse to 0 it's a special case where the frame will always fit the entire window edge
 	// for proper uncollapsing later
 	if (collapseSizeScaled[sizeKey] === 0) {
+		const oppositePosKey = isVertical ? "y" : "x"
+		const oppositeSizeKey = isVertical ? "height" : "width"
 		frame[oppositePosKey] = 0
 		frame[oppositeSizeKey] = settings.maxInt
 	}
 
 	return { modified: toExtract.map(_ => win.frames[_]), created: [], deleted: [] }
 }
-

package/src/runtime/layout/getFrameDockInfo.ts

@@ -3,10 +3,12 @@ import { walk } from "@alanscodelog/utils/walk"
 
 import { applyFrameChanges } from "./applyFrameChanges.js"
 import { getFillEmptySpaceInfo } from "./getFillEmptySpaceInfo.js"
+import { getFrameShrinkInfo } from "./getFrameShrinkInfo.js"
 import { getFramesRedistributeInfo } from "./getFramesRedistributeInfo.js"
 import { getFrameUndockInfo } from "./getFrameUndockInfo.js"
 
 import { cloneFrame } from "../helpers/cloneFrame.js"
+import { findEdgesTouchingWindow } from "../helpers/findEdgesTouchingWindow.js"
 import { getDockBoundaries } from "../helpers/getDockBoundaries.js"
 import { getPinnedEdgesForCollapsedFrames } from "../helpers/getPinnedEdgesForCollapsedFrames.js"
 import { oppositeSide } from "../helpers/oppositeSide.js"
@@ -33,7 +35,8 @@ export function getFrameDockInfo(
 	| 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> {
+	| KnownError<typeof LAYOUT_ERROR.NO_FILL_CANDIDATES>
+	| KnownError<typeof LAYOUT_ERROR.CANT_RESIZE_SINGLE_FRAME> {
 	// its easier to just clone the window and extract changes later
 	// setting the var ensures we don't accidentally mutate the original
 	win = walk(win, undefined, { save: true }) as typeof win
@@ -57,8 +60,9 @@ export function getFrameDockInfo(
 
 	const isHorizontal = side === "left" || side === "right"
 	const perpendicular = isHorizontal ? "width" : "height"
+	const posKey = isHorizontal ? "x" : "y"
+	const sizeKey = isHorizontal ? "width" : "height"
 
-	const oldFrame = cloneFrame(frame)
 	const otherFrameIds = Object.keys(win.frames).filter(_ => _ !== frameId)
 	const nonDockedFrameIds = otherFrameIds.filter(id => !win.frames[id].docked)
 	if (nonDockedFrameIds.length === 0) {
@@ -66,68 +70,84 @@ export function getFrameDockInfo(
 	}
 
 	// if its the only frame allow it to be as big as it likes
-	const effectiveMaxPerpendicular = maxPerpendicularLength ?? settings.maxPerpendicularLengthScaled.width
-	const perpendicularLength = otherFrameIds.length > 0 ? Math.min(frame[perpendicular], effectiveMaxPerpendicular) : frame[perpendicular]
+	const maxPerpendicular = maxPerpendicularLength ?? settings.maxPerpendicularLengthScaled.width
+	const perpendicularLength = otherFrameIds.length > 0 ? Math.min(frame[perpendicular], maxPerpendicular) : frame[perpendicular]
 
 	frame.docked = side
 	frame.collapsed = undefined
 
 	const toExtract = [frame.id]
 
-	// fills just the hole left by the frame when it was moved
-	const changes = getFillEmptySpaceInfo(win, oldFrame, [], [frameId])
-	if (changes instanceof Error) return changes
-	applyFrameChanges(win, changes)
-	pushIfNotIn(toExtract, changes.modified.map(_ => _.id))
-
-
-	// redistribute other non-docked frames to make room for the new dock.
-	const sideToPushTowards = oppositeSide(side)
-
-	const posKey = isHorizontal ? "x" : "y"
-	const sizeKey = isHorizontal ? "width" : "height"
-
-	const pinnedEdgeCoordinates: number[] = getPinnedEdgesForCollapsedFrames(win, frame, side, posKey, sizeKey)
-
-	const redistributeChanges = getFramesRedistributeInfo(win, sideToPushTowards, nonDockedFrameIds, perpendicularLength, { pinnedEdgeCoordinates })
-
-	if (redistributeChanges instanceof KnownError) {
-		return redistributeChanges
+	if (frame[perpendicular] === perpendicularLength) {
+		return { modified: toExtract.map(_ => win.frames[_]), created: [], deleted: [] }
 	}
-	applyFrameChanges(win, redistributeChanges)
-	pushIfNotIn(toExtract, redistributeChanges.modified.map(_ => _.id))
-
-
-	const { minX, maxX, minY, maxY } = getDockBoundaries(win)
-	switch (side) {
-		case "left":
-			frame.x = 0
-			frame.y = minY
-			frame.width = perpendicularLength
-			frame.height = maxY - minY
-			break
-		case "right":
-			frame.x = settings.maxInt - perpendicularLength
-			frame.y = minY
-			frame.width = perpendicularLength
-			frame.height = maxY - minY
-			break
-		case "top":
-			frame.x = minX
-			frame.y = 0
-			frame.width = maxX - minX
-			frame.height = perpendicularLength
-			break
-		case "bottom":
-			frame.x = minX
-			frame.y = settings.maxInt - perpendicularLength
-			frame.width = maxX - minX
-			frame.height = perpendicularLength
-			break
-	}
-
 
-	const res = toExtract.map(_ => win.frames[_])
+	// check if the frame touches the full edge it will be docked to (not just it's dock boundary)
+	// if so, we can use getFrameShrinkInfo instead of fill-empty-space + redistribute
+	// this feels better as otherwise, the other frames feel like they are unnecessarily moved to the other side
+	// this way where the frame *was* feels like it's taken into account
+	const touchesEntireEdge = findEdgesTouchingWindow(frame)[side] === "full"
+
+	if (touchesEntireEdge) {
+		const shrinkAmount = frame[sizeKey] - perpendicularLength
+		if (shrinkAmount > 0) {
+			const shrinkResult = getFrameShrinkInfo(win, frameId, shrinkAmount, side)
+			if (shrinkResult instanceof KnownError) {
+				return shrinkResult
+			}
+			applyFrameChanges(win, shrinkResult)
+			pushIfNotIn(toExtract, shrinkResult.modified.map(_ => _.id))
+		}
+	} else {
+		const oldFrame = cloneFrame(frame)
+
+		// fills just the hole left by the frame when it was moved
+		const changes = getFillEmptySpaceInfo(win, oldFrame, [], [frameId])
+		if (changes instanceof Error) return changes
+		applyFrameChanges(win, changes)
+		pushIfNotIn(toExtract, changes.modified.map(_ => _.id))
+
+		// redistribute other non-docked frames to make room for the new dock.
+		const sideToPushTowards = oppositeSide(side)
+
+		const pinnedEdgeCoordinates: number[] = getPinnedEdgesForCollapsedFrames(win, frame, side, posKey, sizeKey)
+
+		const redistributeChanges = getFramesRedistributeInfo(win, sideToPushTowards, nonDockedFrameIds, perpendicularLength, { pinnedEdgeCoordinates })
+
+		if (redistributeChanges instanceof KnownError) {
+			return redistributeChanges
+		}
+		applyFrameChanges(win, redistributeChanges)
+		pushIfNotIn(toExtract, redistributeChanges.modified.map(_ => _.id))
+
+		const { minX, maxX, minY, maxY } = getDockBoundaries(win)
+		switch (side) {
+			case "left":
+				frame.x = 0
+				frame.y = minY
+				frame.width = perpendicularLength
+				frame.height = maxY - minY
+				break
+			case "right":
+				frame.x = settings.maxInt - perpendicularLength
+				frame.y = minY
+				frame.width = perpendicularLength
+				frame.height = maxY - minY
+				break
+			case "top":
+				frame.x = minX
+				frame.y = 0
+				frame.width = maxX - minX
+				frame.height = perpendicularLength
+				break
+			case "bottom":
+				frame.x = minX
+				frame.y = settings.maxInt - perpendicularLength
+				frame.width = maxX - minX
+				frame.height = perpendicularLength
+				break
+		}
+	}
 
-	return { modified: res, created: [], deleted: [] }
+	return { modified: toExtract.map(_ => win.frames[_]), created: [], deleted: [] }
 }

package/src/runtime/layout/getFrameExpandInfo.ts

@@ -0,0 +1,84 @@
+import { pushIfNotIn } from "@alanscodelog/utils/pushIfNotIn"
+import { walk } from "@alanscodelog/utils/walk"
+
+import { applyFrameChanges } from "./applyFrameChanges.js"
+import { getFramesRedistributeInfo } from "./getFramesRedistributeInfo.js"
+
+import { findEdgesTouchingWindow } from "../helpers/findEdgesTouchingWindow.js"
+import { framesRedistributeFix } from "../helpers/framesRedistributeFix.js"
+import { getPinnedEdgesForCollapsedFrames } from "../helpers/getPinnedEdgesForCollapsedFrames.js"
+import { oppositeSide } from "../helpers/oppositeSide.js"
+import type { EdgeSide, LayoutChange, LayoutWindow } from "../types/index.js"
+import { LAYOUT_ERROR } from "../types/index.js"
+import { KnownError } from "../utils/KnownError.js"
+
+/**
+ * Returns a {@link LayoutChange} with the information necessary to expand a frame touching a window edge by a given amount.
+ *
+ * Changes can be applied to a window with {@link applyFrameChanges}.
+ *
+ * It expands the frame by redistributing space from neighboring frames.
+ */
+export function getFrameExpandInfo(
+	win: LayoutWindow,
+	frameId: string,
+	amount: number,
+	expandSide: EdgeSide
+): 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_RESIZE_SINGLE_FRAME> {
+	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]
+
+	if (Object.keys(win.frames).length === 1) {
+		return new KnownError(LAYOUT_ERROR.CANT_RESIZE_SINGLE_FRAME, `Frame ${frameId} is the only frame, cannot expand.`, { frame })
+	}
+
+	// verify the frame actually touches the specified edge
+	if (!(expandSide in findEdgesTouchingWindow(frame))) {
+		throw new Error(`Frame ${frameId} does not touch the ${expandSide} edge.`)
+	}
+
+
+	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 dockedSide = frame.docked as EdgeSide
+
+	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 pinnedEdgeCoordinates: number[] = getPinnedEdgesForCollapsedFrames(win, frame, dockedSide, posKey, sizeKey)
+
+	const changes = getFramesRedistributeInfo(win, redistributeSide, otherFrameIds, amount, { pinnedEdgeCoordinates })
+
+	if (changes instanceof KnownError) {
+		return changes
+	}
+
+	applyFrameChanges(win, changes)
+	pushIfNotIn(toExtract, changes.modified.map(_ => _.id))
+
+	applyFixes()
+	pushIfNotIn(toExtract, toFix)
+
+	frame[sizeKey] = currentSize + amount
+
+	if (frame.docked === "right" || frame.docked === "bottom") {
+		frame[posKey] -= amount
+	}
+
+	return { modified: toExtract.map(_ => win.frames[_]), created: [], deleted: [] }
+}

package/src/runtime/layout/getFrameShrinkInfo.ts

@@ -0,0 +1,87 @@
+import { pushIfNotIn } from "@alanscodelog/utils/pushIfNotIn"
+import { walk } from "@alanscodelog/utils/walk"
+
+import { applyFrameChanges } from "./applyFrameChanges.js"
+import { getFramesRedistributeInfo } from "./getFramesRedistributeInfo.js"
+
+import { findEdgesTouchingWindow } from "../helpers/findEdgesTouchingWindow.js"
+import { framesRedistributeFix } from "../helpers/framesRedistributeFix.js"
+import { getPinnedEdgesForCollapsedFrames } from "../helpers/getPinnedEdgesForCollapsedFrames.js"
+import { oppositeSide } from "../helpers/oppositeSide.js"
+import type { EdgeSide, LayoutChange, LayoutWindow } from "../types/index.js"
+import { LAYOUT_ERROR } from "../types/index.js"
+import { KnownError } from "../utils/KnownError.js"
+
+/**
+ * Returns a {@link LayoutChange} with the information necessary to shrink a frame touching a window edge by a given amount.
+ *
+ * Changes can be applied to a window with {@link applyFrameChanges}.
+ *
+ * It shrinks the frame by redistributing the freed space to neighboring frames.
+ */
+export function getFrameShrinkInfo(
+	win: LayoutWindow,
+	frameId: string,
+	amount: number,
+	shrinkSide: EdgeSide,
+	{
+		allowOutOfBounds = false
+	}: {
+		/** Allow the resize span to exceed window bounds. */
+		allowOutOfBounds?: boolean
+	} = {}
+): LayoutChange
+	| KnownError<typeof LAYOUT_ERROR.REDISTRIBUTE_WOULD_RESULT_IN_INVALID_FRAMES>
+	| KnownError<typeof LAYOUT_ERROR.CANT_RESIZE_SINGLE_FRAME> {
+	win = walk(win, undefined, { save: true }) as typeof win
+	const frame = win.frames[frameId]
+	if (!frame) throw new Error(`Unknown frame ${frameId}`)
+
+	if (Object.keys(win.frames).length === 1) {
+		return new KnownError(LAYOUT_ERROR.CANT_RESIZE_SINGLE_FRAME, `Frame ${frameId} is the only frame, cannot shrink.`, { frame })
+	}
+
+	// verify the frame actually touches the specified edge
+	if (!(shrinkSide in findEdgesTouchingWindow(frame))) {
+		throw new Error(`Frame ${frameId} does not touch the ${shrinkSide} edge.`)
+	}
+
+	const isVertical = shrinkSide === "left" || shrinkSide === "right"
+	const sizeKey = isVertical ? "width" : "height" as const
+	const posKey = isVertical ? "x" : "y"
+
+	const toExtract = [frame.id]
+
+	const { applyFixes, toFix } = framesRedistributeFix(win, frame, shrinkSide, posKey, sizeKey, "shrink")
+
+	// 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(shrinkSide)
+
+	const pinnedEdgeCoordinates: number[] = getPinnedEdgesForCollapsedFrames(win, frame, shrinkSide, posKey, sizeKey)
+
+	const changes = getFramesRedistributeInfo(win, redistributeSide, otherFrameIds, -amount, { allowOutOfBounds, pinnedEdgeCoordinates })
+
+	if (changes instanceof KnownError) {
+		// we should never get out of bounds and because this is a shrink there should always be space
+		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
+		}
+		return changes
+	}
+	applyFrameChanges(win, changes)
+	pushIfNotIn(toExtract, changes.modified.map(_ => _.id))
+
+
+	applyFixes()
+	pushIfNotIn(toExtract, toFix)
+
+	if (shrinkSide === "right" || shrinkSide === "bottom") {
+		frame[posKey] = frame[posKey] + amount
+	}
+	frame[sizeKey] = frame[sizeKey] - amount
+
+	return { modified: toExtract.map(_ => win.frames[_]), created: [], deleted: [] }
+}