@yuzhouu/canvas-kit 0.1.2 → 0.1.3

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

@@ -0,0 +1,57 @@
+export { Editor } from "./editor/Editor";
+export { distanceBetweenSegments, distanceToSegment, nearestPointOnSegment, segmentsIntersect, } from "./geometry";
+export { getShapeGeometry, getShapeExportBounds, getShapeExportPageBounds, getShapeExportToPageTransform, getShapeLocalBounds, getShapeLocalToPageTransform, getShapePositionedOutlineVertices, getShapePositionedToPageTransform, getShapePageBounds, getShapePageCenter, getShapePageCorners, getShapePageOutlineVertices, pagePointToShapePositionedPoint, positionedShapePointToPagePoint, getShapeRenderBounds, getShapeRenderToPageTransform, } from "./editor/queries/shapeTransforms";
+export type { ShapeGeometry } from "./editor/queries/shapeTransforms";
+export type { ArrowBindingPreviewState, GapSnapIndicatorGapState, GapSnapIndicatorState, PointSnapIndicatorState, SnapIndicatorState, SelectionArrowMiddleHandle, SelectionArrowMiddleHandleAnchor, SelectionArrowTerminalHandle, SelectionArrowTerminalHandleAnchor, SelectionCustomHandle, SelectionCustomHandleAnchor, SelectionHandle, SelectionOverlayFrameState, SelectionOverlayFrameGeometryState, SelectionOverlayFrameStyleState, SelectionOverlayHandleAnchorsState, SelectionOverlayHandleCountsState, SelectionOverlayHandlesState, SelectionOverlayState, SelectionResizeHandle, SelectionResizeHandleAnchor, SelectionResizeHandleId, SelectionRotateHandle, SelectionRotateHandleAnchor, SelectionRotateHandleId, SelectionMirrorAxis, } from "./editor/selection";
+export { flipSelectionLocalBounds, getSelectionLocalBoundsFromPagePoints, mapSelectionLocalBoundsBetweenBounds, mapSelectionLocalPointBetweenBounds, mirrorSelectionLocalPoint, rotateSelectionPagePoint, selectionLocalPointToPagePoint, selectionPagePointToLocalPoint, } from "./editor/selection";
+export { getAnchoredSelectionResizeLocalBounds, getAspectRatioLockedSelectionResizeBounds, getCenteredSelectionResizeBounds, getConstrainedSelectionResizeBounds, getSelectionResizeBounds, getSelectionResizeScalesFromBounds, isSelectionResizeCorner, normalizeSelectionResizeBoundsFromEdges, selectionResizeHandleMovesBottomEdge, selectionResizeHandleMovesLeftEdge, selectionResizeHandleMovesRightEdge, selectionResizeHandleMovesTopEdge, } from "./editor/resizeGeometry";
+export { InteractionHandlerRegistry } from "./editor/interactions";
+export { SelectionHandleInteractionRegistry } from "./editor/selectionHandleInteractions";
+export type { EditorEventInteractionDecision, EditorEventInteractionHandler, LandInteractionHandler, SelectionHandleInteractionHandler, SelectionHandleInteractionInput, SelectionHandleInteractionSession, SelectionHandleInteractionUpdateResult, } from "./editor/interactions";
+export type { ContainerBoundsQueryOptions, EditorPageState, EditorOverlayDebugState, EditorRenderHostDebugState, EditorSelectionState, LayerOrderDirection, LayerOrderEdge, LayerTreeNode, ReparentShapePlacementInput, ReparentShapePlacementFailureReason, ReparentShapePlacementResult, ShapeSiblingOrderDirection, ShapeSiblingOrderEdge, ShapeSiblingOrderState, ShapeGroupState, ShapeSelectionSiblingOrderState, ShapePropsPatch, EditorToolState, EditorShapeEditingState, } from "./editor/Editor";
+export type { ShapeContainment } from "./editor/managers/QueryManager";
+export type { ShapeAtPointOptions, ShapeLineSegmentHitTestOptions, SpatialQueryOptions, } from "./editor/managers/SpatialIndexManager";
+export type { ArrowBindingTargetInput, ConnectionPoint, ConnectionTerminal, ArrowTerminalBindingResolver, ArrowTerminalBindingResolverInput, ResolvedArrowTerminalBinding, } from "./bindings/arrow/arrowBindingHelpers";
+export type { EditorCommandOptions, EditorCommands, CreateAssetInput, CreateBindingInput, CreatePageInput, MovePageInput, RenamePageInput, ReparentShapesInput, CreateShapeInput, SetCameraInput, ShapeUpdate, StartEditingShapeInput, UpdateAssetInput, UpdateBindingInput, } from "./editor/commands";
+export { reparentShapeToContainingParent } from "./editor/commands";
+export { isEditorClipboardPayload, } from "./editor/clipboard";
+export type { ClipboardAssetSidecar, DuplicateSelectionInput, EditorClipboardPayload, PasteClipboardPayloadInput, } from "./editor/clipboard";
+export type { EditorEvent, ClickEditorEvent, PointerEditorEvent, KeyboardEditorEvent, WheelEditorEvent, TickEditorEvent, CancelEditorEvent, EditorPointerType, } from "./editor/events";
+export type { ChangeSource, RecordUpdate, RecordsDiff, ScopedStoreRecord, StoreRecord, StoreChange, StoreScopeOf, StoreSnapshot, } from "../store/index";
+export { composeRecordsDiff, createEmptyRecordsDiff, filterRecordsDiff, getRecordMap, getRecordsDiff, hasRecordsDiff, invertRecordsDiff, squashRecordsDiffs, } from "../store/index";
+export { appendStoreHistoryMark, createStoreHistoryEntry, createStoreHistoryMark, Store, StoreHistoryBuffer, } from "../store/index";
+export type { StoreHistoryEntry, StoreHistoryMark, StoreHistoryState, } from "../store/index";
+export { SnapshotParseError, parseDocumentSnapshot, parseSessionSnapshot, migrateSnapshotRecords, } from "./schema/snapshots";
+export type { DocumentSnapshot, SessionSnapshot, SnapshotMigration, } from "./schema/snapshots";
+export { ShapeUtil } from "./shapes/ShapeUtil";
+export type { ShapeBoundsSnapGeometry, ShapeBrushSelectInput, ShapeBrushWrapInput, ShapeBindingPointInput, ShapeEditEndResult, ShapeHandleSnapContext, ShapeHandleSnapGeometry, ShapeLineSegmentHitTestInput, ShapeSelectionHandleAnchorInput, ShapeSelectionHandleAnchors, ShapeSelectionFrameInput, ShapeSelectionFlipAxis, ShapeSelectionFlipInput, ShapeSelectionOverlayInfo, ShapeSelectionPagePoints, ShapeSelectionPagePointsInput, ShapeSelectionResizeAspectRatioLockInput, ShapeSelectionResizeInput, ShapeSelectionTranslateInput, } from "./shapes/ShapeUtil";
+export { SnapManager } from "./editor/managers/SnapManager";
+export type { LaserTrailState } from "./editor/managers/InteractionTransientManager";
+export { SideEffectManager } from "./editor/managers/SideEffectManager";
+export type { BeforeDeleteHandler, AfterDeleteHandler, RecordTypeName, } from "./editor/managers/SideEffectManager";
+export type { HandleSnapContext, HandleSnapInput, HandleSnapMode, HandleSnapResult, HandleSnapSnapshot, HandleSnapSnapshotInput, ResizeSnapInput, ResizeSnapResult, ResizeSnapSnapshot, SnapAxis, SnapCoordinateSpace, TranslateSnapInput, TranslateSnapResult, TranslateSnapSnapshot, } from "./editor/managers/snapTypes";
+export { ShapeUtilRegistry } from "./shapes/ShapeUtilRegistry";
+export { resolveArrowTerminalBindingAtPoint, } from "./bindings/arrow/arrowBindingHelpers";
+export { ShapeSvgExporterRegistry, exportShapesToSvgString, renderSvgNode, } from "./exports/svg";
+export type { ShapeSvgExporter, SvgAttributeValue, SvgElementNode, SvgExportContext, SvgExportOptions, SvgExportResult, SvgExportSkipReason, SvgExportSkippedShape, SvgNode, } from "./exports/svg";
+export { getExportIntegrityReport, repairExportIntegrity, } from "./exports/integrity";
+export type { ExportIntegrityIssue, ExportIntegrityIssueKind, ExportIntegrityRepairResult, ExportIntegrityReport, } from "./exports/integrity";
+export { getShapeCapabilityManifest } from "./shapes/capabilities";
+export type { ShapeCapabilityDefinition, ShapeCapabilityManifest, ShapeCapabilityManifestEntry, ShapeCapabilitySupport, } from "./shapes/capabilities";
+export { BindingUtil } from "./bindings/BindingUtil";
+export type { BindingSelectionCompanionFrameContext, BindingUtilEffect, } from "./bindings/BindingUtil";
+export { BindingUtilRegistry } from "./bindings/BindingUtilRegistry";
+export { StateNode } from "./editor/StateNode";
+export { getEdgeScrollDelta } from "./editor/edgeScroll";
+export { HandTool } from "./tools/hand/HandTool";
+export { SelectTool } from "./tools/select/SelectTool";
+export { SET_ACTIVE_TOOL_TOOLBAR_ACTION_ID, TOGGLE_TOOL_LOCKED_TOOLBAR_ACTION_ID, } from "./toolbar";
+export type { ContextMenuBadgeItem, ContextMenuCanvasTarget, ContextMenuCommandItem, ContextMenuContext, ContextMenuContribution, ContextMenuContributionTarget, ContextMenuItem, ContextMenuOpenSnapshot, ContextMenuSection, ContextMenuSelectionTarget, ContextMenuSeparatorItem, ContextMenuShapeTarget, ContextMenuTarget, } from "./contextMenu";
+export { getEditorOptionsFromCorePlugins, setupCorePlugins, type LandCorePlugin, } from "./plugins";
+export type { ToolbarAction, ToolbarActionRunInput, ToolbarActionValue, ToolbarBadgeItem, ToolbarButtonItem, ToolbarContext, ToolbarContribution, ToolbarGroup, ToolbarItem, ToolbarSegmentedItem, ToolbarSegmentedOption, ToolbarSelectionSnapshot, ToolbarSeparatorItem, ToolbarStepperItem, ToolbarStepperOption, ToolbarTextInputItem, ToolbarPlacement, ToolbarSurface, ToolbarSwatchesItem, ToolbarSwatchOption, ToolbarToolSnapshot, } from "./toolbar";
+export { DEFAULT_CAMERA, DEFAULT_PAGE_ID, DEFAULT_SESSION_ID, createDefaultPage, createDefaultSession, isAnyAssetRecord, isAnyBindingRecord, isAnyShapeRecord, isAssetRecord, isBindingRecord, isDocumentRecord, isPageRecord, isSessionRecord, isShapeRecord, type AnyBindingRecord, type AnyAssetRecord, type AnyShapeRecord, type AssetId, type AssetRecord, type AssetRecordBase, type BaseRecord, type BindingId, type BindingRecordBase, type BindingRecord, type Camera, type DocumentRecord, type EditorRecord, type PageCameraById, type PageId, type PageSelectionById, type PageRecord, type RecordScope, type SessionRecord, type ShapeId, type ShapeParentId, type ShapeRecordBase, type ShapeRecord, type ShapeEditingEntryRequest, type ShapeEditingEntryMode, type ShapeEditingPoint, type ShapeEditingSession, } from "./schema/records";
+export { Vec } from "./geometry/Vec";
+export { Box } from "./geometry/Box";
+export { Mat } from "./geometry/Mat";
+export { observeValue } from "./reactivity";
+export type { ReadonlyValue } from "./reactivity";

