@witchcraft/layout 0.1.3 → 0.2.1

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

@@ -0,0 +1,139 @@
+import type { DragZone, 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 rearrange a frame relative to another.
+ *
+ * Changes can be applied to a window with {@link applyFrameChanges}.
+ *
+ * Rearrangement is usually done by dragging a frame onto another frame's zone.
+ *
+ * The action taken depends on their placement relative to each other, see examples below.
+ *
+ * ## Examples
+ *
+ * Dragging a frame onto itself in the left/right/top/bottom zones splits it and creates a new frame. Center returns an error.
+ *
+ * Then there are the more typical cases:
+ *
+ * Shared Edge Case:
+ *
+ * ┌─────┬─────┬─────┐
+ * │A    │B    │C    │
+ * │     │     ├─────┤
+ * │     │     │D    │
+ * └─────┴─────┴─────┘
+ *
+ * A and B here are on the same edge, with A on the left of B.
+ *
+ * Dragging A onto B will result in the following depending on what drop zone of B the dragged frame lands on:
+ *
+ * Left - Error that can be safely ignored - A is already on the left of B
+ * Right - Swap A and B
+ * Top
+ * 	- B is "split" up (we only simulate it to get the positions). The position of the new split frame is taken and applied to A to move it above B.
+ * 	- The gap left behind by A is filled however possible using {@link getFillEmptySpaceInfo}.
+ *
+ * The result looks like this:
+ *
+ * ┌───────────┬─────┐
+ * │A          │C    │
+ * ├───────────┼─────┤
+ * │B          │D    │
+ * └───────────┴─────┘
+ *
+ * Bottom - Like top, but A ends up on the bottom of B.
+ *
+ *
+ * Partially Shared Edge Case:
+ *
+ * ┌─────┬─────┬─────┐
+ * │A    │B    │C    │
+ * │     │     │     │
+ * │     │     │     │
+ * │     │     ├─────┤
+ * │     │     │D    │
+ * │     │     │     │
+ * └─────┴─────┴─────┘
+ *
+ * Same case but we'll be using B and C here as they share part of an edge but not the whole edge. Dragging B onto C will result in the following:
+ *
+ * Left
+ * 	- C will be "split" to the left. The position of the new split frame is taken and applied to B. The space left behind is filled resulting in this.
+ * 	- Note how c has shrunk due to the initial location of the split.
+ *
+ * ┌─────┬────────┬──┐
+ * │A    │B       │C │
+ * │     │        │  │
+ * │     │        │  │
+ * │     ├────────┴──┤
+ * │     │D          │
+ * │     │           │
+ * └─────┴───────────┘
+ *
+ * Right - Like left but C ends up on the right of B.
+ *
+ * Top
+ * ┌─────┬───────────┐
+ * │A    │B          │
+ * │     ├───────────┤
+ * │     │C          │
+ * │     ├───────────┤
+ * │     │D          │
+ * │     │           │
+ * └─────┴───────────┘
+ *
+ * Bottom - Like top, but B ends up on the bottom of C.
+ *
+ * None-Shared Edge Case:
+ *
+ * Same case but we'll be dragging A over C.
+ * ┌─────┬─────┬─────┐
+ * │A    │B    │C    │
+ * │     │     │     │
+ * │     │     │     │
+ * │     │     ├─────┤
+ * │     │     │D    │
+ * │     │     │     │
+ * └─────┴─────┴─────┘
+ *
+ * These are a bit easier to reason about because the frame usually ends up at the split location exactly.
+ *
+ * Left
+ * ┌───────────┬──┬──┐
+ * │B          │A │C │
+ * │           │  │  │
+ * │           │  │  │
+ * │           ├──┴──┤
+ * │           │D    │
+ * │           │     │
+ * └───────────┴─────┘
+ * Right
+ * ┌───────────┬──┬──┐
+ * │B          │C │A │
+ * │           │  │  │
+ * │           │  │  │
+ * │           ├──┴──┤
+ * │           │D    │
+ * │           │     │
+ * └───────────┴─────┘
+ * Top
+ * ┌───────────┬─────┐
+ * │B          │A    │
+ * │           ├─────┤
+ * │           │C    │
+ * │           ├─────┤
+ * │           │D    │
+ * │           │     │
+ * └───────────┴─────┘
+ * Bottom
+ * ┌───────────┬─────┐
+ * │B          │C    │
+ * │           ├─────┤
+ * │           │A    │
+ * │           ├─────┤
+ * │           │D    │
+ * │           │     │
+ * └───────────┴─────┘
+ */
+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>;

package/dist/runtime/layout/getFrameRearrangeInfo.js

@@ -0,0 +1,87 @@
+import { getFillEmptySpaceInfo } from "./getFillEmptySpaceInfo.js";
+import { getFrameSplitInfo } from "./getFrameSplitInfo.js";
+import { getFrameSwapInfo } from "./getFrameSwapInfo.js";
+import { frameToEdges } from "../helpers/frameToEdges.js";
+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 { LAYOUT_ERROR } from "../types/index.js";
+import { KnownError } from "../utils/KnownError.js";
+export function getFrameRearrangeInfo(win, draggingFrameId, hoveredFrameId, zoneSide) {
+  const draggingFrame = { ...win.frames[draggingFrameId] };
+  const hoveredFrame = { ...win.frames[hoveredFrameId] };
+  if (draggingFrameId === 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") {
+    const res = getFrameSwapInfo(win, draggingFrame.id, hoveredFrame.id);
+    if (res instanceof KnownError) return res;
+    return {
+      modified: res.modified,
+      created: res.created,
+      deleted: res.deleted,
+      info: "swap"
+    };
+  }
+  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 });
+  }
+  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 });
+  }
+  const touchingSide = getSideTouching(draggingFrame, hoveredFrame);
+  if (touchingSide) {
+    const dragEdges = frameToEdges(draggingFrame);
+    const hoverEdges = frameToEdges(hoveredFrame);
+    const hoverOppositeSide = oppositeSide(touchingSide);
+    if (isEdgeEqual(dragEdges[touchingSide], hoverEdges[hoverOppositeSide])) {
+      if (touchingSide === zoneSide) {
+        const res = getFrameSwapInfo(win, draggingFrame.id, hoveredFrame.id);
+        if (res instanceof KnownError) return res;
+        return {
+          modified: res.modified,
+          created: res.created,
+          deleted: res.deleted,
+          info: "swap"
+        };
+      }
+      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 });
+      }
+    }
+  }
+  const emptySpace = { ...draggingFrame };
+  const dir = sideToDirection(zoneSide);
+  const splitResult = getFrameSplitInfo(hoveredFrame, dir, "midpoint", void 0, { x: 1e-3, y: 1e-3 });
+  if (splitResult instanceof KnownError) {
+    return splitResult;
+  }
+  const splitFrame = splitResult.modified[0];
+  const newFrame = splitResult.created[0];
+  if (draggingFrameId === hoveredFrameId) {
+    return { ...splitResult, deleted: [], info: "split" };
+  }
+  hoveredFrame.x = splitFrame.x;
+  hoveredFrame.y = splitFrame.y;
+  hoveredFrame.width = splitFrame.width;
+  hoveredFrame.height = splitFrame.height;
+  draggingFrame.x = newFrame.x;
+  draggingFrame.y = newFrame.y;
+  draggingFrame.width = newFrame.width;
+  draggingFrame.height = newFrame.height;
+  const winCopy = {
+    ...win,
+    frames: {
+      ...win.frames,
+      [hoveredFrame.id]: hoveredFrame,
+      [draggingFrame.id]: draggingFrame
+    }
+  };
+  const changes = getFillEmptySpaceInfo(winCopy, emptySpace, [hoveredFrameId, draggingFrameId]);
+  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);
+  if (!notMissing.includes(draggingFrame.id)) changes.modified.push(draggingFrame);
+  return { ...changes, info: "split" };
+}

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

