@yuzhouu/canvas-kit 0.1.2

package/_vendor/canvas-core/editor/edgeScroll.ts

@@ -0,0 +1,37 @@
+import { Vec } from "../geometry/Vec";
+
+const EDGE_SCROLL_MARGIN_SCREEN = 96;
+const EDGE_SCROLL_MAX_SPEED_SCREEN = 1.25;
+const EDGE_SCROLL_MAX_ELAPSED = 32;
+
+function getEdgeScrollFactor(distance: number): number {
+  return Math.min(
+    1,
+    Math.max(
+      0,
+      (EDGE_SCROLL_MARGIN_SCREEN - distance) / EDGE_SCROLL_MARGIN_SCREEN,
+    ),
+  );
+}
+
+export function getEdgeScrollDelta(
+  screenPoint: Vec,
+  viewportSize: { w: number; h: number },
+  elapsed: number,
+): Vec {
+  if (viewportSize.w <= 0 || viewportSize.h <= 0 || elapsed <= 0) {
+    return Vec.Zero();
+  }
+
+  const clampedElapsed = Math.min(elapsed, EDGE_SCROLL_MAX_ELAPSED);
+  const leftFactor = getEdgeScrollFactor(screenPoint.x);
+  const rightFactor = getEdgeScrollFactor(viewportSize.w - screenPoint.x);
+  const topFactor = getEdgeScrollFactor(screenPoint.y);
+  const bottomFactor = getEdgeScrollFactor(viewportSize.h - screenPoint.y);
+  const deltaX =
+    (rightFactor - leftFactor) * EDGE_SCROLL_MAX_SPEED_SCREEN * clampedElapsed;
+  const deltaY =
+    (bottomFactor - topFactor) * EDGE_SCROLL_MAX_SPEED_SCREEN * clampedElapsed;
+
+  return deltaX === 0 && deltaY === 0 ? Vec.Zero() : new Vec(deltaX, deltaY);
+}

package/_vendor/canvas-core/editor/editorComputedHelpers.ts