package/_vendor/canvas-core/plugins/index.d.ts

@@ -0,0 +1 @@
+export { getEditorOptionsFromCorePlugins, setupCorePlugins, type LandCorePlugin, } from "./types";

package/_vendor/canvas-core/plugins/types.d.ts

@@ -0,0 +1,27 @@
+import type { BindingUtil } from "../bindings/BindingUtil";
+import type { Editor } from "../editor/Editor";
+import type { LandInteractionHandler } from "../editor/interactions";
+import type { ShapeSvgExporter } from "../exports/svg";
+import type { ShapeCapabilityDefinition } from "../shapes/capabilities";
+import type { ShapeUtil } from "../shapes/ShapeUtil";
+import type { ToolbarAction, ToolbarContribution } from "../toolbar";
+import type { ContextMenuContribution } from "../contextMenu";
+export interface LandCorePlugin {
+    id: string;
+    shapeCapabilities?: ShapeCapabilityDefinition[];
+    shapeUtils?: ShapeUtil[];
+    shapeSvgExporters?: ShapeSvgExporter[];
+    bindingUtils?: BindingUtil[];
+    interactionHandlers?: LandInteractionHandler[];
+    toolbarActions?: ToolbarAction[];
+    toolbarContributions?: ToolbarContribution[];
+    contextMenuContributions?: ContextMenuContribution[];
+    setup?(editor: Editor): void;
+}
+export declare function getEditorOptionsFromCorePlugins(plugins: readonly LandCorePlugin[]): {
+    shapeUtils: ShapeUtil[];
+    shapeSvgExporters: ShapeSvgExporter[];
+    bindingUtils: BindingUtil[];
+    shapeCapabilities: ShapeCapabilityDefinition[];
+};
+export declare function setupCorePlugins(editor: Editor, plugins: readonly LandCorePlugin[]): void;

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

