@yuzhouu/canvas-kit 0.1.2 → 0.1.3

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

@@ -0,0 +1,161 @@
+import { Box } from "../../geometry/Box";
+import { Vec } from "../../geometry/Vec";
+import type { ShapeUpdate } from "../../editor/commands";
+import type { Editor } from "../../editor/Editor";
+import type { PointerEditorEvent, TickEditorEvent } from "../../editor/events";
+import type { SelectionResizeHandleId, SelectionResizePointShapeSnapshot, SelectionResizeShapeSnapshot, SelectionRotationTransform, SelectionRotatePointShapeSnapshot, SelectionRotateShapeSnapshot } from "../../editor/selection";
+import type { HandleSnapSnapshot, ResizeSnapSnapshot, TranslateSnapSnapshot } from "../../editor/managers/snapTypes";
+import type { SelectionHandleInteractionSession } from "../../editor/selectionHandleInteractions";
+import type { ShapeId, ShapeRecord } from "../../schema/records";
+export declare const DRAG_START_DISTANCE = 3;
+export declare const DRAG_START_DISTANCE_SQUARED: number;
+export declare const ROTATION_SNAP_STEP: number;
+export declare const ROTATION_SOFT_SNAP_STEP: number;
+export declare const ROTATION_SOFT_SNAP_THRESHOLD: number;
+export declare const ROTATION_SOFT_SNAP_MAX_SCREEN_VELOCITY = 0.5;
+export declare const GROUP_CHILD_QUICK_SELECT_DURATION_MS = 250;
+export declare const TRANSLATE_SNAP_DISTANCE_SCREEN = 8;
+export declare const TRANSLATE_SNAP_MAX_SCREEN_VELOCITY = 0.5;
+export declare const RESIZE_SNAP_DISTANCE_SCREEN = 8;
+export declare const HANDLE_SNAP_DISTANCE_SCREEN = 8;
+export declare const TRANSLATE_HISTORY_MARK = "select.translate";
+export declare const RESIZE_HISTORY_MARK = "select.resize";
+export declare const ROTATE_HISTORY_MARK = "select.rotate";
+export type TranslateAxis = "x" | "y";
+export interface PointingCanvasInfo {
+    originPagePoint: Vec;
+    previousSelection: ShapeId[];
+    additiveSelection: boolean;
+}
+export interface PointingShapeInfo {
+    shapeId: ShapeId;
+    translateTargetId: ShapeId;
+    originPagePoint: Vec;
+    originTimestamp: number;
+    previousSelection: ShapeId[];
+    additiveSelection: boolean;
+    wasSelected: boolean;
+    fromSelectionBounds: boolean;
+    quickClickSelectionTargetId: ShapeId | null;
+}
+export interface TranslatingShapeSnapshot {
+    id: ShapeId;
+    x: number;
+    y: number;
+}
+export interface TranslatingInfo {
+    originPagePoint: Vec;
+    previousSelection: ShapeId[];
+    selectedShapeIds: ShapeId[];
+    startBounds: Box | null;
+    snapSnapshot: TranslateSnapSnapshot;
+    snapRotation: number;
+    selectedShapes: TranslatingShapeSnapshot[];
+    updates: ShapeUpdate[];
+    lockedAxis: TranslateAxis | null;
+    lastDeltaX: number;
+    lastDeltaY: number;
+}
+export interface BrushInfo {
+    originPagePoint: Vec;
+    previousSelection: ShapeId[];
+    additiveSelection: boolean;
+}
+export interface PointingResizeHandleInfo {
+    handleId: SelectionResizeHandleId;
+    originPagePoint: Vec;
+    cursorHandleOffset: Vec;
+    previousSelection: ShapeId[];
+}
+export interface ResizingInfo extends PointingResizeHandleInfo {
+    startBounds: Box;
+    rotation: number;
+    rotationCenter: Vec;
+    aspectRatio: number;
+    snapSnapshot: ResizeSnapSnapshot;
+    shapes: SelectionResizeShapeSnapshot[];
+    pointShapes: SelectionResizePointShapeSnapshot[];
+    updates: ShapeUpdate[];
+    aspectRatioLockOverride: boolean | null;
+    lastPagePointX: number;
+    lastPagePointY: number;
+    lastShiftKey: boolean;
+    lastAltKey: boolean;
+    lastAccelKey: boolean;
+}
+export interface PointingRotateHandleInfo {
+    originPagePoint: Vec;
+    previousSelection: ShapeId[];
+}
+export interface RotatingInfo extends PointingRotateHandleInfo {
+    center: Vec;
+    startAngle: number;
+    initialSelectionRotation: number;
+    shapes: SelectionRotateShapeSnapshot[];
+    pointShapes: SelectionRotatePointShapeSnapshot[];
+    updates: ShapeUpdate[];
+    lastPointerX: number;
+    lastPointerY: number;
+    lastShiftKey: boolean;
+    lastAccelKey: boolean;
+}
+export interface PointingSelectionHandleInteractionInfo {
+    originPagePoint: Vec;
+    previousSelection: ShapeId[];
+    session: SelectionHandleInteractionSession;
+    snapSnapshot: HandleSnapSnapshot | null;
+}
+export interface DraggingSelectionHandleInteractionInfo extends PointingSelectionHandleInteractionInfo {
+    lastPagePointX: number;
+    lastPagePointY: number;
+    lastAccelKey: boolean;
+}
+export interface SelectionDragInput {
+    pagePoint: Vec;
+    shiftKey: boolean;
+    altKey: boolean;
+    accelKey: boolean;
+    ctrlKey: boolean;
+}
+export type EdgeScrollTickMode = "always_apply" | "apply_after_scroll_or_without_screen_point" | "apply_after_scroll";
+export declare function getSelectionDragInputFromCurrentInputs(editor: Editor): SelectionDragInput | null;
+export declare function getSelectionDragInputForTick(editor: Editor, event: TickEditorEvent, mode: EdgeScrollTickMode): SelectionDragInput | null;
+export declare function applySelectionDragFromCurrentInputs(editor: Editor, apply: (input: SelectionDragInput) => void): void;
+export declare function createBrushBounds(origin: Vec, current: Vec): Box;
+export declare function hasExceededDragThreshold(origin: Vec, point: Vec): boolean;
+export declare function arePagePointsApproximatelyEqual(left: Vec, right: Vec): boolean;
+export declare function toggleIds(base: ShapeId[], toggled: ShapeId[]): ShapeId[];
+export declare function getOutermostSelectableShapeIds(editor: Editor, shapeIds: Iterable<ShapeId>): ShapeId[];
+export declare function getSelectableShapeIdForHit(editor: Editor, shapeId: ShapeId, selectedShapeIds: readonly ShapeId[]): ShapeId;
+export declare function getSelectedTransformAncestorIdForHit(editor: Editor, shapeId: ShapeId, selectedShapeIds: readonly ShapeId[]): ShapeId | null;
+export interface TransformDescendantAncestorPathEntry {
+    ancestorId: ShapeId;
+    childId: ShapeId;
+}
+export declare function getNearestTransformDescendantAncestorId(editor: Editor, shapeId: ShapeId): ShapeId | null;
+export declare function getTransformDescendantAncestorPath(editor: Editor, shapeId: ShapeId): TransformDescendantAncestorPathEntry[];
+export declare function isAdditiveSelectionActive({ shiftKey, accelKey, }: {
+    shiftKey: boolean;
+    accelKey: boolean;
+}): boolean;
+export declare function isBrushWrappingSelection({ ctrlKey }: {
+    ctrlKey: boolean;
+}): boolean;
+export declare function isQuickClick(info: PointingShapeInfo, event: PointerEditorEvent): boolean;
+export declare function normalizeAngle(angle: number): number;
+export declare function snapAngle(angle: number, step: number): number;
+export declare function getBoxCorners(bounds: Box): Vec[];
+export declare function getShapeSelectionResizePageOutlineVertices(editor: Editor, shape: ShapeRecord): Vec[];
+export declare function getResizedShapeUpdate(editor: Editor, shape: SelectionResizeShapeSnapshot, startBounds: Box, nextBounds: Box, scaleX: number, scaleY: number, handleId: SelectionResizeHandleId, isResizingFromCenter: boolean, rotationCenter: Vec, selectionRotation: number, update: ShapeUpdate): void;
+export declare function getSelectionTransform(rotationCenter: Vec, selectionRotation: number): SelectionRotationTransform;
+export declare function getResizedPagePointsUpdate(editor: Editor, shape: SelectionResizePointShapeSnapshot, startBounds: Box, nextBounds: Box, scaleX: number, scaleY: number, handleId: SelectionResizeHandleId, isResizingFromCenter: boolean, rotationCenter: Vec, selectionRotation: number, update: ShapeUpdate): void;
+export declare function getSelectionResizeAspectRatioLockOverride(editor: Editor, shapes: readonly ShapeRecord[], handleId: SelectionResizeHandleId): boolean | null;
+export declare function getRotatedShapeUpdate(shape: SelectionRotateShapeSnapshot, center: Vec, delta: number, update: ShapeUpdate): void;
+export declare function getRotatedPagePointsUpdate(editor: Editor, shape: SelectionRotatePointShapeSnapshot, center: Vec, delta: number, update: ShapeUpdate): void;
+export declare function createTranslatingUpdates(shapes: TranslatingShapeSnapshot[]): ShapeUpdate[];
+export declare function getTranslateShapeSnapshots(editor: Editor, selectedShapeIds: ShapeId[]): TranslatingShapeSnapshot[];
+export declare function isShapeWrappedByBrush(editor: Editor, brushBounds: Box, shapeId: ShapeId): boolean;
+export declare function shouldSelectShapeWithBrush(editor: Editor, brushBounds: Box, shapeId: ShapeId, isWrapping: boolean): boolean;
+export declare function isBrushSelectableShapeId(editor: Editor, shapeId: ShapeId): boolean;
+export declare function createResizingUpdates(shapes: SelectionResizeShapeSnapshot[], pointShapes: SelectionResizePointShapeSnapshot[]): ShapeUpdate[];
+export declare function createRotatingUpdates(shapes: SelectionRotateShapeSnapshot[], pointShapes: SelectionRotatePointShapeSnapshot[]): ShapeUpdate[];

