@yuzhouu/canvas-kit 0.1.2

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

@@ -0,0 +1,430 @@
+import { Box } from "../../geometry/Box";
+import { Vec } from "../../geometry/Vec";
+import type {
+  ShapeId,
+  ShapeParentId,
+  ShapeRecord,
+} from "../../schema/records";
+import type { Editor } from "../Editor";
+import { selectionPagePointToLocalPoint } from "../selection";
+import {
+  getBoxLocalOutline,
+  getBoxPagePoints,
+  getBoxSnapPoints,
+} from "./snapGeometry";
+import type {
+  HandleSnapContext,
+  HandleSnapOutline,
+  HandleSnapPoint,
+  HandleSnapSnapshot,
+  HandleSnapSnapshotInput,
+  ResizeSnapSnapshot,
+  SnapCoordinateSpace,
+  SnapNode,
+  SnapPoint,
+  TranslateSnapSnapshot,
+} from "./snapTypes";
+
+export class SnapSnapshotBuilder {
+  constructor(private readonly editor: Editor) {}
+
+  createTranslateSnapshot({
+    movingShapeIds,
+    coordinateSpace,
+  }: {
+    movingShapeIds: Iterable<ShapeId>;
+    coordinateSpace: SnapCoordinateSpace;
+  }): TranslateSnapSnapshot {
+    return this.createBoundsSnapSnapshot({
+      movingShapeIds,
+      coordinateSpace,
+    });
+  }
+
+  createResizeSnapshot({
+    resizingShapeIds,
+    coordinateSpace,
+  }: {
+    resizingShapeIds: Iterable<ShapeId>;
+    coordinateSpace: SnapCoordinateSpace;
+  }): ResizeSnapSnapshot {
+    return this.createBoundsSnapSnapshot({
+      movingShapeIds: resizingShapeIds,
+      coordinateSpace,
+    });
+  }
+
+  createHandleSnapshot({
+    context,
+    currentPagePoint,
+    allowSelfSnap = false,
+    excludedShapeIds = [],
+  }: HandleSnapSnapshotInput): HandleSnapSnapshot {
+    const currentShape = this.editor.getShape(context.shapeId);
+    const excludedIds = new Set(
+      this.editor.getShapeIdsIncludingDescendants([context.shapeId]),
+    );
+    this.collectBindingDrivenExcludedShapeIds([context.shapeId], excludedIds);
+    for (const shapeId of excludedShapeIds) {
+      excludedIds.add(shapeId);
+    }
+
+    const points: HandleSnapPoint[] = [];
+    const outlines: HandleSnapOutline[] = [];
+    const scopeParentId = this.getSnapScopeParentId([context.shapeId]);
+    const candidateShapeIds = this.getCandidateShapeIds({
+      excludedShapeIds: excludedIds,
+      scopeParentId,
+    });
+
+    if (currentShape && allowSelfSnap) {
+      this.collectSelfHandleSnapGeometry({
+        shape: currentShape,
+        context,
+        currentPagePoint,
+        points,
+        outlines,
+      });
+    }
+
+    for (const shapeId of candidateShapeIds) {
+      const shape = this.editor.getShape(shapeId);
+      if (!shape) {
+        continue;
+      }
+      this.collectHandleSnapGeometry({
+        shape,
+        points,
+        outlines,
+      });
+    }
+
+    return {
+      points,
+      outlines,
+      scopeParentId,
+      candidateShapeIds,
+    };
+  }
+
+  private collectHandleSnapGeometry({
+    shape,
+    points,
+    outlines,
+  }: {
+    shape: ShapeRecord;
+    points: HandleSnapPoint[];
+    outlines: HandleSnapOutline[];
+  }): void {
+    const util = this.editor.getShapeUtil(shape);
+    if (!util.canSnap(shape)) {
+      return;
+    }
+    const clippedBounds = this.editor.getShapeClippedPageBounds(shape.id);
+    if (!clippedBounds) {
+      return;
+    }
+
+    const transform = this.editor.computeShapeLocalToPageTransform(shape);
+    const geometry = util.getHandleSnapGeometry(shape);
+
+    for (const point of geometry.points ?? []) {
+      const pagePoint = transform.applyToPoint(point);
+      if (!this.editor.isPagePointInShapeClip(shape.id, pagePoint)) {
+        continue;
+      }
+      points.push({
+        id: `${shape.id}:point:${points.length}`,
+        nodeId: shape.id,
+        point: pagePoint,
+      });
+    }
+
+    const outline = geometry.outline;
+    if (outline === null) {
+      return;
+    }
+
+    const pageOutline =
+      this.editor.getShapeClipAncestorIds(shape.id).length > 0
+        ? getBoxPagePoints(clippedBounds)
+        : (outline ?? getBoxLocalOutline(util.getLocalBounds(shape))).map(
+            (point) => transform.applyToPoint(point),
+          );
+    if (pageOutline.length > 0) {
+      outlines.push({
+        id: shape.id,
+        points: pageOutline,
+      });
+    }
+  }
+
+  private collectSelfHandleSnapGeometry({
+    shape,
+    context,
+    currentPagePoint,
+    points,
+    outlines,
+  }: {
+    shape: ShapeRecord;
+    context: HandleSnapContext;
+    currentPagePoint: Vec;
+    points: HandleSnapPoint[];
+    outlines: HandleSnapOutline[];
+  }): void {
+    const util = this.editor.getShapeUtil(shape);
+    if (!util.canSnap(shape)) {
+      return;
+    }
+    const clippedBounds = this.editor.getShapeClippedPageBounds(shape.id);
+    if (!clippedBounds) {
+      return;
+    }
+
+    const geometry = util.getHandleSnapGeometry(shape);
+    const transform = this.editor.computeShapeLocalToPageTransform(shape);
+    const snapContext = {
+      ...context,
+      currentPagePoint: currentPagePoint.clone(),
+    };
+
+    for (const point of geometry.getSelfSnapPoints?.(snapContext) ?? []) {
+      const pagePoint = transform.applyToPoint(point);
+      if (!this.editor.isPagePointInShapeClip(shape.id, pagePoint)) {
+        continue;
+      }
+      points.push({
+        id: `${shape.id}:self-point:${points.length}`,
+        nodeId: shape.id,
+        point: pagePoint,
+      });
+    }
+
+    const selfOutline = geometry.getSelfSnapOutline?.(snapContext) ?? null;
+    if (!selfOutline) {
+      return;
+    }
+
+    const pageOutline =
+      this.editor.getShapeClipAncestorIds(shape.id).length > 0
+        ? getBoxPagePoints(clippedBounds)
+        : selfOutline.map((point) => transform.applyToPoint(point));
+    if (pageOutline.length > 0) {
+      outlines.push({
+        id: shape.id,
+        points: pageOutline,
+      });
+    }
+  }
+
+  private createBoundsSnapSnapshot({
+    movingShapeIds,
+    coordinateSpace,
+  }: {
+    movingShapeIds: Iterable<ShapeId>;
+    coordinateSpace: SnapCoordinateSpace;
+  }): TranslateSnapSnapshot {
+    const movingRootIds = Array.from(movingShapeIds);
+    const movingIds = new Set(
+      this.editor.getShapeIdsIncludingDescendants(movingRootIds),
+    );
+    this.collectBindingDrivenExcludedShapeIds(movingRootIds, movingIds);
+    const points: SnapPoint[] = [];
+    const nodes: SnapNode[] = [];
+    const transform = {
+      rotation: coordinateSpace.rotation,
+      rotationCenter: coordinateSpace.rotationCenter,
+    };
+    const scopeParentId = this.getSnapScopeParentId(movingRootIds);
+    const candidateShapeIds = this.getCandidateShapeIds({
+      excludedShapeIds: movingIds,
+      scopeParentId,
+    });
+
+    for (const shapeId of candidateShapeIds) {
+      const shape = this.editor.getShape(shapeId);
+      if (!shape) {
+        continue;
+      }
+      const util = this.editor.getShapeUtil(shape);
+      if (!util.canSnap(shape)) {
+        continue;
+      }
+      const clippedBounds = this.editor.getShapeClippedPageBounds(shape.id);
+      if (!clippedBounds) {
+        continue;
+      }
+      const hasClipAncestors =
+        this.editor.getShapeClipAncestorIds(shape.id).length > 0;
+      const pageOutline = hasClipAncestors
+        ? getBoxPagePoints(clippedBounds)
+        : this.editor.getShapePageOutlineVertices(shape.id);
+      const snapOutline = pageOutline.map((point) =>
+        coordinateSpace.rotation === 0
+          ? point.clone()
+          : selectionPagePointToLocalPoint(point, transform),
+      );
+      if (snapOutline.length === 0) {
+        continue;
+      }
+      const bounds = Box.FromPoints(snapOutline);
+      nodes.push({ id: shape.id, bounds });
+
+      const geometryPoints = util.getBoundsSnapGeometry(shape).points;
+      const snapPoints =
+        geometryPoints === undefined
+          ? getBoxSnapPoints(bounds)
+          : geometryPoints
+              .map((point) => {
+                const pagePoint = this.editor
+                  .computeShapeLocalToPageTransform(shape)
+                  .applyToPoint(point);
+                return this.editor.isPagePointInShapeClip(shape.id, pagePoint)
+                  ? pagePoint
+                  : null;
+              })
+              .filter((point): point is Vec => point !== null)
+              .map((pagePoint) =>
+                coordinateSpace.rotation === 0
+                  ? pagePoint
+                  : selectionPagePointToLocalPoint(pagePoint, transform),
+              );
+      snapPoints.forEach((point, index) => {
+        points.push({
+          id: `${shape.id}:${index}`,
+          nodeId: shape.id,
+          point,
+        });
+      });
+    }
+
+    const snapshot: TranslateSnapSnapshot = {
+      points,
+      nodes,
+      coordinateSpace: {
+        rotation: coordinateSpace.rotation,
+        rotationCenter: coordinateSpace.rotationCenter.clone(),
+      },
+      scopeParentId,
+      candidateShapeIds,
+    };
+    return snapshot;
+  }
+
+  private collectBindingDrivenExcludedShapeIds(
+    rootShapeIds: readonly ShapeId[],
+    excludedShapeIds: Set<ShapeId>,
+  ): void {
+    const expandedShapeIds = new Set<ShapeId>();
+    const pendingShapeIds = [...rootShapeIds];
+
+    while (pendingShapeIds.length > 0) {
+      const shapeId = pendingShapeIds.pop();
+      if (!shapeId || expandedShapeIds.has(shapeId)) {
+        continue;
+      }
+      expandedShapeIds.add(shapeId);
+
+      const shape = this.editor.getShape(shapeId);
+      if (!shape) {
+        continue;
+      }
+
+      for (const binding of this.editor.getBindingsForShape(shapeId)) {
+        const role =
+          binding.fromId === shapeId
+            ? "from"
+            : binding.toId === shapeId
+              ? "to"
+              : null;
+        if (!role) {
+          continue;
+        }
+
+        const dependentShapeIds =
+          this.editor
+            .getBindingUtil(binding)
+            .getGeometryDependentShapeIds?.(this.editor, binding as never, {
+              shape,
+              role,
+            }) ?? [];
+
+        for (const dependentShapeId of dependentShapeIds) {
+          for (const descendantId of this.editor.getShapeIdsIncludingDescendants(
+            [dependentShapeId],
+          )) {
+            if (excludedShapeIds.has(descendantId)) {
+              continue;
+            }
+            excludedShapeIds.add(descendantId);
+            pendingShapeIds.push(descendantId);
+          }
+        }
+      }
+    }
+  }
+
+  private getSnapScopeParentId(
+    shapeIds: readonly ShapeId[],
+  ): ShapeParentId | null {
+    let parentId: ShapeParentId | null = null;
+    for (const shapeId of shapeIds) {
+      const shape = this.editor.getShape(shapeId);
+      if (!shape) {
+        continue;
+      }
+      if (!parentId) {
+        parentId = shape.parentId;
+        continue;
+      }
+      if (shape.parentId !== parentId) {
+        return this.editor.getCurrentPageId();
+      }
+    }
+
+    return parentId ?? this.editor.getCurrentPageId();
+  }
+
+  private getCandidateShapeIds({
+    excludedShapeIds,
+    scopeParentId,
+  }: {
+    excludedShapeIds: ReadonlySet<ShapeId>;
+    scopeParentId: ShapeParentId | null;
+  }): ShapeId[] {
+    const pageId = this.editor.getCurrentPageId();
+    const viewportBounds = this.editor.renderViewportPageBoundsSignal.get();
+    const scopedIds = new Set<ShapeId>();
+
+    if (scopeParentId?.startsWith("shape:")) {
+      scopedIds.add(scopeParentId as ShapeId);
+    }
+
+    const childParentId = scopeParentId ?? pageId;
+    for (const childId of this.editor.getChildShapeIds(childParentId)) {
+      scopedIds.add(childId);
+    }
+
+    const candidateIds =
+      viewportBounds === null
+        ? Array.from(scopedIds)
+        : this.editor
+            .getShapeIdsInBounds(viewportBounds, { pageId })
+            .filter((shapeId) => scopedIds.has(shapeId));
+
+    return candidateIds.filter((shapeId) => {
+      if (excludedShapeIds.has(shapeId)) {
+        return false;
+      }
+      const shape = this.editor.getShape(shapeId);
+      if (!shape || shape.parentId !== childParentId) {
+        return shapeId === scopeParentId;
+      }
+      const clippedBounds = this.editor.getShapeClippedPageBounds(shapeId);
+      if (!clippedBounds) {
+        return false;
+      }
+      return viewportBounds ? clippedBounds.intersects(viewportBounds) : true;
+    });
+  }
+}