@yuzhouu/canvas-kit 0.1.2 → 0.1.4

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

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

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

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

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

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

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

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