@witchcraft/layout 0.4.3 → 0.4.4

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

package/dist/runtime/layout/getUpdateWindowSizeInfo.js

@@ -1,8 +1,8 @@
 import { pushIfNotIn } from "@alanscodelog/utils/pushIfNotIn";
 import { walk } from "@alanscodelog/utils/walk";
 import { applyFrameChanges } from "../layout/applyFrameChanges.js";
-import { getFrameCollapseInfo } from "../layout/getFrameCollapseInfo.js";
-import { getFrameUncollapseInfo } from "../layout/getFrameUncollapseInfo.js";
+import { getFrameExpandInfo } from "../layout/getFrameExpandInfo.js";
+import { getFrameShrinkInfo } from "../layout/getFrameShrinkInfo.js";
 import { getRelaxFramesInfo } from "../layout/getRelaxFramesInfo.js";
 import { settings } from "../settings.js";
 import { KnownError } from "../utils/KnownError.js";
@@ -30,23 +30,21 @@ export function getUpdateWindowSizeInfo(win, event, { relaxPasses = 2 } = {}) {
     const targetScaled = Math.round(targetPxSize / (orientation === "horizontal" ? win.pxWidth : win.pxHeight) * maxInt);
     if (frame[sizeKey] === targetScaled) continue;
     if (frame[sizeKey] === 0) continue;
+    const side = frame.docked;
+    const diff = targetScaled - frame[sizeKey];
     let result;
-    const wasCollapsed = frame.collapsed;
-    const wasMinSize = { ...settings.minSize };
-    settings.minSize = 1;
-    if (targetScaled < frame[sizeKey]) {
-      frame.collapsed = void 0;
-      result = getFrameCollapseInfo(win, frame.id, { collapseSizeScaled: { width: targetScaled, height: targetScaled } });
+    if (diff < 0) {
+      result = getFrameShrinkInfo(win, frame.id, -diff, side, { allowOutOfBounds: true });
     } else {
-      frame.collapsed = Infinity;
-      result = getFrameUncollapseInfo(win, frame.id, { restoreSize: { width: targetScaled, height: targetScaled } });
+      const wasMinSize = { ...settings.minSize };
+      settings.minSize = 1;
+      result = getFrameExpandInfo(win, frame.id, diff, side);
+      settings.minSize = wasMinSize;
     }
     if (!(result instanceof KnownError)) {
       applyFrameChanges(win, result);
       pushIfNotIn(toExtract, result.modified.map((f) => f.id));
     }
-    frame.collapsed = wasCollapsed;
-    settings.minSize = wasMinSize;
     const result2 = getRelaxFramesInfo(win, relaxPasses);
     if (!(result2 instanceof KnownError)) {
       applyFrameChanges(win, result2);

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

@@ -12,13 +12,16 @@ export { getFillEmptySpaceInfo } from "./getFillEmptySpaceInfo.js";
 export { getFrameCollapseInfo } from "./getFrameCollapseInfo.js";
 export { getFrameDockInfo } from "./getFrameDockInfo.js";
 export { getFrameDragZones } from "./getFrameDragZones.js";
+export { getFrameExpandInfo } from "./getFrameExpandInfo.js";
 export { getFrameRearrangeInfo } from "./getFrameRearrangeInfo.js";
+export { getFrameShrinkInfo } from "./getFrameShrinkInfo.js";
 export { getFrameSplitInfo } from "./getFrameSplitInfo.js";
 export { getFramesRedistributeInfo } from "./getFramesRedistributeInfo.js";
 export { getFrameSwapInfo } from "./getFrameSwapInfo.js";
 export { getFrameTo } from "./getFrameTo.js";
 export { getFrameUncollapseInfo } from "./getFrameUncollapseInfo.js";
 export { getFrameUndockInfo } from "./getFrameUndockInfo.js";
+export { getRelaxFramesInfo } from "./getRelaxFramesInfo.js";
 export { getUpdateWindowSizeInfo } from "./getUpdateWindowSizeInfo.js";
 export { getWindowDragZones } from "./getWindowDragZones.js";
 export { isPointInRect } from "./isPointInRect.js";

package/dist/runtime/layout/index.js

@@ -12,13 +12,16 @@ export { getFillEmptySpaceInfo } from "./getFillEmptySpaceInfo.js";
 export { getFrameCollapseInfo } from "./getFrameCollapseInfo.js";
 export { getFrameDockInfo } from "./getFrameDockInfo.js";
 export { getFrameDragZones } from "./getFrameDragZones.js";
+export { getFrameExpandInfo } from "./getFrameExpandInfo.js";
 export { getFrameRearrangeInfo } from "./getFrameRearrangeInfo.js";
+export { getFrameShrinkInfo } from "./getFrameShrinkInfo.js";
 export { getFrameSplitInfo } from "./getFrameSplitInfo.js";
 export { getFramesRedistributeInfo } from "./getFramesRedistributeInfo.js";
 export { getFrameSwapInfo } from "./getFrameSwapInfo.js";
 export { getFrameTo } from "./getFrameTo.js";
 export { getFrameUncollapseInfo } from "./getFrameUncollapseInfo.js";
 export { getFrameUndockInfo } from "./getFrameUndockInfo.js";
+export { getRelaxFramesInfo } from "./getRelaxFramesInfo.js";
 export { getUpdateWindowSizeInfo } from "./getUpdateWindowSizeInfo.js";
 export { getWindowDragZones } from "./getWindowDragZones.js";
 export { isPointInRect } from "./isPointInRect.js";

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

@@ -105,6 +105,8 @@ export declare const zEdge: z.ZodObject<{
         frame: LayoutFrame;
     } | {
         frame: LayoutFrame;
+    } | {
+        frame: LayoutFrame;
     }>, KnownError<LayoutError, {} | {
         id: string | undefined;
     } | {
@@ -162,6 +164,8 @@ export declare const zEdge: z.ZodObject<{
         frame: LayoutFrame;
     } | {
         frame: LayoutFrame;
+    } | {
+        frame: LayoutFrame;
     }>>, z.ZodObject<{
         code: z.ZodString;
         message: z.ZodString;
@@ -504,6 +508,8 @@ declare const zLayoutShape: z.ZodDiscriminatedUnion<[z.ZodObject<{
             frame: LayoutFrame;
         } | {
             frame: LayoutFrame;
+        } | {
+            frame: LayoutFrame;
         }>, KnownError<LayoutError, {} | {
             id: string | undefined;
         } | {
@@ -561,6 +567,8 @@ declare const zLayoutShape: z.ZodDiscriminatedUnion<[z.ZodObject<{
             frame: LayoutFrame;
         } | {
             frame: LayoutFrame;
+        } | {
+            frame: LayoutFrame;
         }>>, z.ZodObject<{
             code: z.ZodString;
             message: z.ZodString;
@@ -643,6 +651,8 @@ declare const zBaseDeco: z.ZodObject<{
                 frame: LayoutFrame;
             } | {
                 frame: LayoutFrame;
+            } | {
+                frame: LayoutFrame;
             }>, KnownError<LayoutError, {} | {
                 id: string | undefined;
             } | {
@@ -700,6 +710,8 @@ declare const zBaseDeco: z.ZodObject<{
                 frame: LayoutFrame;
             } | {
                 frame: LayoutFrame;
+            } | {
+                frame: LayoutFrame;
             }>>, z.ZodObject<{
                 code: z.ZodString;
                 message: z.ZodString;
@@ -783,6 +795,8 @@ export declare const zSplitDeco: z.ZodObject<{
                 frame: LayoutFrame;
             } | {
                 frame: LayoutFrame;
+            } | {
+                frame: LayoutFrame;
             }>, KnownError<LayoutError, {} | {
                 id: string | undefined;
             } | {
@@ -840,6 +854,8 @@ export declare const zSplitDeco: z.ZodObject<{
                 frame: LayoutFrame;
             } | {
                 frame: LayoutFrame;
+            } | {
+                frame: LayoutFrame;
             }>>, z.ZodObject<{
                 code: z.ZodString;
                 message: z.ZodString;
@@ -944,6 +960,8 @@ declare const zCloseDeco: z.ZodObject<{
                 frame: LayoutFrame;
             } | {
                 frame: LayoutFrame;
+            } | {
+                frame: LayoutFrame;
             }>, KnownError<LayoutError, {} | {
                 id: string | undefined;
             } | {
@@ -1001,6 +1019,8 @@ declare const zCloseDeco: z.ZodObject<{
                 frame: LayoutFrame;
             } | {
                 frame: LayoutFrame;
+            } | {
+                frame: LayoutFrame;
             }>>, z.ZodObject<{
                 code: z.ZodString;
                 message: z.ZodString;
@@ -1087,6 +1107,8 @@ declare const zFrameDragDeco: z.ZodObject<{
                 frame: LayoutFrame;
             } | {
                 frame: LayoutFrame;
+            } | {
+                frame: LayoutFrame;
             }>, KnownError<LayoutError, {} | {
                 id: string | undefined;
             } | {
@@ -1144,6 +1166,8 @@ declare const zFrameDragDeco: z.ZodObject<{
                 frame: LayoutFrame;
             } | {
                 frame: LayoutFrame;
+            } | {
+                frame: LayoutFrame;
             }>>, z.ZodObject<{
                 code: z.ZodString;
                 message: z.ZodString;
@@ -1237,6 +1261,8 @@ export declare const zDeco: z.ZodUnion<readonly [z.ZodObject<{
                 frame: LayoutFrame;
             } | {
                 frame: LayoutFrame;
+            } | {
+                frame: LayoutFrame;
             }>, KnownError<LayoutError, {} | {
                 id: string | undefined;
             } | {
@@ -1294,6 +1320,8 @@ export declare const zDeco: z.ZodUnion<readonly [z.ZodObject<{
                 frame: LayoutFrame;
             } | {
                 frame: LayoutFrame;
+            } | {
+                frame: LayoutFrame;
             }>>, z.ZodObject<{
                 code: z.ZodString;
                 message: z.ZodString;
@@ -1384,6 +1412,8 @@ export declare const zDeco: z.ZodUnion<readonly [z.ZodObject<{
                 frame: LayoutFrame;
             } | {
                 frame: LayoutFrame;
+            } | {
+                frame: LayoutFrame;
             }>, KnownError<LayoutError, {} | {
                 id: string | undefined;
             } | {
@@ -1441,6 +1471,8 @@ export declare const zDeco: z.ZodUnion<readonly [z.ZodObject<{
                 frame: LayoutFrame;
             } | {
                 frame: LayoutFrame;
+            } | {
+                frame: LayoutFrame;
             }>>, z.ZodObject<{
                 code: z.ZodString;
                 message: z.ZodString;
@@ -1525,6 +1557,8 @@ export declare const zDeco: z.ZodUnion<readonly [z.ZodObject<{
                 frame: LayoutFrame;
             } | {
                 frame: LayoutFrame;
+            } | {
+                frame: LayoutFrame;
             }>, KnownError<LayoutError, {} | {
                 id: string | undefined;
             } | {
@@ -1582,6 +1616,8 @@ export declare const zDeco: z.ZodUnion<readonly [z.ZodObject<{
                 frame: LayoutFrame;
             } | {
                 frame: LayoutFrame;
+            } | {
+                frame: LayoutFrame;
             }>>, z.ZodObject<{
                 code: z.ZodString;
                 message: z.ZodString;
@@ -1627,6 +1663,7 @@ export declare const LAYOUT_ERROR: {
     CANT_UNCOLLAPSE_NOT_COLLAPSED: "CANT_UNCOLLAPSE_NOT_COLLAPSED";
     NO_FILL_CANDIDATES: "NO_FILL_CANDIDATES";
     CANT_RESIZE_COLLAPSED_FRAME: "CANT_RESIZE_COLLAPSED_FRAME";
+    CANT_RESIZE_SINGLE_FRAME: "CANT_RESIZE_SINGLE_FRAME";
 };
 export type LayoutError = EnumLike<typeof LAYOUT_ERROR>;
 export type LayoutErrorInfo<T extends LayoutError> = LayoutErrorsInfo[T] extends undefined ? never : LayoutErrorsInfo[T];
@@ -1710,6 +1747,9 @@ export type LayoutErrorsInfo = {
     [LAYOUT_ERROR.CANT_RESIZE_COLLAPSED_FRAME]: {
         frame: LayoutFrame;
     };
+    [LAYOUT_ERROR.CANT_RESIZE_SINGLE_FRAME]: {
+        frame: LayoutFrame;
+    };
     [LAYOUT_ERROR.REDISTRIBUTE_WOULD_RESULT_IN_INVALID_FRAMES]: {
         problemEdgeCoordinates: number[];
     };
@@ -1852,6 +1892,8 @@ export type DragState = {
      * Whether the drag was initiated from a point along the window edge.
      */
     isDraggingFromWindowEdge: boolean;
+    /** Custom context passed to dragStart, available to action handlers via state.eventContext. */
+    eventContext?: Record<string, unknown>;
     win: LayoutWindow;
 };
 export interface ActionDragChangeResult {
@@ -1956,6 +1998,34 @@ export type EdgeDragStartData = {
 export type FrameDragStartData = {
     frameId: FrameId;
 };
+/**
+ * Handler interface for drag actions.
+ */
+export interface ActionHandler {
+    eventHandler: (e: KeyboardEvent, state: DragState, forceRecalculateEdges: () => void) => void;
+    /**
+     * Called when the drag coordinates change (during any event). Should return true to allow the edges to be updated/moved, or false to prevent it.
+     *
+     * Can return anything for the end event as it's ignored.
+     *
+     * Can be used to save some context/info to later apply safely during onDragApply.
+     */
+    onDragChange: (...args: Parameters<DragChangeHandler>) => DragChangeResult;
+    /**
+     * Called when drag will be applied. If dragEnd was called with apply false, it will not be called.
+     * Return false to not apply the regular drag end changes (i.e. return false to reset to the position before dragging).
+     */
+    onDragApply: (state: DragState, forceRecalculateEdges: () => void) => {
+        /** Whether to apply the regular drag end changes. Return false to reset to the position before dragging. */
+        apply: boolean;
+        /** Value to resolve the drag promise with. Ignored if `apply` is false. */
+        result: any;
+    };
+    /**
+     * Called after visual edges are recalculated. Action handlers can annotate edges with error info.
+     */
+    annotateEdges?: (edges: Edge[], frames: LayoutFrame[]) => void;
+}
 export type DragStartFn = {
     (e: PointerEvent, type: "edge", data: EdgeDragStartData): void;
     (e: PointerEvent, type: "frame", data: FrameDragStartData): void;

package/dist/runtime/types/index.js

@@ -153,7 +153,8 @@ export const LAYOUT_ERROR = enumFromArray([
   "CANT_COLLAPSE_NOT_DOCKED",
   "CANT_UNCOLLAPSE_NOT_COLLAPSED",
   "NO_FILL_CANDIDATES",
-  "CANT_RESIZE_COLLAPSED_FRAME"
+  "CANT_RESIZE_COLLAPSED_FRAME",
+  "CANT_RESIZE_SINGLE_FRAME"
 ]);
 export const zWindowCreate = zLayoutWindowLoose.partial({ id: true, pxWidth: true, pxHeight: true, pxX: true, pxY: true }).extend({ frames: zLayoutWindow.shape.frames.optional() });
 export const zLayoutCreate = baseLayout.loose().extend({