@yuzhouu/canvas-kit 0.1.2 → 0.1.3

package/_vendor/canvas-product-react/capabilities/context-menu/systemContextMenu.d.ts

@@ -0,0 +1,17 @@
+import { type ContextMenuContext, type ContextMenuContributionTarget, type ContextMenuTarget, type Editor, type ToolbarActionValue } from "../../../canvas-core/index";
+import { type CanvasPluginHostRuntime } from "../../../canvas-react/host/index";
+export declare const SYSTEM_VIEW_ZOOM_IN_ACTION_ID = "system.view.zoom-in";
+export declare const SYSTEM_VIEW_ZOOM_OUT_ACTION_ID = "system.view.zoom-out";
+export declare const SYSTEM_VIEW_RESET_ZOOM_ACTION_ID = "system.view.reset-zoom";
+export declare function registerSystemContextMenuContributions(pluginHostRuntime: CanvasPluginHostRuntime): void;
+export declare function createContextMenuContext({ editor, menu, }: {
+    editor: Editor;
+    menu: ContextMenuContext["menu"];
+}): ContextMenuContext;
+export declare function getContextMenuContributionTarget(target: ContextMenuTarget, editor: Editor): ContextMenuContributionTarget;
+export declare function runContextMenuAction({ actionId, context, pluginHostRuntime, value, }: {
+    actionId: string;
+    context: ContextMenuContext;
+    pluginHostRuntime: CanvasPluginHostRuntime;
+    value?: ToolbarActionValue;
+}): void;

package/_vendor/canvas-product-react/capabilities/context-menu/useContextMenuSurface.d.ts

@@ -0,0 +1,12 @@
+import type { ContextMenuContext, ContextMenuOpenSnapshot, ContextMenuSection, Editor } from "../../../canvas-core/index";
+import type { CanvasPluginHostRuntime } from "../../../canvas-react/host/index";
+export interface ContextMenuSurface {
+    context: ContextMenuContext | null;
+    openSnapshot: ContextMenuOpenSnapshot | null;
+    sections: readonly ContextMenuSection[];
+}
+export declare function useContextMenuSurface({ editor, openSnapshot, pluginHostRuntime, }: {
+    editor: Editor;
+    openSnapshot: ContextMenuOpenSnapshot | null;
+    pluginHostRuntime: CanvasPluginHostRuntime;
+}): ContextMenuSurface;

package/_vendor/canvas-product-react/capabilities/export/useSvgExport.d.ts

@@ -0,0 +1,29 @@
+import type { Editor, ExportIntegrityReport, ShapeCapabilityManifest, ShapeId, SvgExportSkippedShape } from "../../../canvas-core/index";
+export interface SvgAssetInliner {
+    inline(input: {
+        editor: Editor;
+        exportedShapeIds: readonly ShapeId[];
+        svg: string;
+    }): Promise<string>;
+}
+export type ExportStatus = {
+    tone: "success" | "warning" | "error";
+    title: string;
+    details: string;
+    integrity: ExportIntegrityReport;
+    capabilityManifest: ShapeCapabilityManifest;
+};
+export interface SvgExportResult {
+    status: ExportStatus;
+    svg: string | null;
+    exportedShapeIds: readonly ShapeId[];
+    skippedShapes: readonly SvgExportSkippedShape[];
+}
+export interface SvgExportControls {
+    status: ExportStatus | null;
+    exportSvg(shapeIds: readonly ShapeId[]): Promise<SvgExportResult>;
+}
+export declare function useSvgExport({ assetInliners, editor, }: {
+    assetInliners?: readonly SvgAssetInliner[];
+    editor: Editor;
+}): SvgExportControls;

package/_vendor/canvas-product-react/capabilities/history/useHistoryControls.d.ts

@@ -0,0 +1,8 @@
+import type { Editor } from "../../../canvas-core/index";
+export interface HistoryControls {
+    canUndo: boolean;
+    canRedo: boolean;
+    undo(): void;
+    redo(): void;
+}
+export declare function useHistoryControls(editor: Editor): HistoryControls;

package/_vendor/canvas-product-react/capabilities/pages/usePageControls.d.ts

@@ -0,0 +1,12 @@
+import type { Editor, PageId, PageRecord } from "../../../canvas-core/index";
+export interface PageControls {
+    pages: readonly PageRecord[];
+    currentPage: PageRecord | null;
+    currentPageId: PageId;
+    canDeleteCurrentPage: boolean;
+    createPage(): void;
+    deleteCurrentPage(): void;
+    renameCurrentPage(nextName: string): void;
+    selectPage(pageId: PageId): void;
+}
+export declare function usePageControls(editor: Editor): PageControls;

package/_vendor/canvas-product-react/capabilities/toolbar/systemToolbar.d.ts