@@ -0,0 +1,4 @@
+export interface ReadonlyValue<T> {
+    get(): T;
+}
+export declare function observeValue<T>(name: string, value: ReadonlyValue<T>, onChange: () => void): () => void;

package/_vendor/canvas-core/schema/records.d.ts

@@ -0,0 +1,112 @@
+export type RecordScope = "document" | "session";
+export type PageId = `page:${string}`;
+export type ShapeId = `shape:${string}`;
+export type BindingId = `binding:${string}`;
+export type AssetId = `asset:${string}`;
+export type SessionId = "session:main";
+export type ShapeParentId = PageId | ShapeId;
+export type PageCameraById = Partial<Record<PageId, Camera>>;
+export type PageSelectionById = Partial<Record<PageId, ShapeId[]>>;
+export interface ShapeEditingPoint {
+    x: number;
+    y: number;
+}
+export type ShapeEditingEntryMode = "selectAll" | "placeCaret" | "focusEnd";
+export interface ShapeEditingEntryRequest {
+    id: number;
+    shapeId: ShapeId;
+    entryMode: ShapeEditingEntryMode;
+    caretPagePoint?: ShapeEditingPoint;
+}
+export interface ShapeEditingSession {
+    shapeId: ShapeId;
+    markId: string;
+    entryMode: ShapeEditingEntryMode;
+    caretPagePoint?: ShapeEditingPoint;
+    isComposing: boolean;
+}
+export interface Camera {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface BaseRecord {
+    id: string;
+    typeName: string;
+    scope: RecordScope;
+    meta: Record<string, unknown>;
+}
+export interface PageRecord extends BaseRecord {
+    id: PageId;
+    typeName: "page";
+    scope: "document";
+    name: string;
+    index: string;
+}
+export interface ShapeRecordBase<Type extends string = string, Props extends object = object> extends BaseRecord {
+    id: ShapeId;
+    typeName: "shape";
+    scope: "document";
+    type: Type;
+    parentId: ShapeParentId;
+    index: string;
+    x: number;
+    y: number;
+    rotation: number;
+    scaleX: number;
+    scaleY: number;
+    opacity: number;
+    isHidden: boolean;
+    isLocked: boolean;
+    props: Props;
+}
+export interface BindingRecordBase<Type extends string = string, Props extends object = object> extends BaseRecord {
+    id: BindingId;
+    typeName: "binding";
+    scope: "document";
+    type: Type;
+    fromId: ShapeId;
+    toId: ShapeId;
+    props: Props;
+}
+export interface AssetRecordBase<Type extends string = string, Props extends object = object> extends BaseRecord {
+    id: AssetId;
+    typeName: "asset";
+    scope: "document";
+    type: Type;
+    props: Props;
+}
+export type ShapeRecord = ShapeRecordBase<string, object>;
+export type BindingRecord = BindingRecordBase<string, object>;
+export type AssetRecord = AssetRecordBase<string, object>;
+export type AnyShapeRecord = ShapeRecord;
+export type AnyBindingRecord = BindingRecord;
+export type AnyAssetRecord = AssetRecord;
+export interface SessionRecord extends BaseRecord {
+    id: SessionId;
+    typeName: "session";
+    scope: "session";
+    currentPageId: PageId;
+    activeToolId: string;
+    isToolLocked: boolean;
+    editingShapeId: ShapeId | null;
+    shapeEditingSession: ShapeEditingSession | null;
+    pageCameraById: PageCameraById;
+    pageSelectedShapeIdsById: PageSelectionById;
+}
+export type DocumentRecord = PageRecord | AnyShapeRecord | AnyBindingRecord | AnyAssetRecord;
+export type EditorRecord = DocumentRecord | SessionRecord;
+export declare const DEFAULT_PAGE_ID: PageId;
+export declare const DEFAULT_SESSION_ID: SessionId;
+export declare const DEFAULT_CAMERA: Camera;
+export declare function createDefaultPage(): PageRecord;
+export declare function createDefaultSession(currentPageId?: PageId): SessionRecord;
+export declare function isPageRecord(record: BaseRecord | null | undefined): record is PageRecord;
+export declare function isShapeRecord(record: BaseRecord | null | undefined): record is ShapeRecord;
+export declare function isAnyShapeRecord(record: BaseRecord | null | undefined): record is AnyShapeRecord;
+export declare function isSessionRecord(record: BaseRecord | null | undefined): record is SessionRecord;
+export declare function isBindingRecord(record: BaseRecord | null | undefined): record is BindingRecord;
+export declare function isAnyBindingRecord(record: BaseRecord | null | undefined): record is AnyBindingRecord;
+export declare function isAssetRecord(record: BaseRecord | null | undefined): record is AssetRecord;
+export declare function isAnyAssetRecord(record: BaseRecord | null | undefined): record is AnyAssetRecord;
+export declare function isDocumentRecord(record: EditorRecord): record is DocumentRecord;

package/_vendor/canvas-core/schema/snapshots.d.ts

@@ -0,0 +1,27 @@
+import type { BindingUtilRegistry } from "../bindings/BindingUtilRegistry";
+import type { ShapeUtilRegistry } from "../shapes/ShapeUtilRegistry";
+import type { StoreSnapshot } from "../../store/index";
+import { type DocumentRecord, type SessionRecord } from "./records";
+export type DocumentSnapshot = StoreSnapshot<DocumentRecord, 1>;
+export type SessionSnapshot = StoreSnapshot<SessionRecord, 1>;
+export declare class SnapshotParseError extends Error {
+    constructor(message: string);
+}
+/**
+ * A single forward migration step. `up` transforms the raw records array from
+ * `fromVersion` to `fromVersion + 1`. Steps are chained in order, so adding a
+ * new schema version means bumping the CURRENT_* constant and appending one
+ * migration with `fromVersion` equal to the previous current version.
+ */
+export interface SnapshotMigration {
+    fromVersion: number;
+    up: (records: unknown[]) => unknown[];
+}
+/**
+ * Apply forward migration steps to bring a records array from `fromVersion` up
+ * to `toVersion`. Throws if a step is missing or the snapshot is newer than the
+ * supported version (no down-migration).
+ */
+export declare function migrateSnapshotRecords(records: unknown[], fromVersion: number, toVersion: number, migrations: readonly SnapshotMigration[], kind?: "document" | "session"): unknown[];
+export declare function parseDocumentSnapshot(snapshot: unknown, shapeUtils: ShapeUtilRegistry, bindingUtils: BindingUtilRegistry): DocumentSnapshot;
+export declare function parseSessionSnapshot(snapshot: unknown): SessionSnapshot;

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

@@ -0,0 +1,133 @@
+import { Box } from "../geometry/Box";
+import { Mat } from "../geometry/Mat";
+import { Vec } from "../geometry/Vec";
+import type { Editor } from "../editor/Editor";
+import type { ShapeUpdate } from "../editor/commands";
+import { type SelectionMirrorAxis } from "../editor/selection";
+import type { SelectionArrowMiddleHandleAnchor, SelectionArrowTerminalHandleAnchor, SelectionCustomHandleAnchor, SelectionHandle, SelectionResizeHandleId } from "../editor/selection";
+import type { ShapeId, ShapeRecordBase } from "../schema/records";
+export interface ShapeEditEndResult {
+    deleteShapeIds?: ShapeId[];
+}
+export interface ShapeBindingPointInput {
+    rawPagePoint: Vec;
+    oppositePagePoint: Vec;
+}
+export interface ShapeSelectionResizeInput {
+    handleId: SelectionResizeHandleId;
+    pageCenter: Vec;
+    selectionLocalBounds: Box;
+    scaleX: number;
+    scaleY: number;
+    isResizingFromCenter: boolean;
+    selectionRotation: number;
+    selectionRotationCenter: Vec;
+}
+export interface ShapeSelectionResizeAspectRatioLockInput {
+    editor: Editor;
+    handleId: SelectionResizeHandleId;
+    isOnlySelected: boolean;
+}
+export type ShapeSelectionFlipAxis = SelectionMirrorAxis;
+export interface ShapeSelectionFlipInput {
+    axis: ShapeSelectionFlipAxis;
+    selectionBounds: Box;
+    selectionLocalBounds: Box;
+    selectionRotation: number;
+    selectionRotationCenter: Vec;
+}
+export type ShapeSelectionPagePoints = readonly [Vec, Vec];
+export interface ShapeSelectionPagePointsInput {
+    pagePoints: ShapeSelectionPagePoints;
+}
+export interface ShapeBrushWrapInput {
+    brushBounds: Box;
+    pageOutlineVertices: readonly Vec[];
+    pageBounds: Box | null;
+}
+export interface ShapeBrushSelectInput extends ShapeBrushWrapInput {
+    isWrapping: boolean;
+}
+export interface ShapeLineSegmentHitTestInput {
+    pageStart: Vec;
+    pageEnd: Vec;
+    positionedStart: Vec;
+    positionedEnd: Vec;
+    margin: number;
+}
+export interface ShapeBoundsSnapGeometry {
+    points?: readonly Vec[];
+}
+export interface ShapeHandleSnapContext {
+    shapeId: ShapeId;
+    handle: SelectionHandle;
+    currentPagePoint: Vec;
+}
+export interface ShapeHandleSnapGeometry {
+    points?: readonly Vec[];
+    outline?: readonly Vec[] | null;
+    getSelfSnapPoints?(context: ShapeHandleSnapContext): readonly Vec[];
+    getSelfSnapOutline?(context: ShapeHandleSnapContext): readonly Vec[] | null;
+}
+export interface ShapeSelectionHandleAnchorInput {
+    isOnlySelected: boolean;
+    editor: Editor;
+}
+export interface ShapeSelectionFrameInput {
+    editor: Editor;
+}
+export interface ShapeSelectionTranslateInput {
+    editor: Editor;
+}
+export interface ShapeSelectionHandleAnchors {
+    terminalHandleAnchors: readonly SelectionArrowTerminalHandleAnchor[];
+    middleHandleAnchors: readonly SelectionArrowMiddleHandleAnchor[];
+    customHandleAnchors?: readonly SelectionCustomHandleAnchor[];
+}
+export interface ShapeSelectionOverlayInfo {
+    usesSelectionPathOverlay: boolean;
+    startPagePoint: Vec | null;
+    endPagePoint: Vec | null;
+    middlePagePoint: Vec | null;
+    path: string | null;
+}
+export declare abstract class ShapeUtil<S extends ShapeRecordBase = ShapeRecordBase> {
+    abstract readonly type: S["type"];
+    abstract getDefaultProps(): S["props"];
+    abstract validateProps(props: unknown): S["props"];
+    abstract getBounds(shape: S): Box;
+    getLocalBounds(shape: S): Box;
+    getRenderBounds(shape: S): Box;
+    getExportBounds(shape: S): Box;
+    getChildClipLocalBounds(_shape: S): Box | null;
+    getChildExportClipLocalBounds(shape: S): Box | null;
+    getSelectionResizeLocalBounds(shape: S): Box;
+    resizeSelectionBounds(shape: S, input: ShapeSelectionResizeInput): ShapeUpdate;
+    getSelectionResizeAspectRatioLock(_shape: S, _input: ShapeSelectionResizeAspectRatioLockInput): boolean | null;
+    flipSelectionBounds(shape: S, input: ShapeSelectionFlipInput): ShapeUpdate;
+    updateSelectionPagePoints(shape: S, _input: ShapeSelectionPagePointsInput): ShapeUpdate;
+    getSelectionPagePoints(_shape: S): ShapeSelectionPagePoints | null;
+    contributesToSelectionFrame(_shape: S, _input: ShapeSelectionFrameInput): boolean;
+    canUseSelectionFrameHandles(_shape: S, _input: ShapeSelectionFrameInput): boolean;
+    getSelectionTargetId(shape: S, _input: ShapeSelectionFrameInput): ShapeId;
+    getTranslateTargetId(shape: S, _input: ShapeSelectionTranslateInput): ShapeId;
+    shouldTransformDescendants(_shape: S): boolean;
+    shouldRotateDescendants(shape: S): boolean;
+    canStartTranslateFromSelectionBounds(_shape: S): boolean;
+    canSnap(_shape: S): boolean;
+    getBoundsSnapGeometry(_shape: S): ShapeBoundsSnapGeometry;
+    getHandleSnapGeometry(shape: S): ShapeHandleSnapGeometry;
+    getPositionedOutlineVertices(shape: S): Vec[];
+    getSelectionHandleAnchors(_shape: S, _input: ShapeSelectionHandleAnchorInput): ShapeSelectionHandleAnchors;
+    getSelectionOverlayInfo(_shape: S): ShapeSelectionOverlayInfo;
+    isWrappedByBrush(_shape: S, input: ShapeBrushWrapInput): boolean;
+    canSelectByBrush(shape: S, input: ShapeBrushSelectInput): boolean;
+    getLocalToPageTransform(shape: S): Mat;
+    canEdit(_shape: S): boolean;
+    canReceiveChildren(_shape: S): boolean;
+    repairLoadedShape(_shape: S): S | null;
+    onEditEnd(_shape: S): ShapeEditEndResult | void;
+    hitTest(shape: S, positionedPoint: Vec): boolean;
+    hitTestLineSegment(shape: S, input: ShapeLineSegmentHitTestInput): boolean;
+    resolveBindingPoint(_shape: S, input: ShapeBindingPointInput): Vec;
+}

package/_vendor/canvas-core/shapes/ShapeUtilRegistry.d.ts

@@ -0,0 +1,9 @@
+import type { ShapeRecordBase } from "../schema/records";
+import { ShapeUtil } from "./ShapeUtil";
+export declare class ShapeUtilRegistry {
+    private readonly registry;
+    register<S extends ShapeRecordBase>(util: ShapeUtil<S>): void;
+    has(type: ShapeRecordBase["type"]): boolean;
+    values(): IterableIterator<ShapeUtil>;
+    get<S extends ShapeRecordBase>(type: S["type"]): ShapeUtil<S>;
+}

package/_vendor/canvas-core/shapes/capabilities.d.ts

@@ -0,0 +1,25 @@
+import type { ShapeSvgExporterRegistry } from "../exports/svg";
+import type { ShapeRecordBase } from "../schema/records";
+import type { ShapeUtilRegistry } from "./ShapeUtilRegistry";
+export type ShapeCapabilitySupport = "supported" | "partial" | "missing";
+export interface ShapeCapabilityManifestEntry {
+    type: ShapeRecordBase["type"];
+    schemaProps: string[];
+    shapeUtil: ShapeCapabilitySupport;
+    reactRenderer: ShapeCapabilitySupport;
+    svgExporter: ShapeCapabilitySupport;
+    toolbarEntry: ShapeCapabilitySupport;
+    exportSupport: ShapeCapabilitySupport;
+    notes: string[];
+}
+export interface ShapeCapabilityManifest {
+    entries: ShapeCapabilityManifestEntry[];
+    supportedExportTypes: ShapeRecordBase["type"][];
+    missingExporterTypes: ShapeRecordBase["type"][];
+}
+export type ShapeCapabilityDefinition = Omit<ShapeCapabilityManifestEntry, "shapeUtil" | "svgExporter" | "exportSupport">;
+export declare function getShapeCapabilityManifest({ definitions, exporters, shapeUtils, }: {
+    definitions: readonly ShapeCapabilityDefinition[];
+    exporters: ShapeSvgExporterRegistry;
+    shapeUtils: ShapeUtilRegistry;
+}): ShapeCapabilityManifest;

package/_vendor/canvas-core/shapes/types.d.ts

@@ -0,0 +1,2 @@
+export type { BindingId, BindingRecord, PageRecord, PageId, EditorRecord, ShapeRecord, ShapeId, SessionRecord, } from "../schema/records";
+export { DEFAULT_PAGE_ID, DEFAULT_SESSION_ID, createDefaultPage, createDefaultSession, isBindingRecord, isPageRecord, isShapeRecord, isSessionRecord, } from "../schema/records";

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

@@ -0,0 +1,117 @@
+import type { Editor } from "./editor/Editor";
+import type { ShapeId, ShapeRecordBase } from "./schema/records";
+export declare const SET_ACTIVE_TOOL_TOOLBAR_ACTION_ID = "editor.tool.set-active-tool";
+export declare const TOGGLE_TOOL_LOCKED_TOOLBAR_ACTION_ID = "editor.tool.toggle-locked";
+export type ToolbarSurface = "selection" | "tool";
+export type ToolbarPlacement = "chrome" | "context";
+export interface ToolbarSelectionSnapshot {
+    selectedShapeIds: readonly ShapeId[];
+    selectedShapes: readonly ShapeRecordBase[];
+    count: number;
+    singleShapeType: ShapeRecordBase["type"] | null;
+    commonShapeType: ShapeRecordBase["type"] | null;
+    canResetRotation: boolean;
+    isMixedFrameAndPointHandleSelection: boolean;
+}
+export interface ToolbarToolSnapshot {
+    activeToolId: string;
+    isToolLocked: boolean;
+}
+export interface ToolbarContext {
+    editor: Editor;
+    selection: ToolbarSelectionSnapshot;
+    tool: ToolbarToolSnapshot;
+}
+export type ToolbarActionValue = string | number | boolean | null;
+export interface ToolbarActionRunInput<TValue extends ToolbarActionValue> {
+    context: ToolbarContext;
+    value: TValue;
+}
+export interface ToolbarAction<TValue extends ToolbarActionValue = ToolbarActionValue> {
+    id: string;
+    isVisible?(context: ToolbarContext): boolean;
+    isEnabled?(context: ToolbarContext): boolean;
+    getValue?(context: ToolbarContext): TValue;
+    run(input: ToolbarActionRunInput<TValue>): void;
+}
+export interface ToolbarButtonItem {
+    kind: "button";
+    id: string;
+    actionId: string;
+    label: string;
+    icon: string;
+    value?: ToolbarActionValue;
+    shortcut?: string;
+    dataUi?: string;
+}
+export interface ToolbarSegmentedOption {
+    value: string;
+    label: string;
+    icon?: string;
+    dataUi?: string;
+}
+export interface ToolbarSegmentedItem {
+    kind: "segmented";
+    id: string;
+    actionId: string;
+    options: readonly ToolbarSegmentedOption[];
+}
+export interface ToolbarSwatchOption {
+    value: string;
+    label: string;
+    color: string;
+    dataUi?: string;
+}
+export interface ToolbarSwatchesItem {
+    kind: "swatches";
+    id: string;
+    actionId: string;
+    label: string;
+    options: readonly ToolbarSwatchOption[];
+}
+export interface ToolbarStepperOption {
+    value: number;
+    label: string;
+    dataUi?: string;
+}
+export interface ToolbarStepperItem {
+    kind: "stepper";
+    id: string;
+    actionId: string;
+    label: string;
+    options: readonly ToolbarStepperOption[];
+    dataUi?: string;
+}
+export interface ToolbarTextInputItem {
+    kind: "text-input";
+    id: string;
+    actionId: string;
+    label: string;
+    placeholder?: string;
+    dataUi?: string;
+}
+export interface ToolbarBadgeItem {
+    kind: "badge";
+    id: string;
+    label: string;
+    dataUi?: string;
+}
+export interface ToolbarSeparatorItem {
+    kind: "separator";
+    id: string;
+}
+export type ToolbarItem = ToolbarButtonItem | ToolbarSegmentedItem | ToolbarSwatchesItem | ToolbarStepperItem | ToolbarTextInputItem | ToolbarBadgeItem | ToolbarSeparatorItem;
+export interface ToolbarGroup {
+    id: string;
+    order?: number;
+    items: readonly ToolbarItem[];
+}
+export interface ToolbarContribution {
+    id: string;
+    surface: ToolbarSurface;
+    placement?: ToolbarPlacement;
+    order?: number;
+    actionIds: readonly string[];
+    when?(context: ToolbarContext): boolean;
+    getGroups(context: ToolbarContext): readonly ToolbarGroup[];
+}

package/_vendor/canvas-core/tools/hand/HandTool.d.ts

@@ -0,0 +1,5 @@
+import type { Editor } from "../../editor/Editor";
+import { StateNode } from "../../editor/StateNode";
+export declare class HandTool extends StateNode {
+    constructor(editor: Editor);
+}

package/_vendor/canvas-core/tools/select/SelectTool.d.ts

@@ -0,0 +1,5 @@
+import type { Editor } from "../../editor/Editor";
+import { StateNode } from "../../editor/StateNode";
+export declare class SelectTool extends StateNode {
+    constructor(editor: Editor);
+}

package/_vendor/canvas-core/tools/select/selectContainment.d.ts

@@ -0,0 +1,11 @@
+import type { Editor } from "../../editor/Editor";
+import type { ShapeId, ShapeParentId } from "../../schema/records";
+/**
+ * Containment / reparenting helpers used by the translating gesture. These are
+ * pure with respect to the state node: they read and mutate editor state only,
+ * driven by the set of shape ids being dragged.
+ */
+export declare function getSharedCurrentParentId(editor: Editor, shapeIds: readonly ShapeId[]): ShapeParentId | null;
+export declare function resolveContainmentParentId(editor: Editor, shapeIds: readonly ShapeId[]): ShapeParentId | null;
+export declare function updateDropTarget(editor: Editor, shapeIds: readonly ShapeId[]): void;
+export declare function applyContainmentParent(editor: Editor, shapeIds: readonly ShapeId[]): void;