@@ -1,6 +1,8 @@
-import { type Direction, LAYOUT_ERROR, type LayoutFrame, type Point, type Size } from "../types/index.js";
+import { type Direction, LAYOUT_ERROR, type LayoutChange, type LayoutFrame, type Point, type Size } from "../types/index.js";
 import { KnownError } from "../utils/KnownError.js";
-export declare function getFrameSplitInfo(frame: LayoutFrame, dir: Direction, dragPointOrPosition?: Point | number | "midpoint", minSize?: Size, snapAmount?: Point): {
-    splitFrame: LayoutFrame;
-    newFrame: LayoutFrame;
-} | KnownError<typeof LAYOUT_ERROR.CANT_SPLIT_FRAME_TOO_SMALL>;
+/**
+ * Returns a {@link LayoutChange} with the information necessary to split a frame in the given direction.
+ *
+ * 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>;

package/dist/runtime/layout/getFrameSplitInfo.js

@@ -1,12 +1,19 @@
 import { findSafeSplitEdgeAndPosition } from "./findSafeSplitEdge.js";
 import { frameCreate } from "./frameCreate.js";
 import { cloneFrame } from "../helpers/cloneFrame.js";
-import { getMarginSize, getSnapPoint } from "../settings.js";
+import { settings } from "../settings.js";
 import {
   LAYOUT_ERROR
 } from "../types/index.js";
 import { KnownError } from "../utils/KnownError.js";
-export function getFrameSplitInfo(frame, dir, dragPointOrPosition = "midpoint", minSize = getMarginSize(), snapAmount = getSnapPoint()) {
+export function getFrameSplitInfo(frame, dir, dragPointOrPosition = "midpoint", minSize = settings.minSizeScaled, snapAmount = settings.snapPointScaled) {
+  if (frame.docked) {
+    return new KnownError(
+      LAYOUT_ERROR.CANT_SPLIT_DOCKED_FRAME,
+      `Can't split docked frame ${frame.id}.`,
+      { frame }
+    );
+  }
   frame = cloneFrame(frame);
   let newFrame = { ...frame };
   const isHorz = dir === "left" || dir === "right";
@@ -36,5 +43,5 @@ export function getFrameSplitInfo(frame, dir, dragPointOrPosition = "midpoint",
     frame[posKey] = safePosition.position;
   }
   newFrame = frameCreate({ ...newFrame, id: void 0 });
-  return { splitFrame: frame, newFrame };
+  return { modified: [frame], created: [newFrame], deleted: [] };
 }

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

@@ -0,0 +1,9 @@
+import type { 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 swap two frames within the same window.
+ *
+ * Changes can be applied to a window with {@link applyFrameChanges}.
+ */
+export declare function getFrameSwapInfo(window: LayoutWindow, frameIdA: string, frameIdB: string): LayoutChange | KnownError<typeof LAYOUT_ERROR.CANT_SWAP_WITH_SELF>;

