@yuzhouu/canvas-kit 0.1.2 → 0.1.4

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

@@ -0,0 +1,559 @@
+import { type Signal } from "../../signals/index";
+import type { TerminalBindingResolver, TerminalBindingResolverInput, ResolvedTerminalBinding } from "../bindings/terminalBinding";
+import type { BindingUtil } from "../bindings/bindingUtil";
+import { BindingUtilRegistry } from "../bindings/bindingUtilRegistry";
+import { Box } from "../geometry/box";
+import { Mat } from "../geometry/mat";
+import { Vec } from "../geometry/vec";
+import { type BindingId, type BindingRecord, type AssetId, type AssetRecord, type Camera, type PageId, type PageRecord, type EditorRecord, type RecordScope, type SessionRecord, type ShapeId, type ShapeParentId, type ShapeRecord, type ShapeEditingEntryRequest, type ShapeEditingSession } from "../schema/records";
+import { type DocumentSnapshot, type SessionSnapshot } from "../schema/snapshots";
+import type { ShapeSelectionFlipAxis, ShapeUtil } from "../shapes/shapeUtil";
+import { ShapeUtilRegistry } from "../shapes/shapeUtilRegistry";
+import { ShapeSvgExporterRegistry, type ShapeSvgExporter, type SvgExportOptions, type SvgExportResult } from "../exports/svg";
+import { type ExportIntegrityRepairResult, type ExportIntegrityReport } from "../exports/integrity";
+import { type ShapeCapabilityDefinition, type ShapeCapabilityManifest } from "../shapes/capabilities";
+import { Store, type ChangeSource, type StoreChange } from "../../store/index";
+import { type CreateAssetInput, type CreateBindingInput, type CreatePageInput, type CreateShapeInput, type StartEditingShapeInput, type EditorCommands } from "./commands";
+import type { CancelEditorEvent, EditorEvent } from "./events";
+import { HistoryManager, type HistoryState } from "./historyManager";
+import { BindingManager } from "./managers/bindingManager";
+import { CameraManager } from "./managers/cameraManager";
+import { ClipboardManager } from "./managers/clipboardManager";
+import { DocumentSnapshotManager } from "./managers/documentSnapshotManager";
+import { InputsManager } from "./managers/inputsManager";
+import { InteractionTransientManager, type LaserTrailState } from "./managers/interactionTransientManager";
+import { QueryManager, type ShapeContainment } from "./managers/queryManager";
+import { SpatialIndexManager, type ShapeAtPointOptions, type ShapeLineSegmentHitTestOptions, type SpatialQueryOptions } from "./managers/spatialIndexManager";
+import { SnapManager } from "./managers/snapManager";
+import { SideEffectManager } from "./managers/sideEffectManager";
+import { SelectionLayoutManager } from "./managers/selectionLayoutManager";
+import { SelectionManager } from "./managers/selectionManager";
+import { SelectionOverlayManager } from "./managers/selectionOverlayManager";
+import { ShapeEditingManager } from "./managers/shapeEditingManager";
+import { ShapeGeometryManager } from "./managers/shapeGeometryManager";
+import { ShapeHierarchyManager } from "./managers/shapeHierarchyManager";
+import { ShortcutManager } from "./managers/shortcutManager";
+import { RenderWindowManager } from "./managers/renderWindowManager";
+import { ToolManager } from "./managers/toolManager";
+import type { ShapeGeometry } from "./queries/shapeTransforms";
+import { editorStoreSymbol } from "./internal";
+import type { DuplicateSelectionInput, EditorClipboardPayload, PasteClipboardPayloadInput } from "./clipboard";
+import { InteractionHandlerRegistry } from "./interactions";
+import { SelectionHandleInteractionRegistry } from "./selectionHandleInteractions";
+import { type SelectedShapeOverlayItem } from "./selectionOverlay";
+import type { BindingPreviewState, SnapIndicatorState, SelectionBindingSegment, SelectionHandle, SelectionFrame, SelectionOverlayFrameState, SelectionOverlayFrameGeometryState, SelectionOverlayFrameStyleState, SelectionOverlayHandleAnchorsState, SelectionOverlayHandleCountsState, SelectionOverlayHandlesState, SelectionOverlayState } from "./selection";
+export interface EditorOptions {
+    shapeUtils?: ShapeUtil[];
+    shapeSvgExporters?: ShapeSvgExporter[];
+    bindingUtils?: BindingUtil[];
+    shapeCapabilities?: readonly ShapeCapabilityDefinition[];
+    resolveAssetUrl?: (assetId: AssetId) => string | null;
+    documentSnapshot?: unknown;
+    sessionSnapshot?: unknown;
+}
+export interface ContainerBoundsQueryOptions {
+    includeIntersecting?: boolean;
+}
+export interface RenderItem {
+    id: ShapeId;
+    shape: ShapeRecord;
+    bounds: Box;
+    isSelected: boolean;
+}
+export interface EditorPageState {
+    pages: PageRecord[];
+    currentPageId: PageId;
+    currentPage: PageRecord | null;
+    canDeleteCurrentPage: boolean;
+}
+export interface EditorToolState {
+    activeToolId: string;
+    isToolLocked: boolean;
+}
+export type ShapeSiblingOrderDirection = "backward" | "forward";
+export type ShapeSiblingOrderEdge = "back" | "front";
+export interface ShapeSiblingOrderState {
+    parentId: ShapeParentId;
+    index: number;
+    count: number;
+    canMoveBackward: boolean;
+    canMoveForward: boolean;
+}
+export interface ShapeSelectionSiblingOrderState {
+    parentId: ShapeParentId;
+    selectedCount: number;
+    count: number;
+    canMoveBackward: boolean;
+    canMoveForward: boolean;
+}
+export type ReparentShapePlacementFailureReason = "notFound" | "locked" | "hidden" | "invalidParent" | "cycle" | "invalidBeforeId";
+export type ReparentShapePlacementResult = {
+    ok: true;
+    movedIds: ShapeId[];
+} | {
+    ok: false;
+    reason: ReparentShapePlacementFailureReason;
+};
+export interface ReparentShapePlacementInput {
+    ids: readonly ShapeId[];
+    parentId: ShapeParentId;
+    beforeId?: ShapeId;
+}
+export interface ShapeGroupState {
+    parentId: ShapeParentId;
+    shapeIds: ShapeId[];
+    bounds: Box;
+}
+export type LayerOrderDirection = "backward" | "forward";
+export type LayerOrderEdge = "back" | "front";
+export type ShapePropsPatch = Record<string, unknown>;
+export interface EditorShapeEditingState {
+    editingShapeId: ShapeId | null;
+    session: ShapeEditingSession | null;
+}
+export interface EditorShapeEditingEntryRequestState {
+    request: ShapeEditingEntryRequest | null;
+}
+export interface EditorSelectionState {
+    count: number;
+    singleShapeType: ShapeRecord["type"] | null;
+    commonShapeType: ShapeRecord["type"] | null;
+    hasPointHandleSelection: boolean;
+    hasFrameSelection: boolean;
+    isMixedFrameAndPointHandleSelection: boolean;
+    canDragPointHandles: boolean;
+    hasSelectionRotation: boolean;
+    hasMixedSelectionRotation: boolean;
+    canResetSelectionRotation: boolean;
+    frameBounds: Box | null;
+    frameRotation: number;
+    frameRotationCenter: Vec | null;
+    selectionAnchorPagePoint: Vec | null;
+}
+export interface EditorRenderHostDebugState {
+    culledCount: number;
+    visibleCount: number;
+    retainedCount: number;
+    retainedBaseCount: number;
+    culledRangeCount: number;
+    culledRangeSpan: number;
+    culledRangesSummary: string;
+    retainedBaseRangeCount: number;
+    retainedBaseRangeSpan: number;
+    retainedBaseRangesSummary: string;
+    retainedRangeCount: number;
+    retainedRangeSpan: number;
+    retainedRangesSummary: string;
+    retainedChangeCount: number;
+    retainedAddedCount: number;
+    retainedRemovedCount: number;
+    selectedOutsideCulledCount: number;
+}
+export interface EditorOverlayDebugState {
+    selectionFrameActive: boolean;
+    selectionHandlesActive: boolean;
+    bindingPreviewActive: boolean;
+    brushBoxActive: boolean;
+    selectionFrameChangeCount: number;
+    selectionHandlesChangeCount: number;
+    resizeHandleCount: number;
+    rotateHandleCount: number;
+    terminalHandleCount: number;
+    middleHandleCount: number;
+    customHandleCount: number;
+    boundsSummary: string;
+    rotation: number | null;
+    strokeWidth: number | null;
+}
+interface ReadonlyStore {
+    readonly recordsSignal: Signal<Map<string, EditorRecord>>;
+    get(id: string): EditorRecord | undefined;
+    getRecordSignal(id: string): Signal<EditorRecord | undefined>;
+    getAll(): EditorRecord[];
+    getByScope(scope: RecordScope): EditorRecord[];
+    listen(listener: (change: StoreChange<EditorRecord>) => void): () => void;
+}
+export declare class Editor {
+    readonly store: ReadonlyStore;
+    readonly [editorStoreSymbol]: Store<EditorRecord>;
+    readonly inputs: InputsManager;
+    readonly snapshots: DocumentSnapshotManager;
+    readonly clipboard: ClipboardManager;
+    readonly shortcuts: ShortcutManager;
+    readonly tools: ToolManager;
+    readonly camera: CameraManager;
+    readonly selection: SelectionManager;
+    readonly selectionLayout: SelectionLayoutManager;
+    readonly editing: ShapeEditingManager;
+    readonly geometry: ShapeGeometryManager;
+    readonly hierarchy: ShapeHierarchyManager;
+    readonly shapeUtils: ShapeUtilRegistry;
+    readonly shapeSvgExporters: ShapeSvgExporterRegistry;
+    readonly bindingUtils: BindingUtilRegistry;
+    readonly interactions: InteractionHandlerRegistry;
+    readonly selectionHandleInteractions: SelectionHandleInteractionRegistry;
+    readonly queries: QueryManager;
+    readonly bindings: BindingManager;
+    readonly spatialIndex: SpatialIndexManager;
+    readonly snaps: SnapManager;
+    readonly renderWindow: RenderWindowManager;
+    readonly selectionOverlay: SelectionOverlayManager;
+    readonly transients: InteractionTransientManager;
+    readonly history: HistoryManager;
+    readonly sideEffects: SideEffectManager;
+    readonly commands: EditorCommands;
+    private readonly shapeCapabilityDefinitions;
+    readonly brushBoxSignal: Signal<Box | null>;
+    readonly brushBoxActiveSignal: Signal<boolean>;
+    readonly erasingShapeIdsSignal: Signal<ShapeId[]>;
+    readonly erasingShapeIdsActiveSignal: Signal<boolean>;
+    readonly eraserTrailSignal: Signal<Vec[]>;
+    readonly eraserTrailActiveSignal: Signal<boolean>;
+    readonly laserTrailSignal: Signal<LaserTrailState | null>;
+    readonly laserTrailActiveSignal: Signal<boolean>;
+    readonly bindingPreviewSignal: Signal<BindingPreviewState | null>;
+    readonly bindingPreviewActiveSignal: Signal<boolean>;
+    readonly dropTargetShapeIdSignal: Signal<ShapeId | null>;
+    readonly selectionTranslationActiveSignal: Signal<boolean>;
+    readonly snapIndicatorsSignal: Signal<SnapIndicatorState[]>;
+    readonly snapIndicatorsActiveSignal: Signal<boolean>;
+    get viewportScreenSizeSignal(): Signal<{
+        w: number;
+        h: number;
+    }>;
+    readonly shapeEditingEntryRequestSignal: Signal<ShapeEditingEntryRequest | null>;
+    private readonly _shapeDefaultPropsByTypeSignal;
+    readonly shapeDefaultPropsByTypeSignal: Signal<ReadonlyMap<ShapeRecord["type"], ShapePropsPatch>>;
+    private nextShapeNumber;
+    private nextPageNumber;
+    private nextBindingNumber;
+    private nextAssetNumber;
+    private assetUrlResolver;
+    private get _internalStore();
+    readonly sessionSignal: import("../../signals/index").Computed<SessionRecord>;
+    readonly currentPageIdSignal: import("../../signals/index").Computed<`page:${string}`>;
+    readonly currentPageShapeIdsSignal: Signal<ShapeId[]>;
+    readonly currentPageShapesSignal: Signal<ShapeRecord[]>;
+    readonly culledShapeIdsSignal: Signal<ShapeId[]>;
+    readonly renderVisibleShapeIdsSignal: Signal<ShapeId[]>;
+    readonly retainedShapeIdsSignal: Signal<ShapeId[]>;
+    readonly selectionPageBoundsSignal: Signal<Box | null>;
+    readonly selectionFrameBoundsSignal: Signal<Box | null>;
+    readonly selectionAnchorPagePointSignal: Signal<Vec | null>;
+    readonly pagesSignal: import("../../signals/index").Computed<PageRecord[]>;
+    readonly currentPageSignal: import("../../signals/index").Computed<PageRecord | null>;
+    readonly pageStateSignal: import("../../signals/index").Computed<EditorPageState>;
+    readonly toolStateSignal: import("../../signals/index").Computed<EditorToolState>;
+    readonly editingShapeIdSignal: import("../../signals/index").Computed<`shape:${string}` | null>;
+    readonly shapeEditingSessionSignal: import("../../signals/index").Computed<ShapeEditingSession | null>;
+    readonly shapeEditingStateSignal: import("../../signals/index").Computed<EditorShapeEditingState>;
+    readonly currentCameraSignal: import("../../signals/index").Computed<Camera>;
+    readonly selectedShapeIdsSignal: import("../../signals/index").Computed<`shape:${string}`[]>;
+    readonly selectedShapeIdSetSignal: import("../../signals/index").Computed<Set<`shape:${string}`>>;
+    readonly selectedShapesSignal: import("../../signals/index").Computed<ShapeRecord[]>;
+    readonly selectedShapeOverlayItemsSignal: import("../../signals/index").Computed<SelectedShapeOverlayItem[]>;
+    readonly selectionStateSignal: import("../../signals/index").Computed<EditorSelectionState>;
+    readonly pageTransformSignal: import("../../signals/index").Computed<Mat>;
+    readonly cameraZoomSignal: import("../../signals/index").Computed<number>;
+    readonly viewportPageBoundsSignal: import("../../signals/index").Computed<Box | null>;
+    readonly renderViewportPageBoundsSignal: import("../../signals/index").Computed<Box | null>;
+    readonly renderItemsSignal: Signal<RenderItem[]>;
+    readonly renderHostDebugStateSignal: Signal<EditorRenderHostDebugState>;
+    readonly historyStateSignal: Signal<HistoryState>;
+    readonly shapeRenderOrderByIdSignal: Signal<Map<ShapeId, number>>;
+    readonly culledShapeIdSetSignal: Signal<Set<ShapeId>>;
+    readonly selectedShapeIdsOutsideCulledSignal: Signal<ShapeId[]>;
+    readonly selectedShapeIdsOutsideCulledSetSignal: Signal<Set<ShapeId>>;
+    readonly renderVisibleShapeIdSetSignal: Signal<Set<ShapeId>>;
+    private readonly shapeSignals;
+    private readonly shapeSelectedSignals;
+    private readonly shapeRenderOrderSignals;
+    private readonly shapeRenderVisibleSignals;
+    private readonly shapeDocumentVisibleSignals;
+    private readonly shapeEditingSessionSignals;
+    private readonly shapeDropTargetSignals;
+    private readonly shapeErasingSignals;
+    private readonly shapeSelectedDescendantTransformAncestorSignals;
+    private lastPointerDownForClickCount;
+    private lastPointerUpForClickCount;
+    private currentPointerClickCount;
+    readonly selectionOverlayFrameGeometrySignal: Signal<SelectionOverlayFrameGeometryState | null>;
+    readonly selectionOverlayCompanionFrameGeometriesSignal: Signal<SelectionOverlayFrameGeometryState[]>;
+    readonly selectionOverlayPathSignal: Signal<string | null>;
+    readonly selectionOverlayBindingSegmentsSignal: Signal<SelectionBindingSegment[]>;
+    readonly selectionOverlayFrameStyleSignal: Signal<SelectionOverlayFrameStyleState>;
+    readonly selectionOverlayFrameSignal: Signal<SelectionOverlayFrameState | null>;
+    readonly selectionOverlayHandleAnchorsSignal: Signal<SelectionOverlayHandleAnchorsState | null>;
+    readonly selectionOverlayHandlesSignal: Signal<SelectionOverlayHandlesState | null>;
+    readonly selectionOverlayHandleCountsSignal: Signal<SelectionOverlayHandleCountsState | null>;
+    readonly selectionOverlaySignal: Signal<SelectionOverlayState | null>;
+    readonly overlayDebugStateSignal: Signal<EditorOverlayDebugState>;
+    constructor(options?: EditorOptions);
+    private registerBuiltInShortcuts;
+    private registerBuiltInSideEffects;
+    dispatch(event: EditorEvent): void;
+    handleInteractionEvent(event: EditorEvent): boolean;
+    private runKeyboardShortcutTarget;
+    private runEditorKeyboardShortcut;
+    private normalizeEvent;
+    private getDoubleClickEvent;
+    listen(listener: (change: StoreChange<EditorRecord>) => void): () => void;
+    getRenderItems(): RenderItem[];
+    getPages(): PageRecord[];
+    getCurrentPageId(): PageId;
+    getActiveToolId(): string;
+    isToolLocked(): boolean;
+    isActiveToolInInitialState(): boolean;
+    getEditingShapeId(): ShapeId | null;
+    getShapeEditingSession(): ShapeEditingSession | null;
+    getShapeEditingEntryRequest(): ShapeEditingEntryRequest | null;
+    resetPointerClickTracking(): void;
+    getCurrentPageShapeIds(): ShapeId[];
+    getPage(id: PageId): PageRecord | undefined;
+    getCurrentCamera(): Camera;
+    undo(): boolean;
+    redo(): boolean;
+    createPageAndSelect(input?: CreatePageInput, source?: ChangeSource): PageRecord;
+    selectPage(pageId: PageId, source?: ChangeSource): void;
+    renamePage(pageId: PageId, name: string, source?: ChangeSource): void;
+    deletePage(pageId: PageId, source?: ChangeSource): boolean;
+    setActiveTool(toolId: string, source?: ChangeSource): void;
+    setToolLocked(locked: boolean, source?: ChangeSource): void;
+    toggleToolLocked(source?: ChangeSource): void;
+    getCamera(pageId?: PageId): Camera;
+    pageToScreen(point: Vec, pageId?: PageId): Vec;
+    screenToPage(point: Vec, pageId?: PageId): Vec;
+    getSelectedShapeIds(pageId?: PageId): ShapeId[];
+    isShapeHidden(shapeId: ShapeId): boolean;
+    getSelectedShapes(): ShapeRecord[];
+    getDefaultShapeProps<TProps extends object = object>(type: ShapeRecord["type"]): TProps;
+    updateDefaultShapeProps(type: ShapeRecord["type"], props: ShapePropsPatch): void;
+    getSelectionParentOrderState(): ShapeSelectionSiblingOrderState | null;
+    getSelectionGroupState(): ShapeGroupState | null;
+    canGroupSelection(): boolean;
+    canGroupShapes(ids: readonly ShapeId[]): boolean;
+    groupShapes(ids: readonly ShapeId[], source?: ChangeSource): ShapeRecord | null;
+    groupSelection(source?: ChangeSource): ShapeRecord | null;
+    getUngroupableSelectedShapeIds(): ShapeId[];
+    getUngroupableShapeIds(ids: readonly ShapeId[]): ShapeId[];
+    canUngroupSelection(): boolean;
+    canUngroupShapes(ids: readonly ShapeId[]): boolean;
+    ungroupShapes(ids: readonly ShapeId[], source?: ChangeSource): ShapeId[];
+    ungroupSelection(source?: ChangeSource): ShapeId[];
+    getSelectionSiblingOrderState(): ShapeSiblingOrderState | null;
+    canMoveSelectionWithinParent(direction: ShapeSiblingOrderDirection): boolean;
+    canMoveSelectionInParentOrder(direction: ShapeSiblingOrderDirection): boolean;
+    canMoveShapesInParentOrder(ids: readonly ShapeId[], direction: LayerOrderDirection): boolean;
+    moveShapesInParentOrder(ids: readonly ShapeId[], direction: LayerOrderDirection, source?: ChangeSource): boolean;
+    moveShapesToParentOrderEdge(ids: readonly ShapeId[], edge: LayerOrderEdge, source?: ChangeSource): boolean;
+    moveSelectionWithinParent(direction: ShapeSiblingOrderDirection, source?: ChangeSource): boolean;
+    /**
+     * Align selected top-level shapes along an edge or center of their combined
+     * page bounds. Only shapes parented directly to the current page are moved so
+     * the page-space delta maps directly onto `x`/`y`. Needs at least two shapes.
+     */
+    alignSelection(mode: "left" | "horizontal-center" | "right" | "top" | "vertical-center" | "bottom", source?: ChangeSource): boolean;
+    /**
+     * Distribute selected top-level shapes so the gaps between them are equal
+     * along the given axis. Needs at least three shapes.
+     */
+    distributeSelection(axis: "horizontal" | "vertical", source?: ChangeSource): boolean;
+    moveShapesToParentPlacement(input: ReparentShapePlacementInput, source?: ChangeSource): boolean;
+    moveShapesToParentPlacementResult(input: ReparentShapePlacementInput, source?: ChangeSource): ReparentShapePlacementResult;
+    moveSelectionInParentOrder(direction: ShapeSiblingOrderDirection, source?: ChangeSource): boolean;
+    moveSelectionToParentOrderEdge(edge: ShapeSiblingOrderEdge, source?: ChangeSource): boolean;
+    canEditShape(shapeOrId: ShapeRecord | ShapeId | null | undefined): boolean;
+    startEditingShape(input: StartEditingShapeInput, source?: ChangeSource): ShapeEditingSession | null;
+    completeEditing(source?: ChangeSource): boolean;
+    cancelEditing(source?: ChangeSource): boolean;
+    setShapeEditingComposition(isComposing: boolean, source?: ChangeSource): void;
+    consumeShapeEditingEntryRequest(requestId: number): void;
+    deleteSelection(source?: ChangeSource): void;
+    deleteShapesById(ids: readonly ShapeId[], source?: ChangeSource): void;
+    setShapesHidden(ids: readonly ShapeId[], isHidden: boolean, source?: ChangeSource): ShapeId[];
+    setShapesLocked(ids: readonly ShapeId[], isLocked: boolean, source?: ChangeSource): ShapeId[];
+    createClipboardPayloadFromSelection(): EditorClipboardPayload | null;
+    pasteClipboardPayload(input: PasteClipboardPayloadInput): ShapeId[];
+    duplicateSelection(input?: DuplicateSelectionInput): ShapeId[];
+    selectAllCurrentPage(source?: ChangeSource): void;
+    resetSelectionRotation(source?: ChangeSource): void;
+    flipSelection(axis: ShapeSelectionFlipAxis, source?: ChangeSource): void;
+    getShape(id: ShapeId): ShapeRecord | undefined;
+    getAsset(id: AssetId): AssetRecord | undefined;
+    getAssets(): AssetRecord[];
+    resolveAssetUrl(assetId: AssetId): string | null;
+    getUnreferencedAssetIdsAfterShapeDelete(shapeIds: readonly ShapeId[]): AssetId[];
+    getShapeSignal(id: ShapeId): Signal<ShapeRecord | undefined>;
+    getShapeSelectedSignal(id: ShapeId): Signal<boolean>;
+    getShapeRenderOrderSignal(id: ShapeId): Signal<number>;
+    getShapeRenderVisibleSignal(id: ShapeId): Signal<boolean>;
+    getShapeDocumentVisibleSignal(id: ShapeId): Signal<boolean>;
+    getShapeEditingSessionForShapeSignal(id: ShapeId): Signal<ShapeEditingSession | null>;
+    getShapeDropTargetSignal(id: ShapeId): Signal<boolean>;
+    getShapeErasingSignal(id: ShapeId): Signal<boolean>;
+    getShapeSelectedDescendantTransformAncestorSignal(id: ShapeId): Signal<boolean>;
+    getBinding(id: BindingId): BindingRecord | undefined;
+    getShapesForPage(pageId: PageId): ShapeRecord[];
+    getBindingsFromShape(shapeId: ShapeId): BindingRecord[];
+    getBindingsToShape(shapeId: ShapeId): BindingRecord[];
+    getBindingsForShape(shapeId: ShapeId): BindingRecord[];
+    getChildShapeIds(parentId: ShapeParentId): ShapeId[];
+    getChildShapes(parentId: ShapeParentId): ShapeRecord[];
+    getDescendantShapeIds(parentId: ShapeParentId): ShapeId[];
+    getDescendantPageBounds(parentId: ShapeParentId): Box | null;
+    getShapeSubtreePageBounds(shapeId: ShapeId): Box | null;
+    getShapePageId(shapeId: ShapeId): PageId | null;
+    isShapeOrAncestorLocked(shapeId: ShapeId): boolean;
+    hasLockedDescendant(shapeId: ShapeId): boolean;
+    getOutermostSelectableShapeId(shapeId: ShapeId): ShapeId;
+    getShapeIdsIncludingDescendants(shapeIds: Iterable<ShapeId>): ShapeId[];
+    getShapeIdsForSelectionTransform(shapeIds: Iterable<ShapeId>): ShapeId[];
+    getShapeIdsForSelectionRotation(shapeIds: Iterable<ShapeId>): ShapeId[];
+    getSelectionTransformTargetShapes(): ShapeRecord[];
+    getSelectionRotationTargetShapes(): ShapeRecord[];
+    getShapeExportTraversalIds(shapeIds: Iterable<ShapeId>): ShapeId[];
+    getShapeContainment(containerId: ShapeId, shapeId: ShapeId): ShapeContainment | null;
+    getContainingShapeParentId(shapeIds: Iterable<ShapeId>): ShapeParentId | null;
+    getContainingShapeParentIdAtPoint(shapeIds: Iterable<ShapeId>, point: Vec): ShapeParentId | null;
+    getContainingParentIdForShapeRecord(shape: ShapeRecord): ShapeParentId | null;
+    getShapeClipAncestorIds(shapeId: ShapeId): ShapeId[];
+    getShapeClipAncestorIdsSignal(shapeId: ShapeId): Signal<ShapeId[]>;
+    isPagePointInShapeClip(shapeId: ShapeId, point: Vec): boolean;
+    getShapeClippedPageBounds(shapeId: ShapeId): Box | null;
+    getShapeIdsInContainerBounds(containerId: ShapeId, options?: ContainerBoundsQueryOptions): ShapeId[];
+    canUseShapeParent(parentId: ShapeParentId, childId?: ShapeId): boolean;
+    getShapeUtil<S extends ShapeRecord>(shape: S): ShapeUtil<S>;
+    getBindingUtil<B extends BindingRecord>(binding: B): BindingUtil<B>;
+    computeShapeBounds(shape: ShapeRecord): Box;
+    computeShapeLocalBounds(shape: ShapeRecord): Box;
+    computeShapeRenderBounds(shape: ShapeRecord): Box;
+    computeShapeExportBounds(shape: ShapeRecord): Box;
+    computeShapeLocalToPageTransform(shape: ShapeRecord): Mat;
+    computeShapeRenderToPageTransform(shape: ShapeRecord): Mat;
+    computeShapeExportToPageTransform(shape: ShapeRecord): Mat;
+    computeShapePageBounds(shape: ShapeRecord): Box;
+    computeShapeExportPageBounds(shape: ShapeRecord): Box;
+    computeShapeGeometry(shape: ShapeRecord): ShapeGeometry;
+    computeShapePositionedToPageTransform(shape: ShapeRecord): Mat;
+    computeShapePageCenter(shape: ShapeRecord): Vec;
+    computeShapePageCorners(shape: ShapeRecord): Vec[];
+    computeShapePageOutlineVertices(shape: ShapeRecord): Vec[];
+    getShapeBounds(shapeId: ShapeId): Box | null;
+    getShapePageBounds(shapeId: ShapeId): Box | null;
+    getShapeGeometry(shapeId: ShapeId): ShapeGeometry | null;
+    getShapePositionedToPageTransform(shapeId: ShapeId): Mat | null;
+    getShapePageCenter(shapeId: ShapeId): Vec | null;
+    getShapePageCorners(shapeId: ShapeId): Vec[] | null;
+    getShapePageOutlineVertices(shapeId: ShapeId): Vec[];
+    getSelectionPageBounds(): Box | null;
+    getSelectionFrame(): SelectionFrame | null;
+    isPointInSelectionBounds(point: Vec): boolean;
+    getSelectionFrameLocalBoundsPoint(point: Vec): Vec | null;
+    getSelectionPageOutlineVertices(): Vec[];
+    getSelectionAnchorPagePoint(): Vec | null;
+    hitTestSelectionHandle(point: Vec): SelectionHandle | null;
+    setBrushBox(brushBox: Box | null): void;
+    getErasingShapeIds(): ShapeId[];
+    setErasingShapeIds(shapeIds: readonly ShapeId[]): void;
+    clearErasingShapeIds(): void;
+    getEraserTrail(): Vec[];
+    setEraserTrail(points: readonly Vec[]): void;
+    clearEraserTrail(): void;
+    startLaserTrail(): number;
+    setLaserTrail(sessionId: number, points: readonly Vec[]): void;
+    finishLaserTrail(sessionId: number): void;
+    clearLaserTrail(sessionId: number): void;
+    setBindingPreview(preview: BindingPreviewState | null): void;
+    setDropTargetShapeId(shapeId: ShapeId | null): void;
+    setSelectionTranslationActive(active: boolean): void;
+    setSnapIndicators(indicators: SnapIndicatorState[] | null): void;
+    setTerminalBindingResolver(resolver: TerminalBindingResolver): void;
+    resolveTerminalBinding(input: TerminalBindingResolverInput): ResolvedTerminalBinding;
+    clearSelectionTransients(): void;
+    hitTestShape(point: Vec): ShapeRecord | null;
+    hitTestShapesAtPoint(point: Vec, options?: ShapeAtPointOptions): ShapeRecord[];
+    hitTestShapesByLineSegment(start: Vec, end: Vec, options?: ShapeLineSegmentHitTestOptions): ShapeRecord[];
+    getShapeIdsInBounds(bounds: Box, options?: SpatialQueryOptions): ShapeId[];
+    getShapesInBounds(bounds: Box, options?: SpatialQueryOptions): ShapeRecord[];
+    getShapesInViewport(bounds: Box, options?: SpatialQueryOptions): ShapeRecord[];
+    getDocumentSnapshot(): DocumentSnapshot;
+    getSessionSnapshot(): SessionSnapshot;
+    getSvgString(shapeIds?: Iterable<ShapeId>, options?: SvgExportOptions): SvgExportResult | null;
+    getExportIntegrityReport(shapeIds?: Iterable<ShapeId>): ExportIntegrityReport;
+    repairExportIntegrity(shapeIds?: Iterable<ShapeId>): ExportIntegrityRepairResult;
+    getShapeCapabilityManifest(): ShapeCapabilityManifest;
+    createPageRecord(input?: {
+        name?: string;
+        index?: string;
+        meta?: Record<string, unknown>;
+    }): PageRecord;
+    loadDocumentSnapshot(snapshot: unknown, options?: {
+        source?: ChangeSource;
+    }): void;
+    loadSessionSnapshot(snapshot: unknown, options?: {
+        source?: ChangeSource;
+    }): void;
+    syncAfterDocumentRestore(): void;
+    cancelInteractionForCommand(): void;
+    cancelInteractionAndClearTransients(reason: CancelEditorEvent["reason"]): void;
+    syncToolStateFromSession(source: ChangeSource): void;
+    createShapeRecord(input: CreateShapeInput): ShapeRecord;
+    createBindingRecord(input: CreateBindingInput): BindingRecord;
+    createAssetRecord(input: CreateAssetInput): AssetRecord;
+    updateSession(partial: Partial<SessionRecord>, source?: ChangeSource): void;
+    setCurrentPage(pageId: PageId, source?: ChangeSource): void;
+    setSelectedShapeIds(ids: ShapeId[], options?: {
+        pageId?: PageId;
+        source?: ChangeSource;
+    }): void;
+    removeShapeIdsFromSelection(ids: ShapeId[], source?: ChangeSource): void;
+    removeShapeIdsFromEditingSession(ids: ShapeId[], source?: ChangeSource): void;
+    ensurePageSessionState(pageId: PageId, source?: ChangeSource): void;
+    removePageSessionState(pageId: PageId, nextCurrentPageId: PageId, source?: ChangeSource): void;
+    setCamera(partial: Partial<Camera>, options?: {
+        pageId?: PageId;
+        source?: ChangeSource;
+    }): void;
+    panCamera(delta: Vec, source?: ChangeSource): void;
+    zoomCameraAtScreenPoint(screenPoint: Vec, deltaY: number, source?: ChangeSource): void;
+    zoomCameraToScreenPoint(screenPoint: Vec, zoom: number, source?: ChangeSource): void;
+    zoomAtViewportCenter(deltaY: number, source?: ChangeSource): void;
+    resetZoom(source?: ChangeSource): void;
+    setViewportScreenSize(size: {
+        w: number;
+        h: number;
+    }): void;
+    /** Combined page bounds of every shape on a page, or null when empty. */
+    getCurrentPageBounds(pageId?: PageId): Box | null;
+    /**
+     * Move and zoom the camera so `bounds` fits inside the viewport with optional
+     * padding (screen px). Returns false when the viewport or bounds are empty.
+     */
+    zoomToBounds(bounds: Box, options?: {
+        padding?: number;
+        maxZoom?: number;
+        source?: ChangeSource;
+    }): boolean;
+    /** Fit all shapes on the current page into the viewport. */
+    zoomToFit(options?: {
+        padding?: number;
+        source?: ChangeSource;
+    }): boolean;
+    /** Fit the current selection into the viewport. */
+    zoomToSelection(options?: {
+        padding?: number;
+        source?: ChangeSource;
+    }): boolean;
+    private createShapeId;
+    createShapeIndex(shapeNumber: number): string;
+    private createBindingId;
+    private createAssetId;
+    syncShapeCounter(): void;
+    syncPageCounter(): void;
+    syncBindingCounter(): void;
+    syncAssetCounter(): void;
+    private createPageId;
+    private createPageIndex;
+    private handleWheelEvent;
+}
+export {};

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

