@yuzhouu/canvas-kit 0.1.2 → 0.1.4

package/_vendor/canvas-core/editor/managers/QueryManager.ts

@@ -1,837 +0,0 @@
-import { atom, computed, type Atom, type Signal } from "@land/signals";
-import type { StoreChange } from "@land/store";
-import { Box } from "../../geometry/Box";
-import { Mat } from "../../geometry/Mat";
-import { Vec } from "../../geometry/Vec";
-import {
-  type BindingId,
-  type BindingRecord,
-  type EditorRecord,
-  type PageId,
-  type ShapeId,
-  type ShapeParentId,
-  type ShapeRecord,
-} from "../../schema/records";
-import type { Editor } from "../Editor";
-import { getEditorStore } from "../internal";
-import {
-  getShapeGeometry,
-  getShapePositionedToPageTransform,
-  type ShapeGeometry,
-} from "../queries/shapeTransforms";
-import {
-  areShapeIdArraysEqual,
-  buildQueryState,
-  compareBindings,
-  getRemovedShapeIdsFromQueryStateChange,
-  type QueryState,
-  updateQueryStateFromStoreChange,
-} from "./queryState";
-import {
-  createSelectionGeometrySignals,
-  type SelectionGeometrySnapshot,
-} from "./selectionGeometry";
-
-interface ShapeQuerySignals {
-  bounds: Signal<Box | undefined>;
-  geometry: Signal<ShapeGeometry | undefined>;
-  positionedToPageTransform: Signal<Mat | undefined>;
-  pageBounds: Signal<Box | undefined>;
-  clipAncestorIds: Signal<ShapeId[]>;
-}
-
-export type ShapeContainment = "inside" | "intersecting" | "outside";
-
-function areBoxesEqual(
-  a: Box | undefined | null,
-  b: Box | undefined | null,
-): boolean {
-  if (a === b) return true;
-  if (!a || !b) return a === b;
-  return a.x === b.x && a.y === b.y && a.w === b.w && a.h === b.h;
-}
-
-function areVecsEqual(a: Vec | undefined | null, b: Vec | undefined | null) {
-  if (a === b) return true;
-  if (!a || !b) return a === b;
-  return a.x === b.x && a.y === b.y;
-}
-
-function areVecArraysEqual(a: Vec[], b: Vec[]): boolean {
-  if (a === b) return true;
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i += 1) {
-    const left = a[i];
-    const right = b[i];
-    if (!left || !right || !areVecsEqual(left, right)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-function areMatsEqual(a: Mat | undefined, b: Mat | undefined): boolean {
-  if (a === b) return true;
-  if (!a || !b) return a === b;
-  return (
-    a.a === b.a &&
-    a.b === b.b &&
-    a.c === b.c &&
-    a.d === b.d &&
-    a.e === b.e &&
-    a.f === b.f
-  );
-}
-
-function areShapeGeometriesEqual(
-  a: ShapeGeometry | undefined,
-  b: ShapeGeometry | undefined,
-): boolean {
-  if (a === b) return true;
-  if (!a || !b) return a === b;
-  return (
-    areBoxesEqual(a.bounds, b.bounds) &&
-    areVecsEqual(a.center, b.center) &&
-    areVecArraysEqual(a.corners, b.corners) &&
-    areVecArraysEqual(a.outlineVertices, b.outlineVertices)
-  );
-}
-
-function cloneBox(box: Box | undefined | null): Box | undefined | null {
-  return box ? box.clone() : box;
-}
-
-function cloneVec(vec: Vec | undefined | null): Vec | undefined | null {
-  return vec ? vec.clone() : vec;
-}
-
-function cloneVecArray(points: Vec[] | undefined): Vec[] | undefined {
-  return points?.map((point) => point.clone());
-}
-
-function cloneMat(transform: Mat | undefined): Mat | undefined {
-  return transform
-    ? new Mat(
-        transform.a,
-        transform.b,
-        transform.c,
-        transform.d,
-        transform.e,
-        transform.f,
-      )
-    : undefined;
-}
-
-function cloneShapeGeometry(
-  geometry: ShapeGeometry | undefined,
-): ShapeGeometry | undefined {
-  if (!geometry) {
-    return undefined;
-  }
-
-  return {
-    bounds: geometry.bounds.clone(),
-    center: geometry.center.clone(),
-    corners: geometry.corners.map((point) => point.clone()),
-    outlineVertices: geometry.outlineVertices.map((point) => point.clone()),
-  };
-}
-
-function unionBoxes(boxes: readonly Box[]): Box | null {
-  if (boxes.length === 0) {
-    return null;
-  }
-
-  let minX = Infinity;
-  let minY = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  for (const box of boxes) {
-    minX = Math.min(minX, box.minX);
-    minY = Math.min(minY, box.minY);
-    maxX = Math.max(maxX, box.maxX);
-    maxY = Math.max(maxY, box.maxY);
-  }
-
-  return new Box(minX, minY, maxX - minX, maxY - minY);
-}
-
-function isValidBox(box: Box): boolean {
-  return (
-    Number.isFinite(box.x) &&
-    Number.isFinite(box.y) &&
-    Number.isFinite(box.w) &&
-    Number.isFinite(box.h) &&
-    box.w >= 0 &&
-    box.h >= 0
-  );
-}
-
-function transformBox(bounds: Box, transform: Mat): Box {
-  return Box.FromPoints(
-    [
-      new Vec(bounds.minX, bounds.minY),
-      new Vec(bounds.maxX, bounds.minY),
-      new Vec(bounds.maxX, bounds.maxY),
-      new Vec(bounds.minX, bounds.maxY),
-    ].map((point) => transform.applyToPoint(point)),
-  );
-}
-
-function intersectBoxes(a: Box, b: Box): Box | null {
-  const minX = Math.max(a.minX, b.minX);
-  const minY = Math.max(a.minY, b.minY);
-  const maxX = Math.min(a.maxX, b.maxX);
-  const maxY = Math.min(a.maxY, b.maxY);
-  if (maxX < minX || maxY < minY) {
-    return null;
-  }
-  return new Box(minX, minY, maxX - minX, maxY - minY);
-}
-
-export class QueryManager {
-  readonly stateSignal: Signal<QueryState>;
-  readonly currentPageShapeIdsSignal: Signal<ShapeId[]>;
-  readonly currentPageShapesSignal: Signal<ShapeRecord[]>;
-  readonly selectionGeometrySignal: Signal<SelectionGeometrySnapshot>;
-  readonly selectionPageOutlineVerticesSignal: Signal<Vec[]>;
-  readonly selectionPageBoundsSignal: Signal<Box | null>;
-  readonly selectionFrameBoundsSignal: Signal<Box | null>;
-  readonly selectionHasRotationSignal: Signal<boolean>;
-  readonly selectionRotationSignal: Signal<number>;
-  readonly selectionRotationCenterSignal: Signal<Vec | null>;
-  readonly selectionHasCompatibleRotationSignal: Signal<boolean>;
-  readonly selectionToolbarAnchorPagePointSignal: Signal<Vec | null>;
-
-  private readonly stateAtom: Atom<QueryState>;
-  private readonly shapeQuerySignals = new Map<ShapeId, ShapeQuerySignals>();
-
-  constructor(private readonly editor: Editor) {
-    const store = getEditorStore(this.editor);
-    this.stateAtom = atom<QueryState>(
-      "editor.query.state",
-      buildQueryState(Array.from(store.recordsSignal.get().values())),
-    );
-    this.stateSignal = this.stateAtom;
-    store.listen((change) => {
-      this.handleStoreChange(change);
-    });
-
-    this.currentPageShapeIdsSignal = computed<ShapeId[]>(
-      "editor.query.currentPageShapeIds",
-      () => this.getShapeIdsForPageSnapshot(this.editor.getCurrentPageId()),
-      { isEqual: areShapeIdArraysEqual },
-    );
-
-    this.currentPageShapesSignal = computed<ShapeRecord[]>(
-      "editor.query.currentPageShapes",
-      () =>
-        this.currentPageShapeIdsSignal
-          .get()
-          .map((id) => this.editor.getShapeSignal(id).get())
-          .filter((shape): shape is ShapeRecord => !!shape),
-    );
-
-    const selectionGeometrySignals = createSelectionGeometrySignals(
-      this.editor,
-      (shapeId) => this.getShapeGeometrySnapshot(shapeId),
-    );
-    this.selectionGeometrySignal = selectionGeometrySignals.geometry;
-    this.selectionPageOutlineVerticesSignal =
-      selectionGeometrySignals.pageOutlineVertices;
-    this.selectionPageBoundsSignal = selectionGeometrySignals.pageBounds;
-    this.selectionFrameBoundsSignal = selectionGeometrySignals.frameBounds;
-    this.selectionRotationSignal = selectionGeometrySignals.rotation;
-    this.selectionHasRotationSignal = selectionGeometrySignals.hasRotation;
-    this.selectionRotationCenterSignal =
-      selectionGeometrySignals.rotationCenter;
-    this.selectionHasCompatibleRotationSignal =
-      selectionGeometrySignals.hasCompatibleRotation;
-    this.selectionToolbarAnchorPagePointSignal =
-      selectionGeometrySignals.toolbarAnchorPagePoint;
-  }
-
-  getShapeIdsForPage(pageId: PageId): ShapeId[] {
-    return [...this.getShapeIdsForPageSnapshot(pageId)];
-  }
-
-  getShapesForPage(pageId: PageId): ShapeRecord[] {
-    return this.getShapeIdsForPageSnapshot(pageId)
-      .map((id) => this.editor.getShape(id))
-      .filter((shape): shape is ShapeRecord => !!shape);
-  }
-
-  getChildShapeIds(parentId: ShapeParentId): ShapeId[] {
-    return [...this.getChildShapeIdsSnapshot(parentId)];
-  }
-
-  getChildShapes(parentId: ShapeParentId): ShapeRecord[] {
-    return this.getChildShapeIdsSnapshot(parentId)
-      .map((id) => this.editor.getShape(id))
-      .filter((shape): shape is ShapeRecord => !!shape);
-  }
-
-  getDescendantShapeIds(parentId: ShapeParentId): ShapeId[] {
-    const descendantIds: ShapeId[] = [];
-    const visit = (currentParentId: ShapeParentId) => {
-      for (const childId of this.getChildShapeIdsSnapshot(currentParentId)) {
-        descendantIds.push(childId);
-        visit(childId);
-      }
-    };
-
-    visit(parentId);
-    return descendantIds;
-  }
-
-  getPageIdForShape(shapeId: ShapeId): PageId | null {
-    return this.stateSignal.get().pageIdByShape.get(shapeId) ?? null;
-  }
-
-  getPageIdForShapeParent(parentId: ShapeParentId): PageId | null {
-    if (parentId.startsWith("page:")) {
-      return this.editor.getPage(parentId as PageId) ? (parentId as PageId) : null;
-    }
-
-    return this.getPageIdForShape(parentId as ShapeId);
-  }
-
-  getDescendantPageBounds(parentId: ShapeParentId): Box | null {
-    const bounds: Box[] = [];
-    for (const descendantId of this.getDescendantShapeIds(parentId)) {
-      const descendantBounds = this.getShapePageBounds(descendantId);
-      if (descendantBounds) {
-        bounds.push(descendantBounds);
-      }
-    }
-
-    return unionBoxes(bounds);
-  }
-
-  getShapeSubtreePageBounds(shapeId: ShapeId): Box | null {
-    const bounds: Box[] = [];
-    const shapeBounds = this.getShapePageBounds(shapeId);
-    if (shapeBounds) {
-      bounds.push(shapeBounds);
-    }
-
-    for (const descendantId of this.getDescendantShapeIds(shapeId)) {
-      const descendantBounds = this.getShapePageBounds(descendantId);
-      if (descendantBounds) {
-        bounds.push(descendantBounds);
-      }
-    }
-
-    return unionBoxes(bounds);
-  }
-
-  getShapeContainment(
-    containerId: ShapeId,
-    shapeId: ShapeId,
-  ): ShapeContainment | null {
-    const container = this.editor.getShape(containerId);
-    if (!container) {
-      return null;
-    }
-
-    const containerGeometry = this.getShapeGeometrySnapshot(containerId);
-    const shapeGeometry = this.getShapeGeometrySnapshot(shapeId);
-    if (!containerGeometry || !shapeGeometry) {
-      return null;
-    }
-
-    const containerUtil = this.editor.getShapeUtil(container);
-    const containerLocalBounds = containerUtil.getLocalBounds(container);
-    const pageToContainerLocal =
-      containerUtil.getLocalToPageTransform(container).invert();
-
-    const isInside =
-      shapeGeometry.outlineVertices.length > 0 &&
-      shapeGeometry.outlineVertices.every((point) =>
-        containerLocalBounds.containsPoint(
-          pageToContainerLocal.applyToPoint(point),
-        ),
-      );
-    if (isInside) {
-      return "inside";
-    }
-
-    return containerGeometry.bounds.intersects(shapeGeometry.bounds)
-      ? "intersecting"
-      : "outside";
-  }
-
-  getContainingShapeParentId(
-    shapeIds: Iterable<ShapeId>,
-  ): ShapeParentId | null {
-    const selectedIds = Array.from(new Set(shapeIds));
-    if (selectedIds.length === 0) {
-      return null;
-    }
-
-    const selectedShapes = selectedIds
-      .map((id) => this.editor.getShape(id))
-      .filter((shape): shape is ShapeRecord => !!shape);
-    if (selectedShapes.length !== selectedIds.length) {
-      return null;
-    }
-
-    const pageId = this.getPageIdForShape(selectedShapes[0]!.id);
-    if (!pageId) {
-      return null;
-    }
-
-    if (
-      selectedShapes.some((shape) => this.getPageIdForShape(shape.id) !== pageId)
-    ) {
-      return null;
-    }
-
-    const blockedParentIds = new Set<ShapeId>();
-    for (const shape of selectedShapes) {
-      blockedParentIds.add(shape.id);
-      for (const descendantId of this.getDescendantShapeIds(shape.id)) {
-        blockedParentIds.add(descendantId);
-      }
-    }
-
-    let bestShape: ShapeRecord | null = null;
-    let bestArea = Infinity;
-    let bestPageIndex = -1;
-    const pageShapeIds =
-      this.stateSignal.get().pageShapeIdsByPage.get(pageId) ?? [];
-    for (let pageIndex = 0; pageIndex < pageShapeIds.length; pageIndex += 1) {
-      const candidateId = pageShapeIds[pageIndex]!;
-      if (blockedParentIds.has(candidateId)) {
-        continue;
-      }
-
-      const candidate = this.editor.getShape(candidateId);
-      if (!candidate) {
-        continue;
-      }
-
-      const candidateUtil = this.editor.getShapeUtil(candidate);
-      if (!canUseAutomaticContainment(candidate, candidateUtil)) {
-        continue;
-      }
-
-      const canReceiveAll = selectedShapes.every((shape) =>
-        this.editor.canUseShapeParent(candidate.id, shape.id),
-      );
-      if (!canReceiveAll) {
-        continue;
-      }
-
-      const containsAll = selectedShapes.every(
-        (shape) => this.getShapeContainment(candidate.id, shape.id) === "inside",
-      );
-      if (!containsAll) {
-        continue;
-      }
-
-      const candidateBounds = this.getShapePageBounds(candidate.id);
-      if (!candidateBounds) {
-        continue;
-      }
-
-      const area = candidateBounds.w * candidateBounds.h;
-      if (
-        !bestShape ||
-        area < bestArea ||
-        (area === bestArea && pageIndex > bestPageIndex)
-      ) {
-        bestShape = candidate;
-        bestArea = area;
-        bestPageIndex = pageIndex;
-      }
-    }
-
-    return bestShape?.id ?? pageId;
-  }
-
-  getContainingParentIdForShapeRecord(shape: ShapeRecord): ShapeParentId | null {
-    const pageId = this.getPageIdForShapeParent(shape.parentId);
-    if (!pageId) {
-      return null;
-    }
-
-    const shapeGeometry = getShapeGeometry(shape, this.editor.getShapeUtil(shape));
-    let bestShape: ShapeRecord | null = null;
-    let bestArea = Infinity;
-    let bestPageIndex = -1;
-    const pageShapeIds =
-      this.stateSignal.get().pageShapeIdsByPage.get(pageId) ?? [];
-
-    for (let pageIndex = 0; pageIndex < pageShapeIds.length; pageIndex += 1) {
-      const candidate = this.editor.getShape(pageShapeIds[pageIndex]!);
-      if (!candidate || candidate.id === shape.id) {
-        continue;
-      }
-
-      const candidateUtil = this.editor.getShapeUtil(candidate);
-      if (!canUseAutomaticContainment(candidate, candidateUtil)) {
-        continue;
-      }
-      if (!this.editor.canUseShapeParent(candidate.id, shape.id)) {
-        continue;
-      }
-
-      const candidateBounds = this.getShapePageBounds(candidate.id);
-      if (!candidateBounds) {
-        continue;
-      }
-
-      const candidateLocalBounds = candidateUtil.getLocalBounds(candidate);
-      const pageToCandidateLocal =
-        candidateUtil.getLocalToPageTransform(candidate).invert();
-      const containsShape =
-        shapeGeometry.outlineVertices.length > 0 &&
-        shapeGeometry.outlineVertices.every((point) =>
-          candidateLocalBounds.containsPoint(
-            pageToCandidateLocal.applyToPoint(point),
-          ),
-        );
-      if (!containsShape) {
-        continue;
-      }
-
-      const area = candidateBounds.w * candidateBounds.h;
-      if (
-        !bestShape ||
-        area < bestArea ||
-        (area === bestArea && pageIndex > bestPageIndex)
-      ) {
-        bestShape = candidate;
-        bestArea = area;
-        bestPageIndex = pageIndex;
-      }
-    }
-
-    return bestShape?.id ?? pageId;
-  }
-
-  getShapeClipAncestorIds(shapeId: ShapeId): ShapeId[] {
-    return [...this.getShapeClipAncestorIdsSignal(shapeId).get()];
-  }
-
-  getShapeClipAncestorIdsSignal(shapeId: ShapeId): Signal<ShapeId[]> {
-    return this.getShapeQuerySignals(shapeId).clipAncestorIds;
-  }
-
-  isPagePointInShapeClip(shapeId: ShapeId, point: Vec): boolean {
-    const shape = this.editor.getShape(shapeId);
-    if (!shape) {
-      return false;
-    }
-
-    for (const ancestor of this.getShapeClipAncestorsForShape(
-      shape,
-      (id) => this.editor.getShape(id),
-    )) {
-      const util = this.editor.getShapeUtil(ancestor);
-      const clipBounds = util.getChildClipLocalBounds(ancestor);
-      if (!clipBounds || !isValidBox(clipBounds)) {
-        continue;
-      }
-
-      const localPoint = util
-        .getLocalToPageTransform(ancestor)
-        .invert()
-        .applyToPoint(point);
-      if (!clipBounds.containsPoint(localPoint)) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  getShapeClippedPageBounds(shapeId: ShapeId): Box | null {
-    let bounds = this.getShapePageBounds(shapeId);
-    if (!bounds) {
-      return null;
-    }
-
-    for (const ancestor of this.getShapeClipAncestors(shapeId)) {
-      const clipBounds = this.getShapeChildClipPageBounds(ancestor);
-      if (!clipBounds) {
-        continue;
-      }
-
-      const nextBounds = intersectBoxes(bounds, clipBounds);
-      if (!nextBounds) {
-        return null;
-      }
-      bounds = nextBounds;
-    }
-
-    return bounds;
-  }
-
-  private getShapeClipAncestors(shapeId: ShapeId): ShapeRecord[] {
-    const shape = this.editor.getShape(shapeId);
-    return shape
-      ? this.getShapeClipAncestorsForShape(shape, (id) =>
-          this.editor.getShape(id),
-        )
-      : [];
-  }
-
-  private getShapeClipAncestorsForShape(
-    shape: ShapeRecord,
-    getShape: (id: ShapeId) => ShapeRecord | undefined,
-  ): ShapeRecord[] {
-    const ancestors: ShapeRecord[] = [];
-    const seen = new Set<ShapeId>();
-    let parentId = shape.parentId;
-
-    while (parentId.startsWith("shape:")) {
-      const ancestorId = parentId as ShapeId;
-      if (seen.has(ancestorId)) {
-        break;
-      }
-      seen.add(ancestorId);
-
-      const ancestor = getShape(ancestorId);
-      if (!ancestor) {
-        break;
-      }
-
-      const clipBounds = this.editor
-        .getShapeUtil(ancestor)
-        .getChildClipLocalBounds(ancestor);
-      if (clipBounds && isValidBox(clipBounds)) {
-        ancestors.push(ancestor);
-      }
-      parentId = ancestor.parentId;
-    }
-
-    return ancestors.reverse();
-  }
-
-  private getShapeChildClipPageBounds(shape: ShapeRecord): Box | null {
-    const util = this.editor.getShapeUtil(shape);
-    const clipBounds = util.getChildClipLocalBounds(shape);
-    if (!clipBounds || !isValidBox(clipBounds)) {
-      return null;
-    }
-
-    return transformBox(clipBounds, util.getLocalToPageTransform(shape));
-  }
-
-  private getShapeIdsForPageSnapshot(pageId: PageId): ShapeId[] {
-    return this.stateSignal.get().pageShapeIdsByPage.get(pageId) ?? [];
-  }
-
-  private getChildShapeIdsSnapshot(parentId: ShapeParentId): ShapeId[] {
-    return this.stateSignal.get().childShapeIdsByParent.get(parentId) ?? [];
-  }
-
-  private handleStoreChange(change: StoreChange<EditorRecord>): void {
-    for (const shapeId of getRemovedShapeIdsFromQueryStateChange(change)) {
-      this.shapeQuerySignals.delete(shapeId);
-    }
-
-    const store = getEditorStore(this.editor);
-    this.stateAtom.update((previous) => {
-      return updateQueryStateFromStoreChange(previous, change, (id) =>
-        store.get(id),
-      );
-    });
-  }
-
-  private getShapeQuerySignals(shapeId: ShapeId): ShapeQuerySignals {
-    let signals = this.shapeQuerySignals.get(shapeId);
-    if (!signals) {
-      const bounds = computed<Box | undefined>(
-        `editor.query.shapeBounds.${shapeId}`,
-        () => {
-          const shape = this.editor.getShapeSignal(shapeId).get();
-          if (!shape) {
-            return undefined;
-          }
-
-          return this.editor.getShapeUtil(shape).getBounds(shape);
-        },
-        { isEqual: areBoxesEqual },
-      );
-      const geometry = computed<ShapeGeometry | undefined>(
-        `editor.query.shapeGeometry.${shapeId}`,
-        () => {
-          const shape = this.editor.getShapeSignal(shapeId).get();
-          if (!shape) {
-            return undefined;
-          }
-
-          return getShapeGeometry(shape, this.editor.getShapeUtil(shape));
-        },
-        { isEqual: areShapeGeometriesEqual },
-      );
-      const positionedToPageTransform = computed<Mat | undefined>(
-        `editor.query.shapePositionedToPageTransform.${shapeId}`,
-        () => {
-          const shape = this.editor.getShapeSignal(shapeId).get();
-          if (!shape) {
-            return undefined;
-          }
-
-          return getShapePositionedToPageTransform(
-            shape,
-            this.editor.getShapeUtil(shape),
-          );
-        },
-        { isEqual: areMatsEqual },
-      );
-      const pageBounds = computed<Box | undefined>(
-        `editor.query.shapePageBounds.${shapeId}`,
-        () => geometry.get()?.bounds,
-        { isEqual: areBoxesEqual },
-      );
-      const clipAncestorIds = computed<ShapeId[]>(
-        `editor.query.shapeClipAncestorIds.${shapeId}`,
-        () => {
-          const shape = this.editor.getShapeSignal(shapeId).get();
-          if (!shape) {
-            return [];
-          }
-
-          return this.getShapeClipAncestorsForShape(shape, (id) =>
-            this.editor.getShapeSignal(id).get(),
-          ).map((ancestor) => ancestor.id);
-        },
-        { isEqual: areShapeIdArraysEqual },
-      );
-
-      signals = {
-        bounds,
-        geometry,
-        positionedToPageTransform,
-        pageBounds,
-        clipAncestorIds,
-      };
-      this.shapeQuerySignals.set(shapeId, signals);
-    }
-
-    return signals;
-  }
-
-  private getShapeGeometrySnapshot(shapeId: ShapeId): ShapeGeometry | undefined {
-    return this.getShapeQuerySignals(shapeId).geometry.get();
-  }
-
-  getShapePageBoundsSignal(shapeId: ShapeId): Signal<Box | undefined> {
-    return this.getShapeQuerySignals(shapeId).pageBounds;
-  }
-
-  getShapeGeometry(shapeId: ShapeId): ShapeGeometry | undefined {
-    return cloneShapeGeometry(this.getShapeGeometrySnapshot(shapeId));
-  }
-
-  getShapePositionedToPageTransform(shapeId: ShapeId): Mat | undefined {
-    return cloneMat(
-      this.getShapeQuerySignals(shapeId).positionedToPageTransform.get(),
-    );
-  }
-
-  getShapePageBounds(shapeId: ShapeId): Box | undefined {
-    return cloneBox(this.getShapePageBoundsSignal(shapeId).get()) ?? undefined;
-  }
-
-  getShapeBounds(shapeId: ShapeId): Box | undefined {
-    return cloneBox(this.getShapeQuerySignals(shapeId).bounds.get()) ?? undefined;
-  }
-
-  getShapePageCenter(shapeId: ShapeId): Vec | undefined {
-    return cloneVec(this.getShapeGeometrySnapshot(shapeId)?.center) ?? undefined;
-  }
-
-  getShapePageCorners(shapeId: ShapeId): Vec[] | undefined {
-    return cloneVecArray(this.getShapeGeometrySnapshot(shapeId)?.corners);
-  }
-
-  getShapePageOutlineVertices(shapeId: ShapeId): Vec[] | undefined {
-    return cloneVecArray(
-      this.getShapeGeometrySnapshot(shapeId)?.outlineVertices,
-    );
-  }
-
-  getSelectionPageOutlineVertices(): Vec[] {
-    return cloneVecArray(this.selectionPageOutlineVerticesSignal.get()) ?? [];
-  }
-
-  getSelectionPageBounds(): Box | null {
-    return cloneBox(this.selectionPageBoundsSignal.get()) ?? null;
-  }
-
-  getSelectionFrameBounds(): Box | null {
-    return cloneBox(this.selectionFrameBoundsSignal.get()) ?? null;
-  }
-
-  getSelectionRotation(): number {
-    return this.selectionRotationSignal.get();
-  }
-
-  getSelectionHasRotation(): boolean {
-    return this.selectionHasRotationSignal.get();
-  }
-
-  getSelectionRotationCenter(): Vec | null {
-    return cloneVec(this.selectionRotationCenterSignal.get()) ?? null;
-  }
-
-  getSelectionHasCompatibleRotation(): boolean {
-    return this.selectionHasCompatibleRotationSignal.get();
-  }
-
-  getSelectionToolbarAnchorPagePoint(): Vec | null {
-    return cloneVec(this.selectionToolbarAnchorPagePointSignal.get()) ?? null;
-  }
-
-  getBinding(id: BindingId): BindingRecord | undefined {
-    return this.stateSignal.get().bindingById.get(id);
-  }
-
-  getBindings(): BindingRecord[] {
-    return Array.from(this.stateSignal.get().bindingById.values()).sort(
-      compareBindings,
-    );
-  }
-
-  getBindingIdsFromShape(shapeId: ShapeId): BindingId[] {
-    return this.stateSignal.get().bindingIdsByFromShape.get(shapeId) ?? [];
-  }
-
-  getBindingIdsToShape(shapeId: ShapeId): BindingId[] {
-    return this.stateSignal.get().bindingIdsByToShape.get(shapeId) ?? [];
-  }
-
-  getBindingIdsForShape(shapeId: ShapeId): BindingId[] {
-    return this.stateSignal.get().relatedBindingIdsByShape.get(shapeId) ?? [];
-  }
-
-  getBindingsFromShape(shapeId: ShapeId): BindingRecord[] {
-    return this.getBindingIdsFromShape(shapeId)
-      .map((id) => this.getBinding(id))
-      .filter((binding): binding is BindingRecord => !!binding);
-  }
-
-  getBindingsToShape(shapeId: ShapeId): BindingRecord[] {
-    return this.getBindingIdsToShape(shapeId)
-      .map((id) => this.getBinding(id))
-      .filter((binding): binding is BindingRecord => !!binding);
-  }
-
-  getBindingsForShape(shapeId: ShapeId): BindingRecord[] {
-    return this.getBindingIdsForShape(shapeId)
-      .map((id) => this.getBinding(id))
-      .filter((binding): binding is BindingRecord => !!binding);
-  }
-}
-
-function canUseAutomaticContainment(
-  shape: ShapeRecord,
-  util: ReturnType<Editor["getShapeUtil"]>,
-): boolean {
-  return util.canReceiveChildren(shape) && !util.shouldTransformDescendants(shape);
-}