@@ -0,0 +1,32 @@
+import { type Editor, type ToolbarContext, type ToolbarGroup } from "../../../canvas-core/index";
+import { type CanvasPluginHostRuntime } from "../../../canvas-react/host/index";
+export declare const SYSTEM_SELECTION_DELETE_ACTION_ID = "system.selection.delete";
+export declare const SYSTEM_SELECTION_GROUP_ACTION_ID = "system.selection.group";
+export declare const SYSTEM_SELECTION_UNGROUP_ACTION_ID = "system.selection.ungroup";
+export declare function registerSystemToolbarContributions(pluginHostRuntime: CanvasPluginHostRuntime): void;
+export declare function createToolbarContext({ editor, toolState, selectionState, }: {
+    editor: Editor;
+    toolState: {
+        activeToolId: string;
+        isToolLocked: boolean;
+    };
+    selectionState: {
+        count: number;
+        singleShapeType: ToolbarContext["selection"]["singleShapeType"];
+        commonShapeType: ToolbarContext["selection"]["commonShapeType"];
+        canResetSelectionRotation: boolean;
+        isMixedFrameAndPointHandleSelection: boolean;
+    };
+}): ToolbarContext;
+export declare function getActiveToolLabel(groups: readonly ToolbarGroup[], activeToolId: string): string;
+export declare function getSelectionToolbarTitle({ commonShapeType, count, isMixedFrameAndPointHandleSelection, singleShapeType, }: {
+    commonShapeType: string | null;
+    count: number;
+    isMixedFrameAndPointHandleSelection: boolean;
+    singleShapeType: string | null;
+}): string;
+export declare function runToolbarAction({ context, pluginHostRuntime, actionId, }: {
+    context: ToolbarContext;
+    pluginHostRuntime: CanvasPluginHostRuntime;
+    actionId: string;
+}): void;

package/_vendor/canvas-product-react/capabilities/toolbar/useToolbarSurfaces.d.ts

@@ -0,0 +1,19 @@
+import type { Editor, ToolbarContext, ToolbarGroup } from "../../../canvas-core/index";
+import type { CanvasPluginHostRuntime } from "../../../canvas-react/host/index";
+export interface ToolbarSurfaces {
+    context: ToolbarContext;
+    activeToolId: string;
+    activeToolLabel: string;
+    isToolLocked: boolean;
+    selectionCount: number;
+    hasMixedSelectionRotation: boolean;
+    toolChromeToolbarGroups: readonly ToolbarGroup[];
+    contextToolbarGroups: readonly ToolbarGroup[];
+    contextToolbarTitle: string;
+    showContextToolbar: boolean;
+}
+export declare function useToolbarSurfaces({ canShowContextToolbarDuringEditing, editor, pluginHostRuntime, }: {
+    canShowContextToolbarDuringEditing?: (context: ToolbarContext) => boolean;
+    editor: Editor;
+    pluginHostRuntime: CanvasPluginHostRuntime;
+}): ToolbarSurfaces;

package/_vendor/canvas-product-react/capabilities/zoom/useZoomControls.d.ts

@@ -0,0 +1,9 @@
+import type { Editor } from "../../../canvas-core/index";
+export interface ZoomControlsState {
+    zoom: number;
+    label: string;
+    zoomIn(): void;
+    zoomOut(): void;
+    resetZoom(): void;
+}
+export declare function useZoomControls(editor: Editor): ZoomControlsState;

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

