@yuzhouu/canvas-kit 0.1.2 → 0.1.4

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

@@ -0,0 +1,28 @@
+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 { CanvasAction } from "../surfaces/actions";
+import type { ContextMenuContribution } from "../surfaces/contextMenu";
+import type { ToolbarContribution } from "../surfaces/toolbar";
+export interface LandEditorPlugin {
+    id: string;
+    shapeCapabilities?: ShapeCapabilityDefinition[];
+    shapeUtils?: ShapeUtil[];
+    shapeSvgExporters?: ShapeSvgExporter[];
+    bindingUtils?: BindingUtil[];
+    interactionHandlers?: LandInteractionHandler[];
+    canvasActions?: CanvasAction[];
+    toolbarContributions?: ToolbarContribution[];
+    contextMenuContributions?: ContextMenuContribution[];
+    setup?(editor: Editor): void;
+}
+export declare function getEditorOptionsFromEditorPlugins(plugins: readonly LandEditorPlugin[]): {
+    shapeUtils: ShapeUtil[];
+    shapeSvgExporters: ShapeSvgExporter[];
+    bindingUtils: BindingUtil[];
+    shapeCapabilities: ShapeCapabilityDefinition[];
+};
+export declare function setupEditorPlugins(editor: Editor, plugins: readonly LandEditorPlugin[]): void;

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

@@ -0,0 +1 @@
+export { getEditorOptionsFromEditorPlugins, setupEditorPlugins, type LandEditorPlugin, } from "./editorPlugin";

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/snapshotSupport.d.ts

@@ -0,0 +1,43 @@
+import type { BindingUtilRegistry } from "../bindings/bindingUtilRegistry";
+import type { ShapeUtilRegistry } from "../shapes/shapeUtilRegistry";
+import type { AssetRecord, BindingId, BindingRecord, ShapeId, ShapeRecord } from "./records";
+export interface DocumentSnapshotRequirements {
+    shapeTypes: readonly ShapeRecord["type"][];
+    bindingTypes: readonly BindingRecord["type"][];
+    assetTypes: readonly AssetRecord["type"][];
+}
+export interface DocumentSnapshotSupport {
+    modelShapeTypes: ReadonlySet<ShapeRecord["type"]>;
+    modelBindingTypes: ReadonlySet<BindingRecord["type"]>;
+    renderableShapeTypes?: ReadonlySet<ShapeRecord["type"]>;
+}
+export interface UnsupportedDocumentSnapshotRequirements {
+    modelShapeTypes: readonly ShapeRecord["type"][];
+    modelBindingTypes: readonly BindingRecord["type"][];
+    renderableShapeTypes: readonly ShapeRecord["type"][];
+}
+export interface FilterDocumentSnapshotBySupportResult {
+    snapshot: {
+        schemaVersion: 1;
+        records: unknown[];
+    };
+    removedShapeIds: readonly ShapeId[];
+    removedShapeTypes: readonly ShapeRecord["type"][];
+    removedBindingIds: readonly BindingId[];
+    removedBindingTypes: readonly BindingRecord["type"][];
+    removedRecords: readonly unknown[];
+}
+export declare function createDocumentSnapshotSupport({ bindingUtils, renderableShapeTypes, shapeUtils, }: {
+    bindingUtils: BindingUtilRegistry;
+    renderableShapeTypes?: Iterable<ShapeRecord["type"]>;
+    shapeUtils: ShapeUtilRegistry;
+}): DocumentSnapshotSupport;
+export declare function getDocumentSnapshotRequirements(snapshot: unknown): DocumentSnapshotRequirements;
+export declare function getUnsupportedDocumentSnapshotRequirements({ requirements, support, }: {
+    requirements: DocumentSnapshotRequirements;
+    support: DocumentSnapshotSupport;
+}): UnsupportedDocumentSnapshotRequirements;
+export declare function filterDocumentSnapshotBySupport({ snapshot, support, }: {
+    snapshot: unknown;
+    support: DocumentSnapshotSupport;
+}): FilterDocumentSnapshotBySupportResult;

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

@@ -0,0 +1,31 @@
+import type { ShapeUtilRegistry } from "../shapes/shapeUtilRegistry";
+import type { BindingUtilRegistry } from "../bindings/bindingUtilRegistry";
+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 getSnapshotEnvelope(snapshot: unknown, kind: "document" | "session"): {
+    schemaVersion: number;
+    records: unknown[];
+};
+export declare function parseDocumentSnapshot(snapshot: unknown, shapeUtils: ShapeUtilRegistry, bindingUtils: BindingUtilRegistry): DocumentSnapshot;
+export declare function parseSessionSnapshot(snapshot: unknown): SessionSnapshot;

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/colors.d.ts

