@yuzhouu/canvas-kit 0.1.12 → 0.1.14

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

@@ -1,12 +1,12 @@
 import type { Editor } from "../../../editor/editor";
-import { StateNode } from "../../../editor/stateNode";
-import type { PointerEditorEvent } from "../../../editor/events";
+import { StateNode } from "../../stateNode";
+import type { EditorEventContext, EditorEventRoutingEffect, PointerEditorEvent } from "../../../editor/events/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(event: PointerEditorEvent): void;
-    protected onPointerUp(event: PointerEditorEvent): void;
+    protected onPointerUp(event: PointerEditorEvent, context: EditorEventContext): EditorEventRoutingEffect | void;
     protected onCancel(): void;
 }

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

@@ -1,13 +1,13 @@
 import type { Editor } from "../../../editor/editor";
-import { StateNode } from "../../../editor/stateNode";
+import type { PointerEditorEvent } from "../../../editor/events/events";
+import { StateNode } from "../../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 getOperationKind(): string;
     protected onDragStart(): void;
-    protected onPointerUp(): void;
+    protected onPointerUp(event: PointerEditorEvent): void;
     protected onCancel(): void;
     protected onInfoExit(): void;
     protected apply({ pagePoint, shiftKey, altKey, accelKey, }: DragApplyInput): void;

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

@@ -1,12 +1,12 @@
 import type { Editor } from "../../../editor/editor";
-import { StateNode } from "../../../editor/stateNode";
+import type { PointerEditorEvent } from "../../../editor/events/events";
+import { StateNode } from "../../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 getOperationKind(): string;
-    protected onPointerUp(): void;
+    protected onPointerUp(event: PointerEditorEvent): void;
     protected onCancel(): void;
     protected apply({ pagePoint, shiftKey, accelKey }: DragApplyInput): void;
     private complete;

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

@@ -1,8 +1,7 @@
 import type { Vec } from "../../../geometry/vec";
-import { StateNode } from "../../../editor/stateNode";
-import type { PointerEditorEvent, TickEditorEvent } from "../../../editor/events";
-import { type EdgeScrollTickMode } from "../selectToolHelpers";
-import type { EditorOperation } from "../../../editor/operationManager";
+import { StateNode } from "../../stateNode";
+import type { PointerEditorEvent, TickEditorEvent } from "../../../editor/events/events";
+import type { EditorOperation } from "../../../editor/history/operationManager";
 /**
  * Base for every select-tool state that carries a transient `info` payload.
  * Centralises the identical `info` lifecycle (assign on enter, clear on exit)
@@ -38,23 +37,20 @@ export interface DragApplyInput {
 }
 /**
  * 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.
+ * interaction). Centralises the identical event wiring: open an operation on
+ * enter, apply the latest input once per animation 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> {
     protected operation: EditorOperation | null;
-    /** Edge-scroll behaviour for this gesture's tick handling. */
-    protected abstract readonly tickMode: EdgeScrollTickMode;
     /** Stable operation kind for this gesture. */
     protected abstract getOperationKind(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). */