package/_vendor/canvas-core/tools/select/states/BrushingState.d.ts

@@ -0,0 +1,19 @@
+import type { Editor } from "../../../editor/Editor";
+import { StateNode } from "../../../editor/StateNode";
+import type { PointerEditorEvent, TickEditorEvent } from "../../../editor/events";
+import { type BrushInfo } from "../selectToolHelpers";
+import { InfoStateNode } from "./SelectStateNode";
+export declare class BrushingState extends InfoStateNode<BrushInfo> {
+    constructor(editor: Editor, parent: StateNode);
+    protected onInfoEnter(): void;
+    protected onPointerMove(event: PointerEditorEvent): void;
+    protected onTick(event: TickEditorEvent): void;
+    protected onKeyDown(): void;
+    protected onKeyUp(): void;
+    protected onPointerUp(event: PointerEditorEvent): void;
+    protected onCancel(): void;
+    private updateBrush;
+    private updateBrushFromInputs;
+    private complete;
+    private cancel;
+}

package/_vendor/canvas-core/tools/select/states/DraggingSelectionHandleInteractionState.d.ts

@@ -0,0 +1,15 @@
+import type { Editor } from "../../../editor/Editor";
+import { StateNode } from "../../../editor/StateNode";
+import type { PointerEditorEvent } from "../../../editor/events";
+import { type DraggingSelectionHandleInteractionInfo } from "../selectToolHelpers";
+import { DraggingStateNode, type DragApplyInput } from "./SelectStateNode";
+export declare class DraggingSelectionHandleInteractionState extends DraggingStateNode<DraggingSelectionHandleInteractionInfo> {
+    protected readonly tickMode: "apply_after_scroll";
+    constructor(editor: Editor, parent: StateNode);
+    protected getHistoryMark(info: DraggingSelectionHandleInteractionInfo): string;
+    protected onPointerUp(event: PointerEditorEvent): void;
+    protected onCancel(): void;
+    protected onInfoExit(): void;
+    protected apply({ pagePoint, accelKey }: DragApplyInput): void;
+    private complete;
+}

