@yuzhouu/canvas-kit 0.1.2 → 0.1.4

package/_vendor/canvas-core/tools/select/selectToolHelpers.ts

@@ -1,801 +0,0 @@
-import { Box } from "../../geometry/Box";
-import { Vec } from "../../geometry/Vec";
-import type { ShapeUpdate } from "../../editor/commands";
-import type { Editor } from "../../editor/Editor";
-import { getEdgeScrollDelta } from "../../editor/edgeScroll";
-import type { PointerEditorEvent, TickEditorEvent } from "../../editor/events";
-import {
-  mapSelectionLocalBoundsBetweenBounds,
-  rotateSelectionPagePoint,
-  selectionLocalPointToPagePoint,
-} from "../../editor/selection";
-import {
-  selectionResizeHandleMovesBottomEdge,
-  selectionResizeHandleMovesLeftEdge,
-  selectionResizeHandleMovesRightEdge,
-  selectionResizeHandleMovesTopEdge,
-} from "../../editor/resizeGeometry";
-import type {
-  SelectionResizeHandleId,
-  SelectionResizePointShapeSnapshot,
-  SelectionResizeShapeSnapshot,
-  SelectionRotationTransform,
-  SelectionRotatePointShapeSnapshot,
-  SelectionRotateShapeSnapshot,
-} from "../../editor/selection";
-import type {
-  HandleSnapSnapshot,
-  ResizeSnapSnapshot,
-  TranslateSnapSnapshot,
-} from "../../editor/managers/snapTypes";
-import type { SelectionHandleInteractionSession } from "../../editor/selectionHandleInteractions";
-import type { ShapeId, ShapeParentId, ShapeRecord } from "../../schema/records";
-
-export const DRAG_START_DISTANCE = 3;
-export const DRAG_START_DISTANCE_SQUARED = DRAG_START_DISTANCE * DRAG_START_DISTANCE;
-export const ROTATION_SNAP_STEP = (Math.PI / 180) * 15;
-export const ROTATION_SOFT_SNAP_STEP = Math.PI / 2;
-export const ROTATION_SOFT_SNAP_THRESHOLD = (Math.PI / 180) * 5;
-export const ROTATION_SOFT_SNAP_MAX_SCREEN_VELOCITY = 0.5;
-export const GROUP_CHILD_QUICK_SELECT_DURATION_MS = 250;
-export const TRANSLATE_SNAP_DISTANCE_SCREEN = 8;
-export const TRANSLATE_SNAP_MAX_SCREEN_VELOCITY = 0.5;
-export const RESIZE_SNAP_DISTANCE_SCREEN = 8;
-export const HANDLE_SNAP_DISTANCE_SCREEN = 8;
-export const TRANSLATE_HISTORY_MARK = "select.translate";
-export const RESIZE_HISTORY_MARK = "select.resize";
-export const ROTATE_HISTORY_MARK = "select.rotate";
-
-export type TranslateAxis = "x" | "y";
-
-export interface PointingCanvasInfo {
-  originPagePoint: Vec;
-  previousSelection: ShapeId[];
-  additiveSelection: boolean;
-}
-
-export interface PointingShapeInfo {
-  shapeId: ShapeId;
-  translateTargetId: ShapeId;
-  originPagePoint: Vec;
-  originTimestamp: number;
-  previousSelection: ShapeId[];
-  additiveSelection: boolean;
-  wasSelected: boolean;
-  fromSelectionBounds: boolean;
-  quickClickSelectionTargetId: ShapeId | null;
-}
-
-export interface TranslatingShapeSnapshot {
-  id: ShapeId;
-  x: number;
-  y: number;
-}
-
-export interface TranslatingInfo {
-  originPagePoint: Vec;
-  previousSelection: ShapeId[];
-  selectedShapeIds: ShapeId[];
-  startBounds: Box | null;
-  snapSnapshot: TranslateSnapSnapshot;
-  snapRotation: number;
-  selectedShapes: TranslatingShapeSnapshot[];
-  updates: ShapeUpdate[];
-  lockedAxis: TranslateAxis | null;
-  lastDeltaX: number;
-  lastDeltaY: number;
-}
-
-export interface BrushInfo {
-  originPagePoint: Vec;
-  previousSelection: ShapeId[];
-  additiveSelection: boolean;
-}
-
-export interface PointingResizeHandleInfo {
-  handleId: SelectionResizeHandleId;
-  originPagePoint: Vec;
-  cursorHandleOffset: Vec;
-  previousSelection: ShapeId[];
-}
-
-export interface ResizingInfo extends PointingResizeHandleInfo {
-  startBounds: Box;
-  rotation: number;
-  rotationCenter: Vec;
-  aspectRatio: number;
-  snapSnapshot: ResizeSnapSnapshot;
-  shapes: SelectionResizeShapeSnapshot[];
-  pointShapes: SelectionResizePointShapeSnapshot[];
-  updates: ShapeUpdate[];
-  aspectRatioLockOverride: boolean | null;
-  lastPagePointX: number;
-  lastPagePointY: number;
-  lastShiftKey: boolean;
-  lastAltKey: boolean;
-  lastAccelKey: boolean;
-}
-
-export interface PointingRotateHandleInfo {
-  originPagePoint: Vec;
-  previousSelection: ShapeId[];
-}
-
-export interface RotatingInfo extends PointingRotateHandleInfo {
-  center: Vec;
-  startAngle: number;
-  initialSelectionRotation: number;
-  shapes: SelectionRotateShapeSnapshot[];
-  pointShapes: SelectionRotatePointShapeSnapshot[];
-  updates: ShapeUpdate[];
-  lastPointerX: number;
-  lastPointerY: number;
-  lastShiftKey: boolean;
-  lastAccelKey: boolean;
-}
-
-export interface PointingSelectionHandleInteractionInfo {
-  originPagePoint: Vec;
-  previousSelection: ShapeId[];
-  session: SelectionHandleInteractionSession;
-  snapSnapshot: HandleSnapSnapshot | null;
-}
-
-export interface DraggingSelectionHandleInteractionInfo
-  extends PointingSelectionHandleInteractionInfo {
-  lastPagePointX: number;
-  lastPagePointY: number;
-  lastAccelKey: boolean;
-}
-
-export interface SelectionDragInput {
-  pagePoint: Vec;
-  shiftKey: boolean;
-  altKey: boolean;
-  accelKey: boolean;
-  ctrlKey: boolean;
-}
-
-export type EdgeScrollTickMode =
-  | "always_apply"
-  | "apply_after_scroll_or_without_screen_point"
-  | "apply_after_scroll";
-
-export function getSelectionDragInputFromCurrentInputs(
-  editor: Editor,
-): SelectionDragInput | null {
-  const inputs = editor.inputs.state.get();
-  if (inputs.dragPhase !== "dragging" || !inputs.currentPagePoint) {
-    return null;
-  }
-
-  return {
-    pagePoint: inputs.currentPagePoint,
-    shiftKey: inputs.shiftKey,
-    altKey: inputs.altKey,
-    accelKey: inputs.accelKey,
-    ctrlKey: inputs.ctrlKey,
-  };
-}
-
-export function getSelectionDragInputForTick(
-  editor: Editor,
-  event: TickEditorEvent,
-  mode: EdgeScrollTickMode,
-): SelectionDragInput | null {
-  const inputs = editor.inputs.state.get();
-  if (inputs.dragPhase !== "dragging" || !inputs.currentPagePoint) {
-    return null;
-  }
-
-  let pagePoint = inputs.currentPagePoint;
-
-  if (!inputs.currentScreenPoint) {
-    return mode === "apply_after_scroll"
-      ? null
-      : {
-          pagePoint,
-          shiftKey: inputs.shiftKey,
-          altKey: inputs.altKey,
-          accelKey: inputs.accelKey,
-          ctrlKey: inputs.ctrlKey,
-        };
-  }
-
-  const edgeScrollDelta = getEdgeScrollDelta(
-    inputs.currentScreenPoint,
-    editor.viewportScreenSizeSignal.get(),
-    event.elapsed,
-  );
-  const didScroll = edgeScrollDelta.x !== 0 || edgeScrollDelta.y !== 0;
-  if (!didScroll && mode !== "always_apply") {
-    return null;
-  }
-
-  if (didScroll) {
-    editor.panCamera(edgeScrollDelta);
-    pagePoint = editor.screenToPage(inputs.currentScreenPoint);
-  }
-
-  return {
-    pagePoint,
-    shiftKey: inputs.shiftKey,
-    altKey: inputs.altKey,
-    accelKey: inputs.accelKey,
-    ctrlKey: inputs.ctrlKey,
-  };
-}
-
-export function applySelectionDragFromCurrentInputs(
-  editor: Editor,
-  apply: (input: SelectionDragInput) => void,
-): void {
-  const input = getSelectionDragInputFromCurrentInputs(editor);
-  if (input) {
-    apply(input);
-  }
-}
-
-export function createBrushBounds(origin: Vec, current: Vec): Box {
-  const minX = Math.min(origin.x, current.x);
-  const minY = Math.min(origin.y, current.y);
-  const maxX = Math.max(origin.x, current.x);
-  const maxY = Math.max(origin.y, current.y);
-  return new Box(minX, minY, maxX - minX, maxY - minY);
-}
-
-export function hasExceededDragThreshold(origin: Vec, point: Vec): boolean {
-  return origin.dist2(point) >= DRAG_START_DISTANCE_SQUARED;
-}
-
-export function arePagePointsApproximatelyEqual(
-  left: Vec,
-  right: Vec,
-): boolean {
-  return left.dist2(right) <= 1e-6;
-}
-
-export function toggleIds(base: ShapeId[], toggled: ShapeId[]): ShapeId[] {
-  const next = new Set(base);
-  for (const id of toggled) {
-    if (next.has(id)) {
-      next.delete(id);
-    } else {
-      next.add(id);
-    }
-  }
-  return Array.from(next);
-}
-
-export function getOutermostSelectableShapeIds(
-  editor: Editor,
-  shapeIds: Iterable<ShapeId>,
-): ShapeId[] {
-  const ids: ShapeId[] = [];
-  const seen = new Set<ShapeId>();
-
-  for (const shapeId of shapeIds) {
-    const selectableId = editor.getOutermostSelectableShapeId(shapeId);
-    if (seen.has(selectableId)) {
-      continue;
-    }
-    seen.add(selectableId);
-    ids.push(selectableId);
-  }
-
-  return ids;
-}
-
-export function getSelectableShapeIdForHit(
-  editor: Editor,
-  shapeId: ShapeId,
-  selectedShapeIds: readonly ShapeId[],
-): ShapeId {
-  const selectedShapeIdSet = new Set(selectedShapeIds);
-  if (selectedShapeIdSet.has(shapeId)) {
-    return shapeId;
-  }
-
-  const transformAncestorPath = getTransformDescendantAncestorPath(
-    editor,
-    shapeId,
-  );
-  for (const entry of transformAncestorPath) {
-    if (selectedShapeIdSet.has(entry.ancestorId)) {
-      return entry.childId;
-    }
-  }
-
-  const nearestTransformAncestorId = transformAncestorPath[0]?.ancestorId;
-  if (nearestTransformAncestorId) {
-    if (
-      selectedShapeIds.some(
-        (selectedShapeId) =>
-          getNearestTransformDescendantAncestorId(editor, selectedShapeId) ===
-          nearestTransformAncestorId,
-      )
-    ) {
-      return shapeId;
-    }
-  }
-
-  return (
-    transformAncestorPath[transformAncestorPath.length - 1]?.ancestorId ??
-    shapeId
-  );
-}
-
-export function getSelectedTransformAncestorIdForHit(
-  editor: Editor,
-  shapeId: ShapeId,
-  selectedShapeIds: readonly ShapeId[],
-): ShapeId | null {
-  const selectedShapeIdSet = new Set(selectedShapeIds);
-  for (const entry of getTransformDescendantAncestorPath(editor, shapeId)) {
-    if (selectedShapeIdSet.has(entry.ancestorId)) {
-      return entry.ancestorId;
-    }
-  }
-  return null;
-}
-
-export interface TransformDescendantAncestorPathEntry {
-  ancestorId: ShapeId;
-  childId: ShapeId;
-}
-
-export function getNearestTransformDescendantAncestorId(
-  editor: Editor,
-  shapeId: ShapeId,
-): ShapeId | null {
-  return (
-    getTransformDescendantAncestorPath(editor, shapeId)[0]?.ancestorId ?? null
-  );
-}
-
-export function getTransformDescendantAncestorPath(
-  editor: Editor,
-  shapeId: ShapeId,
-): TransformDescendantAncestorPathEntry[] {
-  const path: TransformDescendantAncestorPathEntry[] = [];
-  let shape = editor.getShape(shapeId);
-  let childId = shapeId;
-  const seen = new Set<ShapeId>([shapeId]);
-
-  while (shape?.parentId.startsWith("shape:")) {
-    const parentId = shape.parentId as ShapeId;
-    if (seen.has(parentId)) {
-      return path;
-    }
-    seen.add(parentId);
-
-    const parent = editor.getShape(parentId);
-    if (!parent) {
-      return path;
-    }
-    if (editor.getShapeUtil(parent).shouldTransformDescendants(parent)) {
-      path.push({ ancestorId: parent.id, childId });
-    }
-    childId = parent.id;
-    shape = parent;
-  }
-
-  return path;
-}
-
-export function isAdditiveSelectionActive({
-  shiftKey,
-  accelKey,
-}: {
-  shiftKey: boolean;
-  accelKey: boolean;
-}): boolean {
-  return shiftKey || accelKey;
-}
-
-export function isBrushWrappingSelection({ ctrlKey }: { ctrlKey: boolean }): boolean {
-  return ctrlKey;
-}
-
-export function isQuickClick(info: PointingShapeInfo, event: PointerEditorEvent): boolean {
-  return (
-    event.timestamp - info.originTimestamp <=
-    GROUP_CHILD_QUICK_SELECT_DURATION_MS
-  );
-}
-
-export function normalizeAngle(angle: number): number {
-  let next = angle;
-  while (next <= -Math.PI) next += Math.PI * 2;
-  while (next > Math.PI) next -= Math.PI * 2;
-  return next;
-}
-
-export function snapAngle(angle: number, step: number): number {
-  return Math.round(angle / step) * step;
-}
-
-export function getBoxCorners(bounds: Box): Vec[] {
-  return [
-    new Vec(bounds.minX, bounds.minY),
-    new Vec(bounds.maxX, bounds.minY),
-    new Vec(bounds.maxX, bounds.maxY),
-    new Vec(bounds.minX, bounds.maxY),
-  ];
-}
-
-export function getShapeSelectionResizePageOutlineVertices(
-  editor: Editor,
-  shape: ShapeRecord,
-): Vec[] {
-  const util = editor.getShapeUtil(shape);
-  const bounds = util.getSelectionResizeLocalBounds(shape);
-  const transform = editor.computeShapeLocalToPageTransform(shape);
-  return getBoxCorners(bounds).map((point) => transform.applyToPoint(point));
-}
-
-export function getResizedShapeUpdate(
-  editor: Editor,
-  shape: SelectionResizeShapeSnapshot,
-  startBounds: Box,
-  nextBounds: Box,
-  scaleX: number,
-  scaleY: number,
-  handleId: SelectionResizeHandleId,
-  isResizingFromCenter: boolean,
-  rotationCenter: Vec,
-  selectionRotation: number,
-  update: ShapeUpdate,
-): void {
-  const selectionTransform = getSelectionTransform(
-    rotationCenter,
-    selectionRotation,
-  );
-  const nextLocalBounds = mapSelectionLocalBoundsBetweenBounds({
-    bounds: shape.localBounds,
-    fromBounds: startBounds,
-    toBounds: nextBounds,
-  });
-  const nextCenter = selectionLocalPointToPagePoint(
-    nextLocalBounds.center,
-    selectionTransform,
-  );
-
-  const util = editor.getShapeUtil(shape.shape);
-  const nextShapeUpdate = util.resizeSelectionBounds(shape.shape, {
-    handleId,
-    pageCenter: nextCenter,
-    selectionLocalBounds: nextLocalBounds,
-    scaleX,
-    scaleY,
-    isResizingFromCenter,
-    selectionRotation,
-    selectionRotationCenter: rotationCenter,
-  });
-
-  update.id = shape.shape.id;
-  update.x = nextShapeUpdate.x;
-  update.y = nextShapeUpdate.y;
-  update.rotation = nextShapeUpdate.rotation ?? shape.rotation;
-  update.scaleX = nextShapeUpdate.scaleX;
-  update.scaleY = nextShapeUpdate.scaleY;
-  update.props = nextShapeUpdate.props;
-}
-
-export function getSelectionTransform(
-  rotationCenter: Vec,
-  selectionRotation: number,
-): SelectionRotationTransform {
-  return {
-    rotation: selectionRotation,
-    rotationCenter,
-  };
-}
-
-export function getResizedPagePointsUpdate(
-  editor: Editor,
-  shape: SelectionResizePointShapeSnapshot,
-  startBounds: Box,
-  nextBounds: Box,
-  scaleX: number,
-  scaleY: number,
-  handleId: SelectionResizeHandleId,
-  isResizingFromCenter: boolean,
-  rotationCenter: Vec,
-  selectionRotation: number,
-  update: ShapeUpdate,
-): void {
-  const selectionTransform = getSelectionTransform(
-    rotationCenter,
-    selectionRotation,
-  );
-  const nextStartPagePoint = selectionLocalPointToPagePoint(
-    mapSelectionLocalPointForResize({
-      point: shape.startLocalPagePoint,
-      startBounds,
-      scaleX,
-      scaleY,
-      handleId,
-      isResizingFromCenter,
-    }),
-    selectionTransform,
-  );
-  const nextEndPagePoint = selectionLocalPointToPagePoint(
-    mapSelectionLocalPointForResize({
-      point: shape.endLocalPagePoint,
-      startBounds,
-      scaleX,
-      scaleY,
-      handleId,
-      isResizingFromCenter,
-    }),
-    selectionTransform,
-  );
-  const nextShapeUpdate = editor
-    .getShapeUtil(shape.shape)
-    .updateSelectionPagePoints(shape.shape, {
-      pagePoints: [nextStartPagePoint, nextEndPagePoint],
-    });
-
-  update.id = shape.shape.id;
-  update.x = nextShapeUpdate.x;
-  update.y = nextShapeUpdate.y;
-  update.rotation = nextShapeUpdate.rotation;
-  update.scaleX = nextShapeUpdate.scaleX;
-  update.scaleY = nextShapeUpdate.scaleY;
-  update.props = nextShapeUpdate.props;
-}
-
-function mapSelectionLocalPointForResize({
-  point,
-  startBounds,
-  scaleX,
-  scaleY,
-  handleId,
-  isResizingFromCenter,
-}: {
-  point: Vec;
-  startBounds: Box;
-  scaleX: number;
-  scaleY: number;
-  handleId: SelectionResizeHandleId;
-  isResizingFromCenter: boolean;
-}): Vec {
-  const anchorX = getSelectionResizeAnchorX({
-    startBounds,
-    handleId,
-    isResizingFromCenter,
-  });
-  const anchorY = getSelectionResizeAnchorY({
-    startBounds,
-    handleId,
-    isResizingFromCenter,
-  });
-
-  return new Vec(
-    anchorX + (point.x - anchorX) * scaleX,
-    anchorY + (point.y - anchorY) * scaleY,
-  );
-}
-
-function getSelectionResizeAnchorX({
-  startBounds,
-  handleId,
-  isResizingFromCenter,
-}: {
-  startBounds: Box;
-  handleId: SelectionResizeHandleId;
-  isResizingFromCenter: boolean;
-}): number {
-  if (isResizingFromCenter) {
-    return startBounds.center.x;
-  }
-  if (selectionResizeHandleMovesLeftEdge(handleId)) {
-    return startBounds.maxX;
-  }
-  if (selectionResizeHandleMovesRightEdge(handleId)) {
-    return startBounds.minX;
-  }
-  return startBounds.center.x;
-}
-
-function getSelectionResizeAnchorY({
-  startBounds,
-  handleId,
-  isResizingFromCenter,
-}: {
-  startBounds: Box;
-  handleId: SelectionResizeHandleId;
-  isResizingFromCenter: boolean;
-}): number {
-  if (isResizingFromCenter) {
-    return startBounds.center.y;
-  }
-  if (selectionResizeHandleMovesTopEdge(handleId)) {
-    return startBounds.maxY;
-  }
-  if (selectionResizeHandleMovesBottomEdge(handleId)) {
-    return startBounds.minY;
-  }
-  return startBounds.center.y;
-}
-
-export function getSelectionResizeAspectRatioLockOverride(
-  editor: Editor,
-  shapes: readonly ShapeRecord[],
-  handleId: SelectionResizeHandleId,
-): boolean | null {
-  const isOnlySelected = shapes.length === 1;
-  let override: boolean | null = null;
-
-  for (const shape of shapes) {
-    const nextOverride = editor
-      .getShapeUtil(shape)
-      .getSelectionResizeAspectRatioLock(shape, {
-        editor,
-        handleId,
-        isOnlySelected,
-      });
-    if (nextOverride === null) {
-      continue;
-    }
-    if (override !== null && override !== nextOverride) {
-      return null;
-    }
-    override = nextOverride;
-  }
-
-  return override;
-}
-
-export function getRotatedShapeUpdate(
-  shape: SelectionRotateShapeSnapshot,
-  center: Vec,
-  delta: number,
-  update: ShapeUpdate,
-): void {
-  const localCenter = shape.localBounds.center;
-  const shapeCenter = new Vec(shape.x + localCenter.x, shape.y + localCenter.y);
-  const nextCenter = rotateSelectionPagePoint(shapeCenter, {
-    rotation: delta,
-    rotationCenter: center,
-  });
-  update.id = shape.id;
-  update.x = nextCenter.x - localCenter.x;
-  update.y = nextCenter.y - localCenter.y;
-  update.rotation = shape.rotation + delta;
-}
-
-export function getRotatedPagePointsUpdate(
-  editor: Editor,
-  shape: SelectionRotatePointShapeSnapshot,
-  center: Vec,
-  delta: number,
-  update: ShapeUpdate,
-): void {
-  const nextShapeUpdate = editor
-    .getShapeUtil(shape.shape)
-    .updateSelectionPagePoints(shape.shape, {
-      pagePoints: [
-        rotateSelectionPagePoint(shape.startPagePoint, {
-          rotation: delta,
-          rotationCenter: center,
-        }),
-        rotateSelectionPagePoint(shape.endPagePoint, {
-          rotation: delta,
-          rotationCenter: center,
-        }),
-      ],
-    });
-
-  update.id = shape.shape.id;
-  update.x = nextShapeUpdate.x;
-  update.y = nextShapeUpdate.y;
-  update.rotation = nextShapeUpdate.rotation;
-  update.scaleX = nextShapeUpdate.scaleX;
-  update.scaleY = nextShapeUpdate.scaleY;
-  update.props = nextShapeUpdate.props;
-}
-
-export function createTranslatingUpdates(
-  shapes: TranslatingShapeSnapshot[],
-): ShapeUpdate[] {
-  return shapes.map((shape) => ({
-    id: shape.id,
-    x: shape.x,
-    y: shape.y,
-  }));
-}
-
-export function getTranslateShapeSnapshots(
-  editor: Editor,
-  selectedShapeIds: ShapeId[],
-): TranslatingShapeSnapshot[] {
-  const movableRootIds = selectedShapeIds.filter((shapeId) => {
-    const shape = editor.getShape(shapeId);
-    return !!shape && !shape.isLocked && !editor.hasLockedDescendant(shape.id);
-  });
-
-  return editor
-    .getShapeIdsIncludingDescendants(movableRootIds)
-    .map((shapeId) => editor.getShape(shapeId))
-    .filter((shape): shape is ShapeRecord => !!shape && !shape.isLocked)
-    .map((shape) => ({
-      id: shape.id,
-      x: shape.x,
-      y: shape.y,
-    }));
-}
-
-export function isShapeWrappedByBrush(
-  editor: Editor,
-  brushBounds: Box,
-  shapeId: ShapeId,
-): boolean {
-  const shape = editor.getShape(shapeId);
-  if (!shape) {
-    return false;
-  }
-
-  return editor.getShapeUtil(shape).isWrappedByBrush(shape, {
-    brushBounds,
-    pageOutlineVertices: editor.getShapePageOutlineVertices(shapeId),
-    pageBounds: editor.getShapePageBounds(shapeId),
-  });
-}
-
-export function shouldSelectShapeWithBrush(
-  editor: Editor,
-  brushBounds: Box,
-  shapeId: ShapeId,
-  isWrapping: boolean,
-): boolean {
-  const shape = editor.getShape(shapeId);
-  if (!shape || !isBrushSelectableShapeId(editor, shape.id)) {
-    return false;
-  }
-
-  return editor.getShapeUtil(shape).canSelectByBrush(shape, {
-    brushBounds,
-    isWrapping,
-    pageOutlineVertices: editor.getShapePageOutlineVertices(shape.id),
-    pageBounds: editor.getShapePageBounds(shape.id),
-  });
-}
-
-export function isBrushSelectableShapeId(editor: Editor, shapeId: ShapeId): boolean {
-  const shape = editor.getShape(shapeId);
-  if (!shape) {
-    return false;
-  }
-
-  return !editor.getShapeUtil(shape).shouldTransformDescendants(shape);
-}
-
-export function createResizingUpdates(
-  shapes: SelectionResizeShapeSnapshot[],
-  pointShapes: SelectionResizePointShapeSnapshot[],
-): ShapeUpdate[] {
-  return [
-    ...shapes.map((shape) => ({
-      id: shape.shape.id,
-      rotation: shape.rotation,
-    })),
-    ...pointShapes.map((shape) => ({ id: shape.shape.id })),
-  ];
-}
-
-export function createRotatingUpdates(
-  shapes: SelectionRotateShapeSnapshot[],
-  pointShapes: SelectionRotatePointShapeSnapshot[],
-): ShapeUpdate[] {
-  return [
-    ...shapes.map((shape) => ({
-      id: shape.id,
-      x: shape.x,
-      y: shape.y,
-      rotation: shape.rotation,
-    })),
-    ...pointShapes.map((shape) => ({ id: shape.shape.id })),
-  ];
-}