@yuzhouu/canvas-kit 0.1.2

package/_vendor/canvas-core/shapes/ShapeUtil.ts

@@ -0,0 +1,516 @@
+import { Box } from "../geometry/Box";
+import { Mat } from "../geometry/Mat";
+import { Vec } from "../geometry/Vec";
+import type { Editor } from "../editor/Editor";
+import type { ShapeUpdate } from "../editor/commands";
+import {
+  mirrorSelectionLocalPoint,
+  selectionLocalPointToPagePoint,
+  type SelectionMirrorAxis,
+} from "../editor/selection";
+import {
+  getAnchoredSelectionResizeLocalBounds,
+} from "../editor/resizeGeometry";
+import type {
+  SelectionArrowMiddleHandleAnchor,
+  SelectionArrowTerminalHandleAnchor,
+  SelectionCustomHandleAnchor,
+  SelectionHandle,
+  SelectionResizeHandleId,
+} from "../editor/selection";
+import type { ShapeId, ShapeRecordBase } from "../schema/records";
+
+export interface ShapeEditEndResult {
+  deleteShapeIds?: ShapeId[];
+}
+
+export interface ShapeBindingPointInput {
+  rawPagePoint: Vec;
+  oppositePagePoint: Vec;
+}
+
+export interface ShapeSelectionResizeInput {
+  handleId: SelectionResizeHandleId;
+  pageCenter: Vec;
+  selectionLocalBounds: Box;
+  scaleX: number;
+  scaleY: number;
+  isResizingFromCenter: boolean;
+  selectionRotation: number;
+  selectionRotationCenter: Vec;
+}
+
+export interface ShapeSelectionResizeAspectRatioLockInput {
+  editor: Editor;
+  handleId: SelectionResizeHandleId;
+  isOnlySelected: boolean;
+}
+
+export type ShapeSelectionFlipAxis = SelectionMirrorAxis;
+
+export interface ShapeSelectionFlipInput {
+  axis: ShapeSelectionFlipAxis;
+  selectionBounds: Box;
+  selectionLocalBounds: Box;
+  selectionRotation: number;
+  selectionRotationCenter: Vec;
+}
+
+export type ShapeSelectionPagePoints = readonly [Vec, Vec];
+
+export interface ShapeSelectionPagePointsInput {
+  pagePoints: ShapeSelectionPagePoints;
+}
+
+export interface ShapeBrushWrapInput {
+  brushBounds: Box;
+  pageOutlineVertices: readonly Vec[];
+  pageBounds: Box | null;
+}
+
+export interface ShapeBrushSelectInput extends ShapeBrushWrapInput {
+  isWrapping: boolean;
+}
+
+export interface ShapeLineSegmentHitTestInput {
+  pageStart: Vec;
+  pageEnd: Vec;
+  positionedStart: Vec;
+  positionedEnd: Vec;
+  margin: number;
+}
+
+export interface ShapeBoundsSnapGeometry {
+  // Returned points live in local shape space and are mapped by core.
+  points?: readonly Vec[];
+}
+
+export interface ShapeHandleSnapContext {
+  shapeId: ShapeId;
+  handle: SelectionHandle;
+  currentPagePoint: Vec;
+}
+
+export interface ShapeHandleSnapGeometry {
+  // Returned points/outlines live in local shape space and are mapped by core.
+  points?: readonly Vec[];
+  outline?: readonly Vec[] | null;
+  getSelfSnapPoints?(context: ShapeHandleSnapContext): readonly Vec[];
+  getSelfSnapOutline?(context: ShapeHandleSnapContext): readonly Vec[] | null;
+}
+
+export interface ShapeSelectionHandleAnchorInput {
+  isOnlySelected: boolean;
+  editor: Editor;
+}
+
+export interface ShapeSelectionFrameInput {
+  editor: Editor;
+}
+
+export interface ShapeSelectionTranslateInput {
+  editor: Editor;
+}
+
+export interface ShapeSelectionHandleAnchors {
+  terminalHandleAnchors: readonly SelectionArrowTerminalHandleAnchor[];
+  middleHandleAnchors: readonly SelectionArrowMiddleHandleAnchor[];
+  customHandleAnchors?: readonly SelectionCustomHandleAnchor[];
+}
+
+export interface ShapeSelectionOverlayInfo {
+  usesSelectionPathOverlay: boolean;
+  startPagePoint: Vec | null;
+  endPagePoint: Vec | null;
+  middlePagePoint: Vec | null;
+  path: string | null;
+}
+
+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),
+  ];
+}
+
+function getSegmentIntersectionParameter(
+  start: Vec,
+  end: Vec,
+  edgeStart: Vec,
+  edgeEnd: Vec,
+): number | null {
+  const segment = end.sub(start);
+  const edge = edgeEnd.sub(edgeStart);
+  const denominator = segment.x * edge.y - segment.y * edge.x;
+  if (Math.abs(denominator) < 1e-8) {
+    return null;
+  }
+
+  const delta = edgeStart.sub(start);
+  const t = (delta.x * edge.y - delta.y * edge.x) / denominator;
+  const u = (delta.x * segment.y - delta.y * segment.x) / denominator;
+
+  return t >= 0 && t <= 1 && u >= 0 && u <= 1 ? t : null;
+}
+
+function doesLineSegmentIntersectBox(start: Vec, end: Vec, bounds: Box): boolean {
+  if (bounds.containsPoint(start) || bounds.containsPoint(end)) {
+    return true;
+  }
+
+  const corners = getBoxCorners(bounds);
+  for (let index = 0; index < corners.length; index += 1) {
+    const edgeStart = corners[index];
+    const edgeEnd = corners[(index + 1) % corners.length];
+    if (
+      edgeStart &&
+      edgeEnd &&
+      getSegmentIntersectionParameter(start, end, edgeStart, edgeEnd) !== null
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function getValidatedDimension(
+  props: object,
+  key: "w" | "h",
+  fallback: number,
+): number {
+  const value = (props as Record<string, unknown>)[key];
+  return typeof value === "number" && Number.isFinite(value)
+    ? value
+    : fallback;
+}
+
+export abstract class ShapeUtil<S extends ShapeRecordBase = ShapeRecordBase> {
+  // Coordinate spaces:
+  // - local: shape-owned document truth, without shape.x / shape.y
+  // - positioned: local space translated by shape.x / shape.y, before rotation / scale
+  // - page: final rendered page space after rotation / scale
+  abstract readonly type: S["type"];
+
+  abstract getDefaultProps(): S["props"];
+
+  abstract validateProps(props: unknown): S["props"];
+
+  // Positioned bounds: local geometry translated by shape.x / shape.y.
+  abstract getBounds(shape: S): Box;
+
+  getLocalBounds(shape: S): Box {
+    const bounds = this.getBounds(shape);
+    return new Box(bounds.x - shape.x, bounds.y - shape.y, bounds.w, bounds.h);
+  }
+
+  // Render/export bounds stay in local space and are transformed by core later.
+  getRenderBounds(shape: S): Box {
+    return this.getLocalBounds(shape);
+  }
+
+  getExportBounds(shape: S): Box {
+    return this.getRenderBounds(shape);
+  }
+
+  getChildClipLocalBounds(_shape: S): Box | null {
+    return null;
+  }
+
+  getChildExportClipLocalBounds(shape: S): Box | null {
+    return this.getChildClipLocalBounds(shape);
+  }
+
+  getSelectionResizeLocalBounds(shape: S): Box {
+    return this.getLocalBounds(shape);
+  }
+
+  resizeSelectionBounds(
+    shape: S,
+    input: ShapeSelectionResizeInput,
+  ): ShapeUpdate {
+    const localBounds = this.getSelectionResizeLocalBounds(shape);
+    if (localBounds.x !== 0 || localBounds.y !== 0) {
+      throw new Error(
+        `Shape util "${this.type}" must implement resizeSelectionBounds for non-origin local bounds`,
+      );
+    }
+
+    const flipsSingleAxis =
+      (input.scaleX < 0) !== (input.scaleY < 0);
+    const nextRotation =
+      flipsSingleAxis
+        ? input.selectionRotation * 2 - shape.rotation
+        : shape.rotation;
+    const nextProps = this.validateProps({
+      ...shape.props,
+      w: input.selectionLocalBounds.w,
+      h: input.selectionLocalBounds.h,
+    });
+    const actualWidth = getValidatedDimension(
+      nextProps,
+      "w",
+      input.selectionLocalBounds.w,
+    );
+    const actualHeight = getValidatedDimension(
+      nextProps,
+      "h",
+      input.selectionLocalBounds.h,
+    );
+    const actualSelectionLocalBounds = getAnchoredSelectionResizeLocalBounds({
+      requestedBounds: input.selectionLocalBounds,
+      handleId: input.handleId,
+      actualWidth,
+      actualHeight,
+      scaleX: input.scaleX,
+      scaleY: input.scaleY,
+      isResizingFromCenter: input.isResizingFromCenter,
+    });
+    const pageCenter = selectionLocalPointToPagePoint(
+      actualSelectionLocalBounds.center,
+      {
+        rotation: input.selectionRotation,
+        rotationCenter: input.selectionRotationCenter,
+      },
+    );
+
+    return {
+      id: shape.id,
+      x: pageCenter.x - actualWidth / 2,
+      y: pageCenter.y - actualHeight / 2,
+      rotation: nextRotation,
+      scaleX: input.scaleX < 0 ? -shape.scaleX : shape.scaleX,
+      scaleY: input.scaleY < 0 ? -shape.scaleY : shape.scaleY,
+      props: nextProps as Record<string, unknown>,
+    };
+  }
+
+  getSelectionResizeAspectRatioLock(
+    _shape: S,
+    _input: ShapeSelectionResizeAspectRatioLockInput,
+  ): boolean | null {
+    return null;
+  }
+
+  flipSelectionBounds(
+    shape: S,
+    input: ShapeSelectionFlipInput,
+  ): ShapeUpdate {
+    const selectionPagePoints = this.getSelectionPagePoints(shape);
+    if (selectionPagePoints) {
+      const nextPagePoints = selectionPagePoints.map((point) => {
+        const localPoint =
+          input.selectionRotation === 0
+            ? point.clone()
+            : Vec.RotWith(
+                point,
+                input.selectionRotationCenter,
+                -input.selectionRotation,
+              );
+        const mirrored = mirrorSelectionLocalPoint({
+          axis: input.axis,
+          bounds: input.selectionBounds,
+          point: localPoint,
+        });
+        return input.selectionRotation === 0
+          ? mirrored
+          : Vec.RotWith(
+              mirrored,
+              input.selectionRotationCenter,
+              input.selectionRotation,
+            );
+      });
+
+      return this.updateSelectionPagePoints(shape, {
+        pagePoints: [nextPagePoints[0]!, nextPagePoints[1]!],
+      });
+    }
+
+    const localBounds = this.getSelectionResizeLocalBounds(shape);
+    const pageCenter =
+      input.selectionRotation === 0
+        ? input.selectionLocalBounds.center
+        : Vec.RotWith(
+            input.selectionLocalBounds.center,
+            input.selectionRotationCenter,
+            input.selectionRotation,
+          );
+
+    return {
+      id: shape.id,
+      x: pageCenter.x - localBounds.center.x,
+      y: pageCenter.y - localBounds.center.y,
+      rotation: input.selectionRotation * 2 - shape.rotation,
+      scaleX:
+        input.axis === "horizontal" ? -shape.scaleX : shape.scaleX,
+      scaleY: input.axis === "vertical" ? -shape.scaleY : shape.scaleY,
+    };
+  }
+
+  updateSelectionPagePoints(
+    shape: S,
+    _input: ShapeSelectionPagePointsInput,
+  ): ShapeUpdate {
+    throw new Error(
+      `Shape util "${this.type}" must implement updateSelectionPagePoints before selection can transform point-defined geometry`,
+    );
+  }
+
+  getSelectionPagePoints(_shape: S): ShapeSelectionPagePoints | null {
+    return null;
+  }
+
+  contributesToSelectionFrame(
+    _shape: S,
+    _input: ShapeSelectionFrameInput,
+  ): boolean {
+    return true;
+  }
+
+  canUseSelectionFrameHandles(
+    _shape: S,
+    _input: ShapeSelectionFrameInput,
+  ): boolean {
+    return true;
+  }
+
+  getSelectionTargetId(
+    shape: S,
+    _input: ShapeSelectionFrameInput,
+  ): ShapeId {
+    return shape.id;
+  }
+
+  getTranslateTargetId(
+    shape: S,
+    _input: ShapeSelectionTranslateInput,
+  ): ShapeId {
+    return shape.id;
+  }
+
+  shouldTransformDescendants(_shape: S): boolean {
+    return false;
+  }
+
+  shouldRotateDescendants(shape: S): boolean {
+    return this.shouldTransformDescendants(shape);
+  }
+
+  canStartTranslateFromSelectionBounds(_shape: S): boolean {
+    return true;
+  }
+
+  canSnap(_shape: S): boolean {
+    return true;
+  }
+
+  getBoundsSnapGeometry(_shape: S): ShapeBoundsSnapGeometry {
+    return {};
+  }
+
+  getHandleSnapGeometry(shape: S): ShapeHandleSnapGeometry {
+    return {
+      outline: getBoxCorners(this.getLocalBounds(shape)),
+    };
+  }
+
+  getPositionedOutlineVertices(shape: S): Vec[] {
+    const bounds = this.getBounds(shape);
+    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),
+    ];
+  }
+
+  getSelectionHandleAnchors(
+    _shape: S,
+    _input: ShapeSelectionHandleAnchorInput,
+  ): ShapeSelectionHandleAnchors {
+    return {
+      terminalHandleAnchors: [],
+      middleHandleAnchors: [],
+    };
+  }
+
+  getSelectionOverlayInfo(_shape: S): ShapeSelectionOverlayInfo {
+    return {
+      usesSelectionPathOverlay: false,
+      startPagePoint: null,
+      endPagePoint: null,
+      middlePagePoint: null,
+      path: null,
+    };
+  }
+
+  isWrappedByBrush(
+    _shape: S,
+    input: ShapeBrushWrapInput,
+  ): boolean {
+    if (input.pageOutlineVertices.length === 0) {
+      return input.pageBounds
+        ? input.brushBounds.containsBox(input.pageBounds)
+        : false;
+    }
+
+    return input.pageOutlineVertices.every((point) =>
+      input.brushBounds.containsPoint(point),
+    );
+  }
+
+  canSelectByBrush(
+    shape: S,
+    input: ShapeBrushSelectInput,
+  ): boolean {
+    return input.isWrapping ? this.isWrappedByBrush(shape, input) : true;
+  }
+
+  getLocalToPageTransform(shape: S): Mat {
+    const localBounds = this.getLocalBounds(shape);
+    const localCenter = localBounds.center;
+    return Mat.Translate(shape.x + localCenter.x, shape.y + localCenter.y)
+      .compose(Mat.Rotate(shape.rotation))
+      .compose(Mat.Scale(shape.scaleX, shape.scaleY))
+      .compose(Mat.Translate(-localCenter.x, -localCenter.y));
+  }
+
+  canEdit(_shape: S): boolean {
+    return false;
+  }
+
+  canReceiveChildren(_shape: S): boolean {
+    return false;
+  }
+
+  repairLoadedShape(_shape: S): S | null {
+    return null;
+  }
+
+  onEditEnd(_shape: S): ShapeEditEndResult | void {}
+
+  // Hit tests receive a positioned-space point (page space with rotation / scale removed).
+  hitTest(shape: S, positionedPoint: Vec): boolean {
+    return this.getBounds(shape).containsPoint(positionedPoint);
+  }
+
+  hitTestLineSegment(
+    shape: S,
+    input: ShapeLineSegmentHitTestInput,
+  ): boolean {
+    return doesLineSegmentIntersectBox(
+      input.positionedStart,
+      input.positionedEnd,
+      this.getBounds(shape).expand(input.margin),
+    );
+  }
+
+  resolveBindingPoint(
+    _shape: S,
+    input: ShapeBindingPointInput,
+  ): Vec {
+    return input.rawPagePoint;
+  }
+}

package/_vendor/canvas-core/shapes/ShapeUtilRegistry.ts

@@ -0,0 +1,26 @@
+import type { ShapeRecordBase } from "../schema/records";
+import { ShapeUtil } from "./ShapeUtil";
+
+export class ShapeUtilRegistry {
+  private readonly registry = new Map<string, ShapeUtil>();
+
+  register<S extends ShapeRecordBase>(util: ShapeUtil<S>): void {
+    this.registry.set(util.type, util as ShapeUtil);
+  }
+
+  has(type: ShapeRecordBase["type"]): boolean {
+    return this.registry.has(type);
+  }
+
+  values(): IterableIterator<ShapeUtil> {
+    return this.registry.values();
+  }
+
+  get<S extends ShapeRecordBase>(type: S["type"]): ShapeUtil<S> {
+    const util = this.registry.get(type);
+    if (!util) {
+      throw new Error(`Missing shape util for type \"${type}\"`);
+    }
+    return util as ShapeUtil<S>;
+  }
+}

package/_vendor/canvas-core/shapes/capabilities.ts

@@ -0,0 +1,67 @@
+import type { ShapeSvgExporterRegistry } from "../exports/svg";
+import type { ShapeRecordBase } from "../schema/records";
+import type { ShapeUtilRegistry } from "./ShapeUtilRegistry";
+
+export type ShapeCapabilitySupport = "supported" | "partial" | "missing";
+
+export interface ShapeCapabilityManifestEntry {
+  type: ShapeRecordBase["type"];
+  schemaProps: string[];
+  shapeUtil: ShapeCapabilitySupport;
+  reactRenderer: ShapeCapabilitySupport;
+  svgExporter: ShapeCapabilitySupport;
+  toolbarEntry: ShapeCapabilitySupport;
+  exportSupport: ShapeCapabilitySupport;
+  notes: string[];
+}
+
+export interface ShapeCapabilityManifest {
+  entries: ShapeCapabilityManifestEntry[];
+  supportedExportTypes: ShapeRecordBase["type"][];
+  missingExporterTypes: ShapeRecordBase["type"][];
+}
+
+export type ShapeCapabilityDefinition = Omit<
+  ShapeCapabilityManifestEntry,
+  "shapeUtil" | "svgExporter" | "exportSupport"
+>;
+
+export function getShapeCapabilityManifest({
+  definitions,
+  exporters,
+  shapeUtils,
+}: {
+  definitions: readonly ShapeCapabilityDefinition[];
+  exporters: ShapeSvgExporterRegistry;
+  shapeUtils: ShapeUtilRegistry;
+}): ShapeCapabilityManifest {
+  const entries = definitions.map((entry) => {
+    const shapeUtil: ShapeCapabilitySupport = shapeUtils.has(entry.type)
+      ? "supported"
+      : "missing";
+    const svgExporter: ShapeCapabilitySupport = exporters.has(entry.type)
+      ? "supported"
+      : "missing";
+    const exportSupport: ShapeCapabilitySupport =
+      shapeUtil === "supported" && svgExporter === "supported"
+        ? "supported"
+        : "missing";
+
+    return {
+      ...entry,
+      shapeUtil,
+      svgExporter,
+      exportSupport,
+    };
+  });
+
+  return {
+    entries,
+    supportedExportTypes: entries
+      .filter((entry) => entry.exportSupport === "supported")
+      .map((entry) => entry.type),
+    missingExporterTypes: entries
+      .filter((entry) => entry.svgExporter !== "supported")
+      .map((entry) => entry.type),
+  };
+}

package/_vendor/canvas-core/shapes/types.ts

@@ -0,0 +1,20 @@
+export type {
+  BindingId,
+  BindingRecord,
+  PageRecord,
+  PageId,
+  EditorRecord,
+  ShapeRecord,
+  ShapeId,
+  SessionRecord,
+} from "../schema/records";
+export {
+  DEFAULT_PAGE_ID,
+  DEFAULT_SESSION_ID,
+  createDefaultPage,
+  createDefaultSession,
+  isBindingRecord,
+  isPageRecord,
+  isShapeRecord,
+  isSessionRecord,
+} from "../schema/records";