@@ -0,0 +1,24 @@
+export { CanvasProductRoot } from "./runtime/CanvasProductRoot";
+export { defineCanvasProduct } from "./runtime/productDefinition";
+export { createProductApiRegistry, createProductApiToken, } from "./api/apiRegistry";
+export { createProductServiceRegistry, createProductServiceToken, requireProductService, } from "./runtime/productServices";
+export type { CanvasProductDefinition, CanvasProductShellProps, CanvasProductRuntimeSetup, CanvasProductRuntimeSetupContext, CreateCanvasProductEditorOptions, ProductPersistenceAdapter, } from "./runtime/productDefinition";
+export type { ProductAssetResolverService, ProductServiceFactory, ProductServiceFactoryContext, ProductServiceRegistry, ProductServiceRegistryRuntime, ProductServiceToken, } from "./runtime/productServices";
+export type { ProductApiRegistry, ProductApiRegistryRuntime, ProductApiToken, } from "./api/apiRegistry";
+export { SYSTEM_SELECTION_DELETE_ACTION_ID, SYSTEM_SELECTION_GROUP_ACTION_ID, SYSTEM_SELECTION_UNGROUP_ACTION_ID, createToolbarContext, getActiveToolLabel, getSelectionToolbarTitle, registerSystemToolbarContributions, runToolbarAction, } from "./capabilities/toolbar/systemToolbar";
+export { SYSTEM_VIEW_RESET_ZOOM_ACTION_ID, SYSTEM_VIEW_ZOOM_IN_ACTION_ID, SYSTEM_VIEW_ZOOM_OUT_ACTION_ID, createContextMenuContext, getContextMenuContributionTarget, registerSystemContextMenuContributions, runContextMenuAction, } from "./capabilities/context-menu/systemContextMenu";
+export { useContextMenuSurface } from "./capabilities/context-menu/useContextMenuSurface";
+export type { ContextMenuSurface } from "./capabilities/context-menu/useContextMenuSurface";
+export { canvasClipboardServiceToken, memoryCanvasClipboardService, } from "./capabilities/clipboard/clipboardService";
+export type { CanvasClipboardService } from "./capabilities/clipboard/clipboardService";
+export { SYSTEM_CLIPBOARD_COPY_ACTION_ID, SYSTEM_CLIPBOARD_CUT_ACTION_ID, SYSTEM_CLIPBOARD_PASTE_ACTION_ID, SYSTEM_CLIPBOARD_PASTE_AT_POINT_ACTION_ID, SYSTEM_SELECTION_DUPLICATE_ACTION_ID, SYSTEM_SELECTION_SELECT_ALL_ACTION_ID, getCanvasClipboardService, registerSystemClipboardActions, registerSystemClipboardRuntime, } from "./capabilities/clipboard/systemClipboard";
+export { useHistoryControls } from "./capabilities/history/useHistoryControls";
+export type { HistoryControls } from "./capabilities/history/useHistoryControls";
+export { usePageControls } from "./capabilities/pages/usePageControls";
+export type { PageControls } from "./capabilities/pages/usePageControls";
+export { useSvgExport } from "./capabilities/export/useSvgExport";
+export type { ExportStatus, SvgAssetInliner, SvgExportControls, SvgExportResult, } from "./capabilities/export/useSvgExport";
+export { useToolbarSurfaces } from "./capabilities/toolbar/useToolbarSurfaces";
+export type { ToolbarSurfaces } from "./capabilities/toolbar/useToolbarSurfaces";
+export { useZoomControls } from "./capabilities/zoom/useZoomControls";
+export type { ZoomControlsState } from "./capabilities/zoom/useZoomControls";

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

@@ -0,0 +1,2 @@
+export { LAND_DOCUMENT_INDEXEDDB_NAME, LAND_DOCUMENT_INDEXEDDB_STORE, LAND_DOCUMENT_INDEXEDDB_VERSION, LAND_DOCUMENT_STORAGE_KEY, LAND_IMAGE_BLOB_INDEXEDDB_STORE, LAND_SESSION_STORAGE_KEY, PersistenceManager, createLocalSnapshotPersistence, persistEditorSnapshot, readPersistedDocumentSnapshot, readPersistedEditorSnapshots, readPersistedSessionSnapshot, } from "./localSnapshotPersistence";
+export type { LocalSnapshotPersistenceOptions, PersistedEditorSnapshots, } from "./localSnapshotPersistence";

package/_vendor/canvas-product-react/persistence/localSnapshotPersistence.d.ts

@@ -0,0 +1,40 @@
+import type { Editor } from "../../canvas-core/index";
+import type { ProductPersistenceAdapter } from "../runtime/productDefinition";
+export declare const LAND_DOCUMENT_INDEXEDDB_NAME = "land.canvas.persistence";
+export declare const LAND_DOCUMENT_INDEXEDDB_STORE = "snapshots";
+export declare const LAND_IMAGE_BLOB_INDEXEDDB_STORE = "imageBlobs";
+export declare const LAND_DOCUMENT_STORAGE_KEY = "land.canvas.document";
+export declare const LAND_SESSION_STORAGE_KEY = "land.canvas.session";
+export declare const LAND_DOCUMENT_INDEXEDDB_VERSION = 2;
+export interface PersistedEditorSnapshots {
+    documentSnapshot: unknown | null;
+    sessionSnapshot: unknown | null;
+}
+export interface LocalSnapshotPersistenceOptions {
+    storageNamespace?: string;
+    shouldIgnoreDocumentSnapshot?: (snapshot: unknown) => boolean;
+}
+export declare function createLocalSnapshotPersistence(options?: LocalSnapshotPersistenceOptions): ProductPersistenceAdapter;
+export declare class PersistenceManager {
+    private readonly editor;
+    private readonly options;
+    private static readonly SAVE_DELAY_MS;
+    private unsubscribe;
+    private saveTimeoutId;
+    private hasPendingSave;
+    private isSaving;
+    private saveAgainAfterCurrentSave;
+    constructor(editor: Editor, options?: LocalSnapshotPersistenceOptions);
+    start(): void;
+    stop(): void;
+    flush(): void;
+    private save;
+    private scheduleSave;
+    private cancelScheduledSave;
+    private readonly flushWhenHidden;
+    private readonly flushWhenPageIsLeaving;
+}
+export declare function persistEditorSnapshot(editor: Editor, options?: LocalSnapshotPersistenceOptions): Promise<void>;
+export declare function readPersistedEditorSnapshots(options?: LocalSnapshotPersistenceOptions): Promise<PersistedEditorSnapshots>;
+export declare function readPersistedDocumentSnapshot(): Promise<unknown | null>;
+export declare function readPersistedSessionSnapshot(): Promise<unknown | null>;

