@yuzhouu/canvas-kit 0.1.2 → 0.1.4

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

@@ -1,516 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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";