@witchcraft/layout 0.4.3 → 0.5.0

package/dist/runtime/helpers/index.js

@@ -9,6 +9,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";
@@ -19,19 +20,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";
@@ -52,9 +57,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";
@@ -64,3 +70,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/dist/runtime/layout/createSplitDecoFromDrag.d.ts

@@ -1,5 +1,5 @@
 import type { Direction, LayoutFrame, Point, Size, SplitDeco } from "../types/index.js";
-export declare function createSplitDecoFromDrag(frames: Record<string, LayoutFrame>, frame: LayoutFrame, dragDirection: Direction, dragPoint: Point, snapAmount?: Point, minSize?: Size, classes?: {
+export declare function createSplitDecoFromDrag(frames: Record<string, LayoutFrame>, frame: LayoutFrame, dragDirection: Direction, movePoint: Point, snapAmount?: Point, minSize?: Size, classes?: {
     /** @default "deco-split-edge bg-red-500" */
     splitEdge?: string;
     /** @default "deco-split-new-frame bg-blue-500/50" */

package/dist/runtime/layout/createSplitDecoFromDrag.js

@@ -1,12 +1,12 @@
 import { createSplitDecoShapes } from "./createSplitDecoShapes.js";
 import { dirToOrientation } from "../helpers/dirToOrientation.js";
 import { settings } from "../settings.js";
-export function createSplitDecoFromDrag(frames, frame, dragDirection, dragPoint, snapAmount = settings.snapPointScaled, minSize = settings.minSizeScaled, classes = {}) {
+export function createSplitDecoFromDrag(frames, frame, dragDirection, movePoint, snapAmount = settings.snapPointScaled, minSize = settings.minSizeScaled, classes = {}) {
   const orientation = dirToOrientation(dragDirection);
   const deco = {
     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/dist/runtime/layout/debugFrame.js

@@ -1,5 +1,9 @@
+import { keys } from "@alanscodelog/utils/keys";
+const builtinProperties = ["id", "x", "y", "width", "height", "docked", "collapsed"];
 export function debugFrame(frame) {
   const f = frame;
+  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}
-docked: ${f.docked}, collapsed: ${f.collapsed}`;
+docked: ${f.docked}, collapsed: ${f.collapsed}${otherPropertiesString}`;
 }

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

@@ -1,5 +1,5 @@
 import type { Direction, Edge, LayoutFrame, Point, Size } from "../types/index.js";
-export declare function findSafeSplitEdgeAndPosition(frame: LayoutFrame, dragDirection: Direction, dragPointOrPosition: Point | number, snapAmount?: Point, minSize?: Size): {
+export declare function findSafeSplitEdgeAndPosition(frame: LayoutFrame, dragDirection: Direction, movePointOrPosition: Point | number, snapAmount?: Point, minSize?: Size): {
     edge: Edge;
     position: number;
 };

package/dist/runtime/layout/findSafeSplitEdge.js

@@ -2,9 +2,9 @@ import { clampNumber, snapNumber } from "@alanscodelog/utils";
 import { dirToOrientation } from "../helpers/dirToOrientation.js";
 import { oppositeSide } from "../helpers/oppositeSide.js";
 import { settings } from "../settings.js";
-export function findSafeSplitEdgeAndPosition(frame, dragDirection, dragPointOrPosition, snapAmount = settings.snapPointScaled, minSize = settings.minSizeScaled) {
+export function findSafeSplitEdgeAndPosition(frame, dragDirection, movePointOrPosition, snapAmount = settings.snapPointScaled, minSize = settings.minSizeScaled) {
   const orientation = dirToOrientation(dragDirection);
-  const position = typeof dragPointOrPosition === "number" ? dragPointOrPosition : dragPointOrPosition[orientation === "horizontal" ? "x" : "y"];
+  const position = typeof movePointOrPosition === "number" ? movePointOrPosition : movePointOrPosition[orientation === "horizontal" ? "x" : "y"];
   const coordKey = orientation === "vertical" ? "y" : "x";
   const sizeKey = orientation === "vertical" ? "height" : "width";
   const pos = snapNumber(position, snapAmount[coordKey]);

package/dist/runtime/layout/getCloseFrameInfo.js

@@ -5,7 +5,7 @@ import { findFramesTouchingEdge } from "./findFramesTouchingEdge.js";
 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";
@@ -28,9 +28,9 @@ export function getCloseFrameInfo(frames, visualEdges, frame, closeDirOrSide, cl
   }
   const side = closeBy === "dir" ? oppositeSide(dirToSide(closeDirOrSide)) : closeDirOrSide;
   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 === void 0) unreachable();
   const direction = oppositeSide(getEdgeOrientation(visualEdge));

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

@@ -13,4 +13,4 @@ import { KnownError } from "../utils/KnownError.js";
 export declare function getFrameCollapseInfo(win: LayoutWindow, frameId: string, { collapseSizeScaled }?: {
     /** Override the target collapse size. If provided, the frame will collapse to this size instead of settings.collapseSizeScaled. */
     collapseSizeScaled?: Size;
-}): LayoutChange | KnownError<typeof LAYOUT_ERROR.CANT_COLLAPSE_NOT_DOCKED> | KnownError<typeof LAYOUT_ERROR.REDISTRIBUTE_WOULD_RESULT_IN_INVALID_FRAMES>;
+}): LayoutChange | KnownError<typeof LAYOUT_ERROR.CANT_COLLAPSE_NOT_DOCKED> | KnownError<typeof LAYOUT_ERROR.REDISTRIBUTE_WOULD_RESULT_IN_INVALID_FRAMES> | KnownError<typeof LAYOUT_ERROR.CANT_RESIZE_SINGLE_FRAME>;

package/dist/runtime/layout/getFrameCollapseInfo.js

@@ -1,10 +1,7 @@
 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 { getFrameShrinkInfo } from "./getFrameShrinkInfo.js";
 import { settings } from "../settings.js";
 import { LAYOUT_ERROR } from "../types/index.js";
 import { KnownError } from "../utils/KnownError.js";
@@ -27,35 +24,18 @@ export function getFrameCollapseInfo(win, frameId, {
   }
   const isVertical = frame.docked === "left" || frame.docked === "right";
   const sizeKey = isVertical ? "width" : "height";
-  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;
-  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 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 || 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;
+  const shrinkAmount = currentSize - collapseSizeScaled[sizeKey];
+  const shrinkResult = getFrameShrinkInfo(win, frameId, shrinkAmount, frame.docked, { allowOutOfBounds: true });
+  if (shrinkResult instanceof KnownError) {
+    return shrinkResult;
   }
-  applyFrameChanges(win, changes);
-  pushIfNotIn(toExtract, changes.modified.map((_) => _.id));
-  applyFixes();
-  pushIfNotIn(toExtract, toFix);
-  if (frame.docked === "right" || frame.docked === "bottom") {
-    frame[posKey] = frame[posKey] + (frame[sizeKey] - collapseSizeScaled[sizeKey]);
-  }
-  frame[sizeKey] = collapseSizeScaled[sizeKey];
+  applyFrameChanges(win, shrinkResult);
+  pushIfNotIn(toExtract, shrinkResult.modified.map((_) => _.id));
   frame.collapsed = currentSize;
   if (collapseSizeScaled[sizeKey] === 0) {
+    const oppositePosKey = isVertical ? "y" : "x";
+    const oppositeSizeKey = isVertical ? "height" : "width";
     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.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>;
+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> | KnownError<typeof LAYOUT_ERROR.CANT_RESIZE_SINGLE_FRAME>;

package/dist/runtime/layout/getFrameDockInfo.js

@@ -2,9 +2,11 @@ import { pushIfNotIn } from "@alanscodelog/utils/pushIfNotIn";
 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";
@@ -29,58 +31,73 @@ export function getFrameDockInfo(win, frameId, side, maxPerpendicularLength) {
   }
   const isHorizontal = side === "left" || side === "right";
   const perpendicular = isHorizontal ? "width" : "height";
-  const oldFrame = cloneFrame(frame);
+  const posKey = isHorizontal ? "x" : "y";
+  const sizeKey = isHorizontal ? "width" : "height";
   const otherFrameIds = Object.keys(win.frames).filter((_) => _ !== frameId);
   const nonDockedFrameIds = otherFrameIds.filter((id) => !win.frames[id].docked);
   if (nonDockedFrameIds.length === 0) {
     return new KnownError(LAYOUT_ERROR.CANT_LEAVE_NO_UNDOCKED_FRAMES, `Can't dock frame ${frameId} because there are no other undocked frames.`, { frameId });
   }
-  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 = void 0;
   const toExtract = [frame.id];
-  const changes = getFillEmptySpaceInfo(win, oldFrame, [], [frameId]);
-  if (changes instanceof Error) return changes;
-  applyFrameChanges(win, changes);
-  pushIfNotIn(toExtract, changes.modified.map((_) => _.id));
-  const sideToPushTowards = oppositeSide(side);
-  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;
+  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 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);
+    const changes = getFillEmptySpaceInfo(win, oldFrame, [], [frameId]);
+    if (changes instanceof Error) return changes;
+    applyFrameChanges(win, changes);
+    pushIfNotIn(toExtract, changes.modified.map((_) => _.id));
+    const sideToPushTowards = oppositeSide(side);
+    const pinnedEdgeCoordinates = 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;
+    }
   }
-  const res = toExtract.map((_) => win.frames[_]);
-  return { modified: res, created: [], deleted: [] };
+  return { modified: toExtract.map((_) => win.frames[_]), created: [], deleted: [] };
 }

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

@@ -0,0 +1,11 @@
+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 declare 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>;

package/dist/runtime/layout/getFrameExpandInfo.js

@@ -0,0 +1,49 @@
+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 { LAYOUT_ERROR } from "../types/index.js";
+import { KnownError } from "../utils/KnownError.js";
+export function getFrameExpandInfo(win, frameId, amount, expandSide) {
+  win = walk(win, void 0, { 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 });
+  }
+  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";
+  const posKey = isVertical ? "x" : "y";
+  const currentSize = frame[sizeKey];
+  const dockedSide = frame.docked;
+  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 pinnedEdgeCoordinates = 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/dist/runtime/layout/getFrameRearrangeInfo.d.ts

@@ -1,4 +1,4 @@
-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";
 /**
@@ -136,4 +136,4 @@ import { KnownError } from "../utils/KnownError.js";
  * │           │     │
  * └───────────┴─────┘
  */
-export declare function getFrameRearrangeInfo(win: LayoutWindow, draggingFrameId: string, hoveredFrameId: string, zoneSide: DragZone["side"]): LayoutChange<"split" | "swap" | "rearrange"> | KnownError<typeof LAYOUT_ERROR.CANT_SWAP_WITH_SELF> | KnownError<typeof LAYOUT_ERROR.CANT_SPLIT_FRAME_TOO_SMALL> | KnownError<typeof LAYOUT_ERROR.CANT_REARRANGE_TO_SAME_RELATIVE_POSITION> | KnownError<typeof LAYOUT_ERROR.CANT_REARRANGE_WITH_DOCKED_EDGES> | 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>;
+export declare function getFrameRearrangeInfo(win: LayoutWindow, movingFrameId: string, hoveredFrameId: string, zoneSide: Zone["side"]): LayoutChange<"split" | "swap" | "rearrange"> | KnownError<typeof LAYOUT_ERROR.CANT_SWAP_WITH_SELF> | KnownError<typeof LAYOUT_ERROR.CANT_SPLIT_FRAME_TOO_SMALL> | KnownError<typeof LAYOUT_ERROR.CANT_REARRANGE_TO_SAME_RELATIVE_POSITION> | KnownError<typeof LAYOUT_ERROR.CANT_REARRANGE_WITH_DOCKED_EDGES> | 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>;

package/dist/runtime/layout/getFrameRearrangeInfo.js

@@ -8,10 +8,10 @@ import { oppositeSide } from "../helpers/oppositeSide.js";
 import { sideToDirection } from "../helpers/sideToDirection.js";
 import { LAYOUT_ERROR } from "../types/index.js";
 import { KnownError } from "../utils/KnownError.js";
-export function getFrameRearrangeInfo(win, draggingFrameId, hoveredFrameId, zoneSide) {
-  const draggingFrame = { ...win.frames[draggingFrameId] };
+export function getFrameRearrangeInfo(win, movingFrameId, hoveredFrameId, zoneSide) {
+  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 });
   }
   if (zoneSide === "center") {
@@ -25,10 +25,10 @@ export function getFrameRearrangeInfo(win, draggingFrameId, hoveredFrameId, zone
     };
   }
   if (draggingFrame.docked && !hoveredFrame.docked) {
-    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 });
   }
   if (hoveredFrame.docked) {
-    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);
   if (touchingSide) {
@@ -47,7 +47,7 @@ export function getFrameRearrangeInfo(win, draggingFrameId, hoveredFrameId, zone
         };
       }
       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 });
       }
     }
   }