package/_vendor/canvas-core/tools/select/states/IdleState.d.ts

@@ -0,0 +1,8 @@
+import type { Editor } from "../../../editor/Editor";
+import { StateNode } from "../../../editor/StateNode";
+import type { PointerEditorEvent } from "../../../editor/events";
+export declare class IdleState extends StateNode {
+    constructor(editor: Editor, parent: StateNode);
+    protected onEnter(): void;
+    protected onPointerDown(event: PointerEditorEvent): void;
+}

package/_vendor/canvas-core/tools/select/states/PointingCanvasState.d.ts

@@ -0,0 +1,11 @@
+import type { Editor } from "../../../editor/Editor";
+import { StateNode } from "../../../editor/StateNode";
+import type { PointerEditorEvent } from "../../../editor/events";
+import { type PointingCanvasInfo } from "../selectToolHelpers";
+import { PointingStateNode } from "./SelectStateNode";
+export declare class PointingCanvasState extends PointingStateNode<PointingCanvasInfo> {
+    constructor(editor: Editor, parent: StateNode);
+    protected onDragThresholdExceeded(event: PointerEditorEvent): void;
+    protected onPointerUp(event: PointerEditorEvent): void;
+    protected onCancel(): void;
+}

package/_vendor/canvas-core/tools/select/states/PointingResizeHandleState.d.ts