@@ -0,0 +1,257 @@
+import type { Box } from "../geometry/Box";
+import type { Vec } from "../geometry/Vec";
+import type {
+  AssetId,
+  PageId,
+  ShapeId,
+  ShapeRecord,
+} from "../schema/records";
+import type { ArrowBindingPreviewState } from "./selection";
+import type {
+  EditorOverlayDebugState,
+  EditorRenderHostDebugState,
+  RenderItem,
+} from "./Editor";
+
+export function areShapeIdArraysEqual(a: ShapeId[], b: ShapeId[]): boolean {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+
+export function areVecsEqual(a: Vec | null, b: Vec | null): boolean {
+  if (a === b) return true;
+  if (!a || !b) return a === b;
+  return a.x === b.x && a.y === b.y;
+}
+
+export function areVecArraysEqual(a: readonly Vec[], b: readonly Vec[]): boolean {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  for (let index = 0; index < a.length; index += 1) {
+    const left = a[index];
+    const right = b[index];
+    if (!left || !right || left.x !== right.x || left.y !== right.y) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export function areBoxesEqual(a: Box | null, b: Box | 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;
+}
+
+export 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
+  );
+}
+
+export function areRenderHostDebugStatesEqual(
+  a: EditorRenderHostDebugState,
+  b: EditorRenderHostDebugState,
+): boolean {
+  return (
+    a.culledCount === b.culledCount &&
+    a.visibleCount === b.visibleCount &&
+    a.retainedCount === b.retainedCount &&
+    a.retainedBaseCount === b.retainedBaseCount &&
+    a.culledRangeCount === b.culledRangeCount &&
+    a.culledRangeSpan === b.culledRangeSpan &&
+    a.culledRangesSummary === b.culledRangesSummary &&
+    a.retainedBaseRangeCount === b.retainedBaseRangeCount &&
+    a.retainedBaseRangeSpan === b.retainedBaseRangeSpan &&
+    a.retainedBaseRangesSummary === b.retainedBaseRangesSummary &&
+    a.retainedRangeCount === b.retainedRangeCount &&
+    a.retainedRangeSpan === b.retainedRangeSpan &&
+    a.retainedRangesSummary === b.retainedRangesSummary &&
+    a.retainedChangeCount === b.retainedChangeCount &&
+    a.retainedAddedCount === b.retainedAddedCount &&
+    a.retainedRemovedCount === b.retainedRemovedCount &&
+    a.selectedOutsideCulledCount === b.selectedOutsideCulledCount
+  );
+}
+
+export function areOverlayDebugStatesEqual(
+  a: EditorOverlayDebugState,
+  b: EditorOverlayDebugState,
+): boolean {
+  return (
+    a.selectionFrameActive === b.selectionFrameActive &&
+    a.selectionHandlesActive === b.selectionHandlesActive &&
+    a.bindingPreviewActive === b.bindingPreviewActive &&
+    a.brushBoxActive === b.brushBoxActive &&
+    a.selectionFrameChangeCount === b.selectionFrameChangeCount &&
+    a.selectionHandlesChangeCount === b.selectionHandlesChangeCount &&
+    a.resizeHandleCount === b.resizeHandleCount &&
+    a.rotateHandleCount === b.rotateHandleCount &&
+    a.terminalHandleCount === b.terminalHandleCount &&
+    a.middleHandleCount === b.middleHandleCount &&
+    a.customHandleCount === b.customHandleCount &&
+    a.boundsSummary === b.boundsSummary &&
+    a.rotation === b.rotation &&
+    a.strokeWidth === b.strokeWidth
+  );
+}
+
+export function getBoxDebugSummary(box: Box | null): string {
+  if (!box) {
+    return "none";
+  }
+  return `${Math.round(box.x)},${Math.round(box.y)},${Math.round(
+    box.w,
+  )},${Math.round(box.h)}`;
+}
+
+export function getShapePageIdFromParentChain(
+  shape: ShapeRecord,
+  shapeById: ReadonlyMap<ShapeId, ShapeRecord>,
+  pageIds: ReadonlySet<PageId>,
+): PageId | null {
+  const seen = new Set<ShapeId>([shape.id]);
+  let parentId = shape.parentId;
+
+  while (parentId.startsWith("shape:")) {
+    const parentShapeId = parentId as ShapeId;
+    if (seen.has(parentShapeId)) {
+      return null;
+    }
+    seen.add(parentShapeId);
+
+    const parentShape = shapeById.get(parentShapeId);
+    if (!parentShape) {
+      return null;
+    }
+    parentId = parentShape.parentId;
+  }
+
+  return pageIds.has(parentId as PageId) ? (parentId as PageId) : null;
+}
+
+export function areBindingPreviewStatesEqual(
+  a: ArrowBindingPreviewState | null,
+  b: ArrowBindingPreviewState | null,
+): boolean {
+  if (a === b) return true;
+  if (!a || !b) return a === b;
+  return (
+    a.terminal === b.terminal &&
+    a.targetShapeId === b.targetShapeId &&
+    areVecsEqual(a.rawPagePoint, b.rawPagePoint) &&
+    areVecsEqual(a.resolvedPagePoint, b.resolvedPagePoint)
+  );
+}
+
+export function areRenderItemsEqual(a: RenderItem[], b: RenderItem[]): 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) {
+      return false;
+    }
+    if (
+      left.id !== right.id ||
+      left.shape !== right.shape ||
+      left.isSelected !== right.isSelected ||
+      !areBoxesEqual(left.bounds, right.bounds)
+    ) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export function areShapeIdSetsEqual(a: Set<ShapeId>, b: Set<ShapeId>): boolean {
+  if (a === b) return true;
+  if (a.size !== b.size) return false;
+  for (const id of a) {
+    if (!b.has(id)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export function getCommonShapeType(
+  shapes: readonly ShapeRecord[],
+): ShapeRecord["type"] | null {
+  let commonType: ShapeRecord["type"] | null = null;
+  for (const shape of shapes) {
+    if (commonType === null) {
+      commonType = shape.type;
+      continue;
+    }
+    if (commonType !== shape.type) {
+      return null;
+    }
+  }
+  return commonType;
+}
+
+export function getShapeAssetId(shape: ShapeRecord): AssetId | null {
+  const assetId = (shape.props as Record<string, unknown>).assetId;
+  return typeof assetId === "string" && assetId.startsWith("asset:")
+    ? (assetId as AssetId)
+    : null;
+}
+
+export function areSerializableValuesEqual(a: unknown, b: unknown): boolean {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== typeof b) return false;
+  if (!a || !b || typeof a !== "object" || typeof b !== "object") {
+    return false;
+  }
+
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) {
+      return false;
+    }
+    return a.every((value, index) =>
+      areSerializableValuesEqual(value, b[index]),
+    );
+  }
+
+  const aRecord = a as Record<string, unknown>;
+  const bRecord = b as Record<string, unknown>;
+  const aKeys = Object.keys(aRecord);
+  const bKeys = Object.keys(bRecord);
+  if (aKeys.length !== bKeys.length) {
+    return false;
+  }
+  return aKeys.every(
+    (key) =>
+      Object.prototype.hasOwnProperty.call(bRecord, key) &&
+      areSerializableValuesEqual(aRecord[key], bRecord[key]),
+  );
+}
+
+export function areShapePropsPatchesEqual(
+  a: Readonly<Record<string, unknown>>,
+  b: Readonly<Record<string, unknown>>,
+): boolean {
+  if (a === b) return true;
+  const aEntries = Object.entries(a);
+  const bEntries = Object.entries(b);
+  if (aEntries.length !== bEntries.length) {
+    return false;
+  }
+  for (const [key, value] of aEntries) {
+    if (!areSerializableValuesEqual(value, b[key])) {
+      return false;
+    }
+  }
+  return true;
+}

