@yuzhouu/canvas-standard 0.1.0

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

@@ -0,0 +1,356 @@
+import { type Signal, type SignalGraph } from "../../signals/index";
+import { Store, type ChangeSource, type RecordsDiff, type StoreChange } from "../../store/index";
+import { BindingManager } from "../bindings/bindingManager";
+import type { BindingUtil } from "../bindings/bindingUtil";
+import { BindingUtilRegistry } from "../bindings/bindingUtilRegistry";
+import type { ResolvedTerminalBinding, TerminalBindingResolver, TerminalBindingResolverInput } from "../bindings/terminalBinding";
+import { ShapeSvgExporterRegistry, exportShapesToSvgString, type ShapeSvgExporter } from "../exports/svg";
+import { Box } from "../geometry/box";
+import { Mat } from "../geometry/mat";
+import type { Vec } from "../geometry/vec";
+import { EditorRuntimeRegistry } from "../plugins/editorRuntimeRegistry";
+import { type AssetId, type AssetRecord, type BindingId, type BindingRecord, type Camera, type DocumentMetadataRecord, type EditorRecord, type PageId, type PageRecord, type RecordScope, type SessionRecord, type ShapeEditingSession, type ShapeId, type ShapeParentId, type ShapeRecord } from "../schema/records";
+import type { DocumentSnapshot, SessionSnapshot } from "../schema/snapshots";
+import type { ShapeSelectionFlipAxis, ShapeUtil } from "../shapes/shapeUtil";
+import { ShapeUtilRegistry } from "../shapes/shapeUtilRegistry";
+import { ToolManager } from "../tools/toolManager";
+import type { DuplicateSelectionInput, EditorClipboardPayload, PasteClipboardPayloadInput } from "./clipboard";
+import type { CreatePageInput, EditorCommands, ShapePropsPatch } from "./commands/commandTypes";
+import type { CancelEditorEvent, EditorEvent, EditorEventResult } from "./events/events";
+import { InputsManager } from "./events/inputsManager";
+import { InteractionHandlerRegistry } from "./events/interactions";
+import { HistoryManager } from "./history/historyManager";
+import { EditorOperationManager } from "./history/operationManager";
+import { editorStoreSymbol } from "./internal";
+import type { ShapeGeometry } from "./queries/shapeTransforms";
+import { type ShapeAtPointOptions, type ShapeLineSegmentHitTestOptions, type SpatialQueryOptions } from "./queries/spatialIndexManager";
+import type { BindingPreviewState, SelectionFrame, SelectionHandle, SnapIndicatorState, TerminalBindingGuideState } from "./selection/selection";
+import { ShapeEditingManager } from "./shapes/shapeEditingManager";
+import { type ContainerBoundsQueryOptions, type ShapeContainment } from "./shapes/shapeContainment";
+import type { ShapeGroupState } from "./shapes/shapeGrouping";
+import type { LayerOrderDirection, LayerOrderEdge, ShapeSelectionSiblingOrderState, ShapeSiblingOrderDirection, ShapeSiblingOrderEdge, ShapeSiblingOrderState } from "./shapes/shapeOrder";
+import type { ReparentShapePlacementInput, ReparentShapePlacementResult } from "./shapes/shapeReparenting";
+import { SnapManager, type SnapDiagnostics } from "./snapping/snapManager";
+import type { EditorRenderSignals, EditorStateSignals } from "./state/editorSignals";
+import { type CameraAnimationScheduler } from "./viewport/cameraManager";
+export interface EditorOptions {
+    shapeUtils?: ShapeUtil[];
+    shapeSvgExporters?: ShapeSvgExporter[];
+    bindingUtils?: BindingUtil[];
+    resolveAssetUrl?: (assetId: AssetId) => string | null;
+    documentMeta?: Record<string, unknown>;
+    onUnhandledError?: (error: unknown) => void;
+    snapDiagnostics?: SnapDiagnostics;
+    cameraAnimationScheduler?: CameraAnimationScheduler;
+}
+export interface CenterOnShapeOptions {
+    source?: ChangeSource;
+    animation?: {
+        durationMs: number;
+    };
+}
+interface ReadonlyStore {
+    get(id: string): EditorRecord | undefined;
+    getRevision(): number;
+    getActiveTransactionRevision(): number | null;
+    getActiveTransactionDiff(): RecordsDiff<EditorRecord>;
+    getRecordSignal(id: string): Signal<EditorRecord | undefined>;
+    getAll(): EditorRecord[];
+    getByScope(scope: RecordScope): EditorRecord[];
+    listen(listener: (change: StoreChange<EditorRecord>) => void): () => void;
+}
+export declare class Editor {
+    readonly signals: SignalGraph;
+    readonly store: ReadonlyStore;
+    readonly [editorStoreSymbol]: Store<EditorRecord>;
+    readonly inputs: InputsManager;
+    readonly tools: ToolManager;
+    private readonly cameraManager;
+    readonly editing: ShapeEditingManager;
+    readonly shapeUtils: ShapeUtilRegistry;
+    readonly shapeSvgExporters: ShapeSvgExporterRegistry;
+    readonly bindingUtils: BindingUtilRegistry;
+    readonly interactions: InteractionHandlerRegistry;
+    readonly runtime: EditorRuntimeRegistry;
+    private readonly bindingQueries;
+    private readonly shapeGeometryQueries;
+    private readonly shapeTreeIndex;
+    private readonly selectionGeometry;
+    private readonly bindingManager;
+    private readonly spatialIndex;
+    readonly snaps: SnapManager;
+    private readonly renderWindowManager;
+    private readonly shapeSignals;
+    private readonly selectionOverlay;
+    private readonly interactionManager;
+    private readonly eventRouter;
+    readonly history: HistoryManager;
+    readonly operations: EditorOperationManager;
+    readonly commands: EditorCommands;
+    readonly state: EditorStateSignals;
+    readonly render: EditorRenderSignals;
+    private readonly _shapeDefaultPropsByTypeSignal;
+    private assetUrlResolver;
+    private readonly _readonlySignal;
+    private writesClosed;
+    readonly document: {
+        readonly getMetadata: () => DocumentMetadataRecord | undefined;
+        readonly updateMetadata: (patch: Record<string, unknown>, source?: ChangeSource) => DocumentMetadataRecord;
+        readonly setReadonly: (readonly: boolean) => void;
+    };
+    readonly session: {
+        readonly get: () => SessionRecord;
+        readonly update: (partial: Partial<SessionRecord>, source?: ChangeSource) => void;
+    };
+    readonly pages: {
+        readonly getAll: () => PageRecord[];
+        readonly get: (id: PageId) => PageRecord | undefined;
+        readonly getCurrentId: () => PageId;
+        readonly createAndSelect: (input?: CreatePageInput, source?: ChangeSource) => PageRecord;
+        readonly select: (pageId: PageId, source?: ChangeSource) => void;
+        readonly rename: (pageId: PageId, name: string, source?: ChangeSource) => void;
+        readonly updateMetadata: (pageId: PageId, patch: Record<string, unknown>, source?: ChangeSource) => PageRecord | null;
+        readonly delete: (pageId: PageId, source?: ChangeSource) => boolean;
+    };
+    readonly selection: {
+        readonly getIds: (pageId?: PageId) => ShapeId[];
+        readonly set: (ids: ShapeId[], options?: {
+            pageId?: PageId;
+            source?: ChangeSource;
+        }) => void;
+        readonly remove: (ids: ShapeId[], source?: ChangeSource) => void;
+        readonly delete: (source?: ChangeSource) => void;
+        readonly createClipboardPayload: () => EditorClipboardPayload | null;
+        readonly pasteClipboardPayload: (input: PasteClipboardPayloadInput) => ShapeId[];
+        readonly duplicate: (input?: DuplicateSelectionInput) => ShapeId[];
+        readonly selectAll: (source?: ChangeSource) => void;
+        readonly resetRotation: (source?: ChangeSource) => void;
+        readonly flip: (axis: ShapeSelectionFlipAxis, source?: ChangeSource) => void;
+        readonly canAlign: () => boolean;
+        readonly align: (mode: "left" | "horizontal-center" | "right" | "top" | "vertical-center" | "bottom", source?: ChangeSource) => boolean;
+        readonly canDistribute: () => boolean;
+        readonly distribute: (axis: "horizontal" | "vertical", source?: ChangeSource) => boolean;
+        readonly canResize: () => boolean;
+        readonly canFlip: () => boolean;
+        readonly canRotate: () => boolean;
+        readonly getTransformTargets: () => ShapeRecord[];
+        readonly getResizeTargets: () => ShapeRecord[];
+        readonly getRotationTargets: () => ShapeRecord[];
+        readonly getPageBounds: () => Box | null;
+        readonly getFrame: () => SelectionFrame | null;
+        readonly containsPoint: (point: Vec) => boolean;
+        readonly toFramePoint: (point: Vec) => Vec | null;
+        readonly getPageOutlineVertices: () => Vec[];
+        readonly getAnchorPagePoint: () => Vec | null;
+        readonly getFrameBounds: () => Box | null;
+        readonly getRotationCenter: () => Vec | null;
+        readonly getRotation: () => number;
+        readonly hasCompatibleRotation: () => boolean;
+        readonly hitTestHandle: (point: Vec) => SelectionHandle | null;
+    };
+    readonly shapes: {
+        readonly get: (id: ShapeId) => ShapeRecord | undefined;
+        readonly getForPage: (pageId: PageId) => ShapeRecord[];
+        readonly getSignal: (id: ShapeId) => Signal<ShapeRecord | undefined>;
+        readonly getContentCutoutLocalPolygonsSignal: (id: ShapeId) => Signal<readonly (readonly Vec[])[]>;
+        readonly getLocalToPageTransformSignal: (id: ShapeId) => Signal<Mat | undefined>;
+        readonly getLocalToPageTransform: (id: ShapeId) => Mat | null;
+        readonly getPageBoundsSignal: (id: ShapeId) => Signal<Box | undefined>;
+        readonly getSelectedSignal: (id: ShapeId) => Signal<boolean>;
+        readonly getRenderOrderSignal: (id: ShapeId) => Signal<number>;
+        readonly getRenderVisibleSignal: (id: ShapeId) => Signal<boolean>;
+        readonly getDocumentVisibleSignal: (id: ShapeId) => Signal<boolean>;
+        readonly getEffectiveOpacitySignal: (id: ShapeId) => Signal<number>;
+        readonly getEditingSessionSignal: (id: ShapeId) => Signal<ShapeEditingSession | null>;
+        readonly getDropTargetSignal: (id: ShapeId) => Signal<boolean>;
+        readonly getHoveredSignal: (id: ShapeId) => Signal<boolean>;
+        readonly getSelectedDescendantTransformAncestorSignal: (id: ShapeId) => Signal<boolean>;
+        readonly isHidden: (shapeId: ShapeId) => boolean;
+        readonly getDefaultProps: <TProps extends object = object>(type: ShapeRecord["type"]) => TProps;
+        readonly updateDefaultProps: (type: ShapeRecord["type"], props: ShapePropsPatch) => void;
+        readonly delete: (ids: readonly ShapeId[], source?: ChangeSource) => void;
+        readonly setHidden: (ids: readonly ShapeId[], isHidden: boolean, source?: ChangeSource) => ShapeId[];
+        readonly setLocked: (ids: readonly ShapeId[], isLocked: boolean, source?: ChangeSource) => ShapeId[];
+        readonly getUtil: <S extends ShapeRecord>(shape: S) => ShapeUtil<S>;
+        readonly computePositionedBounds: (shape: ShapeRecord) => Box;
+        readonly computeLocalBounds: (shape: ShapeRecord) => Box;
+        readonly computeRenderBounds: (shape: ShapeRecord) => Box;
+        readonly computeExportBounds: (shape: ShapeRecord) => Box;
+        readonly computeLocalToPageTransform: (shape: ShapeRecord) => Mat;
+        readonly computeRenderToPageTransform: (shape: ShapeRecord) => Mat;
+        readonly computeExportToPageTransform: (shape: ShapeRecord) => Mat;
+        readonly computePageBounds: (shape: ShapeRecord) => Box;
+        readonly computeExportPageBounds: (shape: ShapeRecord) => Box;
+        readonly computeGeometry: (shape: ShapeRecord) => ShapeGeometry;
+        readonly computePositionedToPageTransform: (shape: ShapeRecord) => Mat;
+        readonly computePageCenter: (shape: ShapeRecord) => Vec;
+        readonly computePageCorners: (shape: ShapeRecord) => Vec[];
+        readonly computePageOutlineVertices: (shape: ShapeRecord) => Vec[];
+        readonly getPositionedBounds: (shapeId: ShapeId) => Box | null;
+        readonly getPageBounds: (shapeId: ShapeId) => Box | null;
+        readonly getGeometry: (shapeId: ShapeId) => ShapeGeometry | null;
+        readonly getPositionedToPageTransform: (shapeId: ShapeId) => Mat | null;
+        readonly getPageCenter: (shapeId: ShapeId) => Vec | null;
+        readonly getPageCorners: (shapeId: ShapeId) => Vec[] | null;
+        readonly getPageOutlineVertices: (shapeId: ShapeId) => Vec[];
+        readonly getClipAncestorIds: (shapeId: ShapeId) => ShapeId[];
+        readonly getClipAncestorIdsSignal: (shapeId: ShapeId) => Signal<ShapeId[]>;
+        readonly isPagePointInClip: (shapeId: ShapeId, point: Vec) => boolean;
+        readonly getClippedPageBounds: (shapeId: ShapeId) => Box | null;
+        readonly hitTest: (point: Vec) => ShapeRecord | null;
+        readonly hitTestPoint: (point: Vec, options?: ShapeAtPointOptions) => ShapeRecord[];
+        readonly hitTestLineSegment: (start: Vec, end: Vec, options?: ShapeLineSegmentHitTestOptions) => ShapeRecord[];
+        readonly getIdsInBounds: (bounds: Box, options?: SpatialQueryOptions) => ShapeId[];
+        readonly getInBounds: (bounds: Box, options?: SpatialQueryOptions) => ShapeRecord[];
+        readonly getInViewport: (bounds: Box, options?: SpatialQueryOptions) => ShapeRecord[];
+        readonly getIdsInViewport: (bounds: Box, options?: SpatialQueryOptions) => ShapeId[];
+    };
+    readonly layers: {
+        readonly getSelectionParentOrderState: () => ShapeSelectionSiblingOrderState | null;
+        readonly getSelectionGroupState: () => ShapeGroupState | null;
+        readonly canGroupSelection: () => boolean;
+        readonly canGroup: (ids: readonly ShapeId[]) => boolean;
+        readonly group: (ids: readonly ShapeId[], source?: ChangeSource) => ShapeRecord | null;
+        readonly groupSelection: (source?: ChangeSource) => ShapeRecord | null;
+        readonly getUngroupableSelectionIds: () => ShapeId[];
+        readonly getUngroupableIds: (ids: readonly ShapeId[]) => ShapeId[];
+        readonly canUngroupSelection: () => boolean;
+        readonly canUngroup: (ids: readonly ShapeId[]) => boolean;
+        readonly ungroup: (ids: readonly ShapeId[], source?: ChangeSource) => ShapeId[];
+        readonly ungroupSelection: (source?: ChangeSource) => ShapeId[];
+        readonly getSelectionSiblingOrderState: () => ShapeSiblingOrderState | null;
+        readonly canMoveSelectionWithinParent: (direction: ShapeSiblingOrderDirection) => boolean;
+        readonly canMoveSelection: (direction: ShapeSiblingOrderDirection) => boolean;
+        readonly canMove: (ids: readonly ShapeId[], direction: LayerOrderDirection) => boolean;
+        readonly move: (ids: readonly ShapeId[], direction: LayerOrderDirection, source?: ChangeSource) => boolean;
+        readonly moveToEdge: (ids: readonly ShapeId[], edge: LayerOrderEdge, source?: ChangeSource) => boolean;
+        readonly moveSelectionWithinParent: (direction: ShapeSiblingOrderDirection, source?: ChangeSource) => boolean;
+        readonly moveToPlacement: (input: ReparentShapePlacementInput, source?: ChangeSource) => ReparentShapePlacementResult;
+        readonly moveSelection: (direction: ShapeSiblingOrderDirection, source?: ChangeSource) => boolean;
+        readonly moveSelectionToEdge: (edge: ShapeSiblingOrderEdge, source?: ChangeSource) => boolean;
+        readonly getChildIds: (parentId: ShapeParentId) => ShapeId[];
+        readonly getChildren: (parentId: ShapeParentId) => ShapeRecord[];
+        readonly getDescendantIds: (parentId: ShapeParentId) => ShapeId[];
+        readonly getDescendantPageBounds: (parentId: ShapeParentId) => Box | null;
+        readonly getSubtreePageBounds: (shapeId: ShapeId) => Box | null;
+        readonly getPageId: (shapeId: ShapeId) => PageId | null;
+        readonly isOrAncestorLocked: (shapeId: ShapeId) => boolean;
+        readonly isOrAncestorInSet: (shapeId: ShapeId, ids: ReadonlySet<ShapeId>) => boolean;
+        readonly hasLockedDescendant: (shapeId: ShapeId) => boolean;
+        readonly getOutermostSelectableId: (shapeId: ShapeId) => ShapeId;
+        readonly includeDescendants: (shapeIds: Iterable<ShapeId>) => ShapeId[];
+        readonly getSelectionTransformIds: (shapeIds: Iterable<ShapeId>) => ShapeId[];
+        readonly getSelectionRotationIds: (shapeIds: Iterable<ShapeId>) => ShapeId[];
+        readonly getExportTraversalIds: (shapeIds: Iterable<ShapeId>) => ShapeId[];
+        readonly getContainment: (containerId: ShapeId, shapeId: ShapeId) => ShapeContainment | null;
+        readonly getContainingParentId: (shapeIds: Iterable<ShapeId>) => ShapeParentId | null;
+        readonly getContainingParentIdAtPoint: (shapeIds: Iterable<ShapeId>, point: Vec) => ShapeParentId | null;
+        readonly getContainingParentIdForShape: (shape: ShapeRecord) => ShapeParentId | null;
+        readonly getIdsInContainerBounds: (containerId: ShapeId, options?: ContainerBoundsQueryOptions) => ShapeId[];
+        readonly canReceiveChildren: (parentId: ShapeParentId) => boolean;
+        readonly canReceiveChild: (parentId: ShapeParentId, childId: ShapeId) => boolean;
+    };
+    readonly assets: {
+        readonly get: (id: AssetId) => AssetRecord | undefined;
+        readonly getAll: () => AssetRecord[];
+        readonly resolveUrl: (assetId: AssetId) => string | null;
+    };
+    readonly bindings: {
+        readonly get: (id: BindingId) => BindingRecord | undefined;
+        readonly getFromShape: (shapeId: ShapeId) => BindingRecord[];
+        readonly getFromShapeSignal: (shapeId: ShapeId) => Signal<readonly BindingRecord[]>;
+        readonly getToShape: (shapeId: ShapeId) => BindingRecord[];
+        readonly getToShapeSignal: (shapeId: ShapeId) => Signal<readonly BindingRecord[]>;
+        readonly getForShape: (shapeId: ShapeId) => BindingRecord[];
+        readonly getForShapeSignal: (shapeId: ShapeId) => Signal<readonly BindingRecord[]>;
+        readonly getUtil: <B extends BindingRecord>(binding: B) => BindingUtil<B>;
+        readonly getSuppressedReactionIds: () => ReadonlySet<BindingId>;
+        readonly runWithSuppressedReactions: <T>(bindingIds: Iterable<BindingId>, callback: () => T) => T;
+        readonly getConflicting: (binding: BindingRecord) => BindingRecord[];
+        readonly canBind: (binding: BindingRecord) => boolean;
+        readonly syncCreated: (binding: BindingRecord, source: ChangeSource) => void;
+        readonly syncUpdated: (before: BindingRecord, after: BindingRecord, source: ChangeSource) => void;
+        readonly repairLoaded: (source: ChangeSource) => void;
+        readonly handleShapeChanges: (changes: Parameters<BindingManager["handleShapeChanges"]>[0], source: ChangeSource) => void;
+        readonly getShapeCompanionRootId: (shapeId: ShapeId) => ShapeId;
+        readonly getShapeCompanionRootIds: (shapeIds: readonly ShapeId[], records?: readonly BindingRecord[]) => ReadonlyMap<ShapeId, ShapeId>;
+        readonly getShapeCompanionMemberIds: (shapeIds: readonly ShapeId[]) => ShapeId[];
+        readonly cleanupForDeletedShapes: (shapeIds: readonly ShapeId[], source: ChangeSource) => void;
+        readonly cleanup: (bindingIds: Iterable<BindingId>, source: ChangeSource) => void;
+        readonly setTerminalResolver: (resolver: TerminalBindingResolver) => void;
+        readonly resolveTerminal: (input: TerminalBindingResolverInput) => ResolvedTerminalBinding;
+    };
+    readonly viewport: {
+        readonly getCamera: (pageId?: PageId) => Camera;
+        readonly pageToScreen: (point: Vec, pageId?: PageId) => Vec;
+        readonly screenToPage: (point: Vec, pageId?: PageId) => Vec;
+        readonly setCamera: (partial: Partial<Camera>, options?: {
+            pageId?: PageId;
+            source?: ChangeSource;
+        }) => void;
+        readonly pan: (delta: Vec, source?: ChangeSource) => void;
+        readonly zoomAtScreenPoint: (screenPoint: Vec, deltaY: number, source?: ChangeSource) => void;
+        readonly zoomToScreenPoint: (screenPoint: Vec, zoom: number, source?: ChangeSource) => void;
+        readonly zoomAtCenter: (deltaY: number, source?: ChangeSource) => void;
+        readonly resetZoom: (source?: ChangeSource) => void;
+        readonly setScreenSize: (size: {
+            w: number;
+            h: number;
+        }) => void;
+        readonly stopCameraAnimation: () => void;
+        readonly getCurrentPageBounds: (pageId?: PageId) => Box | null;
+        readonly centerOnShape: (shapeId: ShapeId, options?: CenterOnShapeOptions) => boolean;
+        readonly zoomToBounds: (bounds: Box, options?: {
+            padding?: number;
+            maxZoom?: number;
+            source?: ChangeSource;
+        }) => boolean;
+        readonly zoomToFit: (options?: {
+            padding?: number;
+            source?: ChangeSource;
+        }) => boolean;
+        readonly zoomToSelection: (options?: {
+            padding?: number;
+            source?: ChangeSource;
+        }) => boolean;
+    };
+    readonly interaction: {
+        readonly setBrushBox: (brushBox: Box | null) => void;
+        readonly setBindingPreview: (preview: BindingPreviewState | null) => void;
+        readonly setTerminalBindingGuides: (guides: readonly TerminalBindingGuideState[] | null) => void;
+        readonly setDropTargetShapeId: (shapeId: ShapeId | null) => void;
+        readonly setHoveredShapeId: (shapeId: ShapeId | null) => void;
+        readonly setSelectionTranslationActive: (active: boolean) => void;
+        readonly setSnapIndicators: (indicators: SnapIndicatorState[] | null) => void;
+        readonly clearSelection: () => void;
+        readonly cancelForCommand: () => void;
+        readonly cancel: (reason: CancelEditorEvent["reason"], options?: {
+            notifyInteractionHandlers?: boolean;
+        }) => void;
+    };
+    readonly snapshots: {
+        readonly getDocument: () => DocumentSnapshot;
+        readonly getSession: () => SessionSnapshot;
+        readonly loadDocument: (snapshot: unknown, options?: {
+            source?: ChangeSource;
+        }) => void;
+        readonly loadSession: (snapshot: unknown, options?: {
+            source?: ChangeSource;
+        }) => void;
+        readonly syncAfterDocumentRestore: () => void;
+    };
+    readonly exports: {
+        readonly getSvgString: (shapeIds?: Iterable<ShapeId>, options?: Parameters<typeof exportShapesToSvgString>[3]) => import("..").SvgExportResult | null;
+        readonly getIntegrityReport: (shapeIds?: Iterable<ShapeId>) => import("..").ExportIntegrityReport;
+        readonly repairIntegrity: (shapeIds?: Iterable<ShapeId>) => import("..").ExportIntegrityRepairResult;
+    };
+    constructor(options?: EditorOptions);
+    closeWrites(): void;
+    assertDocumentWriteAllowed(): void;
+    private assertStoreChangeAllowed;
+    private registerBuiltInInteractions;
+    handleEvent(event: EditorEvent): EditorEventResult;
+    listen(listener: (change: StoreChange<EditorRecord>) => void): () => void;
+    dispose(): void;
+}
+export {};

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/events/canvasNavigationInteraction.d.ts