+    /** Extra setup after the operation 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;

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

@@ -1,10 +1,9 @@
 import type { Editor } from "../../../editor/editor";
-import type { PointerEditorEvent } from "../../../editor/events";
-import { StateNode } from "../../../editor/stateNode";
+import type { PointerEditorEvent } from "../../../editor/events/events";
+import { StateNode } from "../../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 getOperationKind(): string;
     protected onDragStart(): void;

package/_vendor/canvas-core/tools/stateNode.d.ts

@@ -0,0 +1,30 @@
+import type { Editor } from "../editor/editor";
+import type { CancelEditorEvent, EditorEventContext, EditorEventRoutingEffect, KeyboardEditorEvent, PointerEditorEvent, TickEditorEvent, WheelEditorEvent } from "../editor/events/events";
+export type StateNodeEvent = PointerEditorEvent | KeyboardEditorEvent | WheelEditorEvent | TickEditorEvent | CancelEditorEvent;
+export declare abstract class StateNode {
+    readonly editor: Editor;
+    readonly id: string;
+    readonly parent?: StateNode | undefined;
+    protected readonly children: Map<string, StateNode>;
+    protected currentChild: StateNode | null;
+    protected initial: string | null;
+    constructor(editor: Editor, id: string, parent?: StateNode | undefined);
+    protected addChild(child: StateNode): void;
+    enter(info?: unknown): void;
+    exit(info?: unknown): void;
+    transition(id: string, info?: unknown): void;
+    isInInitialState(): boolean;
+    dispatch(event: StateNodeEvent, context: EditorEventContext): EditorEventRoutingEffect | void;
+    protected onEnter(_info?: unknown): void;
+    protected onExit(_info?: unknown): void;
+    protected onPointerDown(_event: PointerEditorEvent, _context: EditorEventContext): EditorEventRoutingEffect | void;
+    protected onPointerMove(_event: PointerEditorEvent, _context: EditorEventContext): EditorEventRoutingEffect | void;
+    protected onPointerUp(_event: PointerEditorEvent, _context: EditorEventContext): EditorEventRoutingEffect | void;
+    protected onCancel(_event: CancelEditorEvent, _context: EditorEventContext): EditorEventRoutingEffect | void;
+    protected onKeyDown(_event: KeyboardEditorEvent, _context: EditorEventContext): EditorEventRoutingEffect | void;
+    protected onKeyUp(_event: KeyboardEditorEvent, _context: EditorEventContext): EditorEventRoutingEffect | void;
+    protected onWheel(_event: WheelEditorEvent, _context: EditorEventContext): EditorEventRoutingEffect | void;
+    protected onTick(_event: TickEditorEvent, _context: EditorEventContext): EditorEventRoutingEffect | void;
+    private handlePointerEvent;
+    private handleKeyboardEvent;
+}

package/_vendor/canvas-core/tools/toolManager.d.ts

@@ -0,0 +1,24 @@
+import type { Atom } from "../../signals/index";
+import type { ChangeSource } from "../../store/index";
+import type { Editor } from "../editor/editor";
+import type { CancelEditorEvent, EditorEventContext, EditorEventRoutingEffect } from "../editor/events/events";
+import type { StateNode, StateNodeEvent } from "./stateNode";
+type ToolFactory = (editor: Editor) => StateNode;
+export declare class ToolManager {
+    private readonly editor;
+    readonly activeToolId: Atom<string>;
+    readonly isToolLocked: Atom<boolean>;
+    private readonly registry;
+    private activeTool;
+    constructor(editor: Editor);
+    register(id: string, factory: ToolFactory): void;
+    hasTool(id: string): boolean;
+    select(id: string, source?: ChangeSource): void;
+    setLocked(locked: boolean, source?: ChangeSource): void;
+    toggleLocked(source?: ChangeSource): void;
+    syncActiveTool(id: string, reason?: CancelEditorEvent["reason"]): void;
+    dispatch(event: StateNodeEvent, context: EditorEventContext): EditorEventRoutingEffect | void;
+    syncLockedState(locked: boolean): void;
+    isInInitialState(): boolean;
+}
+export {};

package/_vendor/canvas-core/utils/equality.d.ts

@@ -0,0 +1,9 @@
+import type { Box } from "../geometry/box";
+import type { Vec } from "../geometry/vec";
+export declare function areArraysEqual<T>(left: readonly T[], right: readonly T[], isEqual?: (left: T, right: T) => boolean): boolean;
+export declare function areSetsEqual<T>(left: ReadonlySet<T>, right: ReadonlySet<T>): boolean;
+export declare function areVecsEqual(left: Vec | null | undefined, right: Vec | null | undefined): boolean;
+export declare function areVecArraysEqual(left: readonly Vec[], right: readonly Vec[]): boolean;
+export declare function areVecPolygonArraysEqual(left: readonly (readonly Vec[])[], right: readonly (readonly Vec[])[]): boolean;
+export declare function areBoxesEqual(left: Box | null | undefined, right: Box | null | undefined): boolean;
+export declare function areSerializableValuesEqual(left: unknown, right: unknown): boolean;

package/_vendor/canvas-extension-contracts/contributions.d.ts

@@ -0,0 +1,92 @@
+import type { Editor, ShapeId, ShapeRecord, Vec } from "../canvas-core/index";
+import type { CanvasContextMenuRequest } from "../canvas-react/index";
+export type CanvasImportSource = "clipboard" | "drop" | "file-picker";
+export interface CanvasImportRequest {
+    readonly source: CanvasImportSource;
+    readonly files: readonly File[];
+    readonly text?: string;
+    readonly html?: string;
+    readonly urls?: readonly string[];
+    readonly pagePoint?: Vec;
+}
+export interface CanvasImportPreview {
+    readonly source: "drop";
+    readonly dataTypes: readonly string[];
+    readonly fileTypes: readonly string[];
+}
+export type CanvasImportResult = "handled" | "ignored";
+export interface CanvasImportContribution {
+    readonly id: string;
+    readonly order?: number;
+    acceptsPreview?(preview: CanvasImportPreview): boolean;
+    accepts(request: CanvasImportRequest): boolean;
+    import(request: CanvasImportRequest): CanvasImportResult | Promise<CanvasImportResult>;
+}
+export interface CanvasExportFormat {
+    readonly format: string;
+    readonly label: string;
+    readonly mimeType: string;
+    readonly fileExtension: string;
+}
+export interface CanvasExportProviderInput {
+    readonly editor: Editor;
+    readonly shapeIds: readonly ShapeId[];
+    readonly options?: unknown;
+}
+export interface CanvasExportPayload {
+    readonly data: Blob | string | Uint8Array | null;
+    readonly result?: unknown;
+    readonly status?: unknown;
+}
+export interface CanvasExportArtifact extends CanvasExportFormat, CanvasExportPayload {
+}
+export interface CanvasExportFormatProvider extends CanvasExportFormat {
+    readonly kind: "provider";
+    readonly id: string;
+    export(input: CanvasExportProviderInput, context: {
+        readonly signal: AbortSignal;
+        inlineSvg(input: CanvasSvgInlineInput): Promise<string>;
+    }): CanvasExportPayload | Promise<CanvasExportPayload>;
+}
+export interface SvgResourceInliner {
+    readonly kind: "svg-inliner";
+    readonly id: string;
+    prepare?(input: {
+        readonly editor: Editor;
+        readonly requestedShapeIds: readonly ShapeId[];
+        readonly signal: AbortSignal;
+    }): void | Promise<void>;
+    inline(input: {
+        readonly editor: Editor;
+        readonly exportedShapes: readonly ShapeRecord[];
+        readonly exportedShapeIds: readonly ShapeId[];
+        readonly svg: string;
+        readonly signal: AbortSignal;
+    }): string | Promise<string>;
+}
+export type CanvasExportContribution = CanvasExportFormatProvider | SvgResourceInliner;
+export interface CanvasSvgInlineInput {
+    readonly editor: Editor;
+    readonly exportedShapes: readonly ShapeRecord[];
+    readonly exportedShapeIds: readonly ShapeId[];
+    readonly requestedShapeIds: readonly ShapeId[];
+    readonly svg: string;
+}
+export interface CanvasAssetResolverContribution {
+    readonly id: string;
+    resolve(assetId: string): string | null;
+    preload?(input: {
+        readonly editor: Editor;
+        readonly signal: AbortSignal;
+    }): void | Promise<void>;
+    cleanupAfterRestore?(input: {
+        readonly editor: Editor;
+        readonly signal: AbortSignal;
+    }): void | Promise<void>;
+}
+export interface CanvasStartupResult {
+    readonly documentSource: "restored" | "initial" | "empty";
+    readonly sessionRestored: boolean;
+    readonly warnings: readonly unknown[];
+}
+export type ActiveCanvasContextMenu = CanvasContextMenuRequest;

package/_vendor/canvas-extension-contracts/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./contributions";
+export * from "./operations";
+export * from "./persistence";
+export * from "./plugin";
+export * from "./shape";
+export * from "./tokens";

package/_vendor/canvas-extension-contracts/operations.d.ts

@@ -0,0 +1,131 @@
+import type { AssetId, Camera, ShapeId } from "../canvas-core/index";
+import type { CanvasExportArtifact, CanvasExportFormat } from "./contributions";
+export type CanvasProductExportTarget = {
+    readonly scope: "page" | "selection";
+    readonly shapeIds?: never;
+} | {
+    readonly scope?: never;
+    readonly shapeIds: readonly ShapeId[];
+};
+export type CanvasProductExportInput = CanvasProductExportTarget & {
+    readonly options?: unknown;
+};
+export type CanvasProductExportStatus = {
+    readonly state: "idle";
+} | {
+    readonly state: "exporting";
+    readonly format: string;
+};
+export interface CanvasProductExportController {
+    getFormats(): readonly CanvasExportFormat[];
+    getStatus(): CanvasProductExportStatus;
+    export(format: string, input: CanvasProductExportInput): Promise<CanvasExportArtifact>;
+}
+export interface CanvasProductShapeData {
+    readonly id: ShapeId;
+    readonly type: string;
+    readonly parentId: string;
+    readonly pageId: string | null;
+    readonly index: string;
+    readonly x: number;
+    readonly y: number;
+    readonly rotation: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+    readonly opacity: number;
+    readonly isHidden: boolean;
+    readonly isLocked: boolean;
+    readonly props: Readonly<Record<string, unknown>>;
+    readonly meta: Readonly<Record<string, unknown>>;
+}
+export interface CanvasProductAssetData {
+    readonly id: AssetId;
+    readonly type: string;
+    readonly props: Readonly<Record<string, unknown>>;
+    readonly meta: Readonly<Record<string, unknown>>;
+}
+export interface CanvasProductDocumentRef {
+    readonly id: string;
+    readonly meta: Readonly<Record<string, unknown>>;
+}
+export interface CanvasProductPageRef {
+    readonly id: string;
+    readonly name: string;
+    readonly index: string;
+    readonly meta: Readonly<Record<string, unknown>>;
+}
+export interface CanvasProductSessionPageState {
+    readonly pageId: string;
+    readonly selectedShapeIds: readonly ShapeId[];
+    readonly camera: Readonly<Camera>;
+}
+export interface CanvasProductSessionSnapshot<TToolId extends string = string> {
+    readonly currentPageId: string;
+    readonly activeToolId: TToolId;
+    readonly isToolLocked: boolean;
+    readonly meta: Readonly<Record<string, unknown>>;
+    readonly pages: readonly CanvasProductSessionPageState[];
+}
+export interface CanvasProductSnapshot<TToolId extends string = string> {
+    readonly productId: string;
+    readonly document: CanvasProductDocumentRef;
+    readonly pageId: string;
+    readonly activeToolId: TToolId;
+    readonly selectedShapeIds: readonly ShapeId[];
+    readonly shapeCount: number;
+    readonly session: CanvasProductSessionSnapshot<TToolId>;
+}
+export interface CanvasProductShapeUpdate {
+    readonly id: ShapeId;
+    readonly x?: number;
+    readonly y?: number;
+    readonly rotation?: number;
+    readonly scaleX?: number;
+    readonly scaleY?: number;
+    readonly opacity?: number;
+    readonly isHidden?: boolean;
+    readonly isLocked?: boolean;
+    readonly parentId?: string;
+    readonly index?: string;
+    readonly props?: Readonly<Record<string, unknown>>;
+    readonly meta?: Readonly<Record<string, unknown>>;
+}
+export interface CanvasProductCreatePageInput {
+    readonly name?: string;
+    readonly meta?: Readonly<Record<string, unknown>>;
+}
+export interface CanvasProductLayerPlacement {
+    readonly parentId: string;
+    readonly beforeId?: ShapeId | null;
+}
+export type CanvasProductLayerPlacementFailureReason = "empty-selection" | "invalid-parent" | "invalid-before" | "locked" | "cycle" | "mixed-parent";
+export type CanvasProductLayerPlacementResult = {
+    readonly ok: true;
+    readonly ids: readonly ShapeId[];
+} | {
+    readonly ok: false;
+    readonly reason: CanvasProductLayerPlacementFailureReason;
+};
+export interface CanvasProductLayerNode {
+    readonly id: ShapeId;
+    readonly parentId: string;
+    readonly pageId: string;
+    readonly type: string;
+    readonly companionIds: readonly ShapeId[];
+    readonly childIds: readonly ShapeId[];
+    readonly siblingIndex: number;
+    readonly depth: number;
+    readonly canReceiveChildren: boolean;
+    readonly isHidden: boolean;
+    readonly isLocked: boolean;
+    readonly isEffectivelyHidden: boolean;
+    readonly isEffectivelyLocked: boolean;
+}
+export interface CanvasProductLayerActionState {
+    readonly canGroup: boolean;
+    readonly canUngroup: boolean;
+    readonly canMoveBackward: boolean;
+    readonly canMoveForward: boolean;
+}
+export type CanvasSelectionAlignMode = "left" | "horizontal-center" | "right" | "top" | "vertical-center" | "bottom";
+export type CanvasSelectionDistributeAxis = "horizontal" | "vertical";

package/_vendor/canvas-extension-contracts/persistence.d.ts

@@ -0,0 +1,16 @@
+export interface ProductPersistenceLoadResult {
+    /** `null` means that persistence has no stored document. */
+    readonly documentSnapshot: unknown | null;
+    /** Ignored when `documentSnapshot` is `null`. */
+    readonly sessionSnapshot: unknown | null;
+}
+export interface ProductPersistenceAdapter {
+    /** Load and validation failures must reject; they are not missing documents. */
+    load?(input: {
+        readonly signal: AbortSignal;
+    }): ProductPersistenceLoadResult | Promise<ProductPersistenceLoadResult>;
+    saveDocument?(snapshot: unknown): void | Promise<void>;
+    saveSession?(snapshot: unknown): void | Promise<void>;
+    flush?(): void | Promise<void>;
+    dispose?(): void | Promise<void>;
+}

