@zag-js/rect-utils 1.41.0 → 2.0.0-next.0

package/dist/interact.js

@@ -0,0 +1,377 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/interact.ts
+var interact_exports = {};
+__export(interact_exports, {
+  applyMove: () => applyMove,
+  applyResize: () => applyResize,
+  centerInRect: () => centerInRect,
+  centerOnPoint: () => centerOnPoint,
+  clampPointInRange: () => clampPointInRange,
+  getArrowKeyDelta: () => getArrowKeyDelta,
+  getDirectionDelta: () => getDirectionDelta,
+  getKeyboardResizeDelta: () => getKeyboardResizeDelta,
+  isBottomHandle: () => isBottomHandle,
+  isCornerHandle: () => isCornerHandle,
+  isHorizontalHandle: () => isHorizontalHandle,
+  isLeftHandle: () => isLeftHandle,
+  isRightHandle: () => isRightHandle,
+  isTopHandle: () => isTopHandle,
+  isVerticalHandle: () => isVerticalHandle
+});
+module.exports = __toCommonJS(interact_exports);
+var isLeftHandle = (h) => h === "w" || h === "nw" || h === "sw";
+var isRightHandle = (h) => h === "e" || h === "ne" || h === "se";
+var isTopHandle = (h) => h === "n" || h === "nw" || h === "ne";
+var isBottomHandle = (h) => h === "s" || h === "sw" || h === "se";
+var isCornerHandle = (h) => (isLeftHandle(h) || isRightHandle(h)) && (isTopHandle(h) || isBottomHandle(h));
+var isHorizontalHandle = (h) => (isLeftHandle(h) || isRightHandle(h)) && !isTopHandle(h) && !isBottomHandle(h);
+var isVerticalHandle = (h) => (isTopHandle(h) || isBottomHandle(h)) && !isLeftHandle(h) && !isRightHandle(h);
+var { min, max, abs, round } = Math;
+var clamp = (v, lo, hi) => min(max(v, lo), hi);
+function resolveLimits(opts) {
+  const minW = opts.minSize?.width ?? 0;
+  const minH = opts.minSize?.height ?? 0;
+  let maxW = opts.maxSize?.width ?? Infinity;
+  let maxH = opts.maxSize?.height ?? Infinity;
+  if (opts.boundary) {
+    if (Number.isFinite(maxW)) maxW = min(maxW, opts.boundary.width);
+    else maxW = opts.boundary.width;
+    if (Number.isFinite(maxH)) maxH = min(maxH, opts.boundary.height);
+    else maxH = opts.boundary.height;
+  }
+  return { minW: max(0, minW), minH: max(0, minH), maxW: max(minW, maxW), maxH: max(minH, maxH) };
+}
+function resolveLimitsWithAspect(limits, boundary, ar) {
+  let { minW, minH, maxW, maxH } = limits;
+  const bw = boundary?.width ?? Infinity;
+  const bh = boundary?.height ?? Infinity;
+  const minWa = max(minW, minH * ar);
+  const minHa = minWa / ar;
+  minW = min(minWa, bw);
+  minH = min(minHa, bh);
+  let cmw = min(maxW, maxH * ar, bw);
+  let cmh = cmw / ar;
+  if (cmh > maxH || cmh > bh) {
+    cmh = min(maxH, bh);
+    cmw = cmh * ar;
+  }
+  maxW = max(minW, min(cmw, bw));
+  maxH = max(minH, min(cmh, bh));
+  return { minW, minH, maxW, maxH };
+}
+function applyDelta(edges, delta, handle, limits, boundary) {
+  let { left, top, right, bottom } = edges;
+  const { minW, minH, maxW, maxH } = limits;
+  if (isLeftHandle(handle)) {
+    const lo = boundary ? max(boundary.x, right - maxW) : right - maxW;
+    const hi = right - minW;
+    left = clamp(left + delta.x, lo, hi);
+  }
+  if (isRightHandle(handle)) {
+    const lo = left + minW;
+    const hi = boundary ? min(boundary.x + boundary.width, left + maxW) : left + maxW;
+    right = clamp(right + delta.x, lo, hi);
+  }
+  if (isTopHandle(handle)) {
+    const lo = boundary ? max(boundary.y, bottom - maxH) : bottom - maxH;
+    const hi = bottom - minH;
+    top = clamp(top + delta.y, lo, hi);
+  }
+  if (isBottomHandle(handle)) {
+    const lo = top + minH;
+    const hi = boundary ? min(boundary.y + boundary.height, top + maxH) : top + maxH;
+    bottom = clamp(bottom + delta.y, lo, hi);
+  }
+  return { left, top, right, bottom };
+}
+function clampAspectSize(wHint, hHint, ar, lim, bw, bh) {
+  const fromHeight = (h) => {
+    const w = clamp(h * ar, lim.minW, min(lim.maxW, bw));
+    return { width: w, height: w / ar };
+  };
+  const tryWidth = (value) => {
+    let w = clamp(value, lim.minW, min(lim.maxW, bw));
+    let h = w / ar;
+    if (h < lim.minH) ({ width: w, height: h } = fromHeight(lim.minH));
+    if (h > min(lim.maxH, bh)) ({ width: w, height: h } = fromHeight(min(lim.maxH, bh)));
+    if (h > bh) {
+      ;
+      ({ width: w, height: h } = fromHeight(bh));
+      if (h < lim.minH) ({ width: w, height: h } = fromHeight(lim.minH));
+    }
+    return { width: w, height: h };
+  };
+  const tryHeight = (value) => {
+    let h = clamp(value, lim.minH, min(lim.maxH, bh));
+    let w = clamp(h * ar, lim.minW, min(lim.maxW, bw));
+    let ah = w / ar;
+    if (ah < lim.minH) ({ width: w, height: ah } = fromHeight(lim.minH));
+    if (ah > min(lim.maxH, bh)) ({ width: w, height: ah } = fromHeight(min(lim.maxH, bh)));
+    if (w > bw) {
+      w = bw;
+      ah = w / ar;
+      if (ah > min(lim.maxH, bh)) ({ width: w, height: ah } = fromHeight(min(lim.maxH, bh)));
+      if (ah < lim.minH) ({ width: w, height: ah } = fromHeight(lim.minH));
+    }
+    return { width: w, height: ah };
+  };
+  const byW = tryWidth(wHint);
+  const byH = tryHeight(hHint);
+  const dw = abs(byW.width - wHint) + abs(byW.height - hHint);
+  const dh = abs(byH.width - wHint) + abs(byH.height - hHint);
+  return dh < dw ? byH : byW;
+}
+function enforceAspect(edges, handle, ar, lim, boundary) {
+  const { left, top, right, bottom } = edges;
+  const bw = boundary?.width ?? Infinity;
+  const bh = boundary?.height ?? Infinity;
+  const bx = boundary?.x ?? 0;
+  const by = boundary?.y ?? 0;
+  if (isCornerHandle(handle)) {
+    let w = right - left;
+    let h = w / ar;
+    if (h > bottom - top || boundary && (top + h > by + bh || left + w > bx + bw)) {
+      h = bottom - top;
+      w = h * ar;
+    }
+    const s = clampAspectSize(w, h, ar, lim, bw, bh);
+    w = s.width;
+    h = s.height;
+    if (isRightHandle(handle) && isBottomHandle(handle)) {
+      return { left, top, right: left + w, bottom: top + h };
+    }
+    if (isRightHandle(handle) && isTopHandle(handle)) {
+      return { left, top: bottom - h, right: left + w, bottom };
+    }
+    if (isLeftHandle(handle) && isBottomHandle(handle)) {
+      return { left: right - w, top, right, bottom: top + h };
+    }
+    return { left: right - w, top: bottom - h, right, bottom };
+  }
+  if (isHorizontalHandle(handle)) {
+    const centerY = (top + bottom) / 2;
+    let w = right - left;
+    let h = w / ar;
+    const s = clampAspectSize(w, h, ar, lim, bw, bh);
+    w = s.width;
+    h = s.height;
+    const halfH = h / 2;
+    let newTop = centerY - halfH;
+    let newBottom = centerY + halfH;
+    if (boundary) {
+      if (newTop < by) {
+        newTop = by;
+        newBottom = newTop + h;
+      }
+      if (newBottom > by + bh) {
+        newBottom = by + bh;
+        newTop = newBottom - h;
+      }
+    }
+    return {
+      left: isRightHandle(handle) ? left : right - w,
+      top: newTop,
+      right: isRightHandle(handle) ? left + w : right,
+      bottom: newBottom
+    };
+  }
+  if (isVerticalHandle(handle)) {
+    const centerX = (left + right) / 2;
+    let h = bottom - top;
+    let w = h * ar;
+    const s = clampAspectSize(w, h, ar, lim, bw, bh);
+    w = s.width;
+    h = s.height;
+    const halfW = w / 2;
+    let newLeft = centerX - halfW;
+    let newRight = centerX + halfW;
+    if (boundary) {
+      if (newLeft < bx) {
+        newLeft = bx;
+        newRight = newLeft + w;
+      }
+      if (newRight > bx + bw) {
+        newRight = bx + bw;
+        newLeft = newRight - w;
+      }
+    }
+    return {
+      left: newLeft,
+      top: isBottomHandle(handle) ? top : bottom - h,
+      right: newRight,
+      bottom: isBottomHandle(handle) ? top + h : bottom
+    };
+  }
+  return edges;
+}
+function centerInRect(size, boundary) {
+  return {
+    x: boundary.x + max(0, (boundary.width - size.width) / 2),
+    y: boundary.y + max(0, (boundary.height - size.height) / 2)
+  };
+}
+function centerOnPoint(size, center, boundary) {
+  const pos = {
+    x: center.x - size.width / 2,
+    y: center.y - size.height / 2
+  };
+  return {
+    x: clamp(pos.x, boundary.x, boundary.x + boundary.width - size.width),
+    y: clamp(pos.y, boundary.y, boundary.y + boundary.height - size.height)
+  };
+}
+function clampPointInRange(point, minPoint, maxPoint) {
+  return {
+    x: clamp(point.x, minPoint.x, maxPoint.x),
+    y: clamp(point.y, minPoint.y, maxPoint.y)
+  };
+}
+function applyMove(rect, delta, options = {}) {
+  const { boundary, gridSize = 1 } = options;
+  const dx = round(delta.x / gridSize) * gridSize;
+  const dy = round(delta.y / gridSize) * gridSize;
+  let x = rect.x + dx;
+  let y = rect.y + dy;
+  if (boundary) {
+    x = clamp(x, boundary.x, boundary.x + boundary.width - rect.width);
+    y = clamp(y, boundary.y, boundary.y + boundary.height - rect.height);
+  }
+  return { x, y, width: rect.width, height: rect.height };
+}
+function applyResize(rect, delta, handle, options = {}) {
+  const { boundary, aspectRatio, origin = "extent" } = options;
+  const baseLimits = resolveLimits(options);
+  const effectiveDelta = origin === "center" ? { x: delta.x * 2, y: delta.y * 2 } : delta;
+  let edges = applyDelta(
+    { left: rect.x, top: rect.y, right: rect.x + rect.width, bottom: rect.y + rect.height },
+    effectiveDelta,
+    handle,
+    baseLimits,
+    boundary
+  );
+  if (aspectRatio != null && aspectRatio > 0) {
+    const arLimits = resolveLimitsWithAspect(baseLimits, boundary, aspectRatio);
+    edges = enforceAspect(edges, handle, aspectRatio, arLimits, boundary);
+  }
+  let { left, top, right, bottom } = edges;
+  if (origin === "center") {
+    const cx = rect.x + rect.width / 2;
+    const cy = rect.y + rect.height / 2;
+    const w = right - left;
+    const h = bottom - top;
+    left = cx - w / 2;
+    top = cy - h / 2;
+    right = cx + w / 2;
+    bottom = cy + h / 2;
+    if (boundary) {
+      if (left < boundary.x) {
+        right += boundary.x - left;
+        left = boundary.x;
+      }
+      if (right > boundary.x + boundary.width) {
+        left -= right - (boundary.x + boundary.width);
+        right = boundary.x + boundary.width;
+      }
+      if (top < boundary.y) {
+        bottom += boundary.y - top;
+        top = boundary.y;
+      }
+      if (bottom > boundary.y + boundary.height) {
+        top -= bottom - (boundary.y + boundary.height);
+        bottom = boundary.y + boundary.height;
+      }
+    }
+  }
+  if (boundary) {
+    const maxLeft = max(boundary.x, boundary.x + boundary.width - baseLimits.minW);
+    const maxTop = max(boundary.y, boundary.y + boundary.height - baseLimits.minH);
+    left = clamp(left, boundary.x, maxLeft);
+    top = clamp(top, boundary.y, maxTop);
+    right = clamp(right, left + baseLimits.minW, min(boundary.x + boundary.width, left + baseLimits.maxW));
+    bottom = clamp(bottom, top + baseLimits.minH, min(boundary.y + boundary.height, top + baseLimits.maxH));
+  }
+  return { x: left, y: top, width: right - left, height: bottom - top };
+}
+function getDirectionDelta(direction, step) {
+  switch (direction) {
+    case "left":
+      return { x: -step, y: 0 };
+    case "right":
+      return { x: step, y: 0 };
+    case "up":
+      return { x: 0, y: -step };
+    case "down":
+      return { x: 0, y: step };
+  }
+}
+function getArrowKeyDelta(key, step) {
+  switch (key) {
+    case "ArrowLeft":
+      return { x: -step, y: 0 };
+    case "ArrowRight":
+      return { x: step, y: 0 };
+    case "ArrowUp":
+      return { x: 0, y: -step };
+    case "ArrowDown":
+      return { x: 0, y: step };
+    default:
+      return { x: 0, y: 0 };
+  }
+}
+function getKeyboardResizeDelta(key, handle, step) {
+  let x = 0;
+  let y = 0;
+  if (isLeftHandle(handle)) {
+    if (key === "ArrowLeft") x = -step;
+    else if (key === "ArrowRight") x = step;
+  }
+  if (isRightHandle(handle)) {
+    if (key === "ArrowRight") x = step;
+    else if (key === "ArrowLeft") x = -step;
+  }
+  if (isTopHandle(handle)) {
+    if (key === "ArrowUp") y = -step;
+    else if (key === "ArrowDown") y = step;
+  }
+  if (isBottomHandle(handle)) {
+    if (key === "ArrowDown") y = step;
+    else if (key === "ArrowUp") y = -step;
+  }
+  return { x, y };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyMove,
+  applyResize,
+  centerInRect,
+  centerOnPoint,
+  clampPointInRange,
+  getArrowKeyDelta,
+  getDirectionDelta,
+  getKeyboardResizeDelta,
+  isBottomHandle,
+  isCornerHandle,
+  isHorizontalHandle,
+  isLeftHandle,
+  isRightHandle,
+  isTopHandle,
+  isVerticalHandle
+});

