@witchcraft/layout 0.4.3 → 0.5.0

package/dist/runtime/composables/useFrames.js

@@ -1,7 +1,6 @@
 import { debounce } from "@alanscodelog/utils/debounce";
 import { keys } from "@alanscodelog/utils/keys";
 import { computed, onBeforeUnmount, onMounted, ref, watch } from "vue";
-import { DragDirectionStore } from "../drag/DragDirectionStore.js";
 import { cloneFrame } from "../helpers/cloneFrame.js";
 import { getIntersections } from "../helpers/getIntersections.js";
 import { getVisualEdges } from "../helpers/getVisualEdges.js";
@@ -10,8 +9,9 @@ import { moveEdge } from "../helpers/moveEdge.js";
 import { toWindowCoord } from "../helpers/toWindowCoord.js";
 import { findFramesTouchingEdge } from "../layout/findFramesTouchingEdge.js";
 import { isPointInRect } from "../layout/isPointInRect.js";
+import { MoveDirectionStore } from "../move/MoveDirectionStore.js";
 export function useFrames(win, handler) {
-  const draggingEdges = ref([]);
+  const movingEdges = ref([]);
   const touchingFrames = ref([]);
   const allTouchingFrames = computed(() => {
     const result = {};
@@ -23,22 +23,23 @@ export function useFrames(win, handler) {
     return result;
   });
   const touchingFramesArrays = computed(() => touchingFrames.value.map((entry) => Object.values(entry)));
-  const isDragging = ref(false);
-  const showDragging = ref(false);
-  const dragPoint = ref();
-  const dragDirections = ref({});
-  let dragStartPoint;
-  const dragDistance = ref(-1);
-  const draggingIntersection = ref(void 0);
-  const isDraggingFromWindowEdge = ref(false);
-  const frameDragFrameId = ref();
+  const isMoving = ref(false);
+  const showMoving = ref(false);
+  const movePoint = ref();
+  const moveDirections = ref({});
+  let moveStartPoint;
+  const moveDistance = ref(-1);
+  const movingIntersection = ref(void 0);
+  const isMovingFromWindowEdge = ref(false);
+  const movingFrameId = ref();
+  const eventContext = ref();
   const frames = computed(
-    () => isDragging.value && showDragging.value ? { ...win.value.frames, ...allTouchingFrames.value } : win.value.frames
+    () => isMoving.value && showMoving.value ? { ...win.value.frames, ...allTouchingFrames.value } : win.value.frames
   );
-  const dragHoveredFrame = computed(() => {
-    if (isDragging.value) {
+  const moveHoveredFrame = computed(() => {
+    if (isMoving.value) {
       for (const id of keys(frames.value)) {
-        if (isPointInRect(frames.value[id], dragPoint.value)) {
+        if (isPointInRect(frames.value[id], movePoint.value)) {
           return frames.value[id];
         }
       }
@@ -47,83 +48,101 @@ export function useFrames(win, handler) {
   });
   const visualEdges = ref([]);
   const intersections = computed(() => getIntersections(visualEdges.value));
-  const debounceGetDraggableEdges = debounce((f) => {
+  const debounceGetMoveableEdges = debounce((f) => {
     visualEdges.value = getVisualEdges(f, { includeWindowEdges: true });
     handler.annotateEdges?.(visualEdges.value, f);
   }, 50, {});
-  watch([isDragging, frames], () => {
-    if (isDragging.value) return;
-    debounceGetDraggableEdges(Object.values(frames.value));
+  watch([isMoving, frames], () => {
+    if (isMoving.value) return;
+    debounceGetMoveableEdges(Object.values(frames.value));
   }, { deep: true });
-  debounceGetDraggableEdges(Object.values(frames.value));
+  debounceGetMoveableEdges(Object.values(frames.value));
   function forceRecalculateEdges() {
     visualEdges.value = getVisualEdges(Object.values(frames.value), { includeWindowEdges: true });
     handler.annotateEdges?.(visualEdges.value, Object.values(frames.value));
   }
-  const dragDirStore = new DragDirectionStore({
-    onUpdate: (dir) => dragDirections.value = dir
+  const moveDirStore = new MoveDirectionStore({
+    onUpdate: (dir) => moveDirections.value = dir
   });
   const state = computed(() => ({
-    dragDirections: dragDirections.value,
-    dragPoint: dragPoint.value,
-    dragDistance: dragDistance.value,
-    isDragging: isDragging.value,
-    showDragging: showDragging.value,
-    draggingFrameId: frameDragFrameId.value,
-    draggingEdges: draggingEdges.value,
-    draggingIntersection: draggingIntersection.value,
+    moveDirections: moveDirections.value,
+    movePoint: movePoint.value,
+    moveDistance: moveDistance.value,
+    isMoving: isMoving.value,
+    showMoving: showMoving.value,
+    movingFrameId: movingFrameId.value,
+    movingEdges: movingEdges.value,
+    movingIntersection: movingIntersection.value,
     visualEdges: visualEdges.value,
     touchingFrames: touchingFrames.value,
     touchingFramesArrays: touchingFramesArrays.value,
     frames: frames.value,
-    dragHoveredFrame: dragHoveredFrame.value,
+    moveHoveredFrame: moveHoveredFrame.value,
     intersections: intersections.value,
-    isDraggingFromWindowEdge: isDraggingFromWindowEdge.value,
+    isMovingFromWindowEdge: isMovingFromWindowEdge.value,
+    eventContext: eventContext.value,
     win: win.value
   }));
   let controller;
+  let moveResolve;
+  let moveResult;
   function resetState() {
-    dragStartPoint = void 0;
-    draggingEdges.value = [];
-    draggingIntersection.value = void 0;
-    isDragging.value = false;
-    dragPoint.value = void 0;
-    dragDistance.value = -1;
+    moveStartPoint = void 0;
+    moveResolve?.(moveResult);
+    moveResolve = void 0;
+    moveResult = void 0;
+    movingEdges.value = [];
+    movingIntersection.value = void 0;
+    isMoving.value = false;
+    movePoint.value = void 0;
+    moveDistance.value = -1;
     touchingFrames.value = [];
-    frameDragFrameId.value = void 0;
-    dragDirStore.reset();
-    showDragging.value = false;
+    movingFrameId.value = void 0;
+    eventContext.value = void 0;
+    moveDirStore.reset();
+    showMoving.value = false;
     forceRecalculateEdges();
   }
-  function dragStart(e, type, data) {
+  function moveStart(e, type, data, {
+    moveEvent = "pointermove",
+    endEvent = "pointerup",
+    context
+  } = {}) {
+    if (controller) {
+      controller.abort();
+    }
+    const promise = new Promise((resolve2) => {
+      moveResolve = resolve2;
+    });
     controller = new AbortController();
     controller.signal.addEventListener("abort", () => resetState());
     e.preventDefault();
-    window.addEventListener("pointermove", dragMove, { signal: controller.signal });
-    window.addEventListener("pointerup", dragEnd, { signal: controller.signal });
+    window.addEventListener(moveEvent, onMove, { signal: controller.signal });
+    window.addEventListener(endEvent, moveEnd, { signal: controller.signal });
     const point = toWindowCoord(win.value, e);
-    dragPoint.value = point;
-    dragStartPoint = { ...point };
-    dragDirStore.update(point);
-    isDragging.value = type;
-    showDragging.value = true;
+    movePoint.value = point;
+    moveStartPoint = { ...point };
+    moveDirStore.update(point);
+    eventContext.value = context;
+    isMoving.value = type;
+    showMoving.value = true;
     if (type === "frame") {
-      frameDragFrameId.value = data.frameId;
+      movingFrameId.value = data.frameId;
     } else {
       const { edge, intersection } = data;
-      draggingIntersection.value = intersection;
-      draggingEdges.value = edge ? [edge] : [
-        ...draggingIntersection.value?.sharedEdges.horizontal ?? [],
-        ...draggingIntersection.value?.sharedEdges.vertical ?? []
+      movingIntersection.value = intersection;
+      movingEdges.value = edge ? [edge] : [
+        ...movingIntersection.value?.sharedEdges.horizontal ?? [],
+        ...movingIntersection.value?.sharedEdges.vertical ?? []
       ];
-      isDraggingFromWindowEdge.value = draggingEdges.value.some((_) => isWindowEdge(_));
+      isMovingFromWindowEdge.value = movingEdges.value.some((_) => isWindowEdge(_));
       const framesArray = Object.values(win.value.frames);
       touchingFrames.value = [];
       const clones = /* @__PURE__ */ new Map();
-      for (let i = 0; i < draggingEdges.value.length; i++) {
-        const draggingEdge = draggingEdges.value[i];
+      for (let i = 0; i < movingEdges.value.length; i++) {
+        const movingEdge = movingEdges.value[i];
         touchingFrames.value[i] = {};
-        for (const { frame } of findFramesTouchingEdge(draggingEdge, framesArray)) {
+        for (const { frame } of findFramesTouchingEdge(movingEdge, framesArray)) {
           if (!clones.has(frame.id)) {
             const clone = cloneFrame(frame);
             touchingFrames.value[i][frame.id] = clone;
@@ -134,52 +153,60 @@ export function useFrames(win, handler) {
         }
       }
     }
-    const res = handler.onDragChange("start", e, state.value, forceRecalculateEdges, cancel);
-    showDragging.value = res.showDragging ?? true;
+    const res = handler.onMoveChange("start", e, state.value, forceRecalculateEdges, cancel, resolve);
+    showMoving.value = res.showMoving ?? true;
+    return promise;
   }
-  function dragMove(e) {
+  function onMove(e) {
     e.preventDefault();
     const point = toWindowCoord(win.value, e);
-    const didChange = dragDirStore.update(point);
-    dragPoint.value = point;
-    dragDistance.value = 0;
-    if (dragStartPoint) {
-      dragDistance.value = Math.sqrt(
-        Math.pow(point.x - dragStartPoint.x, 2) + Math.pow(point.y - dragStartPoint.y, 2)
+    const didChange = moveDirStore.update(point);
+    movePoint.value = point;
+    moveDistance.value = 0;
+    if (moveStartPoint) {
+      moveDistance.value = Math.sqrt(
+        Math.pow(point.x - moveStartPoint.x, 2) + Math.pow(point.y - moveStartPoint.y, 2)
       );
     }
     if (!didChange) return;
-    const res = handler.onDragChange("move", e, state.value, forceRecalculateEdges, cancel);
-    showDragging.value = res.showDragging ?? true;
+    const res = handler.onMoveChange("move", e, state.value, forceRecalculateEdges, cancel, resolve);
+    showMoving.value = res.showMoving ?? true;
     if (!res.updateEdges) return;
-    if (isDragging.value === "edge") {
+    if (isMoving.value === "edge") {
       requestAnimationFrame(() => {
-        for (let i = 0; i < draggingEdges.value.length; i++) {
-          const draggingEdge = draggingEdges.value[i];
-          if (draggingEdge) {
-            moveEdge(touchingFramesArrays.value[i], draggingEdge, point);
+        for (let i = 0; i < movingEdges.value.length; i++) {
+          const movingEdge = movingEdges.value[i];
+          if (movingEdge) {
+            moveEdge(touchingFramesArrays.value[i], movingEdge, point);
           }
         }
         forceRecalculateEdges();
       });
     }
   }
-  function dragEnd(e, { apply = true } = {}) {
+  function moveEnd(e, { apply = true } = {}) {
     if (e) {
       const point = toWindowCoord(win.value, e);
-      dragPoint.value = point;
+      movePoint.value = point;
     }
-    const doApply = apply && handler.onDragApply(state.value, forceRecalculateEdges);
-    if (doApply) {
-      for (const frame of touchingFramesArrays.value.flat()) {
-        win.value.frames[frame.id] = frame;
+    if (apply) {
+      const applyResult = handler.onMoveApply(state.value, forceRecalculateEdges);
+      moveResult = applyResult.result;
+      if (applyResult.apply) {
+        for (const frame of touchingFramesArrays.value.flat()) {
+          win.value.frames[frame.id] = frame;
+        }
       }
     }
-    handler.onDragChange("end", e, state.value, forceRecalculateEdges, cancel);
+    handler.onMoveChange("end", e, state.value, forceRecalculateEdges, void 0, void 0);
     controller?.abort();
   }
   function cancel() {
-    dragEnd(void 0, { apply: false });
+    moveEnd(void 0, { apply: false });
+  }
+  function resolve({ apply, result: value }) {
+    moveResult = value;
+    moveEnd(void 0, { apply });
   }
   const keydownController = new AbortController();
   const wrappedKeydownHandler = (e) => {
@@ -194,25 +221,26 @@ export function useFrames(win, handler) {
     keydownController?.abort();
   });
   return {
-    dragStart,
-    dragEnd,
+    moveStart,
+    moveEnd,
     cancel,
-    dragMove,
-    dragDirections,
-    dragPoint,
-    isDragging,
-    draggingEdges,
-    draggingIntersection,
+    onMove,
+    moveDirections,
+    movePoint,
+    isMoving,
+    movingEdges,
+    movingIntersection,
     visualEdges,
     touchingFrames,
     touchingFramesArrays,
     frames,
-    dragHoveredFrame,
+    moveHoveredFrame,
     intersections,
-    isDraggingFromWindowEdge,
+    isMovingFromWindowEdge,
     forceRecalculateEdges,
     state,
-    showDragging,
-    frameDragFrameId
+    showMoving,
+    movingFrameId,
+    actionHandler: handler
   };
 }

package/dist/runtime/demo/App.vue

@@ -10,7 +10,7 @@
 		v-if="win"
 		:frames="frames"
 		:win="win"
-		:dragActionHandler="dragActionHandler"
+		:actionHandler="actionHandler"
 	/>
 
 	<LayoutWindow
@@ -34,8 +34,8 @@
 		:textHints="textHints"
 		textHintsTeleportTo="#status-bar"
 		v-model:win="win"
-		@is-showing-drag="isShowingDrag = $event"
-		@drag-state="dragState = $event"
+		@is-showing-move="isShowingMove = $event"
+		@move-state="moveState = $event"
 	>
 			<LayoutFrame class="
 				flex
@@ -175,7 +175,7 @@ import {
 import { settings } from "../settings.js";
 import { throwIfError } from "@alanscodelog/utils/throwIfError";
 import { useTemplateRef } from "vue";
-import { DragActionHandler } from "../drag/DragActionHandler.js";
+import { ActionHandler } from "../move/ActionHandler.js";
 import LayoutDragEdgeHandle from "../components/LayoutDragEdgeHandle.vue";
 import LayoutDragEdgeVisible from "../components/LayoutDragEdgeVisible.vue";
 import LayoutIntersectionVisible from "../components/LayoutIntersectionVisible.vue";
@@ -213,25 +213,25 @@ function layoutInitialize(layout, { defaultPos, defaultSize } = {
   }));
   w.activeFrame = frame.id;
 }
-const isShowingDrag = ref(false);
-const dragState = ref(void 0);
+const isShowingMove = ref(false);
+const moveState = ref(void 0);
 function handleUndock(frameId) {
   const changes = throwIfError(getFrameUndockInfo(win.value, frameId));
-  DragActionHandler.debugState("undock", "before", dragState.value, {}, void 0);
+  ActionHandler.debugState("undock", "before", moveState.value, {}, void 0);
   applyFrameChanges(win.value, changes);
-  DragActionHandler.debugState("undock", "after", dragState.value, {}, void 0);
+  ActionHandler.debugState("undock", "after", moveState.value, {}, void 0);
 }
 function handleCollapse(frameId) {
   const changes = throwIfError(getFrameCollapseInfo(win.value, frameId));
-  DragActionHandler.debugState("collapse", "before", dragState.value, {}, void 0);
+  ActionHandler.debugState("collapse", "before", moveState.value, {}, void 0);
   applyFrameChanges(win.value, changes);
-  DragActionHandler.debugState("collapse", "after", dragState.value, {}, void 0);
+  ActionHandler.debugState("collapse", "after", moveState.value, {}, void 0);
 }
 function handleUncollapse(frameId) {
   const changes = throwIfError(getFrameUncollapseInfo(win.value, frameId));
-  DragActionHandler.debugState("uncollapse", "before", dragState.value, {}, void 0);
+  ActionHandler.debugState("uncollapse", "before", moveState.value, {}, void 0);
   applyFrameChanges(win.value, changes);
-  DragActionHandler.debugState("uncollapse", "after", dragState.value, {}, void 0);
+  ActionHandler.debugState("uncollapse", "after", moveState.value, {}, void 0);
 }
 const collapsedDocks = computed(() => {
   const sides = {};
@@ -242,12 +242,12 @@ const collapsedDocks = computed(() => {
   }
   return sides;
 });
-const dragActionHandler = computed(() => layoutComponent.value?.dragActionHandler);
+const actionHandler = computed(() => layoutComponent.value?.actionHandler);
 const textHints = computed(() => {
-  const isDragging = dragState.value?.isDragging;
-  const textHints2 = dragActionHandler.value?.textHints ?? { actions: [], errors: [] };
+  const isMoving = moveState.value?.isMoving;
+  const textHints2 = actionHandler.value?.textHints ?? { actions: [], errors: [] };
   return [
-    ...!isDragging ? [{ classes: "", text: "Drag from an edge to create a new frame." }] : [],
+    ...!isMoving ? [{ classes: "", text: "Drag from an edge to create a new frame." }] : [],
     ...textHints2.errors.map((_) => ({ classes: "text-red-500", text: _ })),
     ...textHints2.actions.map((_) => ({ text: _ }))
   ];

package/dist/runtime/demo/DemoControls.d.vue.ts

@@ -1,9 +1,9 @@
 import type { LayoutFrame, LayoutWindow } from "../types/index.js";
-import type { DragActionHandler } from "../drag/DragActionHandler.js";
+import type { ActionHandler } from "../move/ActionHandler.js";
 type __VLS_Props = {
     win: LayoutWindow;
     frames: LayoutFrame[];
-    dragActionHandler?: DragActionHandler<any>;
+    actionHandler?: ActionHandler<any>;
 };
 declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/runtime/demo/DemoControls.vue

@@ -26,7 +26,7 @@
 						<WButton class="flex-1" @click="copyState">Copy State</WButton>
 						<WCheckbox v-model="renameFrames">Easy Ids</WCheckbox>
 					</div>
-					<label class="flex flex-col gap-2 text-sm" v-if="dragActionHandler">
+					<label class="flex flex-col gap-2 text-sm" v-if="actionHandler">
 						<span>Plugin Debug Logs (true | debug path):</span>
 						<WSimpleInput v-model="debugKey" />
 					</label>
@@ -55,7 +55,7 @@ import { rotateLayout } from "../helpers/rotateFrames.js";
 const props = defineProps({
   win: { type: Object, required: true },
   frames: { type: Array, required: true },
-  dragActionHandler: { type: Object, required: false }
+  actionHandler: { type: Object, required: false }
 });
 const showDevActions = ref(false);
 const collapseSizeValue = ref(settings.collapseSizePx.width);
@@ -101,9 +101,9 @@ function copyState() {
 }
 const debugKey = ref(import.meta.dev ? "state.win.frames" : "false");
 watch(debugKey, () => {
-  if (!props.dragActionHandler) return;
+  if (!props.actionHandler) return;
   const value = debugKey.value === "true" ? true : debugKey.value === "false" ? false : debugKey.value;
-  for (const plugin of Object.values(props.dragActionHandler.actions)) {
+  for (const plugin of Object.values(props.actionHandler.actions)) {
     plugin.debug = value;
   }
 });

package/dist/runtime/demo/DemoControls.vue.d.ts

@@ -1,9 +1,9 @@
 import type { LayoutFrame, LayoutWindow } from "../types/index.js";
-import type { DragActionHandler } from "../drag/DragActionHandler.js";
+import type { ActionHandler } from "../move/ActionHandler.js";
 type __VLS_Props = {
     win: LayoutWindow;
     frames: LayoutFrame[];
-    dragActionHandler?: DragActionHandler<any>;
+    actionHandler?: ActionHandler<any>;
 };
 declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/runtime/demo/tailwind.css

@@ -1 +1 @@
-@import "tailwindcss";@import "../../../playground/.nuxt/witchcraft-ui.css";@import "../../../playground/.nuxt/witchcraft-layout.css";@source "../../../src/runtime/demo";
+@import "tailwindcss";@import "../../../playground/.nuxt/witchcraft-ui.css";@import "../../../playground/.nuxt/witchcraft-layout.css";@source "../../../src/runtime/demo";button{cursor:pointer}

package/dist/runtime/helpers/createZoneSideClipPath.d.ts

@@ -5,8 +5,8 @@
  *
  * Accepts scaled coordinates.
  */
-import type { DragZone } from "../types/index.js";
-export declare function createZoneSideClipPath(zone: DragZone, { frameEdgePx, windowEdgePx }: {
+import type { Zone } from "../types/index.js";
+export declare function createZoneSideClipPath(zone: Zone, { frameEdgePx, windowEdgePx }: {
     frameEdgePx: number;
     windowEdgePx: number;
 }): string | undefined;

package/dist/runtime/helpers/findEdgesTouchingWindow.d.ts

@@ -0,0 +1,7 @@
+import type { EdgeSide, LayoutFrame } from "../types/index.js";
+/**
+ * Checks which window edges a frame touches and how.
+ *
+ * @returns Record mapping touched sides to `"full"` (spans the entire edge) or `"partial"` (touches but doesn't span fully). Only touched sides are included as keys.
+ */
+export declare function findEdgesTouchingWindow(frame: LayoutFrame): Partial<Record<EdgeSide, "full" | "partial">>;

package/dist/runtime/helpers/findEdgesTouchingWindow.js

@@ -0,0 +1,20 @@
+import { settings } from "../settings.js";
+export function findEdgesTouchingWindow(frame) {
+  const maxInt = settings.maxInt;
+  const result = {};
+  const spansVertical = frame.y === 0 && frame.y + frame.height === maxInt;
+  const spansHorizontal = frame.x === 0 && frame.x + frame.width === maxInt;
+  if (frame.x === 0) {
+    result.left = spansVertical ? "full" : "partial";
+  }
+  if (frame.x + frame.width === maxInt) {
+    result.right = spansVertical ? "full" : "partial";
+  }
+  if (frame.y === 0) {
+    result.top = spansHorizontal ? "full" : "partial";
+  }
+  if (frame.y + frame.height === maxInt) {
+    result.bottom = spansHorizontal ? "full" : "partial";
+  }
+  return result;
+}

package/dist/runtime/helpers/{findFrameDraggableEdges.d.ts → findFrameMoveableEdges.d.ts}

@@ -1,6 +1,6 @@
 import type { Edge, EdgeSide, LayoutFrame } from "../types/index.js";
-export declare function findFrameDraggableEdges(frame: LayoutFrame, edges: Edge[], 
-/** See {@link findDraggableEdge} */
+export declare function findFrameMoveableEdges(frame: LayoutFrame, edges: Edge[], 
+/** See {@link findMoveableEdge} */
 exact?: boolean, sides?: EdgeSide[]): {
     edge: Edge;
     side: EdgeSide;

package/dist/runtime/helpers/{findFrameDraggableEdges.js → findFrameMoveableEdges.js}

@@ -1,8 +1,8 @@
-import { findDraggableEdge } from "./findDraggableEdge.js";
+import { findMoveableEdge } from "./findMoveableEdge.js";
 import { frameToEdges } from "./frameToEdges.js";
 import { isWindowEdge } from "./isWindowEdge.js";
 import { sideToOrientation } from "./sideToOrientation.js";
-export function findFrameDraggableEdges(frame, edges, exact = true, sides = ["left", "right", "top", "bottom"]) {
+export function findFrameMoveableEdges(frame, edges, exact = true, sides = ["left", "right", "top", "bottom"]) {
   const frameEdges = frameToEdges(frame);
   const res = [];
   for (const side of sides) {
@@ -10,7 +10,7 @@ export function findFrameDraggableEdges(frame, edges, exact = true, sides = ["le
     const edgeDirection = sideToOrientation(side);
     const isWinEdge = isWindowEdge(edge, edgeDirection);
     if (isWinEdge) continue;
-    const maybeEdge = findDraggableEdge(edge, edges, exact, edgeDirection);
+    const maybeEdge = findMoveableEdge(edge, edges, exact, edgeDirection);
     if (maybeEdge) res.push({ edge: maybeEdge, side });
   }
   if (res.length > 0) return res;

package/dist/runtime/helpers/{findDraggableEdge.d.ts → findMoveableEdge.d.ts}

@@ -1,4 +1,4 @@
 import type { Edge, Orientation } from "../types/index.js";
-export declare function findDraggableEdge(edge: Edge, edges: Edge[], 
+export declare function findMoveableEdge(edge: Edge, edges: Edge[], 
 /** Whether the edge must match exactly and does not "contain/touch" another frame. */
 exact?: boolean, edgeOrientation?: Orientation): Edge | undefined;

package/dist/runtime/helpers/{findDraggableEdge.js → findMoveableEdge.js}

@@ -1,7 +1,7 @@
 import { containsEdge } from "./containsEdge.js";
 import { getEdgeOrientation } from "./getEdgeOrientation.js";
 import { isEdgeEqual } from "./isEdgeEqual.js";
-export function findDraggableEdge(edge, edges, exact = true, edgeOrientation) {
+export function findMoveableEdge(edge, edges, exact = true, edgeOrientation) {
   edgeOrientation ??= getEdgeOrientation(edge);
   for (const otherEdge of edges) {
     const didFindEdge = exact ? isEdgeEqual(edge, otherEdge, edgeOrientation) : containsEdge(edge, otherEdge, edgeOrientation);

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

@@ -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";