package/_vendor/canvas-product-react/runtime/CanvasProductRoot.d.ts

@@ -0,0 +1,4 @@
+import type { CanvasProductDefinition } from "./productDefinition";
+export declare function CanvasProductRoot({ product, }: {
+    product: CanvasProductDefinition;
+}): import("react/jsx-runtime").JSX.Element | null;

package/_vendor/canvas-product-react/runtime/productDefinition.d.ts

@@ -0,0 +1,45 @@
+import type { ComponentType, ReactNode } from "react";
+import type { AssetId, ContextMenuOpenSnapshot, Editor, LandCorePlugin } from "../../canvas-core/index";
+import type { LandExtension } from "../../canvas-plugin-api/index";
+import type { CanvasPluginHostRuntime } from "../../canvas-react/host/index";
+import type { ProductApiRegistry, ProductApiRegistryRuntime } from "../api/apiRegistry";
+import type { ProductAssetResolverService, ProductServiceFactory, ProductServiceRegistry, ProductServiceRegistryRuntime, ProductServiceToken } from "./productServices";
+export interface ProductPersistenceAdapter {
+    restore?(editor: Editor): Promise<void>;
+    start?(editor: Editor): () => void;
+}
+export interface CreateCanvasProductEditorOptions {
+    corePlugins: readonly LandCorePlugin[];
+    resolveAssetUrl?: (assetId: AssetId) => string | null;
+}
+export interface CanvasProductRuntimeSetupContext {
+    productId: string;
+    apiRegistry: ProductApiRegistryRuntime;
+    editor: Editor;
+    pluginHostRuntime: CanvasPluginHostRuntime;
+    services: ProductServiceRegistryRuntime;
+}
+export type CanvasProductRuntimeSetup = (context: CanvasProductRuntimeSetupContext) => void;
+export interface CanvasProductShellProps {
+    product: CanvasProductDefinition;
+    editor: Editor;
+    pluginHostRuntime: CanvasPluginHostRuntime;
+    apiRegistry: ProductApiRegistry;
+    services: ProductServiceRegistry;
+    canvas: ReactNode | null;
+    contextMenuOpenSnapshot: ContextMenuOpenSnapshot | null;
+    onContextMenuOpenChange: (snapshot: ContextMenuOpenSnapshot | null) => void;
+    isReady: boolean;
+}
+export interface CanvasProductDefinition {
+    id: string;
+    extensions: readonly LandExtension[];
+    createEditor(options: CreateCanvasProductEditorOptions): Editor;
+    Shell: ComponentType<CanvasProductShellProps>;
+    runtimeSetups?: readonly CanvasProductRuntimeSetup[];
+    services?: readonly ProductServiceFactory<unknown>[];
+    assetResolverTokens?: readonly ProductServiceToken<ProductAssetResolverService>[];
+    persistence?: ProductPersistenceAdapter | null;
+    shouldSkipStoredSnapshots?: () => boolean;
+}
+export declare function defineCanvasProduct(definition: CanvasProductDefinition): CanvasProductDefinition;

package/_vendor/canvas-product-react/runtime/productServices.d.ts

@@ -0,0 +1,31 @@
+import type { AssetId, Editor } from "../../canvas-core/index";
+export interface ProductServiceToken<TService> {
+    readonly id: string;
+    readonly __service?: TService;
+}
+export interface ProductServiceFactoryContext {
+    productId: string;
+}
+export interface ProductServiceFactory<TService> {
+    token: ProductServiceToken<TService>;
+    create(context: ProductServiceFactoryContext): TService;
+    dispose?(service: TService): void;
+}
+export interface ProductServiceRegistry {
+    get<TService>(token: ProductServiceToken<TService>): TService | null;
+}
+export interface ProductServiceRegistryRuntime extends ProductServiceRegistry {
+    register<TService>(factory: ProductServiceFactory<TService>, context: ProductServiceFactoryContext): TService;
+    dispose(): void;
+}
+export interface ProductAssetResolverService {
+    resolveAssetUrl(editor: Editor, assetId: AssetId): string | null;
+    preloadForEditor?(editor: Editor): Promise<void>;
+    cleanupAfterRestore?(editor: Editor): Promise<void> | void;
+}
+export declare function createProductServiceToken<TService>(id: string): ProductServiceToken<TService>;
+export declare function createProductServiceRegistry({ factories, productId, }: {
+    factories: readonly ProductServiceFactory<unknown>[];
+    productId: string;
+}): ProductServiceRegistryRuntime;
+export declare function requireProductService<TService>(services: ProductServiceRegistry, token: ProductServiceToken<TService>): TService;

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