package/_vendor/canvas-extension-contracts/plugin.d.ts

@@ -0,0 +1,37 @@
+import type { Editor, EditorPlugin } from "../canvas-core/index";
+import type { CanvasRenderPlugin } from "../canvas-react/host/index";
+import type { CanvasAssetResolverContribution, CanvasExportContribution, CanvasImportContribution } from "./contributions";
+import type { CanvasApiToken, ScopedProductApiRegistryView } from "./tokens";
+export interface CanvasPluginReference {
+    readonly id: string;
+    readonly __canvasPluginReferenceBrand: "CanvasPluginReference";
+}
+export type CanvasPluginRequirement = CanvasPluginReference;
+export interface CanvasTaskRunner {
+    run<TResult>(operation: (signal: AbortSignal) => Promise<TResult>): Promise<TResult>;
+}
+export interface CanvasPluginSetupContext {
+    readonly editor: Editor;
+    readonly productId: string;
+    readonly apis: ScopedProductApiRegistryView;
+    readonly tasks: CanvasTaskRunner;
+}
+export interface CanvasPluginInstance<TApi = never> {
+    readonly api?: TApi;
+    readonly imports?: readonly CanvasImportContribution[];
+    readonly exports?: readonly CanvasExportContribution[];
+    readonly assetResolvers?: readonly CanvasAssetResolverContribution[];
+    dispose?(): void | Promise<void>;
+}
+export interface CanvasPluginDefinition<TApi = never> {
+    readonly id: string;
+    readonly requires?: readonly CanvasPluginReference[];
+    readonly editor?: EditorPlugin;
+    readonly render?: CanvasRenderPlugin;
+    readonly api?: CanvasApiToken<TApi>;
+    setup?(context: CanvasPluginSetupContext): CanvasPluginInstance<TApi> | void;
+}
+export interface CanvasPlugin<TApi = never> extends CanvasPluginDefinition<TApi>, CanvasPluginReference {
+}
+export type CanvasPluginInput = CanvasPlugin<unknown> | readonly CanvasPluginInput[];
+export declare function defineCanvasPlugin<TApi = never>(plugin: CanvasPluginDefinition<TApi>): CanvasPlugin<TApi>;

