@yuzhouu/canvas-kit 0.1.2

package/_vendor/canvas-core/editor/resizeGeometry.ts

@@ -0,0 +1,654 @@
+import { Box } from "../geometry/Box";
+import { Vec } from "../geometry/Vec";
+import type { SelectionResizeHandleId } from "./selection";
+
+const MIN_SELECTION_RESIZE_SIZE = 1;
+
+export interface SelectionResizeBoundsResult {
+  bounds: Box;
+  scaleX: number;
+  scaleY: number;
+}
+
+export interface SelectionResizeScalesResult {
+  scaleX: number;
+  scaleY: number;
+}
+
+export function selectionResizeHandleMovesLeftEdge(
+  handleId: SelectionResizeHandleId,
+): boolean {
+  return (
+    handleId === "top_left" ||
+    handleId === "left" ||
+    handleId === "bottom_left"
+  );
+}
+
+export function selectionResizeHandleMovesRightEdge(
+  handleId: SelectionResizeHandleId,
+): boolean {
+  return (
+    handleId === "top_right" ||
+    handleId === "right" ||
+    handleId === "bottom_right"
+  );
+}
+
+export function selectionResizeHandleMovesTopEdge(
+  handleId: SelectionResizeHandleId,
+): boolean {
+  return (
+    handleId === "top_left" ||
+    handleId === "top" ||
+    handleId === "top_right"
+  );
+}
+
+export function selectionResizeHandleMovesBottomEdge(
+  handleId: SelectionResizeHandleId,
+): boolean {
+  return (
+    handleId === "bottom_left" ||
+    handleId === "bottom" ||
+    handleId === "bottom_right"
+  );
+}
+
+export function isSelectionResizeCorner(
+  handleId: SelectionResizeHandleId,
+): boolean {
+  return (
+    selectionResizeHandleMovesLeftEdge(handleId) !==
+      selectionResizeHandleMovesRightEdge(handleId) &&
+    selectionResizeHandleMovesTopEdge(handleId) !==
+      selectionResizeHandleMovesBottomEdge(handleId)
+  );
+}
+
+export function getSelectionResizeHandleForScale({
+  handleId,
+  scaleX,
+  scaleY,
+}: {
+  handleId: SelectionResizeHandleId;
+  scaleX: number;
+  scaleY: number;
+}): SelectionResizeHandleId {
+  const horizontal = selectionResizeHandleMovesLeftEdge(handleId)
+    ? scaleX < 0
+      ? "right"
+      : "left"
+    : selectionResizeHandleMovesRightEdge(handleId)
+      ? scaleX < 0
+        ? "left"
+        : "right"
+      : null;
+  const vertical = selectionResizeHandleMovesTopEdge(handleId)
+    ? scaleY < 0
+      ? "bottom"
+      : "top"
+    : selectionResizeHandleMovesBottomEdge(handleId)
+      ? scaleY < 0
+        ? "top"
+        : "bottom"
+      : null;
+
+  if (vertical === "top" && horizontal === "left") return "top_left";
+  if (vertical === "top" && horizontal === "right") return "top_right";
+  if (vertical === "bottom" && horizontal === "right") return "bottom_right";
+  if (vertical === "bottom" && horizontal === "left") return "bottom_left";
+  if (vertical) return vertical;
+  if (horizontal) return horizontal;
+  return handleId;
+}
+
+export function getSelectionResizeScalesFromBounds({
+  startBounds,
+  bounds,
+  handleId,
+  scaleX,
+  scaleY,
+  isResizingFromCenter = false,
+}: {
+  startBounds: Box;
+  bounds: Box;
+  handleId: SelectionResizeHandleId;
+  scaleX?: number;
+  scaleY?: number;
+  isResizingFromCenter?: boolean;
+}): SelectionResizeScalesResult {
+  const scaleXSign = getSelectionResizeScaleSign({
+    axis: "x",
+    startBounds,
+    bounds,
+    handleId,
+    scale: scaleX,
+    isResizingFromCenter,
+  });
+  const scaleYSign = getSelectionResizeScaleSign({
+    axis: "y",
+    startBounds,
+    bounds,
+    handleId,
+    scale: scaleY,
+    isResizingFromCenter,
+  });
+
+  return {
+    scaleX:
+      selectionResizeHandleMovesLeftEdge(handleId) ||
+      selectionResizeHandleMovesRightEdge(handleId)
+        ? scaleXSign *
+          (bounds.w / Math.max(MIN_SELECTION_RESIZE_SIZE, startBounds.w))
+        : (scaleX ?? 1),
+    scaleY:
+      selectionResizeHandleMovesTopEdge(handleId) ||
+      selectionResizeHandleMovesBottomEdge(handleId)
+        ? scaleYSign *
+          (bounds.h / Math.max(MIN_SELECTION_RESIZE_SIZE, startBounds.h))
+        : (scaleY ?? 1),
+  };
+}
+
+function getSelectionResizeScaleSign({
+  axis,
+  startBounds,
+  bounds,
+  handleId,
+  scale,
+  isResizingFromCenter,
+}: {
+  axis: "x" | "y";
+  startBounds: Box;
+  bounds: Box;
+  handleId: SelectionResizeHandleId;
+  scale?: number;
+  isResizingFromCenter: boolean;
+}): number {
+  const fallback = Math.sign(scale ?? 1) || 1;
+  if (isResizingFromCenter) {
+    return fallback;
+  }
+
+  if (axis === "x") {
+    if (selectionResizeHandleMovesLeftEdge(handleId)) {
+      return bounds.minX >= startBounds.maxX ? -1 : 1;
+    }
+    if (selectionResizeHandleMovesRightEdge(handleId)) {
+      return bounds.maxX <= startBounds.minX ? -1 : 1;
+    }
+    return fallback;
+  }
+
+  if (selectionResizeHandleMovesTopEdge(handleId)) {
+    return bounds.minY >= startBounds.maxY ? -1 : 1;
+  }
+  if (selectionResizeHandleMovesBottomEdge(handleId)) {
+    return bounds.maxY <= startBounds.minY ? -1 : 1;
+  }
+  return fallback;
+}
+
+export function getAnchoredSelectionResizeLocalBounds({
+  requestedBounds,
+  handleId,
+  actualWidth,
+  actualHeight,
+  scaleX,
+  scaleY,
+  isResizingFromCenter,
+}: {
+  requestedBounds: Box;
+  handleId: SelectionResizeHandleId;
+  actualWidth: number;
+  actualHeight: number;
+  scaleX: number;
+  scaleY: number;
+  isResizingFromCenter: boolean;
+}): Box {
+  const x = isResizingFromCenter
+    ? requestedBounds.center.x - actualWidth / 2
+    : selectionResizeHandleMovesLeftEdge(handleId)
+      ? scaleX < 0
+        ? requestedBounds.minX
+        : requestedBounds.maxX - actualWidth
+      : selectionResizeHandleMovesRightEdge(handleId)
+        ? scaleX < 0
+          ? requestedBounds.maxX - actualWidth
+          : requestedBounds.minX
+        : requestedBounds.center.x - actualWidth / 2;
+  const y = isResizingFromCenter
+    ? requestedBounds.center.y - actualHeight / 2
+    : selectionResizeHandleMovesTopEdge(handleId)
+      ? scaleY < 0
+        ? requestedBounds.minY
+        : requestedBounds.maxY - actualHeight
+      : selectionResizeHandleMovesBottomEdge(handleId)
+        ? scaleY < 0
+          ? requestedBounds.maxY - actualHeight
+          : requestedBounds.minY
+        : requestedBounds.center.y - actualHeight / 2;
+
+  return new Box(x, y, actualWidth, actualHeight);
+}
+
+export function getSelectionResizeBounds({
+  startBounds,
+  handleId,
+  pagePoint,
+}: {
+  startBounds: Box;
+  handleId: SelectionResizeHandleId;
+  pagePoint: Vec;
+}): Box {
+  return getSelectionResizeBoundsWithScale({
+    startBounds,
+    handleId,
+    pagePoint,
+  }).bounds;
+}
+
+export function getSelectionResizeBoundsWithScale({
+  startBounds,
+  handleId,
+  pagePoint,
+}: {
+  startBounds: Box;
+  handleId: SelectionResizeHandleId;
+  pagePoint: Vec;
+}): SelectionResizeBoundsResult {
+  const startMinX = startBounds.minX;
+  const startMaxX = startBounds.maxX;
+  const startMinY = startBounds.minY;
+  const startMaxY = startBounds.maxY;
+  let movingX = selectionResizeHandleMovesLeftEdge(handleId)
+    ? startMinX
+    : startMaxX;
+  let anchoredX = selectionResizeHandleMovesLeftEdge(handleId)
+    ? startMaxX
+    : startMinX;
+  let movingY = selectionResizeHandleMovesTopEdge(handleId)
+    ? startMinY
+    : startMaxY;
+  let anchoredY = selectionResizeHandleMovesTopEdge(handleId)
+    ? startMaxY
+    : startMinY;
+
+  if (selectionResizeHandleMovesLeftEdge(handleId)) {
+    movingX = pagePoint.x;
+  } else if (selectionResizeHandleMovesRightEdge(handleId)) {
+    movingX = pagePoint.x;
+  } else {
+    movingX = startMaxX;
+    anchoredX = startMinX;
+  }
+
+  if (selectionResizeHandleMovesTopEdge(handleId)) {
+    movingY = pagePoint.y;
+  } else if (selectionResizeHandleMovesBottomEdge(handleId)) {
+    movingY = pagePoint.y;
+  } else {
+    movingY = startMaxY;
+    anchoredY = startMinY;
+  }
+
+  const rawWidth = movingX - anchoredX;
+  const rawHeight = movingY - anchoredY;
+  const signedWidth = selectionResizeHandleMovesLeftEdge(handleId)
+    ? anchoredX - movingX
+    : rawWidth;
+  const signedHeight = selectionResizeHandleMovesTopEdge(handleId)
+    ? anchoredY - movingY
+    : rawHeight;
+  const scaleX =
+    selectionResizeHandleMovesLeftEdge(handleId) ||
+    selectionResizeHandleMovesRightEdge(handleId)
+      ? signedWidth / Math.max(MIN_SELECTION_RESIZE_SIZE, startBounds.w)
+      : 1;
+  const scaleY =
+    selectionResizeHandleMovesTopEdge(handleId) ||
+    selectionResizeHandleMovesBottomEdge(handleId)
+      ? signedHeight / Math.max(MIN_SELECTION_RESIZE_SIZE, startBounds.h)
+      : 1;
+  const width = Math.max(MIN_SELECTION_RESIZE_SIZE, Math.abs(rawWidth));
+  const height = Math.max(MIN_SELECTION_RESIZE_SIZE, Math.abs(rawHeight));
+
+  return {
+    bounds: new Box(
+      Math.min(movingX, anchoredX),
+      Math.min(movingY, anchoredY),
+      width,
+      height,
+    ),
+    scaleX,
+    scaleY,
+  };
+}
+
+export function getCenteredSelectionResizeBounds({
+  startBounds,
+  handleId,
+  pagePoint,
+}: {
+  startBounds: Box;
+  handleId: SelectionResizeHandleId;
+  pagePoint: Vec;
+}): Box {
+  return getCenteredSelectionResizeBoundsWithScale({
+    startBounds,
+    handleId,
+    pagePoint,
+  }).bounds;
+}
+
+export function getCenteredSelectionResizeBoundsWithScale({
+  startBounds,
+  handleId,
+  pagePoint,
+}: {
+  startBounds: Box;
+  handleId: SelectionResizeHandleId;
+  pagePoint: Vec;
+}): SelectionResizeBoundsResult {
+  const center = startBounds.center;
+  const minHalfSize = MIN_SELECTION_RESIZE_SIZE / 2;
+  const rawHalfWidth = pagePoint.x - center.x;
+  const rawHalfHeight = pagePoint.y - center.y;
+  const halfWidth = Math.max(Math.abs(rawHalfWidth), minHalfSize);
+  const halfHeight = Math.max(Math.abs(rawHalfHeight), minHalfSize);
+  const scaleX =
+    selectionResizeHandleMovesLeftEdge(handleId) ||
+    selectionResizeHandleMovesRightEdge(handleId)
+      ? (rawHalfWidth *
+          (selectionResizeHandleMovesLeftEdge(handleId) ? -2 : 2)) /
+        Math.max(MIN_SELECTION_RESIZE_SIZE, startBounds.w)
+      : 1;
+  const scaleY =
+    selectionResizeHandleMovesTopEdge(handleId) ||
+    selectionResizeHandleMovesBottomEdge(handleId)
+      ? (rawHalfHeight *
+          (selectionResizeHandleMovesTopEdge(handleId) ? -2 : 2)) /
+        Math.max(MIN_SELECTION_RESIZE_SIZE, startBounds.h)
+      : 1;
+
+  switch (handleId) {
+    case "top":
+    case "bottom":
+      return {
+        bounds: new Box(
+          startBounds.minX,
+          center.y - halfHeight,
+          startBounds.w,
+          halfHeight * 2,
+        ),
+        scaleX,
+        scaleY,
+      };
+    case "left":
+    case "right":
+      return {
+        bounds: new Box(
+          center.x - halfWidth,
+          startBounds.minY,
+          halfWidth * 2,
+          startBounds.h,
+        ),
+        scaleX,
+        scaleY,
+      };
+    default:
+      return {
+        bounds: new Box(
+          center.x - halfWidth,
+          center.y - halfHeight,
+          halfWidth * 2,
+          halfHeight * 2,
+        ),
+        scaleX,
+        scaleY,
+      };
+  }
+}
+
+export function getAspectRatioLockedSelectionResizeBounds({
+  bounds,
+  startBounds,
+  handleId,
+  aspectRatio,
+  isResizingFromCenter,
+}: {
+  bounds: Box;
+  startBounds: Box;
+  handleId: SelectionResizeHandleId;
+  aspectRatio: number;
+  isResizingFromCenter: boolean;
+}): Box {
+  return getAspectRatioLockedSelectionResizeBoundsWithScale({
+    bounds,
+    startBounds,
+    handleId,
+    aspectRatio,
+    isResizingFromCenter,
+  }).bounds;
+}
+
+export function getAspectRatioLockedSelectionResizeBoundsWithScale({
+  bounds,
+  startBounds,
+  handleId,
+  aspectRatio,
+  isResizingFromCenter,
+  scaleX,
+  scaleY,
+}: {
+  bounds: Box;
+  startBounds: Box;
+  handleId: SelectionResizeHandleId;
+  aspectRatio: number;
+  isResizingFromCenter: boolean;
+  scaleX?: number;
+  scaleY?: number;
+}): SelectionResizeBoundsResult {
+  if (aspectRatio <= 0) {
+    return {
+      bounds,
+      scaleX: scaleX ?? bounds.w / Math.max(MIN_SELECTION_RESIZE_SIZE, startBounds.w),
+      scaleY: scaleY ?? bounds.h / Math.max(MIN_SELECTION_RESIZE_SIZE, startBounds.h),
+    };
+  }
+
+  let width = bounds.w;
+  let height = bounds.h;
+  const scaleXSign = Math.sign(scaleX ?? 1) || 1;
+  const scaleYSign = Math.sign(scaleY ?? 1) || 1;
+  switch (handleId) {
+    case "left":
+    case "right":
+      height = width / aspectRatio;
+      break;
+    case "top":
+    case "bottom":
+      width = height * aspectRatio;
+      break;
+    default: {
+      const widthScale = width / Math.max(1, startBounds.w);
+      const heightScale = height / Math.max(1, startBounds.h);
+
+      if (Math.abs(widthScale) > Math.abs(heightScale)) {
+        height = width / aspectRatio;
+      } else {
+        width = height * aspectRatio;
+      }
+      break;
+    }
+  }
+
+  if (isResizingFromCenter) {
+    const center = startBounds.center;
+    return {
+      bounds: new Box(center.x - width / 2, center.y - height / 2, width, height),
+      scaleX: scaleXSign * (width / Math.max(MIN_SELECTION_RESIZE_SIZE, startBounds.w)),
+      scaleY: scaleYSign * (height / Math.max(MIN_SELECTION_RESIZE_SIZE, startBounds.h)),
+    };
+  }
+
+  let nextBounds: Box;
+  switch (handleId) {
+    case "top_left":
+      nextBounds = new Box(
+        scaleXSign < 0 ? bounds.minX : bounds.maxX - width,
+        scaleYSign < 0 ? bounds.minY : bounds.maxY - height,
+        width,
+        height,
+      );
+      break;
+    case "top_right":
+      nextBounds = new Box(
+        scaleXSign < 0 ? bounds.maxX - width : bounds.minX,
+        scaleYSign < 0 ? bounds.minY : bounds.maxY - height,
+        width,
+        height,
+      );
+      break;
+    case "bottom_right":
+      nextBounds = new Box(
+        scaleXSign < 0 ? bounds.maxX - width : bounds.minX,
+        scaleYSign < 0 ? bounds.maxY - height : bounds.minY,
+        width,
+        height,
+      );
+      break;
+    case "bottom_left":
+      nextBounds = new Box(
+        scaleXSign < 0 ? bounds.minX : bounds.maxX - width,
+        scaleYSign < 0 ? bounds.maxY - height : bounds.minY,
+        width,
+        height,
+      );
+      break;
+    case "top":
+      nextBounds = new Box(
+        startBounds.center.x - width / 2,
+        scaleYSign < 0 ? startBounds.maxY : startBounds.maxY - height,
+        width,
+        height,
+      );
+      break;
+    case "right":
+      nextBounds = new Box(
+        scaleXSign < 0 ? startBounds.minX - width : startBounds.minX,
+        startBounds.center.y - height / 2,
+        width,
+        height,
+      );
+      break;
+    case "bottom":
+      nextBounds = new Box(
+        startBounds.center.x - width / 2,
+        scaleYSign < 0 ? startBounds.minY - height : startBounds.minY,
+        width,
+        height,
+      );
+      break;
+    case "left":
+      nextBounds = new Box(
+        scaleXSign < 0 ? startBounds.maxX : startBounds.maxX - width,
+        startBounds.center.y - height / 2,
+        width,
+        height,
+      );
+      break;
+  }
+
+  return {
+    bounds: nextBounds,
+    scaleX: scaleXSign * (width / Math.max(MIN_SELECTION_RESIZE_SIZE, startBounds.w)),
+    scaleY: scaleYSign * (height / Math.max(MIN_SELECTION_RESIZE_SIZE, startBounds.h)),
+  };
+}
+
+export function getConstrainedSelectionResizeBounds({
+  startBounds,
+  handleId,
+  pagePoint,
+  isAspectRatioLocked,
+  isResizingFromCenter,
+  aspectRatio,
+}: {
+  startBounds: Box;
+  handleId: SelectionResizeHandleId;
+  pagePoint: Vec;
+  isAspectRatioLocked: boolean;
+  isResizingFromCenter: boolean;
+  aspectRatio: number;
+}): Box {
+  return getConstrainedSelectionResizeBoundsWithScale({
+    startBounds,
+    handleId,
+    pagePoint,
+    isAspectRatioLocked,
+    isResizingFromCenter,
+    aspectRatio,
+  }).bounds;
+}
+
+export function getConstrainedSelectionResizeBoundsWithScale({
+  startBounds,
+  handleId,
+  pagePoint,
+  isAspectRatioLocked,
+  isResizingFromCenter,
+  aspectRatio,
+}: {
+  startBounds: Box;
+  handleId: SelectionResizeHandleId;
+  pagePoint: Vec;
+  isAspectRatioLocked: boolean;
+  isResizingFromCenter: boolean;
+  aspectRatio: number;
+}): SelectionResizeBoundsResult {
+  const result = isResizingFromCenter
+    ? getCenteredSelectionResizeBoundsWithScale({
+        startBounds,
+        handleId,
+        pagePoint,
+      })
+    : getSelectionResizeBoundsWithScale({ startBounds, handleId, pagePoint });
+  if (!isAspectRatioLocked) {
+    return result;
+  }
+
+  return getAspectRatioLockedSelectionResizeBoundsWithScale({
+    bounds: result.bounds,
+    startBounds,
+    handleId,
+    aspectRatio,
+    isResizingFromCenter,
+    scaleX: result.scaleX,
+    scaleY: result.scaleY,
+  });
+}
+
+export function normalizeSelectionResizeBoundsFromEdges({
+  minX,
+  minY,
+  maxX,
+  maxY,
+}: {
+  minX: number;
+  minY: number;
+  maxX: number;
+  maxY: number;
+}): Box {
+  const nextMinX = Math.min(minX, maxX);
+  const nextMinY = Math.min(minY, maxY);
+  const nextMaxX = Math.max(minX, maxX);
+  const nextMaxY = Math.max(minY, maxY);
+  return new Box(
+    nextMinX,
+    nextMinY,
+    Math.max(1, nextMaxX - nextMinX),
+    Math.max(1, nextMaxY - nextMinY),
+  );
+}