@@ -0,0 +1,11 @@
+import { type ContextMenuOpenSnapshot } from "../../canvas-core/index";
+import type { CanvasPluginComponent, CanvasPluginProvider } from "../../canvas-plugin-api/index";
+import { type CanvasRendererRegistry } from "../host/rendererRegistry";
+import { type CanvasDomEventGuardRegistry } from "../host/domEventGuards";
+export declare function Canvas({ canvasComponents, canvasProviders, domEventGuardRegistry, onContextMenuRequest, rendererRegistry, }?: {
+    canvasComponents?: readonly CanvasPluginComponent[];
+    canvasProviders?: readonly CanvasPluginProvider[];
+    domEventGuardRegistry?: CanvasDomEventGuardRegistry;
+    onContextMenuRequest?: (snapshot: ContextMenuOpenSnapshot) => void;
+    rendererRegistry?: CanvasRendererRegistry;
+}): import("react/jsx-runtime").JSX.Element;

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

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

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

@@ -0,0 +1,6 @@
+import type { ReactNode } from "react";
+export declare function PageSpace({ children, className, dataUi, }: {
+    children: ReactNode;
+    className?: string;
+    dataUi: string;
+}): import("react/jsx-runtime").JSX.Element;

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

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

package/_vendor/canvas-react/hooks/useEditor.d.ts

@@ -0,0 +1,3 @@
+import type { Editor } from "../../canvas-core/index";
+export declare const EditorContext: import("react").Context<Editor | null>;
+export declare function useEditor(): Editor;

package/_vendor/canvas-react/hooks/useValue.d.ts

@@ -0,0 +1,2 @@
+import { type ReadonlyValue } from "../../canvas-core/index";
+export declare function useValue<T>(signal: ReadonlyValue<T>): T;

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

@@ -0,0 +1,3 @@
+import { type CanvasRendererRegistry } from "./rendererRegistry";
+export declare const CanvasRendererRegistryContext: import("react").Context<CanvasRendererRegistry>;
+export declare function useCanvasRendererRegistry(): CanvasRendererRegistry;

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

@@ -0,0 +1,12 @@
+import type { ContextMenuContext, ContextMenuContribution, ContextMenuContributionTarget, ContextMenuSection, LandCorePlugin } from "../../canvas-core/index";
+export declare class CanvasContextMenuRegistry {
+    private readonly contributions;
+    private readonly duplicateContributionIds;
+    registerContribution(contribution: ContextMenuContribution, options?: {
+        replace?: boolean;
+    }): void;
+    registerCorePlugins(plugins: readonly LandCorePlugin[]): void;
+    getDuplicateContributionIds(): string[];
+    getSections(target: ContextMenuContributionTarget, context: ContextMenuContext): ContextMenuSection[];
+}
+export declare function createCanvasContextMenuRegistry(plugins?: readonly LandCorePlugin[]): CanvasContextMenuRegistry;

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

@@ -0,0 +1,11 @@
+import { type CanvasDomEventGuard, type CanvasDomEventGuardCursorInput, type CanvasDomEventGuardInput, type LandCanvasPlugin } from "../../canvas-plugin-api/index";
+export declare class CanvasDomEventGuardRegistry {
+    private readonly guards;
+    private readonly registeredGuardIds;
+    register(guard: CanvasDomEventGuard): void;
+    registerCanvasPlugins(plugins: readonly LandCanvasPlugin[]): void;
+    getGuards(): readonly CanvasDomEventGuard[];
+    handle(input: CanvasDomEventGuardInput): "continue" | "handled";
+    getCursor(input: CanvasDomEventGuardCursorInput): string | undefined;
+}
+export declare function createCanvasDomEventGuardRegistry(plugins?: readonly LandCanvasPlugin[]): CanvasDomEventGuardRegistry;

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

@@ -0,0 +1,8 @@
+export { CanvasRendererRegistryContext, useCanvasRendererRegistry, } from "./CanvasRendererRegistryContext";
+export { CanvasDomEventGuardRegistry, createCanvasDomEventGuardRegistry, } from "./domEventGuards";
+export { CanvasRendererRegistry, createCanvasRendererRegistry, } from "./rendererRegistry";
+export { CanvasToolbarRegistry, createCanvasToolbarRegistry, } from "./toolbarRegistry";
+export { CanvasContextMenuRegistry, createCanvasContextMenuRegistry, } from "./contextMenuRegistry";
+export type { AnyRegisteredShapeRenderer, RegisteredShapeRenderer, ShapeRendererProps, } from "../../canvas-plugin-api/index";
+export { createCanvasPluginHostRuntime } from "./pluginHost";
+export type { CanvasPluginHostManifestEntry, CanvasPluginHostManifestToolbarContributionEntry, CanvasPluginHostRuntime, CanvasPluginHostShapeValidationSummary, CanvasPluginHostSource, CanvasPluginHostValidationIssue, CanvasPluginHostValidationIssueSeverity, CanvasPluginHostValidationSummary, CanvasPluginHostVerdict, CreateCanvasPluginHostRuntimeOptions, } from "./pluginHost";

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

