@witchcraft/layout 0.4.3 → 0.5.0

package/dist/runtime/layout/{getFrameDragZones.d.ts → getFrameZones.d.ts}

@@ -1,4 +1,4 @@
-import type { DragZone } from "../types/index.js";
+import type { Zone } from "../types/index.js";
 /**
  * Returns frame drag zones (in **unrounded** scaled coordinate space).
  *
@@ -8,9 +8,9 @@ import type { DragZone } from "../types/index.js";
  *
  * Unrounded because these are for display purposes only.
  */
-export declare function getFrameDragZones(frame: {
+export declare function getFrameZones(frame: {
     x: number;
     y: number;
     width: number;
     height: number;
-}, thresholdPx: number, windowPxWidth: number, windowPxHeight: number): DragZone[];
+}, thresholdPx: number, windowPxWidth: number, windowPxHeight: number): Zone[];

package/dist/runtime/layout/{getFrameDragZones.js → getFrameZones.js}

@@ -1,5 +1,5 @@
 import { settings } from "../settings.js";
-export function getFrameDragZones(frame, thresholdPx, windowPxWidth, windowPxHeight) {
+export function getFrameZones(frame, thresholdPx, windowPxWidth, windowPxHeight) {
   const thX = thresholdPx / windowPxWidth * settings.maxInt;
   const thY = thresholdPx / windowPxHeight * settings.maxInt;
   const pxWidth = frame.width / settings.maxInt * windowPxWidth;

package/dist/runtime/layout/getUpdateWindowSizeInfo.js

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

package/dist/runtime/layout/{getWindowDragZones.d.ts → getWindowZones.d.ts}

@@ -3,4 +3,4 @@ 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[];
+export declare function getWindowZones(win: LayoutWindow, thresholdPx: number): WindowEdgeZone[];

package/dist/runtime/layout/{getWindowDragZones.js → getWindowZones.js}

@@ -1,6 +1,6 @@
 import { numberToScaledPercent } from "../helpers/numberToScaledPercent.js";
 import { settings } from "../settings.js";
-export function getWindowDragZones(win, thresholdPx) {
+export function getWindowZones(win, thresholdPx) {
   const thX = numberToScaledPercent(thresholdPx, win.pxWidth);
   const thY = numberToScaledPercent(thresholdPx, win.pxHeight);
   const maxInt = settings.maxInt;

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

@@ -0,0 +1,8 @@
+import type { MoveState, Zone } from "../types/index.js";
+/**
+ * Find the drag zone under the drag point.
+ */
+export declare function getZones(state: Pick<MoveState, "movePoint" | "moveHoveredFrame" | "frames" | "win">, { frameEdgePx, windowEdgePx }: {
+    frameEdgePx: number;
+    windowEdgePx: number;
+}): Zone | undefined;

package/dist/runtime/layout/getZones.js

@@ -0,0 +1,32 @@
+import { getFrameZones } from "./getFrameZones.js";
+import { getWindowZones } from "./getWindowZones.js";
+import { isPointInRect } from "./isPointInRect.js";
+export function getZones(state, { frameEdgePx, windowEdgePx }) {
+  const { movePoint, win } = state;
+  const frameId = state.moveHoveredFrame?.id;
+  if (!frameId) return;
+  const frame = state.frames[frameId];
+  if (!frame || !movePoint) return;
+  const frameZones = getFrameZones(frame, frameEdgePx, win.pxWidth, win.pxHeight);
+  const windowZones = getWindowZones(win, windowEdgePx);
+  let matchedZone;
+  for (const zone of windowZones) {
+    if (isPointInRect(zone, movePoint)) {
+      matchedZone = {
+        ...zone,
+        type: "window"
+      };
+      break;
+    }
+  }
+  if (!matchedZone) {
+    for (const zone of frameZones) {
+      if (isPointInRect(zone, movePoint)) {
+        matchedZone = zone;
+        break;
+      }
+    }
+  }
+  if (!matchedZone) return void 0;
+  return matchedZone;
+}

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

@@ -7,20 +7,23 @@ export { findSafeSplitEdgeAndPosition } from "./findSafeSplitEdge.js";
 export { findVisualEdge } from "./findVisualEdge.js";
 export { frameCreate } from "./frameCreate.js";
 export { getCloseFrameInfo } from "./getCloseFrameInfo.js";
-export { getDragZones } from "./getDragZones.js";
+export { getZones } from "./getZones.js";
 export { getFillEmptySpaceInfo } from "./getFillEmptySpaceInfo.js";
 export { getFrameCollapseInfo } from "./getFrameCollapseInfo.js";
 export { getFrameDockInfo } from "./getFrameDockInfo.js";
-export { getFrameDragZones } from "./getFrameDragZones.js";
+export { getFrameZones } from "./getFrameZones.js";
+export { getFrameExpandInfo } from "./getFrameExpandInfo.js";
 export { getFrameRearrangeInfo } from "./getFrameRearrangeInfo.js";
+export { getFrameShrinkInfo } from "./getFrameShrinkInfo.js";
 export { getFrameSplitInfo } from "./getFrameSplitInfo.js";
 export { getFramesRedistributeInfo } from "./getFramesRedistributeInfo.js";
 export { getFrameSwapInfo } from "./getFrameSwapInfo.js";
 export { getFrameTo } from "./getFrameTo.js";
 export { getFrameUncollapseInfo } from "./getFrameUncollapseInfo.js";
 export { getFrameUndockInfo } from "./getFrameUndockInfo.js";
+export { getRelaxFramesInfo } from "./getRelaxFramesInfo.js";
 export { getUpdateWindowSizeInfo } from "./getUpdateWindowSizeInfo.js";
-export { getWindowDragZones } from "./getWindowDragZones.js";
+export { getWindowZones } from "./getWindowZones.js";
 export { isPointInRect } from "./isPointInRect.js";
 export { layoutAddWindow } from "./layoutAddWindow.js";
 export { layoutCreate } from "./layoutCreate.js";

package/dist/runtime/layout/index.js

@@ -7,20 +7,23 @@ export { findSafeSplitEdgeAndPosition } from "./findSafeSplitEdge.js";
 export { findVisualEdge } from "./findVisualEdge.js";
 export { frameCreate } from "./frameCreate.js";
 export { getCloseFrameInfo } from "./getCloseFrameInfo.js";
-export { getDragZones } from "./getDragZones.js";
+export { getZones } from "./getZones.js";
 export { getFillEmptySpaceInfo } from "./getFillEmptySpaceInfo.js";
 export { getFrameCollapseInfo } from "./getFrameCollapseInfo.js";
 export { getFrameDockInfo } from "./getFrameDockInfo.js";
-export { getFrameDragZones } from "./getFrameDragZones.js";
+export { getFrameZones } from "./getFrameZones.js";
+export { getFrameExpandInfo } from "./getFrameExpandInfo.js";
 export { getFrameRearrangeInfo } from "./getFrameRearrangeInfo.js";
+export { getFrameShrinkInfo } from "./getFrameShrinkInfo.js";
 export { getFrameSplitInfo } from "./getFrameSplitInfo.js";
 export { getFramesRedistributeInfo } from "./getFramesRedistributeInfo.js";
 export { getFrameSwapInfo } from "./getFrameSwapInfo.js";
 export { getFrameTo } from "./getFrameTo.js";
 export { getFrameUncollapseInfo } from "./getFrameUncollapseInfo.js";
 export { getFrameUndockInfo } from "./getFrameUndockInfo.js";
+export { getRelaxFramesInfo } from "./getRelaxFramesInfo.js";
 export { getUpdateWindowSizeInfo } from "./getUpdateWindowSizeInfo.js";
-export { getWindowDragZones } from "./getWindowDragZones.js";
+export { getWindowZones } from "./getWindowZones.js";
 export { isPointInRect } from "./isPointInRect.js";
 export { layoutAddWindow } from "./layoutAddWindow.js";
 export { layoutCreate } from "./layoutCreate.js";

package/dist/runtime/{drag/DragActionHandler.d.ts → move/ActionHandler.d.ts}

@@ -1,16 +1,16 @@
 import { type RecordFromArray } from "@alanscodelog/utils";
-import type { DragChangeHandler, DragChangeResult, DragState, Edge, IDragAction, LayoutFrame, LayoutShape } from "../types/index.js";
+import type { ActionHandlerApplyResult, Edge, IAction, LayoutFrame, LayoutShape, MoveChangeHandler, MoveChangeResult, MoveState } from "../types/index.js";
 /**
- * Handles the lifecycle of a drag actions {@link IDragAction} and provides additional hooks.
+ * Handles the lifecycle of a drag actions {@link IAction} and provides additional hooks.
  *
  * The first action instance that can handle the request is passed control of the event handlers until the request changes.
  */
-export declare class DragActionHandler<TRawDragActions extends IDragAction[], TDragActions extends RecordFromArray<TRawDragActions, "name"> = RecordFromArray<TRawDragActions, "name">> {
-    activeAction?: keyof TDragActions;
-    actions: TDragActions;
-    eventCanceller: ((e: PointerEvent | KeyboardEvent | undefined, state: DragState) => void) | undefined;
-    boundCancel: (e: PointerEvent | KeyboardEvent | undefined, state: DragState) => void;
-    defaultOnDragChange: DragChangeHandler;
+export declare class ActionHandler<TRawActions extends IAction[], TActions extends RecordFromArray<TRawActions, "name"> = RecordFromArray<TRawActions, "name">> {
+    activeAction?: keyof TActions;
+    actions: TActions;
+    eventCanceller: ((e: PointerEvent | KeyboardEvent | undefined, state: MoveState) => void) | undefined;
+    boundCancel: (e: PointerEvent | KeyboardEvent | undefined, state: MoveState) => void;
+    defaultOnMoveChange: MoveChangeHandler;
     hooks: {
         /** Called while dragging during dragChange events. You can use this to update the dragging edges. */
         onRecalculate?: () => void;
@@ -21,7 +21,7 @@ export declare class DragActionHandler<TRawDragActions extends IDragAction[], TD
          */
         onEvent?: (e: PointerEvent | KeyboardEvent | undefined, cancel: () => void) => void;
         /** Called when the action requested changes. */
-        onRequestChange?: (type: keyof TDragActions | undefined) => void;
+        onRequestChange?: (type: keyof TActions | undefined) => void;
         /** Called when the drag action ends either because it was completed or cancelled. */
         onEnd?: (context: {
             cancelled: boolean;
@@ -30,27 +30,27 @@ export declare class DragActionHandler<TRawDragActions extends IDragAction[], TD
     };
     /** All action shapes merged into a single array. If using vue you can set this to a reactive array for reactivity. */
     shapes: LayoutShape[];
-    /** All hint/error text from all actions, updated on every onDragChange. If using vue you can set this to a reactive object for reactivity. */
+    /** All hint/error text from all actions, updated on every onMoveChange. If using vue you can set this to a reactive object for reactivity. */
     textHints: {
         actions: string[];
         errors: string[];
     };
-    constructor(actions: TRawDragActions, hooks?: DragActionHandler<TRawDragActions, TDragActions>["hooks"], 
+    constructor(actions: TRawActions, hooks?: ActionHandler<TRawActions, TActions>["hooks"], 
     /**
-     * Default onDragChange handler for when no action can handle the request.
+     * Default onMoveChange handler for when no action can handle the request.
      *
      * Should return true to allow the edges to be moved, or false to prevent it.
      *
      * The default prevents movement when the edge is a window edge and when the edge is touching a collapsed frame.
      */
-    defaultOnDragChange?: DragChangeHandler);
-    eventHandler(e: KeyboardEvent | PointerEvent, state: DragState, forceRecalculateEdges: () => void): undefined;
-    onDragChange<T extends "start" | "move" | "end">(type: T, e: T extends "end" ? PointerEvent | undefined : PointerEvent, state: DragState, forceRecalculateEdges: () => void, cancel: (e: PointerEvent | KeyboardEvent | undefined, state: DragState) => void): DragChangeResult;
+    defaultOnMoveChange?: MoveChangeHandler);
+    eventHandler(e: KeyboardEvent | PointerEvent, state: MoveState, forceRecalculateEdges: () => void): undefined;
+    onMoveChange<T extends "start" | "move" | "end">(type: T, e: T extends "end" ? PointerEvent | undefined : PointerEvent, state: MoveState, forceRecalculateEdges: () => void, cancel: T extends "end" ? undefined : (e: PointerEvent | KeyboardEvent | undefined, state: MoveState) => void, resolve: T extends "end" ? undefined : (opts: ActionHandlerApplyResult) => void): MoveChangeResult;
     setTextHints(type: "start" | "move" | "end"): void;
     annotateEdges(edges: Edge[], frames: LayoutFrame[]): void;
-    onDragApply(state: DragState, forceRecalculateEdges: () => void): boolean;
-    cancel(e: PointerEvent | KeyboardEvent | undefined, state: DragState): void;
-    static debugState(pluginName: string, type: "before" | "after" | string, state: DragState, pluginState?: Record<string, any>, 
+    onMoveApply(state: MoveState, forceRecalculateEdges: () => void): ActionHandlerApplyResult;
+    cancel(e: PointerEvent | KeyboardEvent | undefined, state: MoveState): void;
+    static debugState(pluginName: string, type: "before" | "after" | string, state: MoveState, pluginState?: Record<string, any>, 
     /** Object key to filter the state by, e.g. state.win.frames. If false is ignored. The idea is you pass this.debug and users can set this.debug to a string to filter. */
     key?: string | boolean): void;
 }

package/dist/runtime/{drag/DragActionHandler.js → move/ActionHandler.js}

@@ -3,30 +3,30 @@ import { isWindowEdge } from "../helpers/isWindowEdge.js";
 import { findFramesTouchingEdge } from "../layout/findFramesTouchingEdge.js";
 import { LAYOUT_ERROR } from "../types/index.js";
 import { KnownError } from "../utils/KnownError.js";
-export class DragActionHandler {
+export class ActionHandler {
   activeAction;
   actions;
   eventCanceller = void 0;
   boundCancel;
-  defaultOnDragChange = (type, _e, state, _forceRecalculateEdges, _cancel) => {
-    const isTouchingCollapsedFrameEdge = type === "move" && state.isDragging === "edge" && state.touchingFramesArrays.some(
+  defaultOnMoveChange = (type, _e, state, _forceRecalculateEdges, _cancel) => {
+    const isTouchingCollapsedFrameEdge = type === "move" && state.isMoving === "edge" && state.touchingFramesArrays.some(
       (frames) => (
         // we check with a falsy check on PURPOSE, frames collapsed to 0 aren't an issue, they are ignored anyways
         Object.values(frames).some((f) => f.collapsed)
       )
     );
     return {
-      updateEdges: type === "move" ? !(state.isDraggingFromWindowEdge || isTouchingCollapsedFrameEdge) : true,
+      updateEdges: type === "move" ? !(state.isMovingFromWindowEdge || isTouchingCollapsedFrameEdge) : true,
       shapes: []
     };
   };
   hooks;
   /** All action shapes merged into a single array. If using vue you can set this to a reactive array for reactivity. */
   shapes = [];
-  /** All hint/error text from all actions, updated on every onDragChange. If using vue you can set this to a reactive object for reactivity. */
+  /** All hint/error text from all actions, updated on every onMoveChange. If using vue you can set this to a reactive object for reactivity. */
   textHints = { actions: [], errors: [] };
-  constructor(actions, hooks = {}, defaultOnDragChange) {
-    if (defaultOnDragChange) this.defaultOnDragChange = defaultOnDragChange;
+  constructor(actions, hooks = {}, defaultOnMoveChange) {
+    if (defaultOnMoveChange) this.defaultOnMoveChange = defaultOnMoveChange;
     this.hooks = hooks;
     this.actions = {};
     for (const action of actions) {
@@ -35,7 +35,7 @@ export class DragActionHandler {
     this.boundCancel = this.cancel.bind(this);
   }
   eventHandler(e, state, forceRecalculateEdges) {
-    if (state.isDragging) {
+    if (state.isMoving) {
       e.preventDefault();
     }
     let cancelled = false;
@@ -62,29 +62,29 @@ export class DragActionHandler {
       }
       this.hooks.onRequestChange?.(this.activeAction);
     }
-    if (state.isDragging) {
+    if (state.isMoving) {
       forceRecalculateEdges();
       this.hooks.onRecalculate?.();
     }
     return void 0;
   }
-  onDragChange(type, e, state, forceRecalculateEdges, cancel) {
+  onMoveChange(type, e, state, forceRecalculateEdges, cancel, resolve) {
     if (type === "start") {
       this.eventCanceller = cancel;
       this.eventHandler(e, state, forceRecalculateEdges);
     }
-    if (type === "end") {
-      this.activeAction = void 0;
-    }
     if (this.activeAction) {
-      const res2 = this.actions[this.activeAction].onDragChange(type, e, state, forceRecalculateEdges, this.boundCancel);
+      const res2 = this.actions[this.activeAction].onMoveChange(type, e, state, forceRecalculateEdges, this.boundCancel, resolve);
       this.shapes.splice(0, this.shapes.length, ...res2.shapes);
       this.setTextHints(type);
       return res2;
     }
     this.setTextHints(type);
-    const res = this.defaultOnDragChange(type, e, state, forceRecalculateEdges, this.boundCancel);
+    const res = this.defaultOnMoveChange(type, e, state, forceRecalculateEdges, this.boundCancel, resolve);
     this.shapes.splice(0, this.shapes.length, ...res.shapes);
+    if (type === "end") {
+      this.activeAction = void 0;
+    }
     return res;
   }
   setTextHints(type) {
@@ -118,14 +118,14 @@ export class DragActionHandler {
       }
     }
   }
-  onDragApply(state, forceRecalculateEdges) {
+  onMoveApply(state, forceRecalculateEdges) {
     if (this.activeAction) {
-      const res = this.actions[this.activeAction].onDragApply(state, forceRecalculateEdges);
+      const res = this.actions[this.activeAction].onMoveApply(state, forceRecalculateEdges);
       this.hooks.onEnd?.({ cancelled: false, applied: res });
-      return false;
+      return { apply: res, result: void 0 };
     }
     this.hooks.onEnd?.({ cancelled: false, applied: false });
-    return true;
+    return { apply: true, result: void 0 };
   }
   cancel(e, state) {
     if (this.activeAction) {

package/dist/runtime/{drag → move}/CloseAction.d.ts

@@ -1,8 +1,8 @@
 import { getCloseFrameInfo } from "../layout/getCloseFrameInfo.js";
-import type { ActionDragChangeResult, CloseDeco, DragState, IDragAction } from "../types/index.js";
+import type { ActionChangeResult, CloseDeco, IAction, MoveState } from "../types/index.js";
 import type { KnownError } from "../utils/KnownError.js";
 export type CloseInfo = Exclude<ReturnType<typeof getCloseFrameInfo>, KnownError>;
-export declare class CloseAction implements IDragAction {
+export declare class CloseAction implements IAction {
     name: "close";
     minDragDistance: number;
     state: {
@@ -10,13 +10,13 @@ export declare class CloseAction implements IDragAction {
         force: boolean;
         res: CloseInfo;
         cacheKey: string | undefined;
-        lastReturn: ActionDragChangeResult;
+        lastReturn: ActionChangeResult;
     } | {
         allowed: false;
         force: boolean;
         res: CloseInfo | undefined;
         cacheKey: string | undefined;
-        lastReturn: ActionDragChangeResult | undefined;
+        lastReturn: ActionChangeResult | undefined;
     };
     debug: boolean | string;
     textHints: {
@@ -29,7 +29,7 @@ export declare class CloseAction implements IDragAction {
         }) => string[]);
         transformError: (e: KnownError) => string;
     };
-    handleEvent: (e: PointerEvent | KeyboardEvent, state: DragState) => boolean | "force";
+    handleEvent: (e: PointerEvent | KeyboardEvent, state: MoveState) => boolean | "force";
     modifyDecos: (shapes: CloseDeco[]) => void;
     hooks: {
         onStart?: (active: boolean) => void;
@@ -51,8 +51,8 @@ export declare class CloseAction implements IDragAction {
         actions: string[];
         errors: string[];
     };
-    canHandleRequest(e: PointerEvent | KeyboardEvent, state: DragState): boolean;
-    onDragChange(_type: "start" | "end" | "move", _e: PointerEvent | undefined, state: DragState): ActionDragChangeResult;
-    onDragApply(state: DragState): boolean;
+    canHandleRequest(e: PointerEvent | KeyboardEvent, state: MoveState): boolean;
+    onMoveChange(type: "start" | "end" | "move", _e: PointerEvent | undefined, state: MoveState): ActionChangeResult;
+    onMoveApply(state: MoveState): boolean;
     cancel(): void;
 }

package/dist/runtime/{drag → move}/CloseAction.js

@@ -1,4 +1,4 @@
-import { DragActionHandler } from "./DragActionHandler.js";
+import { ActionHandler } from "./ActionHandler.js";
 import { dirToOrientation } from "../helpers/dirToOrientation.js";
 import { getEdgeOrientation } from "../helpers/getEdgeOrientation.js";
 import { oppositeSide } from "../helpers/oppositeSide.js";
@@ -46,8 +46,8 @@ export class CloseAction {
   }
   _getDecos(state) {
     let decos = [];
-    const { isDragging } = state;
-    if (isDragging && this.state.allowed && this.state.res) {
+    const { isMoving } = state;
+    if (isMoving && this.state.allowed && this.state.res) {
       const { force } = this.state;
       decos = this.state.res.deleted.map((_) => ({
         id: _.id,
@@ -86,11 +86,11 @@ export class CloseAction {
     return this.textHints;
   }
   canHandleRequest(e, state) {
-    const { draggingEdges } = state;
-    if (draggingEdges.length !== 1) return false;
+    const { movingEdges } = state;
+    if (movingEdges.length !== 1) return false;
     const res = this.handleEvent(e, state);
     this.state.force = res === "force";
-    this.setTextHints(state.isDragging === "edge" ? true : void 0);
+    this.setTextHints(state.isMoving === "edge" ? true : void 0);
     if (res) {
       this.hooks.onStart?.(true);
       return true;
@@ -98,42 +98,46 @@ export class CloseAction {
     this.reset();
     return false;
   }
-  onDragChange(_type, _e, state) {
-    if (state.dragDistance <= this.minDragDistance) {
+  onMoveChange(type, _e, state) {
+    if (type === "end") {
+      this.reset();
+      return { shapes: [] };
+    }
+    if (state.moveDistance <= this.minDragDistance) {
       return { updateEdges: false, shapes: [] };
     }
     const {
       touchingFramesArrays,
-      dragDirections,
-      isDragging,
-      draggingEdges,
+      moveDirections,
+      isMoving,
+      movingEdges,
       visualEdges,
       frames,
-      isDraggingFromWindowEdge,
-      dragPoint
+      isMovingFromWindowEdge,
+      movePoint
     } = state;
-    const oppositeOrientation = oppositeSide(getEdgeOrientation(draggingEdges[0]));
-    const cacheKey = `${dragPoint?.x}-${dragPoint?.y}-${dragDirections[oppositeOrientation]}-${this.state.force}`;
+    const oppositeOrientation = oppositeSide(getEdgeOrientation(movingEdges[0]));
+    const cacheKey = `${movePoint?.x}-${movePoint?.y}-${moveDirections[oppositeOrientation]}-${this.state.force}`;
     if (this.state.allowed) {
       if (this.state.cacheKey === cacheKey) {
         return this.state.lastReturn;
       }
     }
-    if (isDragging && draggingEdges.length === 1) {
+    if (isMoving && movingEdges.length === 1) {
       const res = findFramesTouchingEdge(
-        draggingEdges[0],
+        movingEdges[0],
         touchingFramesArrays[0],
         {
-          // referencePoint: dragPoint.value, // if force pick smallest frame?
-          searchDirections: [dragDirections[oppositeOrientation]]
+          // referencePoint: movePoint.value, // if force pick smallest frame?
+          searchDirections: [moveDirections[oppositeOrientation]]
         }
       );
       if (res.length > 0) {
-        const orientation = dirToOrientation(dragDirections[oppositeOrientation]);
+        const orientation = dirToOrientation(moveDirections[oppositeOrientation]);
         const sizeKey = orientation === "horizontal" ? "width" : "height";
         const smallestFrameSize = Math.min(...res.map((_) => _.frame[sizeKey]));
         const frame = res.find((_) => _.frame[sizeKey] === smallestFrameSize).frame;
-        const closeInfo = getCloseFrameInfo(Object.values(frames), visualEdges, frame, dragDirections[oppositeOrientation], "dir", this.state.force);
+        const closeInfo = getCloseFrameInfo(Object.values(frames), visualEdges, frame, moveDirections[oppositeOrientation], "dir", this.state.force);
         this.state.cacheKey = cacheKey;
         this.setTextHints(closeInfo);
         if (!(closeInfo instanceof Error)) {
@@ -148,20 +152,19 @@ export class CloseAction {
       }
     }
     const decos = this._getDecos(state);
-    this.state.lastReturn = { updateEdges: !isDraggingFromWindowEdge, shapes: decos.flatMap((_) => _.shapes) };
+    this.state.lastReturn = { updateEdges: !isMovingFromWindowEdge, shapes: decos.flatMap((_) => _.shapes) };
     return this.state.lastReturn;
   }
-  onDragApply(state) {
+  onMoveApply(state) {
     if (this.state.res) {
       const win = state.win;
       if (this.debug) {
-        DragActionHandler.debugState(this.name, "before", state, this.state, this.debug);
+        ActionHandler.debugState(this.name, "before", state, this.state, this.debug);
       }
       applyFrameChanges(win, this.state.res);
       if (this.debug) {
-        DragActionHandler.debugState(this.name, "after", state, this.state, this.debug);
+        ActionHandler.debugState(this.name, "after", state, this.state, this.debug);
       }
-      this.reset();
       return true;
     }
     return false;

package/dist/runtime/{drag → move}/FrameDragAction.d.ts

@@ -1,6 +1,6 @@
-import type { ActionDragChangeResult, DragState, DragZone, FrameDragDeco, IDragAction, LayoutChange } from "../types/index.js";
+import type { ActionChangeResult, FrameDeco, IAction, LayoutChange, MoveState, Zone } from "../types/index.js";
 import type { KnownError } from "../utils/KnownError.js";
-export declare class FrameDragAction implements IDragAction {
+export declare class FrameDragAction implements IAction {
     name: "frameDrag";
     minDragDistance: number;
     state: {
@@ -11,7 +11,7 @@ export declare class FrameDragAction implements IDragAction {
         actions: string[];
         errors: string[];
     };
-    handleEvent: (e: PointerEvent | KeyboardEvent, state: DragState) => boolean;
+    handleEvent: (e: PointerEvent | KeyboardEvent, state: MoveState) => boolean;
     dragHints: {
         actions: {
             split?: string;
@@ -23,7 +23,7 @@ export declare class FrameDragAction implements IDragAction {
         }) => string[]);
         transformError: (e: KnownError) => string;
     };
-    modifyDecos: (shapes: FrameDragDeco[]) => void;
+    modifyDecos: (shapes: FrameDeco[]) => void;
     hooks: {
         onStart?: () => void;
         onCancel?: () => void;
@@ -42,9 +42,9 @@ export declare class FrameDragAction implements IDragAction {
         actions: string[];
         errors: string[];
     };
-    getDecos(matchedZone: DragZone | undefined, state: DragState, result: LayoutChange<"split" | "swap" | "rearrange" | "dock"> | KnownError | undefined): FrameDragDeco[];
-    canHandleRequest(e: PointerEvent | KeyboardEvent, state: DragState): boolean;
-    onDragChange<T extends "start" | "move" | "end">(_type: T, _e: PointerEvent | undefined, state: DragState): ActionDragChangeResult;
-    onDragApply(state: DragState): boolean;
+    getDecos(matchedZone: Zone | undefined, state: MoveState, result: LayoutChange<"split" | "swap" | "rearrange" | "dock"> | KnownError | undefined): FrameDeco[];
+    canHandleRequest(e: PointerEvent | KeyboardEvent, state: MoveState): boolean;
+    onMoveChange<T extends "start" | "move" | "end">(type: T, _e: PointerEvent | undefined, state: MoveState): ActionChangeResult;
+    onMoveApply(state: MoveState): boolean;
     cancel(): void;
 }