@witchcraft/layout 0.4.4 → 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,23 +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];
         }
       }
@@ -48,62 +48,62 @@ 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 dragResolve;
-  let dragResult;
+  let moveResolve;
+  let moveResult;
   function resetState() {
-    dragStartPoint = void 0;
-    dragResolve?.(dragResult);
-    dragResolve = void 0;
-    dragResult = 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;
+    movingFrameId.value = void 0;
     eventContext.value = void 0;
-    dragDirStore.reset();
-    showDragging.value = false;
+    moveDirStore.reset();
+    showMoving.value = false;
     forceRecalculateEdges();
   }
-  function dragStart(e, type, data, {
+  function moveStart(e, type, data, {
     moveEvent = "pointermove",
     endEvent = "pointerup",
     context
@@ -111,38 +111,38 @@ export function useFrames(win, handler) {
     if (controller) {
       controller.abort();
     }
-    const promise = new Promise((resolve) => {
-      dragResolve = resolve;
+    const promise = new Promise((resolve2) => {
+      moveResolve = resolve2;
     });
     controller = new AbortController();
     controller.signal.addEventListener("abort", () => resetState());
     e.preventDefault();
-    window.addEventListener(moveEvent, dragMove, { signal: controller.signal });
-    window.addEventListener(endEvent, 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);
+    movePoint.value = point;
+    moveStartPoint = { ...point };
+    moveDirStore.update(point);
     eventContext.value = context;
-    isDragging.value = type;
-    showDragging.value = true;
+    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;
@@ -153,56 +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;
     }
     if (apply) {
-      const applyResult = handler.onDragApply(state.value, forceRecalculateEdges);
-      dragResult = applyResult.result;
+      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) => {
@@ -217,26 +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/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/{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

@@ -20,8 +20,8 @@ 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";

package/dist/runtime/helpers/index.js

@@ -20,8 +20,8 @@ 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";

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

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

package/dist/runtime/layout/createSplitDecoFromDrag.js

@@ -1,12 +1,12 @@
 import { createSplitDecoShapes } from "./createSplitDecoShapes.js";
 import { dirToOrientation } from "../helpers/dirToOrientation.js";
 import { settings } from "../settings.js";
-export function createSplitDecoFromDrag(frames, frame, dragDirection, dragPoint, snapAmount = settings.snapPointScaled, minSize = settings.minSizeScaled, classes = {}) {
+export function createSplitDecoFromDrag(frames, frame, dragDirection, movePoint, snapAmount = settings.snapPointScaled, minSize = settings.minSizeScaled, classes = {}) {
   const orientation = dirToOrientation(dragDirection);
   const deco = {
     type: "split",
     id: frame.id,
-    position: dragPoint[orientation === "horizontal" ? "x" : "y"],
+    position: movePoint[orientation === "horizontal" ? "x" : "y"],
     direction: dragDirection
   };
   deco.shapes = createSplitDecoShapes(frames, deco, snapAmount, minSize, classes);

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

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

package/dist/runtime/layout/findSafeSplitEdge.js

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

package/dist/runtime/layout/getCloseFrameInfo.js

@@ -5,7 +5,7 @@ import { findFramesTouchingEdge } from "./findFramesTouchingEdge.js";
 import { findVisualEdge } from "./findVisualEdge.js";
 import { cloneFrame } from "../helpers/cloneFrame.js";
 import { dirToSide } from "../helpers/dirToSide.js";
-import { findFrameDraggableEdges } from "../helpers/findFrameDraggableEdges.js";
+import { findFrameMoveableEdges } from "../helpers/findFrameMoveableEdges.js";
 import { getEdgeOrientation } from "../helpers/getEdgeOrientation.js";
 import { oppositeSide } from "../helpers/oppositeSide.js";
 import { settings } from "../settings.js";
@@ -28,9 +28,9 @@ export function getCloseFrameInfo(frames, visualEdges, frame, closeDirOrSide, cl
   }
   const side = closeBy === "dir" ? oppositeSide(dirToSide(closeDirOrSide)) : closeDirOrSide;
   const sideOpposite = oppositeSide(side);
-  const draggableEdges = findFrameDraggableEdges(frame, visualEdges, !force, [side]);
-  if (!draggableEdges) return new KnownError(LAYOUT_ERROR.CANT_CLOSE_NO_DRAG_EDGE, `Could not find draggable edge for frame ${frame.id}`, { frame });
-  const { edge: frameEdge } = draggableEdges[0];
+  const moveableEdges = findFrameMoveableEdges(frame, visualEdges, !force, [side]);
+  if (!moveableEdges) return new KnownError(LAYOUT_ERROR.CANT_CLOSE_NO_DRAG_EDGE, `Could not find draggable edge for frame ${frame.id}`, { frame });
+  const { edge: frameEdge } = moveableEdges[0];
   const visualEdge = findVisualEdge(visualEdges, frameEdge);
   if (visualEdge === void 0) unreachable();
   const direction = oppositeSide(getEdgeOrientation(visualEdge));

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

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