package/dist/runtime/layout/getFrameSwapInfo.js

@@ -0,0 +1,27 @@
+import { LAYOUT_ERROR } from "../types/index.js";
+import { KnownError } from "../utils/KnownError.js";
+export function getFrameSwapInfo(window, frameIdA, frameIdB) {
+  const frameA = { ...window.frames[frameIdA] };
+  const frameB = { ...window.frames[frameIdB] };
+  if (frameA.id === frameB.id) {
+    return new KnownError(LAYOUT_ERROR.CANT_SWAP_WITH_SELF, `Cannot swap frames with the same id`, { frame: frameA });
+  }
+  const temp = { x: frameA.x, y: frameA.y, width: frameA.width, height: frameA.height };
+  frameA.x = frameB.x;
+  frameA.y = frameB.y;
+  frameA.width = frameB.width;
+  frameA.height = frameB.height;
+  frameB.x = temp.x;
+  frameB.y = temp.y;
+  frameB.width = temp.width;
+  frameB.height = temp.height;
+  const dockedA = frameA.docked;
+  const dockedB = frameB.docked;
+  frameA.docked = dockedB;
+  frameB.docked = dockedA;
+  const collapsedA = frameA.collapsed;
+  const collapsedB = frameB.collapsed;
+  frameA.collapsed = collapsedB;
+  frameB.collapsed = collapsedA;
+  return { modified: [frameA, frameB], created: [], deleted: [] };
+}

package/dist/runtime/layout/getFrameTo.js

