@yuzhouu/canvas-kit 0.1.2 → 0.1.4

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

@@ -1,654 +0,0 @@
-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),
-  );
-}