package/_vendor/canvas-core/editor/editorSelectionTransforms.ts

@@ -0,0 +1,116 @@
+import type { ChangeSource } from "@land/store";
+import { Box } from "../geometry/Box";
+import type { ShapeRecord } from "../schema/records";
+import type { ShapeSelectionFlipAxis } from "../shapes/ShapeUtil";
+import type { ShapeUpdate } from "./commands";
+import type { Editor } from "./Editor";
+import {
+  flipSelectionLocalBounds,
+  getSelectionLocalBoundsFromPagePoints,
+  type SelectionFrame,
+} from "./selection";
+
+export function resetEditorSelectionRotation(
+  editor: Editor,
+  source: ChangeSource = "user",
+): void {
+  const selectedShapes = editor.getSelectedShapes().filter((shape) =>
+    editor.getShapeUtil(shape).contributesToSelectionFrame(shape, {
+      editor,
+    }),
+  );
+  if (selectedShapes.length === 0) {
+    return;
+  }
+  editor.commands.updateShapes(
+    selectedShapes.map((shape) => ({
+      id: shape.id,
+      rotation: 0,
+    })),
+    { source },
+  );
+}
+
+export function getEditorSelectionFlipUpdates(
+  editor: Editor,
+  axis: ShapeSelectionFlipAxis,
+): ShapeUpdate[] {
+  const selectedShapes = editor.getSelectionTransformTargetShapes();
+  const selectionFrame =
+    editor.getSelectionFrame() ?? getPointSelectionFrame(editor, selectedShapes);
+  if (!selectionFrame || selectedShapes.length === 0) {
+    return [];
+  }
+
+  return selectedShapes
+    .map((shape) => getFlippedShapeUpdate(editor, shape, selectionFrame, axis))
+    .filter((update): update is ShapeUpdate => update !== null);
+}
+
+function getFlippedShapeUpdate(
+  editor: Editor,
+  shape: ShapeRecord,
+  selectionFrame: SelectionFrame,
+  axis: ShapeSelectionFlipAxis,
+): ShapeUpdate | null {
+  const util = editor.getShapeUtil(shape);
+  const pointSelection = util.getSelectionPagePoints(shape);
+  if (
+    !pointSelection &&
+    !util.contributesToSelectionFrame(shape, {
+      editor,
+    })
+  ) {
+    return null;
+  }
+
+  const pagePoints =
+    pointSelection ?
+      [...pointSelection]
+    : util
+        .getPositionedOutlineVertices(shape)
+        .map((point) =>
+          editor
+            .computeShapePositionedToPageTransform(shape)
+            .applyToPoint(point),
+        );
+  const localBounds = getSelectionLocalBoundsFromPagePoints({
+    points: pagePoints,
+    transform: selectionFrame,
+  });
+  if (!localBounds) {
+    return null;
+  }
+
+  return util.flipSelectionBounds(shape, {
+    axis,
+    selectionBounds: selectionFrame.bounds,
+    selectionLocalBounds: flipSelectionLocalBounds({
+      axis,
+      bounds: localBounds,
+      selectionBounds: selectionFrame.bounds,
+    }),
+    selectionRotation: selectionFrame.rotation,
+    selectionRotationCenter: selectionFrame.rotationCenter,
+  });
+}
+
+function getPointSelectionFrame(
+  editor: Editor,
+  shapes: readonly ShapeRecord[],
+): SelectionFrame | null {
+  const points = shapes.flatMap(
+    (shape) => editor.getShapeUtil(shape).getSelectionPagePoints(shape) ?? [],
+  );
+  if (points.length === 0) {
+    return null;
+  }
+
+  const bounds = Box.FromPoints(points);
+  return {
+    bounds,
+    rotation: 0,
+    rotationCenter: bounds.center,
+    hasCompatibleRotation: true,
+  };
+}