package/_vendor/canvas-extension-contracts/shape.d.ts

@@ -0,0 +1,5 @@
+import type { ShapeId } from "../canvas-core/index";
+export interface CanvasShapeRef<TType extends string = string> {
+    readonly id: ShapeId;
+    readonly type: TType;
+}

package/_vendor/canvas-extension-contracts/tokens.d.ts

@@ -0,0 +1,12 @@
+export interface CanvasApiToken<TApi> {
+    readonly id: string;
+    readonly kind: "api";
+    readonly __api?: TApi;
+}
+export declare function createCanvasApiToken<TApi>(id: string): CanvasApiToken<TApi>;
+export declare function isCanvasApiToken(value: unknown): value is CanvasApiToken<unknown>;
+export interface ScopedProductApiRegistryView {
+    get<TApi>(token: CanvasApiToken<TApi>): TApi | null;
+    require<TApi>(token: CanvasApiToken<TApi>): TApi;
+}
+export declare function requireApi<TApi>(apis: ScopedProductApiRegistryView, token: CanvasApiToken<TApi>): TApi;

package/_vendor/canvas-react/components/CanvasView.d.ts

@@ -1,14 +1,7 @@
 import type { CanvasContextMenuRequest } from "../contextMenuRequest";
-import type { CanvasRenderPluginComponent, CanvasRenderPluginProvider } from "../host/canvasRenderPlugin";
-import { type CanvasRendererRegistry } from "../host/rendererRegistry";
-import { type CanvasOverlayRegistry } from "../host/overlayRegistry";
-import { type CanvasDomEventGuardRegistry } from "../host/domEventGuards";
-export declare function Canvas({ canvasComponents, canvasProviders, domEventGuardRegistry, onContextMenuRequest, overlayRegistry, rendererRegistry, showGrid, }?: {
-    canvasComponents?: readonly CanvasRenderPluginComponent[];
-    canvasProviders?: readonly CanvasRenderPluginProvider[];
-    domEventGuardRegistry?: CanvasDomEventGuardRegistry;
+import type { CanvasRenderBindings } from "../host/canvasRenderBindings";
+export declare function Canvas({ onContextMenuRequest, renderBindings, showGrid, }: {
     onContextMenuRequest?: (request: CanvasContextMenuRequest) => void;
-    overlayRegistry?: CanvasOverlayRegistry;
-    rendererRegistry?: CanvasRendererRegistry;
+    renderBindings: CanvasRenderBindings;
     showGrid?: boolean;
 }): import("react/jsx-runtime").JSX.Element;

package/_vendor/canvas-react/components/DefaultGrid.d.ts

@@ -0,0 +1 @@
+export declare function DefaultGrid(): import("react/jsx-runtime").JSX.Element;

package/_vendor/canvas-react/components/canvasKeyboardEvents.d.ts

@@ -1,6 +1,6 @@
-import type { Editor, KeyboardEditorEvent } from "../../canvas-core/index";
+import type { Editor, EditorEventResult, KeyboardEditorEvent } from "../../canvas-core/index";
 export declare function createKeyboardEvent(name: KeyboardEditorEvent["name"], event: KeyboardEvent): KeyboardEditorEvent;
-export declare function routeCanvasKeyUp(editor: Editor, event: KeyboardEvent, isEditableTarget: boolean): void;
+export declare function routeCanvasKeyUp(editor: Editor, event: KeyboardEvent, isEditableTarget: boolean): EditorEventResult | null;
 export declare function getKeyboardShortcutEvent(event: KeyboardEvent): {
     key: string;
     shiftKey: boolean;

package/_vendor/canvas-react/components/index.d.ts

@@ -1,2 +1,3 @@
 export { Canvas } from "./CanvasView";
+export { DefaultGrid } from "./DefaultGrid";
 export { PageSpace } from "./PageSpace";

package/_vendor/canvas-react/components/shape-layer/ShapeClipStack.d.ts

@@ -0,0 +1,11 @@
+import type { ReactNode } from "react";
+import { type Mat, type ShapeId } from "../../../canvas-core/index";
+/**
+ * Shape DOM 节点在页面空间中平铺渲染，并未嵌套在父级 Shape 节点内，
+ * 因此需要在这里重建逻辑上的祖先裁剪层级。
+ */
+export declare function ShapeClipStack({ children, clipAncestorIds, shapeElementToPage, }: {
+    children: ReactNode;
+    clipAncestorIds: readonly ShapeId[];
+    shapeElementToPage: Mat;
+}): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;

package/_vendor/canvas-react/components/shape-layer/ShapeDecorations.d.ts

@@ -0,0 +1,2 @@
+export declare function TransformDescendantAncestorBoundary(): import("react/jsx-runtime").JSX.Element;
+export declare function ShapeDropTargetLabel(): import("react/jsx-runtime").JSX.Element;

package/_vendor/canvas-react/components/shape-layer/ShapeForegroundItem.d.ts

@@ -0,0 +1,5 @@
+import type { ShapeId } from "../../../canvas-core/index";
+export declare const ShapeForegroundItem: import("react").NamedExoticComponent<{
+    shapeId: ShapeId;
+    stackingOrder: number;
+}>;

package/_vendor/canvas-react/components/shape-layer/ShapeItem.d.ts

@@ -0,0 +1,5 @@
+import type { ShapeId } from "../../../canvas-core/index";
+export declare const ShapeItem: import("react").NamedExoticComponent<{
+    shapeId: ShapeId;
+    stackingOrder: number;
+}>;

package/_vendor/canvas-react/components/shape-layer/ShapeRenderList.d.ts

@@ -0,0 +1 @@
+export declare const ShapeRenderList: import("react").NamedExoticComponent<object>;

package/_vendor/canvas-react/components/shape-layer/ShapeRenderer.d.ts

@@ -0,0 +1,12 @@
+import type { Editor, ShapeRecord } from "../../../canvas-core/index";
+import { type AnyRegisteredShapeRenderer, type ShapeRendererProps } from "../../host/canvasRenderPlugin";
+interface MemoizedShapeRendererProps extends ShapeRendererProps {
+    Component: AnyRegisteredShapeRenderer["component"];
+}
+export declare const MemoizedShapeRenderer: import("react").NamedExoticComponent<MemoizedShapeRendererProps>;
+export declare function ShapeHoverDecoration({ Component, editor, shape, }: {
+    Component: NonNullable<AnyRegisteredShapeRenderer["hoverComponent"]>;
+    editor: Editor;
+    shape: ShapeRecord;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/_vendor/canvas-react/components/shape-layer/shapeFrame.d.ts

@@ -0,0 +1,11 @@
+import { Mat, type Editor, type ShapeRecord } from "../../../canvas-core/index";
+export interface ShapeFrame {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    transform: string;
+    transformOrigin: string;
+    elementToPage: Mat;
+}
+export declare function getShapeFrame(editor: Editor, shape: ShapeRecord, renderToPage: Mat): ShapeFrame;

package/_vendor/canvas-react/components/useCanvasDomEvents.d.ts

@@ -1,7 +1,7 @@
 import { type MouseEvent as ReactMouseEvent, type PointerEvent as ReactPointerEvent, type RefObject } from "react";
 import { type Editor, type ShapeEditingSession } from "../../canvas-core/index";
 import type { CanvasContextMenuRequest } from "../contextMenuRequest";
-import type { CanvasDomEventGuardRegistry } from "../host/domEventGuards";
+import type { CanvasDomEventGuards } from "../host/canvasRenderBindings";
 export interface CanvasDomEventHandlers {
     onPointerDown: (event: ReactPointerEvent<HTMLDivElement>) => void;
     onAuxClick: (event: ReactMouseEvent<HTMLDivElement>) => void;
@@ -15,7 +15,7 @@ export interface CanvasDomEventState {
     surfaceCursor: string | undefined;
 }
 export declare function useCanvasDomEvents({ activeDomEventGuards, activeToolId, editor, onContextMenuRequest, shapeEditingSession, }: {
-    activeDomEventGuards: CanvasDomEventGuardRegistry;
+    activeDomEventGuards: CanvasDomEventGuards;
     activeToolId: string;
     editor: Editor;
     onContextMenuRequest?: (request: CanvasContextMenuRequest) => void;

package/_vendor/canvas-react/dom.d.ts

@@ -5,6 +5,6 @@ export declare function getEditableEventTarget(target: EventTarget | null): HTML
 export declare function isEditableEventTarget(target: EventTarget | null): boolean;
 export declare function getCanvasSurfaceElement(root?: ParentNode): HTMLElement | null;
 export declare function getCanvasSurfaceElementForNode(node: Node | null | undefined): HTMLElement | null;
-export declare function forwardWheelEventToCanvasSurface(event: WheelEvent, source: Node): boolean;
+export declare function forwardWheelEventToCanvasSurface(event: WheelEvent, source: Node, root?: ParentNode): boolean;
 export declare function getCanvasSurfaceScreenPoint(point: Pick<MouseEvent, "clientX" | "clientY">, surface?: HTMLElement | null): Vec;
 export declare function getCanvasSurfacePagePoint(editor: Editor, point: Pick<MouseEvent, "clientX" | "clientY">, surface?: HTMLElement | null): Vec;

package/_vendor/canvas-react/host/canvasRenderBindings.d.ts

@@ -0,0 +1,21 @@
+import type { Editor, ReadonlyValue, SelectionCustomHandle, ShapeId, ShapeRecordBase } from "../../canvas-core/index";
+import type { AnyRegisteredSelectionCustomHandleRenderer, AnyRegisteredShapeRenderer, CanvasDomEventGuardCursorInput, CanvasDomEventGuardInput, CanvasOverlayContribution, CanvasRenderPlugin, CanvasRenderPluginComponent } from "./canvasRenderPlugin";
+export interface CanvasRendererLookup {
+    getShapeRenderer(type: ShapeRecordBase["type"]): AnyRegisteredShapeRenderer | null;
+    getShapeOpacityValue(editor: Editor, shapeId: ShapeId): ReadonlyValue<number>;
+}
+export interface CanvasOverlayLookup {
+    getCanvasOverlays(): readonly CanvasOverlayContribution[];
+    getSelectionCustomHandleRenderer(type: SelectionCustomHandle["type"]): AnyRegisteredSelectionCustomHandleRenderer | null;
+}
+export interface CanvasDomEventGuards {
+    handle(input: CanvasDomEventGuardInput): "continue" | "handled";
+    getCursor(input: CanvasDomEventGuardCursorInput): string | undefined;
+}
+export interface CanvasRenderBindings {
+    readonly canvasComponents: readonly CanvasRenderPluginComponent[];
+    readonly renderers: CanvasRendererLookup;
+    readonly overlays: CanvasOverlayLookup;
+    readonly domEventGuards: CanvasDomEventGuards;
+}
+export declare function createCanvasRenderBindings(plugins: readonly CanvasRenderPlugin[]): CanvasRenderBindings;

package/_vendor/canvas-react/host/canvasRenderBindingsContext.d.ts

@@ -0,0 +1,5 @@
+import { type CanvasOverlayLookup, type CanvasRenderBindings, type CanvasRendererLookup } from "./canvasRenderBindings";
+export declare const CanvasRenderBindingsContext: import("react").Context<CanvasRenderBindings>;
+export declare function useCanvasRenderBindings(): CanvasRenderBindings;
+export declare function useCanvasRenderers(): CanvasRendererLookup;
+export declare function useCanvasOverlays(): CanvasOverlayLookup;