@yuzhouu/canvas-kit 0.1.2

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

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