package/_vendor/canvas-core/editor/events.ts

@@ -0,0 +1,93 @@
+import type { Vec } from "../geometry/Vec";
+
+export type EditorPointerType = "mouse" | "touch" | "pen";
+export type EditorClickEventName = "double_click";
+
+export interface PointerEditorEvent {
+  type: "pointer";
+  name: "pointer_down" | "pointer_move" | "pointer_up" | "pointer_cancel";
+  timestamp: number;
+  pointerId: number;
+  button: number;
+  buttons: number;
+  pointerType: EditorPointerType;
+  clickCount?: number;
+  screenPoint: Vec;
+  pagePoint: Vec;
+  pressure: number;
+  shiftKey: boolean;
+  altKey: boolean;
+  ctrlKey: boolean;
+  metaKey: boolean;
+  accelKey: boolean;
+}
+
+export interface ClickEditorEvent {
+  type: "click";
+  name: EditorClickEventName;
+  phase: "down" | "up";
+  timestamp: number;
+  pointerId: number;
+  button: number;
+  buttons: number;
+  pointerType: EditorPointerType;
+  screenPoint: Vec;
+  pagePoint: Vec;
+  pressure: number;
+  shiftKey: boolean;
+  altKey: boolean;
+  ctrlKey: boolean;
+  metaKey: boolean;
+  accelKey: boolean;
+}
+
+export interface KeyboardEditorEvent {
+  type: "keyboard";
+  name: "key_down" | "key_up";
+  key: string;
+  code: string;
+  shiftKey: boolean;
+  altKey: boolean;
+  ctrlKey: boolean;
+  metaKey: boolean;
+  accelKey: boolean;
+}
+
+export interface WheelEditorEvent {
+  type: "wheel";
+  screenPoint: Vec;
+  pagePoint: Vec;
+  delta: Vec;
+  shiftKey: boolean;
+  altKey: boolean;
+  ctrlKey: boolean;
+  metaKey: boolean;
+  accelKey: boolean;
+}
+
+export interface TickEditorEvent {
+  type: "tick";
+  timestamp: number;
+  elapsed: number;
+}
+
+export interface CancelEditorEvent {
+  type: "cancel";
+  reason:
+    | "escape"
+    | "pointer_cancel"
+    | "blur"
+    | "page_switch"
+    | "tool_switch"
+    | "dispose"
+    | "command"
+    | "restore";
+}
+
+export type EditorEvent =
+  | PointerEditorEvent
+  | ClickEditorEvent
+  | KeyboardEditorEvent
+  | WheelEditorEvent
+  | TickEditorEvent
+  | CancelEditorEvent;

package/_vendor/canvas-core/editor/index.ts

@@ -0,0 +1,12 @@
+export { Editor } from "./Editor";
+export { StateNode } from "./StateNode";
+export { HistoryManager } from "./HistoryManager";
+export { InputsManager } from "./managers/InputsManager";
+export { QueryManager } from "./managers/QueryManager";
+export {
+  SpatialIndexManager,
+  type ShapeAtPointOptions,
+  type SpatialQueryOptions,
+} from "./managers/SpatialIndexManager";
+export { ToolManager } from "./managers/ToolManager";
+export type { EditorEvent } from "./events";