@@ -0,0 +1,21 @@
+import type { Box } from "../geometry/box";
+import type { Vec } from "../geometry/vec";
+import type { AssetId, PageId, ShapeId, ShapeRecord } from "../schema/records";
+import type { BindingPreviewState } from "./selection";
+import type { EditorOverlayDebugState, EditorRenderHostDebugState, RenderItem } from "./editor";
+export declare function areShapeIdArraysEqual(a: ShapeId[], b: ShapeId[]): boolean;
+export declare function areVecsEqual(a: Vec | null, b: Vec | null): boolean;
+export declare function areVecArraysEqual(a: readonly Vec[], b: readonly Vec[]): boolean;
+export declare function areBoxesEqual(a: Box | null, b: Box | null): boolean;
+export declare function isValidBox(box: Box): boolean;
+export declare function areRenderHostDebugStatesEqual(a: EditorRenderHostDebugState, b: EditorRenderHostDebugState): boolean;
+export declare function areOverlayDebugStatesEqual(a: EditorOverlayDebugState, b: EditorOverlayDebugState): boolean;
+export declare function getBoxDebugSummary(box: Box | null): string;
+export declare function getShapePageIdFromParentChain(shape: ShapeRecord, shapeById: ReadonlyMap<ShapeId, ShapeRecord>, pageIds: ReadonlySet<PageId>): PageId | null;
+export declare function areBindingPreviewStatesEqual(a: BindingPreviewState | null, b: BindingPreviewState | null): boolean;
+export declare function areRenderItemsEqual(a: RenderItem[], b: RenderItem[]): boolean;
+export declare function areShapeIdSetsEqual(a: Set<ShapeId>, b: Set<ShapeId>): boolean;
+export declare function getCommonShapeType(shapes: readonly ShapeRecord[]): ShapeRecord["type"] | null;
+export declare function getShapeAssetId(shape: ShapeRecord): AssetId | null;
+export declare function areSerializableValuesEqual(a: unknown, b: unknown): boolean;
+export declare function areShapePropsPatchesEqual(a: Readonly<Record<string, unknown>>, b: Readonly<Record<string, unknown>>): boolean;

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

@@ -0,0 +1,6 @@
+import type { ChangeSource } from "../../store/index";
+import type { ShapeSelectionFlipAxis } from "../shapes/shapeUtil";
+import type { ShapeUpdate } from "./commands";
+import type { Editor } from "./editor";
+export declare function resetEditorSelectionRotation(editor: Editor, source?: ChangeSource): void;
+export declare function getEditorSelectionFlipUpdates(editor: Editor, axis: ShapeSelectionFlipAxis): ShapeUpdate[];

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

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