@@ -59,7 +59,7 @@ export function getFrameRearrangeInfo(win, draggingFrameId, hoveredFrameId, zone
   }
   const splitFrame = splitResult.modified[0];
   const newFrame = splitResult.created[0];
-  if (draggingFrameId === hoveredFrameId) {
+  if (movingFrameId === hoveredFrameId) {
     return { ...splitResult, deleted: [], info: "split" };
   }
   hoveredFrame.x = splitFrame.x;
@@ -78,7 +78,7 @@ export function getFrameRearrangeInfo(win, draggingFrameId, hoveredFrameId, zone
       [draggingFrame.id]: draggingFrame
     }
   };
-  const changes = getFillEmptySpaceInfo(winCopy, emptySpace, [hoveredFrameId, draggingFrameId]);
+  const changes = getFillEmptySpaceInfo(winCopy, emptySpace, [hoveredFrameId, movingFrameId]);
   if (changes instanceof KnownError) return changes;
   const notMissing = changes.modified.map((_) => _.id).filter((id) => id === hoveredFrame.id || draggingFrame.id);
   if (!notMissing.includes(hoveredFrame.id)) changes.modified.push(hoveredFrame);

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

@@ -0,0 +1,14 @@
+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 declare function getFrameShrinkInfo(win: LayoutWindow, frameId: string, amount: number, shrinkSide: EdgeSide, { allowOutOfBounds }?: {
+    /** 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>;

package/dist/runtime/layout/getFrameShrinkInfo.js

@@ -0,0 +1,48 @@
+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 { LAYOUT_ERROR } from "../types/index.js";
+import { KnownError } from "../utils/KnownError.js";
+export function getFrameShrinkInfo(win, frameId, amount, shrinkSide, {
+  allowOutOfBounds = false
+} = {}) {
+  win = walk(win, void 0, { save: true });
+  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 });
+  }
+  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";
+  const posKey = isVertical ? "x" : "y";
+  const toExtract = [frame.id];
+  const { applyFixes, toFix } = framesRedistributeFix(win, frame, shrinkSide, posKey, sizeKey, "shrink");
+  const otherFrameIds = Object.keys(win.frames).filter((id) => id !== frameId);
+  const redistributeSide = oppositeSide(shrinkSide);
+  const pinnedEdgeCoordinates = getPinnedEdgesForCollapsedFrames(win, frame, shrinkSide, posKey, sizeKey);
+  const changes = getFramesRedistributeInfo(win, redistributeSide, otherFrameIds, -amount, { allowOutOfBounds, pinnedEdgeCoordinates });
+  if (changes instanceof KnownError) {
+    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/dist/runtime/layout/getFrameSplitInfo.d.ts

@@ -5,4 +5,4 @@ import { KnownError } from "../utils/KnownError.js";
  *
  * Changes can be applied to a window with {@link applyFrameChanges}.
  */
-export declare function getFrameSplitInfo(frame: LayoutFrame, dir: Direction, dragPointOrPosition?: Point | number | "midpoint", minSize?: Size, snapAmount?: Point): LayoutChange | KnownError<typeof LAYOUT_ERROR.CANT_SPLIT_FRAME_TOO_SMALL> | KnownError<typeof LAYOUT_ERROR.CANT_SPLIT_DOCKED_FRAME>;
+export declare function getFrameSplitInfo(frame: LayoutFrame, dir: Direction, movePointOrPosition?: Point | number | "midpoint", minSize?: Size, snapAmount?: Point): LayoutChange | KnownError<typeof LAYOUT_ERROR.CANT_SPLIT_FRAME_TOO_SMALL> | KnownError<typeof LAYOUT_ERROR.CANT_SPLIT_DOCKED_FRAME>;

package/dist/runtime/layout/getFrameSplitInfo.js

@@ -6,7 +6,7 @@ import {
   LAYOUT_ERROR
 } from "../types/index.js";
 import { KnownError } from "../utils/KnownError.js";
-export function getFrameSplitInfo(frame, dir, dragPointOrPosition = "midpoint", minSize = settings.minSizeScaled, snapAmount = settings.snapPointScaled) {
+export function getFrameSplitInfo(frame, dir, movePointOrPosition = "midpoint", minSize = settings.minSizeScaled, snapAmount = settings.snapPointScaled) {
   if (frame.docked) {
     return new KnownError(
       LAYOUT_ERROR.CANT_SPLIT_DOCKED_FRAME,
@@ -19,7 +19,7 @@ export function getFrameSplitInfo(frame, dir, dragPointOrPosition = "midpoint",
   const isHorz = dir === "left" || dir === "right";
   const sizeKey = isHorz ? "width" : "height";
   const posKey = isHorz ? "x" : "y";
-  const position = dragPointOrPosition === "midpoint" ? isHorz ? frame.x + frame.width / 2 : frame.y + frame.height / 2 : typeof dragPointOrPosition === "number" ? dragPointOrPosition : dragPointOrPosition[isHorz ? "x" : "y"];
+  const position = movePointOrPosition === "midpoint" ? isHorz ? frame.x + frame.width / 2 : frame.y + frame.height / 2 : typeof movePointOrPosition === "number" ? movePointOrPosition : movePointOrPosition[isHorz ? "x" : "y"];
   const safePosition = findSafeSplitEdgeAndPosition(
     frame,
     dir,

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

@@ -12,4 +12,4 @@ import { KnownError } from "../utils/KnownError.js";
 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>;
+}): 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> | KnownError<typeof LAYOUT_ERROR.CANT_RESIZE_SINGLE_FRAME>;

package/dist/runtime/layout/getFrameUncollapseInfo.js

@@ -1,10 +1,7 @@
 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 { getFrameExpandInfo } from "./getFrameExpandInfo.js";
 import { LAYOUT_ERROR } from "../types/index.js";
 import { KnownError } from "../utils/KnownError.js";
 export function getFrameUncollapseInfo(win, frameId, {
@@ -21,7 +18,6 @@ export function getFrameUncollapseInfo(win, frameId, {
   const toExtract = [frame.id];
   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) {
@@ -33,22 +29,12 @@ export function getFrameUncollapseInfo(win, frameId, {
   }
   const expandAmount = storedSize - currentSize;
   const dockedSide = frame.docked;
-  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 pinnedEdgeCoordinates = getPinnedEdgesForCollapsedFrames(win, frame, dockedSide, posKey, sizeKey);
-  const changes = getFramesRedistributeInfo(win, redistributeSide, otherFrameIds, expandAmount, { pinnedEdgeCoordinates });
-  if (changes instanceof KnownError) {
-    return changes;
+  const expandResult = getFrameExpandInfo(win, frameId, expandAmount, dockedSide);
+  if (expandResult instanceof KnownError) {
+    return expandResult;
   }
-  applyFrameChanges(win, changes);
-  pushIfNotIn(toExtract, changes.modified.map((_) => _.id));
-  applyFixes();
-  pushIfNotIn(toExtract, toFix);
-  frame[sizeKey] = storedSize;
+  applyFrameChanges(win, expandResult);
+  pushIfNotIn(toExtract, expandResult.modified.map((_) => _.id));
   frame.collapsed = void 0;
-  if (frame.docked === "right" || frame.docked === "bottom") {
-    frame[posKey] -= expandAmount;
-  }
   return { modified: toExtract.map((_) => win.frames[_]), created: [], deleted: [] };
 }