@witchcraft/layout 0.0.1

package/dist/runtime/helpers/getVisualEdges.js

@@ -0,0 +1,89 @@
+import { multisplice, MULTISPLICE_ITEM } from "@alanscodelog/utils/multisplice";
+import { addPointsToIntersection } from "./addPointsToIntersection.js";
+import { assertEdgeSorted } from "./assertEdgeSorted.js";
+import { containsEdge } from "./containsEdge.js";
+import { doEdgesOverlap } from "./doEdgesOverlap.js";
+import { frameToEdges } from "./frameToEdges.js";
+import { frameToPoints } from "./frameToPoints.js";
+import { inRange } from "./inRange.js";
+import { splitEdge } from "./splitEdge.js";
+import { unionEdges } from "./unionEdges.js";
+import { getMaxInt } from "../settings.js";
+export function getVisualEdges(frames, {
+  separateByDir = false,
+  includeWindowEdges = false
+} = {}) {
+  let extVertEdges = [];
+  let extHorzEdges = [];
+  const intersections = {
+    // x: {y: count}
+  };
+  const max = getMaxInt();
+  for (const frame of frames) {
+    const frameEdges = frameToEdges(frame);
+    addPointsToIntersection(intersections, Object.values(frameToPoints(frame)));
+    secondlabel: for (const edge of Object.values(frameEdges)) {
+      const dir = edge === frameEdges.left || edge === frameEdges.right ? "vertical" : "horizontal";
+      const startKey = dir === "vertical" ? "startX" : "startY";
+      const endKey = dir === "vertical" ? "endX" : "endY";
+      const arr = dir === "vertical" ? extVertEdges : extHorzEdges;
+      const indexes = [];
+      const edges = [];
+      for (const [i, e] of arr.entries()) {
+        if (containsEdge(edge, e, dir)) {
+          continue secondlabel;
+        }
+        if (doEdgesOverlap(e, edge, dir)) {
+          indexes.push(i);
+          edges.push(e);
+        }
+      }
+      if (indexes.length > 0) {
+        multisplice(arr, indexes, 1);
+        edges.push(edge);
+        const newEdge = unionEdges(edges, dir);
+        arr.push(newEdge);
+      } else if (includeWindowEdges || edge[startKey] !== 0 && edge[endKey] !== max) {
+        arr.push(edge);
+      }
+    }
+  }
+  const changesV = {};
+  for (const [i, edge] of extVertEdges.entries()) {
+    const possibleIntersections = intersections[edge.startX];
+    assertEdgeSorted(edge);
+    if (possibleIntersections) {
+      const splits = Object.keys(possibleIntersections).filter((_y) => {
+        const y = Number.parseInt(_y, 10);
+        const isIntersection = possibleIntersections[_y] === 4;
+        return isIntersection && inRange(y, edge.startY, edge.endY);
+      }).map((_) => Number.parseInt(_, 10));
+      if (splits.length === 0) continue;
+      changesV[i] = splitEdge(extVertEdges[i], "vertical", splits);
+    }
+  }
+  extVertEdges = multisplice(
+    extVertEdges,
+    Object.keys(changesV),
+    1,
+    Object.values(changesV),
+    { insert: MULTISPLICE_ITEM.MATCH_INDEX }
+  ).array.flat();
+  const changesH = {};
+  for (const [i, edge] of extHorzEdges.entries()) {
+    const splits = Object.keys(intersections).filter((x) => intersections[x][edge.startY] === 4).map((_) => Number.parseInt(_, 10));
+    if (splits.length === 0) continue;
+    changesH[i] = splitEdge(extHorzEdges[i], "horizontal", splits);
+  }
+  extHorzEdges = multisplice(
+    extHorzEdges,
+    Object.keys(changesH),
+    1,
+    Object.values(changesH),
+    { insert: MULTISPLICE_ITEM.MATCH_INDEX }
+  ).array.flat();
+  if (separateByDir) {
+    return { vertical: extVertEdges, horizontal: extHorzEdges };
+  }
+  return extVertEdges.concat(extHorzEdges);
+}