@@ -0,0 +1,93 @@
+import { ShapeCapabilitySupport } from "../../canvas-core/index";
+import { type CanvasPluginComponent, type CanvasPluginProvider, type LandExtension, type LandCanvasPlugin } from "../../canvas-plugin-api/index";
+import type { LandCorePlugin } from "../../canvas-core/index";
+import { type CanvasRendererRegistry } from "./rendererRegistry";
+import { type CanvasDomEventGuardRegistry } from "./domEventGuards";
+import { type CanvasToolbarRegistry } from "./toolbarRegistry";
+import { type CanvasContextMenuRegistry } from "./contextMenuRegistry";
+export type CanvasPluginHostSource = "built-in" | "dev-sample";
+export type CanvasPluginHostVerdict = "pass" | "fail";
+export interface CreateCanvasPluginHostRuntimeOptions {
+    source?: CanvasPluginHostSource;
+}
+export interface CanvasPluginHostManifestEntry {
+    id: string;
+    extensionName: string;
+    source: CanvasPluginHostSource;
+    corePluginIds: string[];
+    canvasPluginIds: string[];
+    interactionHandlerIds: string[];
+    toolbarActionIds: string[];
+    toolbarContributionIds: string[];
+    toolbarContributions: CanvasPluginHostManifestToolbarContributionEntry[];
+    contextMenuContributionIds: string[];
+    contextMenuContributions: CanvasPluginHostManifestContextMenuContributionEntry[];
+    domEventGuardIds: string[];
+    canvasProviderIds: string[];
+    canvasComponentIds: string[];
+    shapeTypes: string[];
+}
+export interface CanvasPluginHostManifestToolbarContributionEntry {
+    id: string;
+    surface: string;
+    placement: string;
+    actionIds: string[];
+}
+export interface CanvasPluginHostManifestContextMenuContributionEntry {
+    id: string;
+    target: string;
+    actionIds: string[];
+}
+export interface CanvasPluginHostRuntime {
+    corePlugins: LandCorePlugin[];
+    canvasPlugins: LandCanvasPlugin[];
+    canvasProviders: CanvasPluginProvider[];
+    canvasComponents: CanvasPluginComponent[];
+    rendererRegistry: CanvasRendererRegistry;
+    domEventGuardRegistry: CanvasDomEventGuardRegistry;
+    toolbarRegistry: CanvasToolbarRegistry;
+    contextMenuRegistry: CanvasContextMenuRegistry;
+    manifest: CanvasPluginHostManifestEntry[];
+    validation: CanvasPluginHostValidationSummary;
+    externalPluginIds: string[];
+    ignoreStoredSnapshots: boolean;
+    disablePersistence: boolean;
+}
+export type CanvasPluginHostValidationIssueSeverity = "error" | "warning";
+export interface CanvasPluginHostValidationIssue {
+    severity: CanvasPluginHostValidationIssueSeverity;
+    code: "duplicate-feature-id" | "duplicate-core-plugin-id" | "duplicate-canvas-plugin-id" | "duplicate-interaction-handler-id" | "duplicate-toolbar-action-id" | "duplicate-toolbar-contribution-id" | "duplicate-context-menu-contribution-id" | "duplicate-dom-event-guard-id" | "duplicate-canvas-provider-id" | "duplicate-canvas-component-id" | "missing-toolbar-action" | "missing-context-menu-action" | "missing-core-plugin" | "missing-canvas-plugin" | "missing-shape-type" | "missing-shape-capability" | "missing-shape-util" | "missing-svg-exporter" | "missing-canvas-renderer";
+    featureId: string | null;
+    pluginId: string | null;
+    shapeType: string | null;
+    message: string;
+}
+export interface CanvasPluginHostShapeValidationSummary {
+    featureId: string;
+    shapeType: string;
+    hasCapability: boolean;
+    hasShapeUtil: boolean;
+    hasSvgExporter: boolean;
+    hasCanvasRenderer: boolean;
+    exportSupport: ShapeCapabilitySupport | null;
+}
+export interface CanvasPluginHostValidationSummary {
+    verdict: CanvasPluginHostVerdict;
+    issueCount: number;
+    errorCount: number;
+    warningCount: number;
+    issues: CanvasPluginHostValidationIssue[];
+    featureIds: string[];
+    corePluginIds: string[];
+    canvasPluginIds: string[];
+    interactionHandlerIds: string[];
+    toolbarActionIds: string[];
+    toolbarContributionIds: string[];
+    contextMenuContributionIds: string[];
+    domEventGuardIds: string[];
+    canvasProviderIds: string[];
+    canvasComponentIds: string[];
+    registeredRendererTypes: string[];
+    shapeSummaries: CanvasPluginHostShapeValidationSummary[];
+}
+export declare function createCanvasPluginHostRuntime(extensions: readonly LandExtension[], options?: CreateCanvasPluginHostRuntimeOptions): CanvasPluginHostRuntime;

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