package/_vendor/canvas-core/editor/interactions.ts

@@ -0,0 +1,101 @@
+import type { ChangeSource } from "@land/store";
+import type { Vec } from "../geometry/Vec";
+import type { ShapeId, ShapeRecord } from "../schema/records";
+import type { Editor } from "./Editor";
+import type { EditorEvent } from "./events";
+import type { SelectionHandle } from "./selection";
+import type {
+  HandleSnapContext,
+  HandleSnapMode,
+} from "./managers/snapTypes";
+
+export interface SelectionHandleInteractionInput {
+  handle: SelectionHandle;
+  shape: ShapeRecord;
+  originPagePoint: Vec;
+}
+
+export interface SelectionHandleInteractionSession {
+  readonly shapeId: ShapeId;
+  readonly historyMark: string;
+  readonly handleSnapMode?: HandleSnapMode;
+  readonly handleSnapContext?: HandleSnapContext;
+  readonly allowSelfSnap?: boolean;
+  readonly excludedSnapShapeIds?: readonly ShapeId[];
+  readonly shouldClearBindingPreviewOnExit?: boolean;
+  update(input: {
+    editor: Editor;
+    pagePoint: Vec;
+    accelKey: boolean;
+    source: ChangeSource;
+  }): "continue" | "stop" | SelectionHandleInteractionUpdateResult;
+}
+
+export interface SelectionHandleInteractionUpdateResult {
+  status: "continue" | "stop";
+  finalPagePoint?: Vec | null;
+}
+
+export interface SelectionHandleInteractionHandler {
+  createSession(
+    editor: Editor,
+    input: SelectionHandleInteractionInput,
+  ): SelectionHandleInteractionSession | null;
+}
+
+export type EditorEventInteractionDecision = "continue" | "handled";
+
+export interface EditorEventInteractionHandler {
+  handleEvent(
+    editor: Editor,
+    event: EditorEvent,
+  ): EditorEventInteractionDecision;
+}
+
+export interface LandInteractionHandler {
+  id: string;
+  editorEvent?: EditorEventInteractionHandler;
+  selectionHandle?: SelectionHandleInteractionHandler;
+}
+
+export class InteractionHandlerRegistry {
+  private readonly handlers: LandInteractionHandler[] = [];
+  private readonly registeredIds = new Set<string>();
+
+  register(handler: LandInteractionHandler): void {
+    if (this.registeredIds.has(handler.id)) {
+      return;
+    }
+
+    this.handlers.push(handler);
+    this.registeredIds.add(handler.id);
+  }
+
+  getHandlers(): readonly LandInteractionHandler[] {
+    return this.handlers;
+  }
+
+  handleEvent(editor: Editor, event: EditorEvent): EditorEventInteractionDecision {
+    for (const handler of this.handlers) {
+      if (handler.editorEvent?.handleEvent(editor, event) === "handled") {
+        return "handled";
+      }
+    }
+
+    return "continue";
+  }
+
+  createSelectionHandleSession(
+    editor: Editor,
+    input: SelectionHandleInteractionInput,
+  ): SelectionHandleInteractionSession | null {
+    for (const handler of this.handlers) {
+      const session = handler.selectionHandle?.createSession(editor, input);
+      if (session) {
+        return session;
+      }
+    }
+
+    return null;
+  }
+}

package/_vendor/canvas-core/editor/internal.ts

@@ -0,0 +1,22 @@
+import type { Editor } from "./Editor";
+import type { Store } from "@land/store";
+import type { EditorRecord } from "../schema/records";
+
+const editorStoreSymbol = Symbol("editorStore");
+
+type EditorWithInternalStore = Editor & {
+  [editorStoreSymbol]: Store<EditorRecord>;
+};
+
+export function setEditorStore(
+  editor: Editor,
+  store: Store<EditorRecord>,
+): void {
+  (editor as EditorWithInternalStore)[editorStoreSymbol] = store;
+}
+
+export function getEditorStore(editor: Editor): Store<EditorRecord> {
+  return (editor as EditorWithInternalStore)[editorStoreSymbol];
+}
+
+export { editorStoreSymbol };