package/dist/runtime/helpers/getVisualEdgesCss.js

@@ -0,0 +1,4 @@
+import { getVisualEdgeCss } from "./getVisualEdgeCss.js";
+export function getVisualEdgesCss(edges, opts = {}) {
+  return edges.map((edge) => getVisualEdgeCss(edge, opts));
+}

package/dist/runtime/helpers/getWinAndFrameById.js

@@ -0,0 +1,14 @@
+import { getFrameConstant } from "./getFrameConstant.js";
+import { getWinByFrameUuid } from "./getWinByFrameUuid.js";
+import { getWindowConstant } from "./getWindowConstant.js";
+export function getWinAndFrameById(layout, winId, frameId, assert = false) {
+  let win;
+  if (winId === void 0) {
+    win = getWinByFrameUuid(layout, frameId, assert);
+  } else {
+    win = layout.windows[getWindowConstant(layout, winId, assert)];
+  }
+  const maybeFrameId = win !== void 0 ? getFrameConstant(win, frameId, assert) : void 0;
+  const frame = win?.frames[maybeFrameId];
+  return { win, frame };
+}

package/dist/runtime/helpers/getWinByFrameUuid.js

@@ -0,0 +1,13 @@
+import { LAYOUT_ERROR } from "../types/index.js";
+import { KnownError } from "../utils/KnownError.js";
+export function getWinByFrameUuid(layout, frameId, assert = false) {
+  for (const win of Object.values(layout.windows)) {
+    if (win.frames[frameId]) {
+      return win;
+    }
+  }
+  if (assert) {
+    throw new KnownError(LAYOUT_ERROR.INVALID_ID, "Could not find window with frame with that id.", { id: frameId });
+  }
+  return void 0;
+}

package/dist/runtime/helpers/getWinById.js

@@ -0,0 +1,5 @@
+import { getWindowConstant } from "./getWindowConstant.js";
+export function getWinById(layout, winId, assert = false) {
+  const winId_ = getWindowConstant(layout, winId, assert);
+  return layout.windows[winId_];
+}

package/dist/runtime/helpers/getWindowConstant.js

@@ -0,0 +1,14 @@
+import { assertItemIn } from "./assertItemIn.js";
+import { assertLayoutHasActiveWindow } from "./assertLayoutHasActiveWindow.js";
+export function getWindowConstant(layout, constant, assert = false) {
+  switch (constant) {
+    case "ACTIVE": {
+      if (assert) assertLayoutHasActiveWindow(layout);
+      return layout.activeWindow;
+    }
+    default: {
+      if (assert) assertItemIn(layout.windows, constant);
+      return constant;
+    }
+  }
+}

package/dist/runtime/helpers/inRange.js

@@ -0,0 +1,3 @@
+export function inRange(coord, lowerLimit, upperLimit, inclusive = true) {
+  return inclusive ? coord >= lowerLimit && coord <= upperLimit : coord > lowerLimit && coord < upperLimit;
+}

package/dist/runtime/helpers/index.js