@@ -0,0 +1,12 @@
+import type { ShapeRecordBase } from "../../canvas-core/index";
+import { type AnyRegisteredShapeRenderer, type LandCanvasPlugin, type RegisteredShapeRenderer } from "../../canvas-plugin-api/index";
+export declare class CanvasRendererRegistry {
+    private readonly registry;
+    private readonly registeredPluginIds;
+    registerShapeRenderer<S extends ShapeRecordBase>(renderer: RegisteredShapeRenderer<S>): void;
+    getShapeRenderer(type: ShapeRecordBase["type"]): AnyRegisteredShapeRenderer | null;
+    hasShapeRenderer(type: ShapeRecordBase["type"]): boolean;
+    getRegisteredShapeTypes(): ShapeRecordBase["type"][];
+    registerCanvasPlugins(plugins: readonly LandCanvasPlugin[]): void;
+}
+export declare function createCanvasRendererRegistry(plugins?: readonly LandCanvasPlugin[]): CanvasRendererRegistry;

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

@@ -0,0 +1,24 @@
+import type { LandCorePlugin, ToolbarAction, ToolbarContext, ToolbarContribution, ToolbarGroup, ToolbarPlacement, ToolbarSurface } from "../../canvas-core/index";
+export declare class CanvasToolbarRegistry {
+    private readonly actions;
+    private readonly contributions;
+    private readonly hostActionIds;
+    private readonly duplicateActionIds;
+    private readonly duplicateContributionIds;
+    registerAction(action: ToolbarAction, options?: {
+        replace?: boolean;
+    }): void;
+    registerHostAction(action: ToolbarAction): void;
+    registerContribution(contribution: ToolbarContribution, options?: {
+        replace?: boolean;
+    }): void;
+    registerCorePlugins(plugins: readonly LandCorePlugin[]): void;
+    getAction(actionId: string): ToolbarAction | null;
+    getHostActionIds(): string[];
+    getDuplicateActionIds(): string[];
+    getDuplicateContributionIds(): string[];
+    getGroups(surface: ToolbarSurface, context: ToolbarContext, options?: {
+        placement?: ToolbarPlacement;
+    }): ToolbarGroup[];
+}
+export declare function createCanvasToolbarRegistry(plugins?: readonly LandCorePlugin[]): CanvasToolbarRegistry;

package/_vendor/plugin-arrow/ArrowBindingUtil.d.ts

@@ -0,0 +1,27 @@
+import { BindingUtil, type BindingUtilEffect, type Editor, type ShapeRecord } from "../canvas-core/index";
+import { type ArrowBindingRecord } from "./types";
+export declare class ArrowBindingUtil extends BindingUtil<ArrowBindingRecord> {
+    readonly type: "arrow";
+    getDefaultProps(): ArrowBindingRecord["props"];
+    validateProps(props: unknown): ArrowBindingRecord["props"];
+    canBind(_editor: Editor, _binding: ArrowBindingRecord, context: {
+        fromShape: ShapeRecord;
+        toShape: ShapeRecord;
+    }): boolean;
+    getExclusiveBindingKey(binding: ArrowBindingRecord): string;
+    onBindingCreate(editor: Editor, binding: ArrowBindingRecord): BindingUtilEffect | void;
+    onBindingUpdate(editor: Editor, _before: ArrowBindingRecord, after: ArrowBindingRecord): BindingUtilEffect | void;
+    onBindingLoad(editor: Editor, binding: ArrowBindingRecord): BindingUtilEffect | void;
+    getGeometryDependentShapeIds(_editor: Editor, binding: ArrowBindingRecord, context: {
+        role: "from" | "to";
+    }): ShapeRecord["id"][];
+    onAfterShapeChange(editor: Editor, binding: ArrowBindingRecord, _context: {
+        role: "from" | "to";
+    }): BindingUtilEffect | void;
+    onBeforeDeleteShape(editor: Editor, binding: ArrowBindingRecord, context: {
+        role: "from" | "to";
+    }): BindingUtilEffect | void;
+    onBeforeDeleteBinding(editor: Editor, binding: ArrowBindingRecord): BindingUtilEffect | void;
+    private syncArrowTerminal;
+    private resolveTerminalPagePoint;
+}

