@yuzhouu/canvas-kit 0.1.2

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

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