@@ -0,0 +1,62 @@
+export { addPointsToIntersection } from "./addPointsToIntersection.js";
+export { assertEdgeSorted } from "./assertEdgeSorted.js";
+export { assertItemIn } from "./assertItemIn.js";
+export { assertItemNotIn } from "./assertItemNotIn.js";
+export { assertLayoutHasActiveWindow } from "./assertLayoutHasActiveWindow.js";
+export { assertValidWinAndFrame } from "./assertValidWinAndFrame.js";
+export { assertValidWinAndFrameIds } from "./assertValidWinAndFrameIds.js";
+export { assertWindowHasActiveFrame } from "./assertWindowHasActiveFrame.js";
+export { clampNumber } from "./clampNumber.js";
+export { cloneFrame } from "./cloneFrame.js";
+export { cloneFrames } from "./cloneFrames.js";
+export { containsEdge } from "./containsEdge.js";
+export { convertLayoutWindowToWorkspace } from "./convertLayoutWindowToWorkspace.js";
+export { copySize } from "./copySize.js";
+export { createEdge } from "./createEdge.js";
+export { dirToOrientation } from "./dirToOrientation.js";
+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 { frameToEdges } from "./frameToEdges.js";
+export { frameToPoints } from "./frameToPoints.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 { getIntersections } from "./getIntersections.js";
+export { getIntersectionsCss } from "./getIntersectionsCss.js";
+export { getMoveEdgeInfo } from "./getMoveEdgeInfo.js";
+export { getResizeLimit } from "./getResizeLimit.js";
+export { getShapeSquareCss } from "./getShapeSquareCss.js";
+export { getSideTouching } from "./getSideTouching.js";
+export { getVisualEdgeCss } from "./getVisualEdgeCss.js";
+export { getVisualEdges } from "./getVisualEdges.js";
+export { getVisualEdgesCss } from "./getVisualEdgesCss.js";
+export { getWinAndFrameById } from "./getWinAndFrameById.js";
+export { getWinByFrameUuid } from "./getWinByFrameUuid.js";
+export { getWinById } from "./getWinById.js";
+export { getWindowConstant } from "./getWindowConstant.js";
+export { inRange } from "./inRange.js";
+export { isEdgeEqual } from "./isEdgeEqual.js";
+export { isEdgeParallel } from "./isEdgeParallel.js";
+export { isPointEqual } from "./isPointEqual.js";
+export { isSizeAboveMin } from "./isSizeAboveMin.js";
+export { isSizeEqual } from "./isSizeEqual.js";
+export { isWindowEdge } from "./isWindowEdge.js";
+export { isWindowEdgePoint } from "./isWindowEdgePoint.js";
+export { moveEdge } from "./moveEdge.js";
+export { numberToScaledPercent } from "./numberToScaledPercent.js";
+export { numberToScaledSize } from "./numberToScaledSize.js";
+export { oppositeSide } from "./oppositeSide.js";
+export { resizeByEdge } from "./resizeByEdge.js";
+export { sideToDirection } from "./sideToDirection.js";
+export { sideToOrientation } from "./sideToOrientation.js";
+export { splitEdge } from "./splitEdge.js";
+export { toCoord } from "./toCoord.js";
+export { toId } from "./toId.js";
+export { toWindowCoord } from "./toWindowCoord.js";
+export { unionEdges } from "./unionEdges.js";

package/dist/runtime/helpers/isEdgeEqual.js

@@ -0,0 +1,11 @@
+import { getEdgeOrientation } from "./getEdgeOrientation.js";
+import { isEdgeParallel } from "./isEdgeParallel.js";
+export function isEdgeEqual(edgeA, edgeB, orientation) {
+  orientation ??= getEdgeOrientation(edgeA);
+  if (!isEdgeParallel(edgeA, edgeB)) return false;
+  if (orientation === "horizontal") {
+    return edgeA.startY === edgeB.startY && edgeB.endY === edgeA.endY;
+  } else {
+    return edgeA.startX === edgeB.startX && edgeB.endX === edgeA.endX;
+  }
+}

package/dist/runtime/helpers/isEdgeParallel.js

@@ -0,0 +1,7 @@
+import { getEdgeSharedDirection } from "./getEdgeSharedDirection.js";
+export function isEdgeParallel(edgeA, edgeB, dir) {
+  const sharedDir = getEdgeSharedDirection(edgeA, edgeB);
+  if (dir === void 0) return sharedDir !== false;
+  if (dir === sharedDir) return true;
+  return false;
+}

package/dist/runtime/helpers/isPointEqual.js

@@ -0,0 +1,3 @@
+export function isPointEqual(pointA, pointB) {
+  return pointA.x === pointB.x && pointA.y === pointB.y;
+}

package/dist/runtime/helpers/isSizeAboveMin.js

@@ -0,0 +1,3 @@
+export function isSizeAboveMin(size, min) {
+  return size.width >= min.width && size.height >= min.height;
+}

package/dist/runtime/helpers/isSizeEqual.js

@@ -0,0 +1,3 @@
+export function isSizeEqual(sizeA, sizeB) {
+  return sizeA.width === sizeB.width && sizeA.height === sizeB.height;
+}