package/_vendor/plugin-arrow/ArrowShapeUtil.d.ts

@@ -0,0 +1,20 @@
+import { Box, ShapeUtil, Vec, type ShapeBrushWrapInput, type ShapeSelectionHandleAnchorInput, type ShapeSelectionHandleAnchors, type ShapeLineSegmentHitTestInput, type ShapeSelectionOverlayInfo, type ShapeSelectionPagePointsInput, type ShapeSelectionPagePoints, type ShapeUpdate } from "../canvas-core/index";
+import type { ArrowShapeProps, ArrowShapeRecord } from "./types";
+export declare class ArrowShapeUtil extends ShapeUtil<ArrowShapeRecord> {
+    readonly type: "arrow";
+    getDefaultProps(): ArrowShapeProps;
+    validateProps(props: unknown): ArrowShapeProps;
+    getBounds(shape: ArrowShapeRecord): Box;
+    getLocalBounds(shape: ArrowShapeRecord): Box;
+    getExportBounds(shape: ArrowShapeRecord): Box;
+    repairLoadedShape(shape: ArrowShapeRecord): ArrowShapeRecord | null;
+    updateSelectionPagePoints(shape: ArrowShapeRecord, input: ShapeSelectionPagePointsInput): ShapeUpdate;
+    isWrappedByBrush(shape: ArrowShapeRecord, input: ShapeBrushWrapInput): boolean;
+    getSelectionPagePoints(shape: ArrowShapeRecord): ShapeSelectionPagePoints;
+    contributesToSelectionFrame(_shape: ArrowShapeRecord): boolean;
+    canStartTranslateFromSelectionBounds(_shape: ArrowShapeRecord): boolean;
+    getSelectionHandleAnchors(shape: ArrowShapeRecord, input: ShapeSelectionHandleAnchorInput): ShapeSelectionHandleAnchors;
+    getSelectionOverlayInfo(shape: ArrowShapeRecord): ShapeSelectionOverlayInfo;
+    hitTest(shape: ArrowShapeRecord, point: Vec): boolean;
+    hitTestLineSegment(shape: ArrowShapeRecord, input: ShapeLineSegmentHitTestInput): boolean;
+}

package/_vendor/plugin-arrow/ArrowTool.d.ts

@@ -0,0 +1,4 @@
+import { StateNode, type Editor } from "../canvas-core/index";
+export declare class ArrowTool extends StateNode {
+    constructor(editor: Editor);
+}

package/_vendor/plugin-arrow/arrowGeometry.d.ts

@@ -0,0 +1,50 @@
+import { Box, Vec } from "../canvas-core/index";
+import type { ArrowShapeProps, ArrowShapeRecord, ArrowTerminal } from "./types";
+export interface ArrowInfoTerminal {
+    terminal: ArrowTerminal;
+    point: Vec;
+    handle: Vec;
+}
+export interface StraightArrowInfo {
+    type: "straight";
+    start: ArrowInfoTerminal;
+    end: ArrowInfoTerminal;
+    middle: Vec;
+    arc: null;
+    bend: number;
+    points: Vec[];
+    bounds: Box;
+    path: string;
+}
+export interface CurvedArrowInfo {
+    type: "curved";
+    start: ArrowInfoTerminal;
+    end: ArrowInfoTerminal;
+    middle: Vec;
+    arc: ArrowArcInfo;
+    bend: number;
+    points: Vec[];
+    bounds: Box;
+    path: string;
+}
+export type ArrowInfo = StraightArrowInfo | CurvedArrowInfo;
+export interface ArrowArcInfo {
+    center: Vec;
+    radius: number;
+    largeArcFlag: 0 | 1;
+    sweepFlag: 0 | 1;
+    size: number;
+    length: number;
+}
+export declare function getArrowTerminalPagePoint(shape: ArrowShapeRecord, terminal: ArrowTerminal): Vec;
+export declare function getOppositeArrowTerminal(terminal: ArrowTerminal): ArrowTerminal;
+export declare function withArrowPagePoints(shape: ArrowShapeRecord, start: Vec, end: Vec): ArrowShapeRecord;
+export declare function setArrowTerminalPagePoint(shape: ArrowShapeRecord, terminal: ArrowTerminal, pagePoint: Vec): ArrowShapeRecord;
+export declare function normalizeArrowShapePoints(start: Vec, end: Vec): Pick<ArrowShapeProps, "w" | "h" | "start" | "end"> & {
+    x: number;
+    y: number;
+};
+export declare function getArrowInfo(shape: ArrowShapeRecord): ArrowInfo;
+export declare function getArrowLocalInfo(shape: ArrowShapeRecord): ArrowInfo;
+export declare function getArrowBendFromMiddlePagePoint(start: Vec, end: Vec, point: Vec): number;
+export declare function getArrowHitDistance(info: ArrowInfo, point: Vec): number;