@@ -0,0 +1,10 @@
+import type { Editor } from "../../../editor/Editor";
+import { StateNode } from "../../../editor/StateNode";
+import { type PointingResizeHandleInfo } from "../selectToolHelpers";
+import { PointingStateNode } from "./SelectStateNode";
+export declare class PointingResizeHandleState extends PointingStateNode<PointingResizeHandleInfo> {
+    constructor(editor: Editor, parent: StateNode);
+    protected onDragThresholdExceeded(): void;
+    protected onPointerUp(): void;
+    protected onCancel(): void;
+}

package/_vendor/canvas-core/tools/select/states/PointingRotateHandleState.d.ts

@@ -0,0 +1,10 @@
+import type { Editor } from "../../../editor/Editor";
+import { StateNode } from "../../../editor/StateNode";
+import { type PointingRotateHandleInfo } from "../selectToolHelpers";
+import { PointingStateNode } from "./SelectStateNode";
+export declare class PointingRotateHandleState extends PointingStateNode<PointingRotateHandleInfo> {
+    constructor(editor: Editor, parent: StateNode);
+    protected onDragThresholdExceeded(): void;
+    protected onPointerUp(): void;
+    protected onCancel(): void;
+}

package/_vendor/canvas-core/tools/select/states/PointingSelectionHandleInteractionState.d.ts

@@ -0,0 +1,10 @@
+import type { Editor } from "../../../editor/Editor";
+import { StateNode } from "../../../editor/StateNode";
+import { type PointingSelectionHandleInteractionInfo } from "../selectToolHelpers";
+import { PointingStateNode } from "./SelectStateNode";
+export declare class PointingSelectionHandleInteractionState extends PointingStateNode<PointingSelectionHandleInteractionInfo> {
+    constructor(editor: Editor, parent: StateNode);
+    protected onDragThresholdExceeded(): void;
+    protected onPointerUp(): void;
+    protected onCancel(): void;
+}

package/_vendor/canvas-core/tools/select/states/PointingShapeState.d.ts

@@ -0,0 +1,12 @@
+import type { Editor } from "../../../editor/Editor";
+import { StateNode } from "../../../editor/StateNode";
+import type { PointerEditorEvent } from "../../../editor/events";
+import { type PointingShapeInfo } from "../selectToolHelpers";
+import { PointingStateNode } from "./SelectStateNode";
+export declare class PointingShapeState extends PointingStateNode<PointingShapeInfo> {
+    constructor(editor: Editor, parent: StateNode);
+    protected onInfoEnter(): void;
+    protected onDragThresholdExceeded(): void;
+    protected onPointerUp(event: PointerEditorEvent): void;
+    protected onCancel(): void;
+}

package/_vendor/canvas-core/tools/select/states/ResizingState.d.ts

@@ -0,0 +1,16 @@
+import type { Editor } from "../../../editor/Editor";
+import { StateNode } from "../../../editor/StateNode";
+import { type ResizingInfo } from "../selectToolHelpers";
+import { DraggingStateNode, type DragApplyInput } from "./SelectStateNode";
+export declare class ResizingState extends DraggingStateNode<ResizingInfo> {
+    protected readonly tickMode: "apply_after_scroll_or_without_screen_point";
+    constructor(editor: Editor, parent: StateNode);
+    protected getHistoryMark(): string;
+    protected onDragStart(): void;
+    protected onPointerUp(): void;
+    protected onCancel(): void;
+    protected onInfoExit(): void;
+    protected apply({ pagePoint, shiftKey, altKey, accelKey, }: DragApplyInput): void;
+    private complete;
+    private cancel;
+}

package/_vendor/canvas-core/tools/select/states/RotatingState.d.ts

@@ -0,0 +1,14 @@
+import type { Editor } from "../../../editor/Editor";
+import { StateNode } from "../../../editor/StateNode";
+import { type RotatingInfo } from "../selectToolHelpers";
+import { DraggingStateNode, type DragApplyInput } from "./SelectStateNode";
+export declare class RotatingState extends DraggingStateNode<RotatingInfo> {
+    protected readonly tickMode: "apply_after_scroll";
+    constructor(editor: Editor, parent: StateNode);
+    protected getHistoryMark(): string;
+    protected onPointerUp(): void;
+    protected onCancel(): void;
+    protected apply({ pagePoint, shiftKey, accelKey }: DragApplyInput): void;
+    private complete;
+    private cancel;
+}

package/_vendor/canvas-core/tools/select/states/SelectStateNode.d.ts

