@yuzhouu/canvas-kit 0.1.2 → 0.1.4

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

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