@witchcraft/layout 0.4.3 → 0.5.0

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"
@@ -22,19 +23,23 @@ export { dirToSide } from "./dirToSide.js"
 export { doEdgesOverlap } from "./doEdgesOverlap.js"
 export { doesEdgeContinueEdge } from "./doesEdgeContinueEdge.js"
 export { edgeToPoints } from "./edgeToPoints.js"
-export { findDraggableEdge } from "./findDraggableEdge.js"
-export { findFrameDraggableEdges } from "./findFrameDraggableEdges.js"
+export { findMoveableEdge } from "./findMoveableEdge.js"
+export { findFrameMoveableEdges } from "./findFrameMoveableEdges.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/createSplitDecoFromDrag.ts

@@ -8,7 +8,7 @@ export function createSplitDecoFromDrag(
 	frames: Record<string, LayoutFrame>,
 	frame: LayoutFrame,
 	dragDirection: Direction,
-	dragPoint: Point,
+	movePoint: Point,
 	snapAmount: Point = settings.snapPointScaled,
 	minSize: Size = settings.minSizeScaled,
 	classes: {
@@ -22,7 +22,7 @@ export function createSplitDecoFromDrag(
 	const deco: RawSplitDeco & Partial<SplitDeco> = {
 		type: "split",
 		id: frame.id,
-		position: dragPoint[orientation === "horizontal" ? "x" : "y"],
+		position: movePoint[orientation === "horizontal" ? "x" : "y"],
 		direction: dragDirection
 	}
 	deco.shapes = createSplitDecoShapes(frames, deco, snapAmount, minSize, classes)

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/findSafeSplitEdge.ts

@@ -8,15 +8,15 @@ import type { Direction, Edge, LayoutFrame, Point, Size } from "../types/index.j
 export function findSafeSplitEdgeAndPosition(
 	frame: LayoutFrame,
 	dragDirection: Direction,
-	dragPointOrPosition: Point | number,
+	movePointOrPosition: Point | number,
 	snapAmount: Point = settings.snapPointScaled,
 	minSize: Size = settings.minSizeScaled
 ): { edge: Edge, position: number } {
 	const orientation = dirToOrientation(dragDirection)
 	const position
-		= typeof dragPointOrPosition === "number"
-			? dragPointOrPosition
-			: dragPointOrPosition[orientation === "horizontal" ? "x" : "y"]
+		= typeof movePointOrPosition === "number"
+			? movePointOrPosition
+			: movePointOrPosition[orientation === "horizontal" ? "x" : "y"]
 
 	const coordKey = orientation === "vertical" ? "y" : "x"
 	const sizeKey = orientation === "vertical" ? "height" : "width"

package/src/runtime/layout/getCloseFrameInfo.ts

@@ -7,7 +7,7 @@ import { findVisualEdge } from "./findVisualEdge.js"
 
 import { cloneFrame } from "../helpers/cloneFrame.js"
 import { dirToSide } from "../helpers/dirToSide.js"
-import { findFrameDraggableEdges } from "../helpers/findFrameDraggableEdges.js"
+import { findFrameMoveableEdges } from "../helpers/findFrameMoveableEdges.js"
 import { getEdgeOrientation } from "../helpers/getEdgeOrientation.js"
 import { oppositeSide } from "../helpers/oppositeSide.js"
 import { settings } from "../settings.js"
@@ -119,9 +119,9 @@ export function getCloseFrameInfo<T extends "edge" | "dir">(
 		: closeDirOrSide as EdgeSide
 	const sideOpposite = oppositeSide(side)
 
-	const draggableEdges = findFrameDraggableEdges(frame, visualEdges, !force, [side])
-	if (!draggableEdges) return new KnownError(LAYOUT_ERROR.CANT_CLOSE_NO_DRAG_EDGE, `Could not find draggable edge for frame ${frame.id}`, { frame })
-	const { edge: frameEdge } = draggableEdges[0]
+	const moveableEdges = findFrameMoveableEdges(frame, visualEdges, !force, [side])
+	if (!moveableEdges) return new KnownError(LAYOUT_ERROR.CANT_CLOSE_NO_DRAG_EDGE, `Could not find draggable edge for frame ${frame.id}`, { frame })
+	const { edge: frameEdge } = moveableEdges[0]
 
 	const visualEdge = findVisualEdge(visualEdges, frameEdge)
 	if (visualEdge === undefined) unreachable()

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/getFrameRearrangeInfo.ts

@@ -7,7 +7,7 @@ import { getSideTouching } from "../helpers/getSideTouching.js"
 import { isEdgeEqual } from "../helpers/isEdgeEqual.js"
 import { oppositeSide } from "../helpers/oppositeSide.js"
 import { sideToDirection } from "../helpers/sideToDirection.js"
-import type { DragZone, LayoutChange, LayoutWindow } from "../types/index.js"
+import type { LayoutChange, LayoutWindow, Zone } from "../types/index.js"
 import { LAYOUT_ERROR } from "../types/index.js"
 import { KnownError } from "../utils/KnownError.js"
 
@@ -150,9 +150,9 @@ import { KnownError } from "../utils/KnownError.js"
 
 export function getFrameRearrangeInfo(
 	win: LayoutWindow,
-	draggingFrameId: string,
+	movingFrameId: string,
 	hoveredFrameId: string,
-	zoneSide: DragZone["side"]
+	zoneSide: Zone["side"]
 ): LayoutChange<"split" | "swap" | "rearrange">
 	| KnownError<typeof LAYOUT_ERROR.CANT_SWAP_WITH_SELF>
 	| KnownError<typeof LAYOUT_ERROR.CANT_SPLIT_FRAME_TOO_SMALL>
@@ -161,10 +161,10 @@ export function getFrameRearrangeInfo(
 	| KnownError<typeof LAYOUT_ERROR.CANT_REARRANGE_DOCKED_WITH_NON_DOCKED>
 	| KnownError<typeof LAYOUT_ERROR.CANT_SPLIT_DOCKED_FRAME>
 	| KnownError<typeof LAYOUT_ERROR.NO_FILL_CANDIDATES> {
-	const draggingFrame = { ...win.frames[draggingFrameId] }
+	const draggingFrame = { ...win.frames[movingFrameId] }
 	const hoveredFrame = { ...win.frames[hoveredFrameId] }
 
-	if (draggingFrameId === hoveredFrameId) {
+	if (movingFrameId === hoveredFrameId) {
 		if (zoneSide === "center") return new KnownError(LAYOUT_ERROR.CANT_SWAP_WITH_SELF, `Can't swap frame with self.`, { frame: hoveredFrame, zoneSide })
 	}
 
@@ -180,12 +180,12 @@ export function getFrameRearrangeInfo(
 	}
 
 	if (draggingFrame.docked && !hoveredFrame.docked) { // center swapping IS allowed above
-		return new KnownError(LAYOUT_ERROR.CANT_REARRANGE_DOCKED_WITH_NON_DOCKED, `Can't rearrange docked frame ${draggingFrameId} with non-docked frame ${hoveredFrameId}, can only swap.`, { draggingFrameId, hoveredFrameId, zoneSide })
+		return new KnownError(LAYOUT_ERROR.CANT_REARRANGE_DOCKED_WITH_NON_DOCKED, `Can't rearrange docked frame ${movingFrameId} with non-docked frame ${hoveredFrameId}, can only swap.`, { movingFrameId, hoveredFrameId, zoneSide })
 	}
 
 	// block edge rearrange on docked frames
 	if (hoveredFrame.docked) { // again center swapping docked to undocked and vice versa is allowed
-		return new KnownError(LAYOUT_ERROR.CANT_REARRANGE_WITH_DOCKED_EDGES, `Can't rearrange with docked frame ${hoveredFrameId} edge, can only swap.`, { draggingFrameId, hoveredFrameId, zoneSide })
+		return new KnownError(LAYOUT_ERROR.CANT_REARRANGE_WITH_DOCKED_EDGES, `Can't rearrange with docked frame ${hoveredFrameId} edge, can only swap.`, { movingFrameId, hoveredFrameId, zoneSide })
 	}
 
 	const touchingSide = getSideTouching(draggingFrame, hoveredFrame)
@@ -206,7 +206,7 @@ export function getFrameRearrangeInfo(
 				}
 			}
 			if (hoverOppositeSide === zoneSide) {
-				return new KnownError(LAYOUT_ERROR.CANT_REARRANGE_TO_SAME_RELATIVE_POSITION, `Frame ${draggingFrameId} is already on the ${zoneSide} of ${hoveredFrameId}`, { draggingFrameId, hoveredFrameId, zoneSide })
+				return new KnownError(LAYOUT_ERROR.CANT_REARRANGE_TO_SAME_RELATIVE_POSITION, `Frame ${movingFrameId} is already on the ${zoneSide} of ${hoveredFrameId}`, { movingFrameId, hoveredFrameId, zoneSide })
 			}
 		}
 	}
@@ -224,7 +224,7 @@ export function getFrameRearrangeInfo(
 	const splitFrame = splitResult.modified[0]
 	const newFrame = splitResult.created[0]
 
-	if (draggingFrameId === hoveredFrameId) {
+	if (movingFrameId === hoveredFrameId) {
 		return { ...splitResult, deleted: [], info: "split" }
 	}
 
@@ -249,7 +249,7 @@ export function getFrameRearrangeInfo(
 			[draggingFrame.id]: draggingFrame
 		}
 	}
-	const changes = getFillEmptySpaceInfo(winCopy, emptySpace, [hoveredFrameId, draggingFrameId])
+	const changes = getFillEmptySpaceInfo(winCopy, emptySpace, [hoveredFrameId, movingFrameId])
 	if (changes instanceof KnownError) return changes
 
 	// it will also be missing said changes unless it further moved the frames which is not alway

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: [] }
+}

package/src/runtime/layout/getFrameSplitInfo.ts

@@ -21,7 +21,7 @@ import { KnownError } from "../utils/KnownError.js"
 export function getFrameSplitInfo(
 	frame: LayoutFrame,
 	dir: Direction,
-	dragPointOrPosition: Point | number | "midpoint" = "midpoint",
+	movePointOrPosition: Point | number | "midpoint" = "midpoint",
 	minSize: Size = settings.minSizeScaled,
 	snapAmount: Point = settings.snapPointScaled
 ): LayoutChange
@@ -42,11 +42,11 @@ export function getFrameSplitInfo(
 	const sizeKey: "width" | "height" = isHorz ? "width" : "height"
 	const posKey: "x" | "y" = isHorz ? "x" : "y"
 
-	const position = dragPointOrPosition === "midpoint"
+	const position = movePointOrPosition === "midpoint"
 		? (isHorz ? frame.x + (frame.width / 2) : frame.y + (frame.height / 2))
-		: typeof dragPointOrPosition === "number"
-			? dragPointOrPosition
-			: dragPointOrPosition[isHorz ? "x" : "y"]
+		: typeof movePointOrPosition === "number"
+			? movePointOrPosition
+			: movePointOrPosition[isHorz ? "x" : "y"]
 
 	const safePosition = findSafeSplitEdgeAndPosition(
 		frame,