@@ -1,6 +1,6 @@
-import { getMaxInt } from "../settings.js";
+import { settings } from "../settings.js";
 export function getFrameTo(side, frame, frames) {
-  const max = getMaxInt();
+  const max = settings.maxInt;
   if (side === "top" && frame.y === 0 || side === "left" && frame.y === 0 || side === "right" && frame.x + frame.width === max || side === "bottom" && frame.x + frame.height === max) return void 0;
   let candidate;
   let candidateDistance = Infinity;

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

@@ -0,0 +1,12 @@
+import type { 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 uncollapse a docked frame.
+ *
+ * Changes can be applied to a window with {@link applyFrameChanges}.
+ *
+ * Uncollapsing restores the frame to its pre-collapse size, shrinking neighboring
+ * frames to make room.
+ */
+export declare function getFrameUncollapseInfo(win: LayoutWindow, frameId: string): 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>;

package/dist/runtime/layout/getFrameUncollapseInfo.js

@@ -0,0 +1,88 @@
+import { pushIfNotIn } from "@alanscodelog/utils/pushIfNotIn";
+import { walk } from "@alanscodelog/utils/walk";
+import { applyFrameChanges } from "./applyFrameChanges.js";
+import { getFramesRedistributeInfo } from "./getFramesRedistributeInfo.js";
+import { oppositeSide } from "../helpers/oppositeSide.js";
+import { settings } from "../settings.js";
+import { LAYOUT_ERROR } from "../types/index.js";
+import { KnownError } from "../utils/KnownError.js";
+export function getFrameUncollapseInfo(win, frameId) {
+  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];
+  const storedSize = frame.collapsed;
+  if (storedSize === void 0) {
+    return new KnownError(
+      LAYOUT_ERROR.CANT_UNCOLLAPSE_NOT_COLLAPSED,
+      `Frame ${frameId} is not collapsed.`,
+      { frame }
+    );
+  }
+  const isVertical = frame.docked === "left" || frame.docked === "right";
+  const sizeKey = isVertical ? "width" : "height";
+  const posKey = isVertical ? "x" : "y";
+  const currentSize = frame[sizeKey];
+  const expandAmount = storedSize - currentSize;
+  const dockedSide = frame.docked;
+  const framesToFix = [];
+  const opposite = oppositeSide(dockedSide);
+  if (frame[sizeKey] !== 0) {
+    for (const other of Object.values(win.frames)) {
+      if (frame.id === other.id || !other.docked) continue;
+      if (other.width === 0 || other.height === 0) continue;
+      if (other.docked === opposite) continue;
+      if (dockedSide === "left" || dockedSide === "top") {
+        if (other[posKey] !== 0) continue;
+        other[posKey] = frame[posKey] + frame[sizeKey];
+        other[sizeKey] -= frame[sizeKey];
+        framesToFix.push({
+          id: other.id,
+          posKey,
+          sizeKey,
+          type: "start"
+        });
+      } else {
+        if (other[posKey] + other[sizeKey] !== settings.maxInt) continue;
+        other[sizeKey] -= frame[sizeKey];
+        framesToFix.push({
+          id: other.id,
+          posKey,
+          sizeKey,
+          type: "end"
+        });
+      }
+    }
+  }
+  const otherFrameIds = Object.keys(win.frames).filter((id) => id !== frameId);
+  const redistributeSide = oppositeSide(frame.docked);
+  const changes = getFramesRedistributeInfo(win, redistributeSide, otherFrameIds, expandAmount);
+  if (changes instanceof KnownError) {
+    return changes;
+  }
+  applyFrameChanges(win, changes);
+  pushIfNotIn(toExtract, changes.modified.map((_) => _.id));
+  for (const fix of framesToFix) {
+    const other = win.frames[fix.id];
+    if (fix.type === "start") {
+      const sizeDiff = other[fix.posKey];
+      other[fix.posKey] = 0;
+      other[fix.sizeKey] += sizeDiff;
+    } else {
+      const sizeDiff = settings.maxInt - (other[fix.posKey] + other[fix.sizeKey]);
+      other[fix.sizeKey] += sizeDiff;
+    }
+  }
+  pushIfNotIn(toExtract, framesToFix.map((_) => _.id));
+  frame[sizeKey] = storedSize;
+  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/getFrameUndockInfo.d.ts

@@ -0,0 +1,13 @@
+import type { 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 undock a frame.
+ *
+ * Changes can be applied to a window with {@link applyFrameChanges}.
+ *
+ * If a frame is not docked it will throw.
+ *
+ * If the frame was collapsed it will be uncollapsed.
+ */
+export declare function getFrameUndockInfo(win: LayoutWindow, frameId: string): LayoutChange | KnownError<typeof LAYOUT_ERROR.CANT_UNDOCK_COLLAPSED_FRAME>;

package/dist/runtime/layout/getFrameUndockInfo.js

@@ -0,0 +1,51 @@
+import { settings } from "../settings.js";
+import { LAYOUT_ERROR } from "../types/index.js";
+import { KnownError } from "../utils/KnownError.js";
+export function getFrameUndockInfo(win, frameId) {
+  const frame = win.frames[frameId];
+  if (!frame) {
+    throw new Error(`Unknown frame ${frameId}`);
+  }
+  if (!frame.docked) throw new Error("Can't undock frame that is not docked.");
+  const frameSide = frame.docked;
+  const isVertical = frameSide === "left" || frameSide === "right";
+  const sizeKey = isVertical ? "height" : "width";
+  const posKey = isVertical ? "y" : "x";
+  const maxInt = settings.maxInt;
+  const shrinkStartKey = isVertical ? "top" : "left";
+  const shrinkEndKey = isVertical ? "bottom" : "right";
+  if (frame.collapsed) {
+    return new KnownError(LAYOUT_ERROR.CANT_UNDOCK_COLLAPSED_FRAME, `Can't undock collapsed frame ${frame.id}.`, { frame: frame.id });
+  }
+  const frameClone = { ...frame, docked: void 0, collapsed: void 0 };
+  const otherDockedFramesToResize = [];
+  const dockedSidesToSearch = [
+    ...frame[posKey] === 0 ? [shrinkStartKey] : [],
+    ...frame[posKey] + frame[sizeKey] === maxInt ? [shrinkEndKey] : []
+  ];
+  for (const other of Object.values(win.frames)) {
+    if (other.id !== frame.id && other.docked && dockedSidesToSearch.includes(other.docked)) {
+      otherDockedFramesToResize.push(other);
+    }
+  }
+  if (otherDockedFramesToResize.length === 0) {
+    return { modified: [frameClone], created: [], deleted: [] };
+  }
+  const adjustmentKey = frameSide === "left" ? "x" : frameSide === "top" ? "y" : frameSide === "right" ? "width" : "height";
+  const secondaryAdjustmentKey = frameSide === "left" ? "width" : frameSide === "top" ? "height" : frameSide === "right" ? "x" : "y";
+  const adjustmentValue = frameSide === "left" || frameSide === "top" ? 0 : maxInt;
+  const otherChanges = otherDockedFramesToResize.map((other) => {
+    if (other.docked === shrinkStartKey) {
+      frameClone[posKey] += other[sizeKey];
+      frameClone[sizeKey] -= other[sizeKey];
+    } else if (other.docked === shrinkEndKey) {
+      frameClone[sizeKey] -= other[sizeKey];
+    }
+    return {
+      ...other,
+      [adjustmentKey]: adjustmentValue,
+      [secondaryAdjustmentKey]: other[secondaryAdjustmentKey] + other[adjustmentKey]
+    };
+  });
+  return { modified: [frameClone, ...otherChanges], created: [], deleted: [] };
+}

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

@@ -0,0 +1,29 @@
+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 redistribute frames to expand/shrink a certain amount towards the given side.
+ *
+ * Changes can be applied to a window with {@link applyFrameChanges}.
+ *
+ * While it checks for bounds/space issues (unless allowOutOfBounds is true), it does not check that all the frames correctly share/fill the start/end edges.
+ *
+ * If you try to resize a layout like this to the right, you will get issues with frame edges not lining up as frame B would be resized less than A. If you had a frame at the empty space that you excluded, it's right edge would no longer align with B's.
+ *
+ * See {@link getFrameCollapseInfo} and {@link getFrameUncollapseInfo} for how to work around this (you must move frames like A to share the edge then move them back). Excluding them from the calcuation usually leads to subtler errors. Such as if there are frames after A and B to the right, excluding A would mean A's right edge would stop aligning with those other frames.
+ *
+ * ┌────────────┐
+ * │A           │
+ * └──┬─────────┤
+ *    │B        │
+ *    └─────────┘
+ *
+ * Also note that it automatically excludes all collapsed frames without an area (height or width === 0).
+ */
+export declare function getFramesRedistributeInfo(win: LayoutWindow, 
+/** Side to expand/shrink to. */
+side: EdgeSide, frameIds: string[], 
+/** This can be negative to expand the frames instead (e.g. when collapsing a docked frame). */
+amountScaled: number, 
+/** Allow the resize span to exceed window bounds. */
+allowOutOfBounds?: boolean): LayoutChange | KnownError<typeof LAYOUT_ERROR.REDISTRIBUTE_OUT_OF_BOUNDS> | KnownError<typeof LAYOUT_ERROR.NO_SPACE_TO_REDISTRIBUTE>;

package/dist/runtime/layout/getFramesRedistributeInfo.js

@@ -0,0 +1,53 @@
+import { settings } from "../settings.js";
+import { LAYOUT_ERROR } from "../types/index.js";
+import { KnownError } from "../utils/KnownError.js";
+export function getFramesRedistributeInfo(win, side, frameIds, amountScaled, allowOutOfBounds = false) {
+  const isLeftOrTop = side === "left" || side === "top";
+  const isHorizontalSide = side === "left" || side === "right";
+  const posKey = isHorizontalSide ? "x" : "y";
+  const sizeKey = isHorizontalSide ? "width" : "height";
+  const frames = frameIds.map((id) => win.frames[id]);
+  const edgeSet = /* @__PURE__ */ new Set();
+  for (const frame of frames) {
+    edgeSet.add(frame[posKey]);
+    edgeSet.add(frame[posKey] + frame[sizeKey]);
+  }
+  const uniqueEdges = [...edgeSet].sort((a, b) => a - b);
+  const maxInt = settings.maxInt;
+  const resizeSpan = uniqueEdges[uniqueEdges.length - 1] - uniqueEdges[0];
+  const newSpan = resizeSpan - amountScaled;
+  if (!allowOutOfBounds && (newSpan > maxInt || newSpan < 0)) {
+    return new KnownError(LAYOUT_ERROR.REDISTRIBUTE_OUT_OF_BOUNDS, `Not enough space to resize frames, needed ${newSpan} but min/max as 0/${maxInt}.`, { max: maxInt, min: 0, wanted: newSpan });
+  }
+  const anchorEdge = isLeftOrTop ? uniqueEdges[0] : uniqueEdges[uniqueEdges.length - 1];
+  const dirMultiplier = isLeftOrTop ? -1 : 1;
+  const newEdges = [];
+  for (let i = 0; i < uniqueEdges.length; i++) {
+    const edge = uniqueEdges[i];
+    const distFromAnchor = anchorEdge === uniqueEdges[0] ? edge - anchorEdge : anchorEdge - edge;
+    const rawMovement = dirMultiplier * distFromAnchor / resizeSpan * amountScaled;
+    const newEdge = edge + Math.trunc(rawMovement);
+    newEdges.push(newEdge);
+  }
+  const oppositeEdgeIndex = isLeftOrTop ? uniqueEdges.length - 1 : 0;
+  newEdges[oppositeEdgeIndex] = isLeftOrTop ? anchorEdge + newSpan : anchorEdge - newSpan;
+  const minSize = settings.minSizeScaled[sizeKey];
+  const result = [];
+  for (const frame of frames) {
+    if (frame.collapsed && (frame.width === 0 || frame.height === 0)) continue;
+    const startEdge = frame[posKey];
+    const endEdge = frame[posKey] + frame[sizeKey];
+    const newStart = newEdges[uniqueEdges.indexOf(startEdge)];
+    const newEnd = newEdges[uniqueEdges.indexOf(endEdge)];
+    const newSize = newEnd - newStart;
+    if (newSize < minSize) {
+      return new KnownError(LAYOUT_ERROR.NO_SPACE_TO_REDISTRIBUTE, `Redistribute would cause frame ${frame.id} to shrink to ${newSize} which is below minimum ${minSize}.`, { frameSizeNeeded: newSize, minFrameSize: minSize });
+    }
+    result.push({
+      ...frame,
+      [posKey]: newStart,
+      [sizeKey]: newSize
+    });
+  }
+  return { modified: result, created: [], deleted: [] };
+}

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

@@ -0,0 +1,6 @@
+import type { LayoutWindow, WindowEdgeZone } from "../types/index.js";
+/**
+ * Returns window edge drag zones (in scaled coordinates)
+ *
+ */
+export declare function getWindowDragZones(win: LayoutWindow, thresholdPx: number): WindowEdgeZone[];

package/dist/runtime/layout/getWindowDragZones.js

@@ -0,0 +1,49 @@
+import { numberToScaledPercent } from "../helpers/numberToScaledPercent.js";
+import { settings } from "../settings.js";
+export function getWindowDragZones(win, thresholdPx) {
+  const thX = numberToScaledPercent(thresholdPx, win.pxWidth);
+  const thY = numberToScaledPercent(thresholdPx, win.pxHeight);
+  const maxInt = settings.maxInt;
+  return [
+    {
+      type: "window",
+      side: "top",
+      x: 0,
+      y: 0,
+      width: maxInt,
+      height: thY,
+      pxWidth: win.pxWidth,
+      pxHeight: thresholdPx
+    },
+    {
+      type: "window",
+      side: "bottom",
+      x: 0,
+      y: maxInt - thY,
+      width: maxInt,
+      height: thY,
+      pxWidth: win.pxWidth,
+      pxHeight: thresholdPx
+    },
+    {
+      type: "window",
+      side: "left",
+      x: 0,
+      y: 0,
+      width: thX,
+      height: maxInt,
+      pxWidth: thresholdPx,
+      pxHeight: win.pxHeight
+    },
+    {
+      type: "window",
+      side: "right",
+      x: maxInt - thX,
+      y: 0,
+      width: thX,
+      height: maxInt,
+      pxWidth: thresholdPx,
+      pxHeight: win.pxHeight
+    }
+  ];
+}

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

@@ -1,17 +1,26 @@
-export { closeFrame } from "./closeFrame.js";
-export { closeFrames } from "./closeFrames.js";
-export { createSplitDecoEdge } from "./createSplitDecoEdge.js";
+export { applyFrameChanges } from "./applyFrameChanges.js";
 export { createSplitDecoFromDrag } from "./createSplitDecoFromDrag.js";
+export { createSplitDecoShapes } from "./createSplitDecoShapes.js";
 export { debugFrame } from "./debugFrame.js";
 export { findFramesTouchingEdge } from "./findFramesTouchingEdge.js";
 export { findSafeSplitEdgeAndPosition } from "./findSafeSplitEdge.js";
 export { findVisualEdge } from "./findVisualEdge.js";
 export { frameCreate } from "./frameCreate.js";
-export { frameSplit } from "./frameSplit.js";
 export { getCloseFrameInfo } from "./getCloseFrameInfo.js";
+export { getDragZones } from "./getDragZones.js";
+export { getFillEmptySpaceInfo } from "./getFillEmptySpaceInfo.js";
+export { getFrameCollapseInfo } from "./getFrameCollapseInfo.js";
+export { getFrameDockInfo } from "./getFrameDockInfo.js";
+export { getFrameDragZones } from "./getFrameDragZones.js";
+export { getFrameRearrangeInfo } from "./getFrameRearrangeInfo.js";
 export { getFrameSplitInfo } from "./getFrameSplitInfo.js";
+export { getFramesRedistributeInfo } from "./getFramesRedistributeInfo.js";
+export { getFrameSwapInfo } from "./getFrameSwapInfo.js";
 export { getFrameTo } from "./getFrameTo.js";
-export { isPointInFrame } from "./isPointInFrame.js";
+export { getFrameUncollapseInfo } from "./getFrameUncollapseInfo.js";
+export { getFrameUndockInfo } from "./getFrameUndockInfo.js";
+export { getWindowDragZones } from "./getWindowDragZones.js";
+export { isPointInRect } from "./isPointInRect.js";
 export { layoutAddWindow } from "./layoutAddWindow.js";
 export { layoutCreate } from "./layoutCreate.js";
 export { layoutRemoveWindow } from "./layoutRemoveWindow.js";