@@ -0,0 +1,60 @@
+import type { Vec } from "../../../geometry/Vec";
+import { StateNode } from "../../../editor/StateNode";
+import type { PointerEditorEvent, TickEditorEvent } from "../../../editor/events";
+import { type EdgeScrollTickMode } from "../selectToolHelpers";
+/**
+ * Base for every select-tool state that carries a transient `info` payload.
+ * Centralises the identical `info` lifecycle (assign on enter, clear on exit)
+ * so concrete states only express their behaviour. Cleanup that must run while
+ * `info` is still readable belongs in {@link onInfoExit}.
+ */
+export declare abstract class InfoStateNode<T> extends StateNode {
+    protected info: T | null;
+    protected onEnter(info?: unknown): void;
+    protected onExit(): void;
+    /** Runs after `info` is assigned. */
+    protected onInfoEnter(): void;
+    /** Runs before `info` is cleared. */
+    protected onInfoExit(): void;
+}
+/**
+ * Base for the "pointing_*" states. They all wait for the pointer to exceed the
+ * drag threshold before committing to a gesture; subclasses only implement what
+ * happens once that threshold is crossed.
+ */
+export declare abstract class PointingStateNode<T extends {
+    originPagePoint: Vec;
+}> extends InfoStateNode<T> {
+    protected onPointerMove(event: PointerEditorEvent): void;
+    protected abstract onDragThresholdExceeded(event: PointerEditorEvent): void;
+}
+/** Pointer/keyboard fields shared by pointer events and synthesized drag inputs. */
+export interface DragApplyInput {
+    pagePoint: Vec;
+    shiftKey: boolean;
+    altKey: boolean;
+    accelKey: boolean;
+}
+/**
+ * Base for the active drag states (translate / resize / rotate / handle
+ * interaction). Centralises the identical event wiring: mark history on enter,
+ * apply on pointer-move, apply edge-scroll-aware input on tick, and re-apply the
+ * current input on key changes. Subclasses implement {@link apply} plus their own
+ * completion/cancellation and any extra cleanup.
+ */
+export declare abstract class DraggingStateNode<T> extends InfoStateNode<T> {
+    /** Edge-scroll behaviour for this gesture's tick handling. */
+    protected abstract readonly tickMode: EdgeScrollTickMode;
+    /** History mark to open on enter (constant or derived from `info`). */
+    protected abstract getHistoryMark(info: T): string;
+    /** Apply one drag sample. Implementations must guard on `this.info`. */
+    protected abstract apply(input: DragApplyInput): void;
+    protected onInfoEnter(): void;
+    /** Extra setup after the history mark is opened (e.g. clearing indicators). */
+    protected onDragStart(): void;
+    protected onPointerMove(event: PointerEditorEvent): void;
+    protected onTick(event: TickEditorEvent): void;
+    protected onKeyDown(): void;
+    protected onKeyUp(): void;
+    protected applyFromInputs(): void;
+}

package/_vendor/canvas-core/tools/select/states/TranslatingState.d.ts

@@ -0,0 +1,16 @@
+import type { Editor } from "../../../editor/Editor";
+import { StateNode } from "../../../editor/StateNode";
+import { type TranslatingInfo } from "../selectToolHelpers";
+import { DraggingStateNode, type DragApplyInput } from "./SelectStateNode";
+export declare class TranslatingState extends DraggingStateNode<TranslatingInfo> {
+    protected readonly tickMode: "always_apply";
+    constructor(editor: Editor, parent: StateNode);
+    protected getHistoryMark(): string;
+    protected onDragStart(): void;
+    protected onPointerUp(): void;
+    protected onCancel(): void;
+    protected onInfoExit(): void;
+    protected apply({ pagePoint, shiftKey, accelKey }: DragApplyInput): void;
+    private complete;
+    private cancel;
+}

package/_vendor/canvas-plugin-api/feature.d.ts

@@ -0,0 +1,37 @@
+import type { LandCorePlugin, ShapeRecordBase } from "../canvas-core/index";
+import type { LandCanvasPlugin } from "./index";
+type LandExtensionOptions = Record<string, unknown>;
+export interface LandFeatureBundle {
+    id: string;
+    corePlugins: readonly LandCorePlugin[];
+    canvasPlugins: readonly LandCanvasPlugin[];
+    shapeTypes: readonly ShapeRecordBase["type"][];
+}
+export interface LandExtension {
+    readonly name: string;
+    readonly options: Readonly<LandExtensionOptions>;
+    readonly priority: number;
+    createFeature(): LandFeatureBundle | null;
+    getExtensions(): readonly LandExtension[];
+}
+export type LandExtensionOptionsInput<T> = T extends readonly unknown[] ? T : T extends LandExtensionOptions ? {
+    [K in keyof T]?: LandExtensionOptionsInput<T[K]>;
+} : T;
+export interface ConfigurableLandExtension<Options extends LandExtensionOptions> extends LandExtension {
+    readonly options: Readonly<Options>;
+    configure(options?: LandExtensionOptionsInput<Options>): ConfigurableLandExtension<Options>;
+}
+export interface LandExtensionConfig<Options extends LandExtensionOptions> {
+    name: string;
+    priority?: number;
+    addOptions?(): Options;
+    addExtensions?(options: Readonly<Options>): readonly LandExtension[];
+    createFeature?(options: Readonly<Options>): LandFeatureBundle;
+}
+export interface ResolvedLandExtension {
+    extension: LandExtension;
+    feature: LandFeatureBundle | null;
+}
+export declare function defineLandExtension<Options extends LandExtensionOptions = Record<string, never>>(config: LandExtensionConfig<Options>): ConfigurableLandExtension<Options>;
+export declare function resolveLandExtensions(extensions: readonly LandExtension[]): ResolvedLandExtension[];
+export {};