@@ -0,0 +1,26 @@
+export declare const LAND_THEME_COLOR_SLOTS: readonly ["fill-blue", "fill-green", "fill-red", "fill-amber", "fill-white", "fill-slate", "stroke-blue", "stroke-green", "stroke-red", "stroke-orange", "stroke-slate", "stroke-muted", "text-slate", "text-blue", "text-green", "text-red"];
+export type ThemeColorSlot = (typeof LAND_THEME_COLOR_SLOTS)[number];
+export type ThemeColorTokenName = `--land-shape-${ThemeColorSlot}`;
+export interface ThemeShapeColorRef {
+    kind: "theme";
+    slot: ThemeColorSlot;
+}
+export interface CustomShapeColorRef {
+    kind: "custom";
+    value: string;
+}
+export type ShapeColorRef = ThemeShapeColorRef | CustomShapeColorRef;
+export type ShapeColor = string | ShapeColorRef;
+export declare const LAND_THEME_COLOR_TOKEN_BY_SLOT: Record<ThemeColorSlot, ThemeColorTokenName>;
+export declare const LAND_DEFAULT_THEME_COLOR_FALLBACKS: Record<ThemeColorSlot, string>;
+export declare function createThemeShapeColor(slot: ThemeColorSlot): ThemeShapeColorRef;
+export declare function createCustomShapeColor(value: string): CustomShapeColorRef;
+export declare function isThemeShapeColorRef(value: unknown): value is ThemeShapeColorRef;
+export declare function isCustomShapeColorRef(value: unknown): value is CustomShapeColorRef;
+export declare function isShapeColor(value: unknown): value is ShapeColor;
+export declare function getThemeColorTokenName(slot: ThemeColorSlot): ThemeColorTokenName;
+export declare function normalizeShapeColor(value: unknown, fallback: ShapeColor): ShapeColor;
+export declare function shapeColorToCssColor(color: ShapeColor): string;
+export declare function resolveShapeColor(color: ShapeColor, resolveThemeColor?: (token: ThemeColorTokenName, fallback: string) => string): string;
+export declare function isTransparentShapeColor(color: ShapeColor): boolean;
+export declare function areShapeColorsEqual(left: ShapeColor | null | undefined, right: ShapeColor | null | undefined): boolean;

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

@@ -0,0 +1,146 @@
+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 { SelectionBindingMiddleHandleAnchor, SelectionBindingSegment, SelectionBindingTerminalHandleAnchor, 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 {
+    editor?: Editor;
+    pageStart: Vec;
+    pageEnd: Vec;
+    positionedStart: Vec;
+    positionedEnd: Vec;
+    margin: number;
+}
+export interface ShapeGeometryInput {
+    editor: Editor;
+}
+export interface ShapePointHitTestInput extends ShapeGeometryInput {
+    pagePoint: Vec;
+    positionedPoint: Vec;
+}
+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 ShapeSelectionOverlayInfoInput {
+    editor: Editor;
+}
+export interface ShapeSelectionHandleAnchors {
+    terminalHandleAnchors: readonly SelectionBindingTerminalHandleAnchor[];
+    middleHandleAnchors: readonly SelectionBindingMiddleHandleAnchor[];
+    customHandleAnchors?: readonly SelectionCustomHandleAnchor[];
+}
+export interface ShapeSelectionOverlayInfo {
+    usesSelectionPathOverlay: boolean;
+    startPagePoint: Vec | null;
+    endPagePoint: Vec | null;
+    middlePagePoint: Vec | null;
+    path: string | null;
+    bindingSegments?: readonly SelectionBindingSegment[];
+}
+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;
+    getPointHitTestBounds(shape: S, _input?: ShapeGeometryInput): 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, _input: ShapeSelectionOverlayInfoInput): 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, _input?: ShapePointHitTestInput): 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/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/surfaces/actions.d.ts