package/dist/runtime/helpers/isWindowEdge.js

@@ -0,0 +1,7 @@
+import { getEdgeOrientation } from "./getEdgeOrientation.js";
+import { getMaxInt } from "../settings.js";
+export function isWindowEdge(edge, edgeDirection) {
+  edgeDirection ??= getEdgeOrientation(edge);
+  const max = getMaxInt();
+  return edgeDirection === "vertical" && (edge.startX === 0 || edge.startX === max) || edgeDirection === "horizontal" && (edge.startY === 0 || edge.startY === max);
+}

package/dist/runtime/helpers/isWindowEdgePoint.js

@@ -0,0 +1,5 @@
+import { getMaxInt } from "../settings.js";
+export function isWindowEdgePoint(point) {
+  const max = getMaxInt();
+  return point.x === 0 || point.x === max || (point.y === 0 || point.y === max);
+}

package/dist/runtime/helpers/moveEdge.js

@@ -0,0 +1,8 @@
+import { getMoveEdgeInfo } from "./getMoveEdgeInfo.js";
+import { resizeByEdge } from "./resizeByEdge.js";
+import { getMarginSize } from "../settings.js";
+export function moveEdge(touchingFrames, edge, position, margin = getMarginSize()) {
+  if (!edge || !touchingFrames) return;
+  const { pos, dir, distance } = getMoveEdgeInfo(touchingFrames, edge, position, margin);
+  resizeByEdge(touchingFrames, edge, dir, pos, distance);
+}

package/dist/runtime/helpers/numberToScaledPercent.js

@@ -0,0 +1,5 @@
+import { snapNumber } from "@alanscodelog/utils/snapNumber";
+import { getMaxInt } from "../settings.js";
+export function numberToScaledPercent(num, max, scale = getMaxInt()) {
+  return snapNumber(num / max * scale, 1);
+}

package/dist/runtime/helpers/numberToScaledSize.js

@@ -0,0 +1,19 @@
+import { unreachable } from "@alanscodelog/utils/unreachable";
+import { numberToScaledPercent } from "./numberToScaledPercent.js";
+import { getMaxInt } from "../settings.js";
+export function numberToScaledSize(win, size, scale = getMaxInt()) {
+  const scaledSize = {
+    width: numberToScaledPercent(
+      typeof size === "number" ? size : size.pxWidth,
+      win.pxWidth,
+      scale
+    ),
+    height: numberToScaledPercent(
+      typeof size === "number" ? size : size.pxHeight,
+      win.pxHeight,
+      scale
+    )
+  };
+  if (scaledSize.width > scale) unreachable();
+  return scaledSize;
+}

package/dist/runtime/helpers/oppositeSide.js

@@ -0,0 +1,30 @@
+import { unreachable } from "@alanscodelog/utils/unreachable";
+export function oppositeSide(dir) {
+  switch (dir) {
+    case "x":
+      return "y";
+    case "y":
+      return "x";
+    case "width":
+      return "height";
+    case "height":
+      return "width";
+    case "left":
+      return "right";
+    case "right":
+      return "left";
+    case "up":
+      return "down";
+    case "top":
+      return "bottom";
+    case "bottom":
+      return "top";
+    case "down":
+      return "up";
+    case "horizontal":
+      return "vertical";
+    case "vertical":
+      return "horizontal";
+  }
+  unreachable();
+}

package/dist/runtime/helpers/resizeByEdge.js

@@ -0,0 +1,29 @@
+export function resizeByEdge(touchingFrames, edge, dir, newPos, distance) {
+  if (distance === 0) return;
+  for (const frame of touchingFrames) {
+    if (dir === "up" || dir === "down") {
+      const isAbove = frame.y < edge.startY;
+      if (isAbove) {
+        frame.height = newPos - frame.y;
+      } else {
+        frame.height = frame.y + frame.height - newPos;
+        frame.y = newPos;
+      }
+    } else {
+      const isLeft = frame.x < edge.startX;
+      if (isLeft) {
+        frame.width = newPos - frame.x;
+      } else {
+        frame.width = frame.x + frame.width - newPos;
+        frame.x = newPos;
+      }
+    }
+  }
+  if (dir === "up" || dir === "down") {
+    edge.startY = newPos;
+    edge.endY = newPos;
+  } else {
+    edge.startX = newPos;
+    edge.endX = newPos;
+  }
+}