package/_vendor/canvas-plugin-api/index.d.ts

@@ -0,0 +1,57 @@
+import type { ComponentType, ReactNode } from "react";
+import type { Editor, ShapeEditingSession, ShapeRecordBase, ToolbarAction, ToolbarActionRunInput, ToolbarActionValue, ToolbarBadgeItem, ToolbarButtonItem, ToolbarContext, ToolbarContribution, ToolbarGroup, ToolbarItem, ToolbarSegmentedItem, ToolbarSegmentedOption, ToolbarSelectionSnapshot, ToolbarSeparatorItem, ToolbarStepperItem, ToolbarStepperOption, ToolbarTextInputItem, ToolbarSurface, ToolbarSwatchesItem, ToolbarSwatchOption, ToolbarToolSnapshot } from "../canvas-core/index";
+export { defineLandExtension, resolveLandExtensions, } from "./feature";
+export type { ConfigurableLandExtension, LandExtension, LandExtensionConfig, LandExtensionOptionsInput, LandFeatureBundle, ResolvedLandExtension, } from "./feature";
+export interface ShapeRendererProps<S extends ShapeRecordBase = ShapeRecordBase> {
+    shape: S;
+    editor: Editor;
+    isSelected: boolean;
+    shapeEditingSession: ShapeEditingSession | null;
+}
+export interface RegisteredShapeRenderer<S extends ShapeRecordBase = ShapeRecordBase> {
+    type: S["type"];
+    component: ComponentType<ShapeRendererProps<S>>;
+}
+export type AnyRegisteredShapeRenderer = RegisteredShapeRenderer<ShapeRecordBase>;
+export interface CanvasPluginComponent {
+    id: string;
+    component: ComponentType;
+}
+export interface CanvasPluginProvider {
+    id: string;
+    component: ComponentType<{
+        children: ReactNode;
+    }>;
+}
+export type ShapeRendererRegistrar = <S extends ShapeRecordBase>(renderer: RegisteredShapeRenderer<S>) => void;
+export type CanvasDomEventGuardName = "pointer_down" | "pointer_move" | "pointer_up" | "pointer_cancel" | "wheel" | "key_down" | "key_up";
+export type CanvasDomEventGuardDecision = "continue" | "handled";
+export interface CanvasDomEventGuardInput {
+    name: CanvasDomEventGuardName;
+    event: Event;
+    editor: Editor;
+    container: HTMLElement;
+}
+export interface CanvasDomEventGuardCursorInput {
+    element: Element | null;
+    editor: Editor;
+    container: HTMLElement;
+    clientPoint: {
+        x: number;
+        y: number;
+    } | null;
+}
+export interface CanvasDomEventGuard {
+    id: string;
+    handle(input: CanvasDomEventGuardInput): CanvasDomEventGuardDecision;
+    getCursor?(input: CanvasDomEventGuardCursorInput): string | undefined;
+}
+export interface LandCanvasPlugin {
+    id: string;
+    domEventGuards?: readonly CanvasDomEventGuard[];
+    canvasProviders?: readonly CanvasPluginProvider[];
+    canvasComponents?: readonly CanvasPluginComponent[];
+    setup(registerShapeRenderer: ShapeRendererRegistrar): void;
+}
+export type { ToolbarAction, ToolbarActionRunInput, ToolbarActionValue, ToolbarBadgeItem, ToolbarButtonItem, ToolbarContext, ToolbarContribution, ToolbarGroup, ToolbarItem, ToolbarSegmentedItem, ToolbarSegmentedOption, ToolbarSelectionSnapshot, ToolbarSeparatorItem, ToolbarStepperItem, ToolbarStepperOption, ToolbarTextInputItem, ToolbarSurface, ToolbarSwatchesItem, ToolbarSwatchOption, ToolbarToolSnapshot, };
+export declare function setupCanvasPlugins(plugins: readonly LandCanvasPlugin[], registerShapeRenderer: ShapeRendererRegistrar): void;

package/_vendor/canvas-product-react/api/apiRegistry.d.ts