@@ -0,0 +1,35 @@
+import type { Editor } from "../editor/editor";
+import type { ShapeId, ShapeRecordBase } from "../schema/records";
+import type { ShapeColorRef } from "../shapes/colors";
+export interface CanvasSelectionSnapshot {
+    selectedShapeIds: readonly ShapeId[];
+    selectedShapes: readonly ShapeRecordBase[];
+    count: number;
+    singleShapeType: ShapeRecordBase["type"] | null;
+    commonShapeType: ShapeRecordBase["type"] | null;
+    canResetRotation: boolean;
+    isMixedFrameAndPointHandleSelection: boolean;
+}
+export interface CanvasToolSnapshot {
+    activeToolId: string;
+    isToolLocked: boolean;
+}
+export interface CanvasActionContext {
+    editor: Editor;
+    selection: CanvasSelectionSnapshot;
+    tool: CanvasToolSnapshot;
+}
+export type CanvasActionValue = string | number | boolean | null | ShapeColorRef | {
+    readonly [key: string]: CanvasActionValue;
+} | readonly CanvasActionValue[];
+export interface CanvasActionRunInput<TValue extends CanvasActionValue> {
+    context: CanvasActionContext;
+    value: TValue;
+}
+export interface CanvasAction<TValue extends CanvasActionValue = CanvasActionValue> {
+    id: string;
+    isVisible?(context: CanvasActionContext): boolean;
+    isEnabled?(context: CanvasActionContext): boolean;
+    getValue?(context: CanvasActionContext): TValue;
+    run(input: CanvasActionRunInput<TValue>): void;
+}

package/_vendor/canvas-core/surfaces/contextMenu.d.ts

@@ -0,0 +1,64 @@
+import type { Vec } from "../geometry";
+import type { ShapeId, ShapeRecordBase } from "../schema/records";
+import type { CanvasActionContext, CanvasActionValue } from "./actions";
+export interface ContextMenuCanvasTarget {
+    type: "canvas";
+}
+export interface ContextMenuShapeTarget {
+    type: "shape";
+    shapeId: ShapeId;
+    shapeType: ShapeRecordBase["type"];
+    selected: boolean;
+}
+export interface ContextMenuSelectionTarget {
+    type: "selection";
+    selectedShapeIds: readonly ShapeId[];
+}
+export type ContextMenuTarget = ContextMenuCanvasTarget | ContextMenuShapeTarget | ContextMenuSelectionTarget;
+export interface ActiveContextMenu {
+    anchor: {
+        screenPoint: Vec;
+        pagePoint: Vec;
+    };
+    target: ContextMenuTarget;
+}
+export interface ContextMenuContext extends CanvasActionContext {
+    menu: ActiveContextMenu;
+}
+export type ContextMenuContributionTarget = "canvas" | "selection" | "shape" | "any";
+export interface ContextMenuCommandItem {
+    kind: "command";
+    id: string;
+    actionId: string;
+    label: string;
+    icon?: string;
+    value?: CanvasActionValue;
+    shortcut?: string;
+    tone?: "default" | "destructive";
+    dataUi?: string;
+}
+export interface ContextMenuSeparatorItem {
+    kind: "separator";
+    id: string;
+}
+export interface ContextMenuBadgeItem {
+    kind: "badge";
+    id: string;
+    label: string;
+    dataUi?: string;
+}
+export type ContextMenuItem = ContextMenuCommandItem | ContextMenuSeparatorItem | ContextMenuBadgeItem;
+export interface ContextMenuSection {
+    id: string;
+    order?: number;
+    title?: string;
+    items: readonly ContextMenuItem[];
+}
+export interface ContextMenuContribution {
+    id: string;
+    target: ContextMenuContributionTarget;
+    order?: number;
+    actionIds: readonly string[];
+    when?(context: ContextMenuContext): boolean;
+    getSections(context: ContextMenuContext): readonly ContextMenuSection[];
+}

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

@@ -0,0 +1,96 @@
+import type { CanvasActionContext, CanvasActionValue } from "./actions";
+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" | "floating";
+export interface ToolbarButtonItem {
+    kind: "button";
+    id: string;
+    actionId: string;
+    label: string;
+    icon: string;
+    value?: CanvasActionValue;
+    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: CanvasActionValue;
+    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 ToolbarSliderItem {
+    kind: "slider";
+    id: string;
+    actionId: string;
+    label: string;
+    min: number;
+    max: number;
+    step?: number;
+    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 | ToolbarSliderItem | 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: CanvasActionContext): boolean;
+    getGroups(context: CanvasActionContext): 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/index.d.ts

@@ -0,0 +1,2 @@
+export { HandTool } from "./hand/handTool";
+export { SelectTool } from "./select/selectTool";

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

@@ -0,0 +1,12 @@
+import type { Editor } from "../../editor/editor";
+import type { Vec } from "../../geometry/vec";
+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[], pagePoint?: Vec): ShapeParentId | null;
+export declare function updateDropTarget(editor: Editor, shapeIds: readonly ShapeId[], pagePoint?: Vec): void;
+export declare function applyContainmentParent(editor: Editor, shapeIds: readonly ShapeId[], pagePoint?: Vec): void;

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);
+}