package/dist/interact.mjs

@@ -0,0 +1,338 @@
+// src/interact.ts
+var isLeftHandle = (h) => h === "w" || h === "nw" || h === "sw";
+var isRightHandle = (h) => h === "e" || h === "ne" || h === "se";
+var isTopHandle = (h) => h === "n" || h === "nw" || h === "ne";
+var isBottomHandle = (h) => h === "s" || h === "sw" || h === "se";
+var isCornerHandle = (h) => (isLeftHandle(h) || isRightHandle(h)) && (isTopHandle(h) || isBottomHandle(h));
+var isHorizontalHandle = (h) => (isLeftHandle(h) || isRightHandle(h)) && !isTopHandle(h) && !isBottomHandle(h);
+var isVerticalHandle = (h) => (isTopHandle(h) || isBottomHandle(h)) && !isLeftHandle(h) && !isRightHandle(h);
+var { min, max, abs, round } = Math;
+var clamp = (v, lo, hi) => min(max(v, lo), hi);
+function resolveLimits(opts) {
+  const minW = opts.minSize?.width ?? 0;
+  const minH = opts.minSize?.height ?? 0;
+  let maxW = opts.maxSize?.width ?? Infinity;
+  let maxH = opts.maxSize?.height ?? Infinity;
+  if (opts.boundary) {
+    if (Number.isFinite(maxW)) maxW = min(maxW, opts.boundary.width);
+    else maxW = opts.boundary.width;
+    if (Number.isFinite(maxH)) maxH = min(maxH, opts.boundary.height);
+    else maxH = opts.boundary.height;
+  }
+  return { minW: max(0, minW), minH: max(0, minH), maxW: max(minW, maxW), maxH: max(minH, maxH) };
+}
+function resolveLimitsWithAspect(limits, boundary, ar) {
+  let { minW, minH, maxW, maxH } = limits;
+  const bw = boundary?.width ?? Infinity;
+  const bh = boundary?.height ?? Infinity;
+  const minWa = max(minW, minH * ar);
+  const minHa = minWa / ar;
+  minW = min(minWa, bw);
+  minH = min(minHa, bh);
+  let cmw = min(maxW, maxH * ar, bw);
+  let cmh = cmw / ar;
+  if (cmh > maxH || cmh > bh) {
+    cmh = min(maxH, bh);
+    cmw = cmh * ar;
+  }
+  maxW = max(minW, min(cmw, bw));
+  maxH = max(minH, min(cmh, bh));
+  return { minW, minH, maxW, maxH };
+}
+function applyDelta(edges, delta, handle, limits, boundary) {
+  let { left, top, right, bottom } = edges;
+  const { minW, minH, maxW, maxH } = limits;
+  if (isLeftHandle(handle)) {
+    const lo = boundary ? max(boundary.x, right - maxW) : right - maxW;
+    const hi = right - minW;
+    left = clamp(left + delta.x, lo, hi);
+  }
+  if (isRightHandle(handle)) {
+    const lo = left + minW;
+    const hi = boundary ? min(boundary.x + boundary.width, left + maxW) : left + maxW;
+    right = clamp(right + delta.x, lo, hi);
+  }
+  if (isTopHandle(handle)) {
+    const lo = boundary ? max(boundary.y, bottom - maxH) : bottom - maxH;
+    const hi = bottom - minH;
+    top = clamp(top + delta.y, lo, hi);
+  }
+  if (isBottomHandle(handle)) {
+    const lo = top + minH;
+    const hi = boundary ? min(boundary.y + boundary.height, top + maxH) : top + maxH;
+    bottom = clamp(bottom + delta.y, lo, hi);
+  }
+  return { left, top, right, bottom };
+}
+function clampAspectSize(wHint, hHint, ar, lim, bw, bh) {
+  const fromHeight = (h) => {
+    const w = clamp(h * ar, lim.minW, min(lim.maxW, bw));
+    return { width: w, height: w / ar };
+  };
+  const tryWidth = (value) => {
+    let w = clamp(value, lim.minW, min(lim.maxW, bw));
+    let h = w / ar;
+    if (h < lim.minH) ({ width: w, height: h } = fromHeight(lim.minH));
+    if (h > min(lim.maxH, bh)) ({ width: w, height: h } = fromHeight(min(lim.maxH, bh)));
+    if (h > bh) {
+      ;
+      ({ width: w, height: h } = fromHeight(bh));
+      if (h < lim.minH) ({ width: w, height: h } = fromHeight(lim.minH));
+    }
+    return { width: w, height: h };
+  };
+  const tryHeight = (value) => {
+    let h = clamp(value, lim.minH, min(lim.maxH, bh));
+    let w = clamp(h * ar, lim.minW, min(lim.maxW, bw));
+    let ah = w / ar;
+    if (ah < lim.minH) ({ width: w, height: ah } = fromHeight(lim.minH));
+    if (ah > min(lim.maxH, bh)) ({ width: w, height: ah } = fromHeight(min(lim.maxH, bh)));
+    if (w > bw) {
+      w = bw;
+      ah = w / ar;
+      if (ah > min(lim.maxH, bh)) ({ width: w, height: ah } = fromHeight(min(lim.maxH, bh)));
+      if (ah < lim.minH) ({ width: w, height: ah } = fromHeight(lim.minH));
+    }
+    return { width: w, height: ah };
+  };
+  const byW = tryWidth(wHint);
+  const byH = tryHeight(hHint);
+  const dw = abs(byW.width - wHint) + abs(byW.height - hHint);
+  const dh = abs(byH.width - wHint) + abs(byH.height - hHint);
+  return dh < dw ? byH : byW;
+}
+function enforceAspect(edges, handle, ar, lim, boundary) {
+  const { left, top, right, bottom } = edges;
+  const bw = boundary?.width ?? Infinity;
+  const bh = boundary?.height ?? Infinity;
+  const bx = boundary?.x ?? 0;
+  const by = boundary?.y ?? 0;
+  if (isCornerHandle(handle)) {
+    let w = right - left;
+    let h = w / ar;
+    if (h > bottom - top || boundary && (top + h > by + bh || left + w > bx + bw)) {
+      h = bottom - top;
+      w = h * ar;
+    }
+    const s = clampAspectSize(w, h, ar, lim, bw, bh);
+    w = s.width;
+    h = s.height;
+    if (isRightHandle(handle) && isBottomHandle(handle)) {
+      return { left, top, right: left + w, bottom: top + h };
+    }
+    if (isRightHandle(handle) && isTopHandle(handle)) {
+      return { left, top: bottom - h, right: left + w, bottom };
+    }
+    if (isLeftHandle(handle) && isBottomHandle(handle)) {
+      return { left: right - w, top, right, bottom: top + h };
+    }
+    return { left: right - w, top: bottom - h, right, bottom };
+  }
+  if (isHorizontalHandle(handle)) {
+    const centerY = (top + bottom) / 2;
+    let w = right - left;
+    let h = w / ar;
+    const s = clampAspectSize(w, h, ar, lim, bw, bh);
+    w = s.width;
+    h = s.height;
+    const halfH = h / 2;
+    let newTop = centerY - halfH;
+    let newBottom = centerY + halfH;
+    if (boundary) {
+      if (newTop < by) {
+        newTop = by;
+        newBottom = newTop + h;
+      }
+      if (newBottom > by + bh) {
+        newBottom = by + bh;
+        newTop = newBottom - h;
+      }
+    }
+    return {
+      left: isRightHandle(handle) ? left : right - w,
+      top: newTop,
+      right: isRightHandle(handle) ? left + w : right,
+      bottom: newBottom
+    };
+  }
+  if (isVerticalHandle(handle)) {
+    const centerX = (left + right) / 2;
+    let h = bottom - top;
+    let w = h * ar;
+    const s = clampAspectSize(w, h, ar, lim, bw, bh);
+    w = s.width;
+    h = s.height;
+    const halfW = w / 2;
+    let newLeft = centerX - halfW;
+    let newRight = centerX + halfW;
+    if (boundary) {
+      if (newLeft < bx) {
+        newLeft = bx;
+        newRight = newLeft + w;
+      }
+      if (newRight > bx + bw) {
+        newRight = bx + bw;
+        newLeft = newRight - w;
+      }
+    }
+    return {
+      left: newLeft,
+      top: isBottomHandle(handle) ? top : bottom - h,
+      right: newRight,
+      bottom: isBottomHandle(handle) ? top + h : bottom
+    };
+  }
+  return edges;
+}
+function centerInRect(size, boundary) {
+  return {
+    x: boundary.x + max(0, (boundary.width - size.width) / 2),
+    y: boundary.y + max(0, (boundary.height - size.height) / 2)
+  };
+}
+function centerOnPoint(size, center, boundary) {
+  const pos = {
+    x: center.x - size.width / 2,
+    y: center.y - size.height / 2
+  };
+  return {
+    x: clamp(pos.x, boundary.x, boundary.x + boundary.width - size.width),
+    y: clamp(pos.y, boundary.y, boundary.y + boundary.height - size.height)
+  };
+}
+function clampPointInRange(point, minPoint, maxPoint) {
+  return {
+    x: clamp(point.x, minPoint.x, maxPoint.x),
+    y: clamp(point.y, minPoint.y, maxPoint.y)
+  };
+}
+function applyMove(rect, delta, options = {}) {
+  const { boundary, gridSize = 1 } = options;
+  const dx = round(delta.x / gridSize) * gridSize;
+  const dy = round(delta.y / gridSize) * gridSize;
+  let x = rect.x + dx;
+  let y = rect.y + dy;
+  if (boundary) {
+    x = clamp(x, boundary.x, boundary.x + boundary.width - rect.width);
+    y = clamp(y, boundary.y, boundary.y + boundary.height - rect.height);
+  }
+  return { x, y, width: rect.width, height: rect.height };
+}
+function applyResize(rect, delta, handle, options = {}) {
+  const { boundary, aspectRatio, origin = "extent" } = options;
+  const baseLimits = resolveLimits(options);
+  const effectiveDelta = origin === "center" ? { x: delta.x * 2, y: delta.y * 2 } : delta;
+  let edges = applyDelta(
+    { left: rect.x, top: rect.y, right: rect.x + rect.width, bottom: rect.y + rect.height },
+    effectiveDelta,
+    handle,
+    baseLimits,
+    boundary
+  );
+  if (aspectRatio != null && aspectRatio > 0) {
+    const arLimits = resolveLimitsWithAspect(baseLimits, boundary, aspectRatio);
+    edges = enforceAspect(edges, handle, aspectRatio, arLimits, boundary);
+  }
+  let { left, top, right, bottom } = edges;
+  if (origin === "center") {
+    const cx = rect.x + rect.width / 2;
+    const cy = rect.y + rect.height / 2;
+    const w = right - left;
+    const h = bottom - top;
+    left = cx - w / 2;
+    top = cy - h / 2;
+    right = cx + w / 2;
+    bottom = cy + h / 2;
+    if (boundary) {
+      if (left < boundary.x) {
+        right += boundary.x - left;
+        left = boundary.x;
+      }
+      if (right > boundary.x + boundary.width) {
+        left -= right - (boundary.x + boundary.width);
+        right = boundary.x + boundary.width;
+      }
+      if (top < boundary.y) {
+        bottom += boundary.y - top;
+        top = boundary.y;
+      }
+      if (bottom > boundary.y + boundary.height) {
+        top -= bottom - (boundary.y + boundary.height);
+        bottom = boundary.y + boundary.height;
+      }
+    }
+  }
+  if (boundary) {
+    const maxLeft = max(boundary.x, boundary.x + boundary.width - baseLimits.minW);
+    const maxTop = max(boundary.y, boundary.y + boundary.height - baseLimits.minH);
+    left = clamp(left, boundary.x, maxLeft);
+    top = clamp(top, boundary.y, maxTop);
+    right = clamp(right, left + baseLimits.minW, min(boundary.x + boundary.width, left + baseLimits.maxW));
+    bottom = clamp(bottom, top + baseLimits.minH, min(boundary.y + boundary.height, top + baseLimits.maxH));
+  }
+  return { x: left, y: top, width: right - left, height: bottom - top };
+}
+function getDirectionDelta(direction, step) {
+  switch (direction) {
+    case "left":
+      return { x: -step, y: 0 };
+    case "right":
+      return { x: step, y: 0 };
+    case "up":
+      return { x: 0, y: -step };
+    case "down":
+      return { x: 0, y: step };
+  }
+}
+function getArrowKeyDelta(key, step) {
+  switch (key) {
+    case "ArrowLeft":
+      return { x: -step, y: 0 };
+    case "ArrowRight":
+      return { x: step, y: 0 };
+    case "ArrowUp":
+      return { x: 0, y: -step };
+    case "ArrowDown":
+      return { x: 0, y: step };
+    default:
+      return { x: 0, y: 0 };
+  }
+}
+function getKeyboardResizeDelta(key, handle, step) {
+  let x = 0;
+  let y = 0;
+  if (isLeftHandle(handle)) {
+    if (key === "ArrowLeft") x = -step;
+    else if (key === "ArrowRight") x = step;
+  }
+  if (isRightHandle(handle)) {
+    if (key === "ArrowRight") x = step;
+    else if (key === "ArrowLeft") x = -step;
+  }
+  if (isTopHandle(handle)) {
+    if (key === "ArrowUp") y = -step;
+    else if (key === "ArrowDown") y = step;
+  }
+  if (isBottomHandle(handle)) {
+    if (key === "ArrowDown") y = step;
+    else if (key === "ArrowUp") y = -step;
+  }
+  return { x, y };
+}
+export {
+  applyMove,
+  applyResize,
+  centerInRect,
+  centerOnPoint,
+  clampPointInRange,
+  getArrowKeyDelta,
+  getDirectionDelta,
+  getKeyboardResizeDelta,
+  isBottomHandle,
+  isCornerHandle,
+  isHorizontalHandle,
+  isLeftHandle,
+  isRightHandle,
+  isTopHandle,
+  isVerticalHandle
+};