package/dist/runtime/helpers/sideToDirection.js

@@ -0,0 +1,11 @@
+export function sideToDirection(side) {
+  switch (side) {
+    case "left":
+    case "right":
+      return side;
+    case "top":
+      return "up";
+    case "bottom":
+      return "down";
+  }
+}

package/dist/runtime/helpers/sideToOrientation.js

@@ -0,0 +1,10 @@
+export function sideToOrientation(dir) {
+  switch (dir) {
+    case "left":
+    case "right":
+      return "vertical";
+    case "top":
+    case "bottom":
+      return "horizontal";
+  }
+}

package/dist/runtime/helpers/splitEdge.js

@@ -0,0 +1,20 @@
+import { last } from "@alanscodelog/utils/last";
+export function splitEdge(edge, edgeDirection, splits) {
+  const startKey = edgeDirection === "horizontal" ? "startX" : "startY";
+  const endKey = edgeDirection === "horizontal" ? "endX" : "endY";
+  const newEdges = [];
+  if (splits.length === 0) throw new Error("There must be at least one split position.");
+  for (const [i, splitPos] of splits.entries()) {
+    if (i === 0) {
+      newEdges.push({ ...edge, [startKey]: edge[startKey], [endKey]: splitPos });
+    } else {
+      const prevEdge2 = newEdges[i - 1];
+      newEdges.push({ ...prevEdge2, [startKey]: prevEdge2[endKey], [endKey]: splitPos });
+    }
+  }
+  const prevEdge = last(newEdges);
+  if (prevEdge[endKey] !== edge[endKey]) {
+    newEdges.push({ ...prevEdge, [startKey]: prevEdge[endKey], [endKey]: edge[endKey] });
+  }
+  return newEdges;
+}

package/dist/runtime/helpers/toCoord.js

@@ -0,0 +1,10 @@
+export function toCoord(dir) {
+  switch (dir) {
+    case "left":
+    case "right":
+    case "horizontal":
+      return "x";
+    default:
+      return "y";
+  }
+}

package/dist/runtime/helpers/toId.js

@@ -0,0 +1,4 @@
+import { unreachable } from "@alanscodelog/utils/unreachable";
+export function toId(item) {
+  return typeof item === "string" ? item : typeof item.id === "string" ? item.id : unreachable();
+}

package/dist/runtime/helpers/toWindowCoord.js

@@ -0,0 +1,14 @@
+import { snapNumber } from "@alanscodelog/utils/snapNumber";
+import { numberToScaledPercent } from "./numberToScaledPercent.js";
+import { getSnapPoint } from "../settings.js";
+export function toWindowCoord(win, e, snapAmount = getSnapPoint()) {
+  const x = numberToScaledPercent(e.clientX - win.pxX, win.pxWidth);
+  const y = numberToScaledPercent(e.clientY - win.pxY, win.pxHeight);
+  if (snapAmount) {
+    return {
+      x: snapNumber(x, snapAmount.x),
+      y: snapNumber(y, snapAmount.x)
+    };
+  }
+  return { x, y };
+}

package/dist/runtime/helpers/unionEdges.js

@@ -0,0 +1,8 @@
+import { last } from "@alanscodelog/utils/last";
+export function unionEdges(edges, dir) {
+  const startKey = dir === "horizontal" ? "startX" : "startY";
+  const endKey = dir === "horizontal" ? "endX" : "endY";
+  edges.sort((a, b) => a[startKey] - b[startKey]);
+  const newEdge = { ...edges[0], [startKey]: edges[0][startKey], [endKey]: last(edges)[endKey] };
+  return newEdge;
+}

package/dist/runtime/helpers/updateWindowSizeWithEvent.js