@@ -0,0 +1,12 @@
+export interface ProductApiToken<TApi> {
+    readonly id: string;
+    readonly __api?: TApi;
+}
+export interface ProductApiRegistry {
+    get<TApi>(token: ProductApiToken<TApi>): TApi | null;
+}
+export interface ProductApiRegistryRuntime extends ProductApiRegistry {
+    register<TApi>(token: ProductApiToken<TApi>, api: TApi): void;
+}
+export declare function createProductApiToken<TApi>(id: string): ProductApiToken<TApi>;
+export declare function createProductApiRegistry(): ProductApiRegistryRuntime;

package/_vendor/canvas-product-react/api/canvasProductApi.d.ts

@@ -0,0 +1,124 @@
+import type { Camera, Editor, LayerOrderDirection, LayerOrderEdge, ReparentShapePlacementFailureReason, ShapeId } from "../../canvas-core/index";
+import type { CanvasPluginHostRuntime } from "../../canvas-react/host/index";
+import type { ProductServiceRegistry } from "../runtime/productServices";
+import type { ProductApiRegistry } from "./apiRegistry";
+export interface CanvasProductShapeRef {
+    id: ShapeId;
+    type: string;
+}
+export interface CanvasProductSessionPageState {
+    pageId: string;
+    selectedShapeIds: ShapeId[];
+    camera: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+export interface CanvasProductSessionSnapshot<TToolId extends string = string> {
+    currentPageId: string;
+    activeToolId: TToolId;
+    isToolLocked: boolean;
+    pages: CanvasProductSessionPageState[];
+}
+export interface CanvasProductApiSnapshot<TToolId extends string = string> {
+    productId: string;
+    pageId: string;
+    activeToolId: TToolId;
+    selectedShapeIds: ShapeId[];
+    shapeCount: number;
+    session: CanvasProductSessionSnapshot<TToolId>;
+}
+export interface CanvasProductLayerNode {
+    id: ShapeId;
+    parentId: string;
+    pageId: string;
+    type: string;
+    childIds: ShapeId[];
+    siblingIndex: number;
+    depth: number;
+    displayName: string;
+    canReceiveChildren: boolean;
+    isHidden: boolean;
+    isLocked: boolean;
+    isEffectivelyHidden: boolean;
+    isEffectivelyLocked: boolean;
+}
+export interface CanvasProductLayerPlacement {
+    parentId: string;
+    beforeId?: ShapeId;
+}
+export type CanvasProductLayerPlacementFailureReason = ReparentShapePlacementFailureReason;
+export type CanvasProductLayerPlacementResult = {
+    ok: true;
+    movedIds: ShapeId[];
+} | {
+    ok: false;
+    reason: CanvasProductLayerPlacementFailureReason;
+};
+export interface CanvasProductLayerActionState {
+    canGroup: boolean;
+    canUngroup: boolean;
+    canMoveBackward: boolean;
+    canMoveForward: boolean;
+}
+export interface CanvasProductPageRef {
+    id: string;
+    name: string;
+    index: string;
+}
+export interface CanvasProductApi<TToolId extends string = string> {
+    plugins: ProductApiRegistry;
+    snapshot(): CanvasProductApiSnapshot<TToolId>;
+    clearHistory(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    select(ids: ShapeId[]): void;
+    selectAll(): void;
+    deleteSelection(): void;
+    deleteShapes(ids: ShapeId[]): void;
+    duplicateSelection(): ShapeId[];
+    centerOnShape(id: ShapeId): boolean;
+    getLayerTree(pageId?: string): CanvasProductLayerNode[];
+    getLayerNode(id: ShapeId): CanvasProductLayerNode | null;
+    setShapesHidden(ids: ShapeId[], isHidden: boolean): ShapeId[];
+    setShapesLocked(ids: ShapeId[], isLocked: boolean): ShapeId[];
+    groupShapes(ids: ShapeId[]): ShapeId | null;
+    ungroupShapes(ids: ShapeId[]): ShapeId[];
+    moveShapesInParentOrder(ids: ShapeId[], direction: LayerOrderDirection): boolean;
+    moveShapesToParentOrderEdge(ids: ShapeId[], edge: LayerOrderEdge): boolean;
+    moveShapesToLayerPlacement(ids: ShapeId[], placement: CanvasProductLayerPlacement): CanvasProductLayerPlacementResult;
+    getLayerActionState(ids: ShapeId[]): CanvasProductLayerActionState;
+    setTool(toolId: TToolId): void;
+    setCamera(camera: Partial<Camera>, pageId?: string): void;
+    resetView(): void;
+    getPages(): CanvasProductPageRef[];
+    createPage(name?: string): CanvasProductPageRef;
+    renamePage(pageId: string, name: string): void;
+    deletePage(pageId: string): boolean;
+    selectPage(pageId: string): void;
+    exportSelectionSvg(): string | null;
+    exportPageSvg(): string | null;
+}
+export interface CanvasProductApiContext {
+    editor: Editor;
+    services: ProductServiceRegistry;
+    pluginHostRuntime: CanvasPluginHostRuntime;
+    apiRegistry: ProductApiRegistry;
+    productId: string;
+}
+export interface CanvasProductApiOptions<TToolId extends string = string> extends CanvasProductApiContext {
+    assertToolId: (toolId: string) => asserts toolId is TToolId;
+}
+export interface CanvasProductApiLifecycleOptions<TApi> {
+    api: TApi;
+    exposeOnWindow?: boolean;
+    windowKey?: string;
+    onDispose?: () => void;
+    onReady?: (api: TApi) => void;
+}
+export declare function createCanvasProductApi<TToolId extends string = string>(options: CanvasProductApiOptions<TToolId>): CanvasProductApi<TToolId>;
+export declare function useCanvasProductApi<TToolId extends string = string>(options: CanvasProductApiOptions<TToolId>): CanvasProductApi<TToolId>;
+export declare function useCanvasProductApiLifecycle<TApi>({ api, exposeOnWindow, windowKey, onDispose, onReady, }: CanvasProductApiLifecycleOptions<TApi>): void;

package/_vendor/canvas-product-react/api/index.d.ts

@@ -0,0 +1,4 @@
+export { createProductApiRegistry, createProductApiToken, } from "./apiRegistry";
+export type { ProductApiRegistry, ProductApiRegistryRuntime, ProductApiToken, } from "./apiRegistry";
+export { createCanvasProductApi, useCanvasProductApi, useCanvasProductApiLifecycle, } from "./canvasProductApi";
+export type { CanvasProductApi, CanvasProductApiContext, CanvasProductApiLifecycleOptions, CanvasProductApiOptions, CanvasProductApiSnapshot, CanvasProductLayerActionState, CanvasProductLayerNode, CanvasProductLayerPlacement, CanvasProductLayerPlacementFailureReason, CanvasProductLayerPlacementResult, CanvasProductPageRef, CanvasProductSessionPageState, CanvasProductSessionSnapshot, CanvasProductShapeRef, } from "./canvasProductApi";

package/_vendor/canvas-product-react/capabilities/clipboard/clipboardService.d.ts

@@ -0,0 +1,9 @@
+import type { EditorClipboardPayload } from "../../../canvas-core/index";
+import { type ProductServiceFactory } from "../../runtime/productServices";
+export interface CanvasClipboardService {
+    write(payload: EditorClipboardPayload): Promise<void>;
+    read(): Promise<EditorClipboardPayload | null>;
+    getMemoryPayload(): EditorClipboardPayload | null;
+}
+export declare const canvasClipboardServiceToken: import("../..").ProductServiceToken<CanvasClipboardService>;
+export declare function memoryCanvasClipboardService(): ProductServiceFactory<CanvasClipboardService>;

package/_vendor/canvas-product-react/capabilities/clipboard/systemClipboard.d.ts

@@ -0,0 +1,16 @@
+import type { CanvasPluginHostRuntime } from "../../../canvas-react/host/index";
+import type { CanvasProductRuntimeSetupContext } from "../../runtime/productDefinition";
+import type { ProductServiceRegistry } from "../../runtime/productServices";
+import { type CanvasClipboardService } from "./clipboardService";
+export declare const SYSTEM_CLIPBOARD_COPY_ACTION_ID = "system.clipboard.copy";
+export declare const SYSTEM_CLIPBOARD_CUT_ACTION_ID = "system.clipboard.cut";
+export declare const SYSTEM_CLIPBOARD_PASTE_ACTION_ID = "system.clipboard.paste";
+export declare const SYSTEM_CLIPBOARD_PASTE_AT_POINT_ACTION_ID = "system.clipboard.paste-at-point";
+export declare const SYSTEM_SELECTION_DUPLICATE_ACTION_ID = "system.selection.duplicate";
+export declare const SYSTEM_SELECTION_SELECT_ALL_ACTION_ID = "system.selection.select-all";
+export declare function registerSystemClipboardRuntime({ pluginHostRuntime, productId, services, }: CanvasProductRuntimeSetupContext): void;
+export declare function registerSystemClipboardActions({ pluginHostRuntime, services, }: {
+    pluginHostRuntime: CanvasPluginHostRuntime;
+    services: ProductServiceRegistry;
+}): void;
+export declare function getCanvasClipboardService(services: ProductServiceRegistry): CanvasClipboardService | null;