@@ -0,0 +1,2 @@
+import type { LandInteractionHandler } from "./interactions";
+export declare function createCanvasNavigationInteractionHandler(): LandInteractionHandler;

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/events/eventRouter.d.ts

@@ -0,0 +1,16 @@
+import type { Editor } from "../editor";
+import type { CancelEditorEvent, EditorEvent, EditorEventResult } from "./events";
+export declare class EditorEventRouter {
+    private readonly editor;
+    private readonly clickRecognizer;
+    private readonly activeRoutes;
+    constructor(editor: Editor);
+    handle(event: EditorEvent): EditorEventResult;
+    cancelInteraction(reason: CancelEditorEvent["reason"], options?: {
+        notifyInteractionHandlers?: boolean;
+    }): void;
+    private routeNewEvent;
+    private routeAfterInputs;
+    private routeCancellation;
+    private routeEscape;
+}

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

@@ -0,0 +1,81 @@
+import type { Vec } from "../../geometry/vec";
+export type EditorPointerType = "mouse" | "touch" | "pen";
+export interface PointerEditorEvent {
+    type: "pointer";
+    name: "pointer_down" | "pointer_move" | "pointer_up" | "pointer_cancel";
+    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 DoubleClickEditorEvent {
+    type: "double_click";
+    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 interface EditorEventContext {
+    readonly origin: "external" | "derived";
+    readonly pointer: {
+        readonly clickCount: number;
+    } | null;
+}
+export interface EditorEventRoutingEffect {
+    propagation?: "stop";
+    clickSequence?: "break";
+}
+export interface EditorEventResult {
+    claimed: boolean;
+}
+export type EditorEvent = PointerEditorEvent | DoubleClickEditorEvent | KeyboardEditorEvent | WheelEditorEvent | TickEditorEvent | CancelEditorEvent;
+export declare function mergeEditorEventRoutingEffects(left?: EditorEventRoutingEffect | void, right?: EditorEventRoutingEffect | void): EditorEventRoutingEffect | undefined;

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/events/inputsManager.d.ts

@@ -0,0 +1,49 @@
+import type { Atom, Computed, SignalGraph } from "../../../signals/index";
+import type { EditorEvent, PointerEditorEvent } from "./events";
+import { Vec } from "../../geometry/vec";
+export type InputDragPhase = "idle" | "pointing" | "dragging";
+export interface InputsState {
+    originPagePoint: Vec | null;
+    currentPagePoint: Vec | null;
+    previousPagePoint: Vec | null;
+    originScreenPoint: Vec | null;
+    currentScreenPoint: Vec | null;
+    previousScreenPoint: Vec | null;
+    currentTimestamp: number | null;
+    previousTimestamp: number | null;
+    pageVelocity: Vec;
+    screenVelocity: Vec;
+    pointerId: number | null;
+    pointerType: PointerEditorEvent["pointerType"] | null;
+    buttons: number;
+    isPointing: boolean;
+    isDragging: boolean;
+    dragPhase: InputDragPhase;
+    shiftKey: boolean;
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    accelKey: boolean;
+}
+export declare class InputsManager {
+    readonly pressedKeyCodes: Atom<ReadonlySet<string>>;
+    readonly isSpacePressed: Computed<boolean>;
+    readonly state: Atom<InputsState>;
+    constructor(signals: SignalGraph);
+    setCurrentPointerPoint(input: {
+        timestamp: number;
+        pagePoint: Vec;
+        screenPoint: Vec;
+        shiftKey: boolean;
+        altKey: boolean;
+        ctrlKey: boolean;
+        metaKey: boolean;
+        accelKey: boolean;
+    }): void;
+    handleEvent(event: EditorEvent): void;
+    resetPointer(): void;
+    private handlePointerEvent;
+    private handleKeyboardEvent;
+    private resetKeyboard;
+    private handleWheelEvent;
+}

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/events/interactions.d.ts

@@ -0,0 +1,84 @@
+import type { ChangeSource } from "../../../store/index";
+import type { Vec } from "../../geometry/vec";
+import type { ShapeId, ShapeRecord } from "../../schema/records";
+import type { Editor } from "../editor";
+import type { CancelEditorEvent, EditorEvent, EditorEventContext, EditorEventRoutingEffect, PointerEditorEvent } from "./events";
+import type { SelectionHandle } from "../selection/selection";
+import type { HandleSnapContext, HandleSnapMode } from "../snapping/snapTypes";
+export interface SelectionHandleInteractionInput {
+    handle: SelectionHandle;
+    shape: ShapeRecord;
+    originPagePoint: Vec;
+}
+export interface PointerDragInteractionSession {
+    readonly shapeId: ShapeId;
+    readonly operationKind: string;
+    readonly shouldClearBindingPreviewOnExit?: boolean;
+    onDragStart?(input: {
+        editor: Editor;
+    }): void;
+    onClick?(input: {
+        editor: Editor;
+        source: ChangeSource;
+    }): void;
+    onDoubleClick?(input: {
+        editor: Editor;
+        source: ChangeSource;
+    }): void;
+    onCancel?(input: {
+        editor: Editor;
+        reason: CancelEditorEvent["reason"];
+    }): void;
+    onComplete?(input: {
+        editor: Editor;
+    }): void;
+    update(input: {
+        editor: Editor;
+        pagePoint: Vec;
+        accelKey: boolean;
+        source: ChangeSource;
+    }): "continue" | "stop" | PointerDragInteractionUpdateResult;
+}
+export interface PointerDragInteractionUpdateResult {
+    status: "continue" | "stop";
+    finalPagePoint?: Vec | null;
+}
+export interface SelectionHandleInteractionSession extends PointerDragInteractionSession {
+    readonly handleSnapMode?: HandleSnapMode;
+    readonly handleSnapContext?: HandleSnapContext;
+    readonly allowSelfSnap?: boolean;
+    readonly excludedSnapShapeIds?: readonly ShapeId[];
+}
+export type SelectionHandleInteractionUpdateResult = PointerDragInteractionUpdateResult;
+export interface SelectionHandleInteractionHandler {
+    createSession(editor: Editor, input: SelectionHandleInteractionInput): SelectionHandleInteractionSession | null;
+}
+export interface ShapePointerInteractionInput {
+    shape: ShapeRecord;
+    selectionTargetId: ShapeId;
+    originPagePoint: Vec;
+    event: PointerEditorEvent;
+}
+export interface ShapePointerInteractionHandler {
+    createSession(editor: Editor, input: ShapePointerInteractionInput): PointerDragInteractionSession | null;
+}
+export interface EditorEventInteractionHandler {
+    handleEvent(editor: Editor, event: EditorEvent, context: EditorEventContext): EditorEventRoutingEffect | void;
+}
+export interface LandInteractionHandler {
+    id: string;
+    enabledInReadonly?: boolean;
+    editorEvent?: EditorEventInteractionHandler;
+    selectionHandle?: SelectionHandleInteractionHandler;
+    shapePointer?: ShapePointerInteractionHandler;
+}
+export declare class InteractionHandlerRegistry {
+    private readonly handlers;
+    private readonly registeredIds;
+    register(handler: LandInteractionHandler): void;
+    getHandlers(): readonly LandInteractionHandler[];
+    handleEvent(editor: Editor, event: EditorEvent, context: EditorEventContext): EditorEventRoutingEffect | undefined;
+    broadcastEvent(editor: Editor, event: EditorEvent, context: EditorEventContext): EditorEventRoutingEffect | undefined;
+    createSelectionHandleSession(editor: Editor, input: SelectionHandleInteractionInput): SelectionHandleInteractionSession | null;
+    createShapePointerSession(editor: Editor, input: ShapePointerInteractionInput): PointerDragInteractionSession | null;
+}

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/events/keyboardShortcuts.d.ts

@@ -0,0 +1,23 @@
+import type { KeyboardEditorEvent } from "./events";
+export interface KeyboardShortcutChord {
+    key: string;
+    altKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey?: boolean;
+    accelKey?: boolean;
+}
+export type KeyboardShortcutInput = string | KeyboardShortcutChord;
+export type KeyboardShortcutEventLike = Pick<KeyboardEditorEvent, "key" | "altKey" | "ctrlKey" | "metaKey" | "shiftKey" | "accelKey">;
+interface NormalizedKeyboardShortcutChord {
+    key: string;
+    altKey: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey: boolean;
+    accelKey?: boolean;
+}
+export declare function normalizeKeyboardShortcut(shortcut: KeyboardShortcutInput): NormalizedKeyboardShortcutChord;
+export declare function formatKeyboardShortcut(shortcut: KeyboardShortcutInput): string;
+export declare function doesKeyboardShortcutMatch(shortcut: KeyboardShortcutInput, event: KeyboardShortcutEventLike): boolean;
+export {};

package/_vendor/plugin-arrow/_vendor/canvas-core/editor/events/pointerClickRecognizer.d.ts

@@ -0,0 +1,11 @@
+import type { DoubleClickEditorEvent, EditorEvent, EditorEventContext, EditorEventRoutingEffect } from "./events";
+export declare class PointerClickRecognizer {
+    private lastPointerDown;
+    private lastPointerUp;
+    private currentClickCount;
+    createContext(event: EditorEvent, origin: EditorEventContext["origin"]): EditorEventContext;
+    complete(event: EditorEvent, context: EditorEventContext, effect?: EditorEventRoutingEffect | void): DoubleClickEditorEvent | null;
+    private isContinuation;
+    private matchesCurrentPointer;
+    private reset;
+}