@@ -0,0 +1,8 @@
+const props = ["pxWidth", "pxHeight", "pxX", "pxY"];
+export function updateWindowWithEvent(win, event) {
+  for (const prop of props) {
+    if (event[prop] && win[prop] !== event[prop]) {
+      win[prop] = event[prop];
+    }
+  }
+}

package/dist/runtime/index.js

@@ -0,0 +1,5 @@
+export * from "./types/index.js";
+export * from "./layout/index.js";
+export * from "./helpers/index.js";
+export * from "./utils/KnownError.js";
+export * from "./settings.js";

package/dist/runtime/layout/closeFrame.js

@@ -0,0 +1,13 @@
+import { closeFrames } from "./closeFrames.js";
+import { getCloseFrameInfo } from "./getCloseFrameInfo.js";
+import { getMarginSize } from "../settings.js";
+export function closeFrame(win, visualEdges, frame, closeDirOrSide, closeBy = "dir", force = false, minSize = getMarginSize()) {
+  const canClose = getCloseFrameInfo(Object.values(win.frames), visualEdges, frame, closeDirOrSide, closeBy, force, minSize);
+  if (canClose instanceof Error) {
+    return canClose;
+  }
+  const { deletedFrames, modifiedFrames } = canClose;
+  closeFrames(win, deletedFrames, modifiedFrames);
+  win.activeFrame = modifiedFrames[0].id;
+  return deletedFrames;
+}

package/dist/runtime/layout/closeFrames.js

@@ -0,0 +1,8 @@
+export function closeFrames(win, deletedFrames, modifiedFrames) {
+  for (const f of deletedFrames) {
+    delete win.frames[f.id];
+  }
+  for (const mod of modifiedFrames) {
+    win.frames[mod.id] = mod;
+  }
+}

package/dist/runtime/layout/createSplitDecoEdge.js

@@ -0,0 +1,24 @@
+import { findSafeSplitEdgeAndPosition } from "./findSafeSplitEdge.js";
+import { getMarginSize, getSnapPoint } from "../settings.js";
+export function createSplitDecoEdge(frames, deco, snapAmount = getSnapPoint(), minSize = getMarginSize()) {
+  const frame = frames[deco.id];
+  const { edge, position } = findSafeSplitEdgeAndPosition(frame, deco.direction, deco.position, snapAmount, minSize);
+  const newFrame = { x: frame.x, y: frame.y, width: frame.width, height: frame.height };
+  switch (deco.direction) {
+    case "right":
+      newFrame.x = position;
+      newFrame.width = frame.x + frame.width - position;
+      break;
+    case "left":
+      newFrame.width = position - frame.x;
+      break;
+    case "down":
+      newFrame.y = position;
+      newFrame.height = frame.y + frame.height - position;
+      break;
+    case "up":
+      newFrame.height = position - frame.y;
+      break;
+  }
+  return { edge, newFrame };
+}

package/dist/runtime/layout/createSplitDecoFromDrag.js

@@ -0,0 +1,14 @@
+import { createSplitDecoEdge } from "./createSplitDecoEdge.js";
+import { dirToOrientation } from "../helpers/dirToOrientation.js";
+import { getMarginSize, getSnapPoint } from "../settings.js";
+export function createSplitDecoFromDrag(frames, frame, dragDirection, dragPoint, snapAmount = getSnapPoint(), minSize = getMarginSize()) {
+  const orientation = dirToOrientation(dragDirection);
+  const deco = {
+    type: "split",
+    id: frame.id,
+    position: dragPoint[orientation === "horizontal" ? "x" : "y"],
+    direction: dragDirection
+  };
+  deco.shapes = createSplitDecoEdge(frames, deco, snapAmount, minSize);
+  return deco;
+}

package/dist/runtime/layout/debugFrame.js

@@ -0,0 +1,4 @@
+export function debugFrame(frame) {
+  const f = frame;
+  return `id: ${f.id.slice(0, 4)}, x:  ${f.x}, y: ${f.y}, w: ${f.width}, h: ${f.height}`;
+}