@yuzhouu/canvas-kit 0.1.9 → 0.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yuzhouu/canvas-kit",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Land canvas packaged as an all-in-one React canvas kit and typed API surface.",
   "type": "module",
   "main": "./index.mjs",
@@ -23,14 +23,17 @@
     "react-dom": "^19.0.0"
   },
   "dependencies": {
-    "@tiptap/core": "^3.25.0",
-    "@tiptap/extension-bold": "^3.25.0",
-    "@tiptap/extension-bubble-menu": "^3.25.0",
-    "@tiptap/extension-italic": "^3.25.0",
-    "@tiptap/extension-strike": "^3.25.0",
-    "@tiptap/pm": "^3.25.0",
-    "@tiptap/react": "^3.25.0",
-    "@tiptap/starter-kit": "^3.25.0"
+    "@tiptap/core": "3.27.3",
+    "@tiptap/extension-bold": "3.27.3",
+    "@tiptap/extension-italic": "3.27.3",
+    "@tiptap/extension-link": "3.27.3",
+    "@tiptap/extension-strike": "3.27.3",
+    "@tiptap/extension-text-align": "3.27.3",
+    "@tiptap/extension-text-style": "3.27.3",
+    "@tiptap/extension-underline": "3.27.3",
+    "@tiptap/extensions": "3.27.3",
+    "@tiptap/react": "3.27.3",
+    "@tiptap/starter-kit": "3.27.3"
   },
   "publishConfig": {
     "access": "public"

package/plugins/standardCanvasKitPlugins.d.ts

@@ -0,0 +1,16 @@
+import { type TextPluginOptions } from "../_vendor/plugin-text/index";
+import type { CanvasPlugin } from "../runtime/canvasKitPluginContracts";
+export interface CanvasKitStandardPluginOptions {
+    arrow?: boolean;
+    connector?: boolean;
+    draw?: boolean;
+    eraser?: boolean;
+    frame?: boolean;
+    geo?: boolean;
+    group?: boolean;
+    image?: boolean;
+    laser?: boolean;
+    path?: boolean;
+    text?: boolean | Partial<TextPluginOptions>;
+}
+export declare function createStandardCanvasKitPlugins(options?: CanvasKitStandardPluginOptions): readonly CanvasPlugin[];

package/react/CanvasKitRoot.d.ts

@@ -1,5 +1,10 @@
-import type { CanvasKitController, CanvasKitBaseController } from "../controller/canvasKitController";
-import type { CanvasKitProduct } from "../product/canvasKitProduct";
-export declare function CanvasKitRoot<TController extends CanvasKitBaseController = CanvasKitController>({ product, }: {
-    product: CanvasKitProduct<TController>;
-}): import("react/jsx-runtime").JSX.Element | null;
+import type { CanvasKitController } from "../controller/canvasKitController";
+import type { CanvasKitRuntime } from "../runtime/canvasKitRuntimeContracts";
+export interface CanvasKitRootProps {
+    runtime: CanvasKitRuntime;
+    onControllerReady?: (controller: CanvasKitController) => void;
+    onControllerDispose?: () => void;
+    exposeControllerOnWindow?: boolean;
+    windowKey?: string;
+}
+export declare function CanvasKitRoot({ runtime, onControllerReady, onControllerDispose, exposeControllerOnWindow, windowKey, }: CanvasKitRootProps): import("react/jsx-runtime").JSX.Element | null;

package/react/useCanvasKitControllerLifecycle.d.ts

@@ -0,0 +1,8 @@
+import type { CanvasKitController } from "../controller/canvasKitController";
+export declare function useCanvasKitControllerLifecycle({ controller, exposeControllerOnWindow, onControllerDispose, onControllerReady, windowKey, }: {
+    controller: CanvasKitController;
+    exposeControllerOnWindow: boolean;
+    onControllerDispose?: () => void;
+    onControllerReady?: (controller: CanvasKitController) => void;
+    windowKey: string;
+}): void;

package/react/useCanvasKitRuntime.d.ts

@@ -1,4 +1,2 @@
-import type { CanvasKitController, CanvasKitBaseController } from "../controller/canvasKitController";
-import type { CanvasKitProduct } from "../product/canvasKitProduct";
-import { type CanvasKitRuntime } from "../runtime/canvasKitRuntime";
-export declare function useCanvasKitRuntime<TController extends CanvasKitBaseController = CanvasKitController>(product: CanvasKitProduct<TController>): CanvasKitRuntime<TController> | null;
+import type { CanvasKitRuntimeOptions, CanvasKitRuntimeState } from "../runtime/canvasKitRuntimeContracts";
+export declare function useCanvasKitRuntime(options: CanvasKitRuntimeOptions): CanvasKitRuntimeState;

package/runtime/canvasKitCommandExecutor.d.ts

@@ -0,0 +1,13 @@
+import type { CanvasActionContext } from "../_vendor/canvas-plugin-sdk/index";
+import type { Editor } from "../_vendor/canvas-core/index";
+import type { CanvasPluginBeforeCommand } from "./canvasKitPluginContracts";
+export interface CanvasKitCommandInput<TResult> {
+    commandId: string;
+    context?: CanvasActionContext;
+    run(): TResult;
+}
+export type ExecuteCanvasKitCommand = <TResult>(input: CanvasKitCommandInput<TResult>) => TResult;
+export declare function createCanvasKitCommandExecutor({ editor, hooks, }: {
+    editor: Editor;
+    hooks: readonly CanvasPluginBeforeCommand[];
+}): ExecuteCanvasKitCommand;

package/runtime/canvasKitPluginContracts.d.ts

@@ -0,0 +1,34 @@
+import { type CanvasPluginBeforeCommand as SdkCanvasPluginBeforeCommand, type CanvasPluginBeforeCommandContext as SdkCanvasPluginBeforeCommandContext, type CanvasPluginBeforeReady as SdkCanvasPluginBeforeReady, type CanvasPluginBeforeReadyContext as SdkCanvasPluginBeforeReadyContext, type CanvasPluginComponent as SdkCanvasPluginComponent, type CanvasPluginComponentProps as SdkCanvasPluginComponentProps, type CanvasPluginProvider as SdkCanvasPluginProvider, type CanvasPluginLifecycleSetup as SdkCanvasPluginLifecycleSetup, type CanvasPluginPersistence as SdkCanvasPluginPersistence, type CanvasPluginUiSetup as SdkCanvasPluginUiSetup, type CanvasPluginApi as SdkCanvasPluginApi, type CanvasPluginApiContext, type CanvasPlugin as SdkCanvasPlugin, type CanvasPluginDefinition as SdkCanvasPluginDefinition, type CanvasPluginSetup as SdkCanvasPluginSetup, type CanvasPluginSetupContext as SdkCanvasPluginSetupContext } from "../_vendor/canvas-plugin-sdk/index";
+import type { ProductAssetResolverService, ProductServiceRegistry, ProductServiceToken } from "../core";
+import type { SvgAssetInliner } from "../_vendor/plugin-builtin-export/index";
+export type CanvasPluginApi<TApi> = SdkCanvasPluginApi<TApi, CanvasPluginContext>;
+export interface CanvasPluginContext extends CanvasPluginApiContext {
+    productId: string;
+    services: ProductServiceRegistry;
+}
+export interface CanvasKitPluginAssetSetup {
+    addResolver(token: ProductServiceToken<ProductAssetResolverService>): void;
+    addSvgInliners(...inliners: readonly SvgAssetInliner[]): void;
+}
+export type CanvasKitPluginLifecycleSetup = SdkCanvasPluginLifecycleSetup;
+export type CanvasKitPluginUiSetup = SdkCanvasPluginUiSetup;
+export type CanvasKitPluginPersistence = SdkCanvasPluginPersistence;
+export interface CanvasKitPluginSetupContext extends SdkCanvasPluginSetupContext<CanvasPluginContext> {
+    readonly assets: CanvasKitPluginAssetSetup;
+}
+export type CanvasKitPluginSetup = SdkCanvasPluginSetup<CanvasKitPluginSetupContext>;
+export type CanvasPlugin = Omit<SdkCanvasPlugin<CanvasKitPluginSetup>, "editor" | "render" | "setup"> & {
+    readonly editor?: unknown;
+    readonly render?: unknown;
+    readonly setup?: (...args: never[]) => unknown;
+};
+export type CanvasPluginDefinition = SdkCanvasPluginDefinition<CanvasKitPluginSetup>;
+export type CanvasPluginInput = CanvasPlugin | readonly CanvasPluginInput[];
+export declare function defineCanvasPlugin(plugin: CanvasPluginDefinition): CanvasPlugin;
+export type CanvasPluginBeforeReadyContext = SdkCanvasPluginBeforeReadyContext;
+export type CanvasPluginBeforeCommandContext = SdkCanvasPluginBeforeCommandContext;
+export type CanvasPluginBeforeReady = SdkCanvasPluginBeforeReady;
+export type CanvasPluginBeforeCommand = SdkCanvasPluginBeforeCommand;
+export type CanvasPluginComponentProps = SdkCanvasPluginComponentProps;
+export type CanvasPluginProvider = SdkCanvasPluginProvider;
+export type CanvasPluginComponent = SdkCanvasPluginComponent;

package/runtime/canvasKitPluginSetup.d.ts

@@ -0,0 +1,32 @@
+import { createCanvasActionRegistry, type CanvasActionContext, type CanvasChromeRegistry, type CanvasContextMenuRegistry, type CanvasImportRegistry, type CanvasPlugin as SdkCanvasPlugin, type CanvasToolbarRegistry, type ProductApiRegistry } from "../_vendor/canvas-plugin-sdk/index";
+import type { Editor } from "../_vendor/canvas-core/index";
+import type { ProductAssetResolverService, ProductServiceRegistryRuntime, ProductServiceToken } from "../core";
+import type { SvgAssetInliner } from "../_vendor/plugin-builtin-export/index";
+import type { CanvasKitPluginSetup, CanvasKitPluginPersistence, CanvasPluginBeforeCommand, CanvasPluginBeforeReady, CanvasPluginComponent, CanvasPluginProvider } from "./canvasKitPluginContracts";
+export interface CanvasKitPluginSetupResult {
+    readonly actionRegistry: ReturnType<typeof createCanvasActionRegistry>;
+    readonly apis: ProductApiRegistry;
+    readonly assetResolverTokens: readonly ProductServiceToken<ProductAssetResolverService>[];
+    readonly beforeCommandHooks: readonly CanvasPluginBeforeCommand[];
+    readonly beforeReadyHooks: readonly CanvasPluginBeforeReady[];
+    readonly components: readonly CanvasPluginComponent[];
+    readonly chromeRegistry: CanvasChromeRegistry;
+    readonly contextMenuRegistry: CanvasContextMenuRegistry;
+    readonly importRegistry: CanvasImportRegistry;
+    readonly providers: readonly CanvasPluginProvider[];
+    readonly toolbarRegistry: CanvasToolbarRegistry;
+    canShowPropertiesDuringEditing(context: CanvasActionContext): boolean;
+}
+export interface CanvasKitPluginSetupSession {
+    install(plugin: SdkCanvasPlugin<CanvasKitPluginSetup>): void;
+    seal(): CanvasKitPluginSetupResult;
+}
+export declare function createCanvasKitPluginSetupSession({ assetResolverTokens, defer, editor, persistence, productId, services, svgAssetInliners, }: {
+    assetResolverTokens: ProductServiceToken<ProductAssetResolverService>[];
+    defer(dispose: () => void): void;
+    editor: Editor;
+    persistence: CanvasKitPluginPersistence | null;
+    productId: string;
+    services: ProductServiceRegistryRuntime;
+    svgAssetInliners: SvgAssetInliner[];
+}): CanvasKitPluginSetupSession;

package/runtime/canvasKitResourceScope.d.ts

@@ -0,0 +1,5 @@
+export interface CanvasKitResourceScope {
+    defer(dispose: () => void): void;
+    dispose(): void;
+}
+export declare function createCanvasKitResourceScope(): CanvasKitResourceScope;

package/runtime/canvasKitRuntime.d.ts

@@ -1,21 +1,50 @@
 import type { Editor } from "../_vendor/canvas-core/index";
-import { type CanvasRenderPluginHostRuntime } from "../_vendor/canvas-react/host/index";
-import { type ProductApiRegistryRuntime, type ProductAssetResolverService, type ProductPersistenceAdapter, type ProductServiceRegistryRuntime, type ProductServiceToken } from "../core";
-import { type CanvasKitController, type CanvasKitBaseController } from "../controller/canvasKitController";
-import type { ResolvedCanvasKitConfig, ResolvedCanvasKitProduct } from "../product/canvasKitProduct";
-import type { CanvasKitHostExtension } from "./canvasKitHostContracts";
-import { type CanvasKitRuntimePlan } from "./canvasKitRuntimePlan";
-export interface CanvasKitRuntime<TController extends CanvasKitBaseController = CanvasKitController> {
-    apis: ProductApiRegistryRuntime;
-    assetResolverTokens: readonly ProductServiceToken<ProductAssetResolverService>[];
-    config: ResolvedCanvasKitConfig<TController>;
-    editor: Editor;
-    hostExtensions: readonly CanvasKitHostExtension[];
-    persistence: ProductPersistenceAdapter | null;
-    plan: CanvasKitRuntimePlan;
-    pluginHostRuntime: CanvasRenderPluginHostRuntime;
-    productId: string;
-    services: ProductServiceRegistryRuntime;
-    shouldSkipStoredSnapshots?: () => boolean;
+import { type CanvasActionContext, type CanvasActionRegistry, type CanvasChromeRegistry, type CanvasContextMenuRegistry, type CanvasImportRegistry, type CanvasToolbarRegistry } from "../_vendor/canvas-plugin-sdk/index";
+import { type CanvasRenderRuntime } from "../_vendor/canvas-react/host/index";
+import { type ProductAssetResolverService, type ProductPersistenceAdapter, type ProductServiceRegistryRuntime, type ProductServiceToken } from "../core";
+import { type CanvasKitController } from "../controller/canvasKitController";
+import { createCanvasKitCommandExecutor } from "./canvasKitCommandExecutor";
+import type { CanvasPluginBeforeReady, CanvasPluginComponent, CanvasPluginProvider } from "./canvasKitPluginContracts";
+import { PersistenceCoordinator } from "./persistenceCoordinator";
+import { type CanvasKitResourceScope } from "./canvasKitResourceScope";
+import type { CanvasKitChromeRenderer, CanvasKitDocumentSeed, CanvasKitRuntime, CanvasKitRuntimeOptions, CanvasKitStartupResult } from "./canvasKitRuntimeContracts";
+export declare const CANVAS_KIT_STORAGE_NAMESPACE = "land.canvasKit";
+type CanvasKitRuntimeLifecycleState = "created" | "starting" | "ready" | "failed" | "disposing" | "disposed";
+export interface CanvasKitRuntimeInternals {
+    readonly abortController: AbortController;
+    readonly assetResolverTokens: readonly ProductServiceToken<ProductAssetResolverService>[];
+    readonly beforeReadyHooks: readonly CanvasPluginBeforeReady[];
+    readonly cleanDocumentSnapshot: unknown;
+    readonly cleanSessionSnapshot: unknown;
+    readonly controller: CanvasKitController;
+    readonly editor: Editor;
+    mountedOwner: object | null;
+    readonly persistence: ProductPersistenceAdapter | null;
+    readonly persistenceCoordinator: PersistenceCoordinator | null;
+    readonly productId: string;
+    readonly resources: CanvasKitResourceScope;
+    readonly render: {
+        readonly canvasRuntime: CanvasRenderRuntime;
+        readonly actionRegistry: CanvasActionRegistry;
+        readonly chromeRegistry: CanvasChromeRegistry;
+        readonly toolbarRegistry: CanvasToolbarRegistry;
+        readonly contextMenuRegistry: CanvasContextMenuRegistry;
+        readonly importRegistry: CanvasImportRegistry;
+        readonly executeCommand: ReturnType<typeof createCanvasKitCommandExecutor>;
+        readonly providers: readonly CanvasPluginProvider[];
+        readonly components: readonly CanvasPluginComponent[];
+        readonly chrome?: CanvasKitChromeRenderer;
+        canShowPropertiesDuringEditing(context: CanvasActionContext): boolean;
+    };
+    readonly seedDocument?: CanvasKitDocumentSeed;
+    readonly services: ProductServiceRegistryRuntime;
+    readonly shouldSkipStoredSnapshots?: () => boolean;
+    startPromise: Promise<CanvasKitStartupResult> | null;
+    state: CanvasKitRuntimeLifecycleState;
 }
-export declare function createCanvasKitRuntime<TController extends CanvasKitBaseController = CanvasKitController>(product: ResolvedCanvasKitProduct<TController>): CanvasKitRuntime<TController>;
+export declare function createCanvasKitRuntime(options?: CanvasKitRuntimeOptions): CanvasKitRuntime;
+export declare function getCanvasKitRuntimeInternals(runtime: CanvasKitRuntime): CanvasKitRuntimeInternals;
+export declare function claimCanvasKitRuntimeMount(runtime: CanvasKitRuntime, owner: object): CanvasKitRuntimeInternals;
+export declare function releaseCanvasKitRuntimeMount(runtime: CanvasKitRuntime, owner: object): void;
+export declare function assertCanvasKitRuntimeReady(internals: CanvasKitRuntimeInternals): void;
+export {};

package/runtime/canvasKitRuntimeContracts.d.ts

@@ -0,0 +1,34 @@
+import type { ReactNode } from "react";
+import type { ProductPersistenceAdapter } from "../core";
+import type { CanvasKitChromeContext } from "../chrome/types";
+import type { CanvasKitController } from "../controller/canvasKitController";
+import type { CanvasPluginInput } from "./canvasKitPluginContracts";
+import type { CanvasPluginStartupResult } from "../_vendor/canvas-plugin-sdk/index";
+export type CanvasKitChromeRenderer = (context: CanvasKitChromeContext<CanvasKitController>) => ReactNode;
+export type CanvasKitDocumentSeed = (controller: CanvasKitController) => void;
+export interface CanvasKitRuntimeOptions {
+    id?: string;
+    chrome?: CanvasKitChromeRenderer;
+    documentMeta?: Record<string, unknown>;
+    persistence?: ProductPersistenceAdapter | null;
+    seedDocument?: CanvasKitDocumentSeed;
+    shouldSkipStoredSnapshots?: () => boolean;
+    plugins?: readonly CanvasPluginInput[];
+    storageNamespace?: string;
+}
+export type CanvasKitStartupResult = CanvasPluginStartupResult;
+export interface CanvasKitRuntime {
+    readonly controller: CanvasKitController;
+    start(): Promise<CanvasKitStartupResult>;
+    dispose(): void;
+}
+export type CanvasKitRuntimeState = {
+    status: "starting";
+} | {
+    status: "ready";
+    runtime: CanvasKitRuntime;
+    startup: CanvasKitStartupResult;
+} | {
+    status: "error";
+    error: unknown;
+};

package/runtime/persistenceCoordinator.d.ts

@@ -0,0 +1,33 @@
+import type { Editor } from "../_vendor/canvas-core/index";
+import type { ProductPersistenceAdapter } from "../core/runtime/runtimeContracts";
+export declare class PersistenceCoordinator {
+    private readonly editor;
+    private readonly adapter;
+    private unsubscribeDocument;
+    private unsubscribeSession;
+    private documentTimer;
+    private sessionTimer;
+    private pendingDocument;
+    private pendingSession;
+    private documentVersion;
+    private sessionVersion;
+    private documentRetryCount;
+    private sessionRetryCount;
+    private writeChain;
+    private isRunning;
+    constructor(editor: Editor, adapter: ProductPersistenceAdapter);
+    start(): void;
+    stop(): void;
+    flush(): Promise<void>;
+    private savePendingDocument;
+    private savePendingSession;
+    private queueWrite;
+    private scheduleDocumentSave;
+    private scheduleSessionSave;
+    private scheduleDocumentRetry;
+    private scheduleSessionRetry;
+    private cancelDocumentTimer;
+    private cancelSessionTimer;
+    private readonly flushWhenHidden;
+    private readonly flushWhenPageIsLeaving;
+}

package/_vendor/canvas-core/editor/createEditorWithRuntimePlugins.d.ts

@@ -1,6 +0,0 @@
-import { type LandEditorRuntimePlugin } from "../plugins";
-import { Editor, type EditorOptions } from "./editor";
-export interface CreateEditorWithRuntimePluginsOptions extends Omit<EditorOptions, "shapeUtils" | "shapeSvgExporters" | "bindingUtils" | "shapeCapabilities"> {
-    editorRuntimePlugins?: readonly LandEditorRuntimePlugin[];
-}
-export declare function createEditorWithRuntimePlugins(options?: CreateEditorWithRuntimePluginsOptions): Editor;

package/_vendor/canvas-core/editor/middleMousePanInteraction.d.ts

@@ -1,2 +0,0 @@
-import type { LandInteractionHandler } from "./interactions";
-export declare function createMiddleMousePanInteractionHandler(): LandInteractionHandler;

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

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

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

@@ -1,15 +0,0 @@
-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-react/host/actionRegistry.d.ts

@@ -1,15 +0,0 @@
-import type { CanvasAction, LandEditorRuntimePlugin } from "../../canvas-core/index";
-export declare class CanvasActionRegistry {
-    private readonly actions;
-    private readonly hostActionIds;
-    private readonly duplicateActionIds;
-    registerAction(action: CanvasAction, options?: {
-        replace?: boolean;
-    }): void;
-    registerHostAction(action: CanvasAction): void;
-    registerEditorRuntimePlugins(plugins: readonly LandEditorRuntimePlugin[]): void;
-    getAction(actionId: string): CanvasAction | null;
-    getHostActionIds(): string[];
-    getDuplicateActionIds(): string[];
-}
-export declare function createCanvasActionRegistry(plugins?: readonly LandEditorRuntimePlugin[]): CanvasActionRegistry;

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

@@ -1,2 +0,0 @@
-export { createCanvasRenderPluginHostRuntime } from "./canvasRenderPluginHostRuntime";
-export type { CanvasRenderPluginHostManifestContextMenuContributionEntry, CanvasRenderPluginHostManifestEntry, CanvasRenderPluginHostManifestToolbarContributionEntry, CanvasRenderPluginHostRuntime, CanvasRenderPluginHostShapeValidationSummary, CanvasRenderPluginHostSource, CanvasRenderPluginHostValidationIssue, CanvasRenderPluginHostValidationIssueSeverity, CanvasRenderPluginHostValidationSummary, CanvasRenderPluginHostVerdict, CreateCanvasRenderPluginHostRuntimeOptions, } from "./canvasRenderPluginHostTypes";

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

@@ -1,2 +0,0 @@
-import type { CanvasRenderPluginHostManifestEntry, ResolvedCanvasFeature } from "./canvasRenderPluginHostTypes";
-export declare function getManifestEntryFromFeature(resolvedFeature: ResolvedCanvasFeature): CanvasRenderPluginHostManifestEntry;

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

@@ -1,3 +0,0 @@
-import { type LandExtension } from "./extension";
-import type { CanvasRenderPluginHostRuntime, CreateCanvasRenderPluginHostRuntimeOptions } from "./canvasRenderPluginHostTypes";
-export declare function createCanvasRenderPluginHostRuntime(extensions: readonly LandExtension[], options?: CreateCanvasRenderPluginHostRuntimeOptions): CanvasRenderPluginHostRuntime;

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

@@ -1,104 +0,0 @@
-import type { LandEditorRuntimePlugin, ShapeCapabilitySupport } from "../../canvas-core/index";
-import type { CanvasRenderPluginComponent, CanvasRenderPluginProvider, LandCanvasRenderPlugin } from "./canvasRenderPlugin";
-import type { CanvasActionRegistry } from "./actionRegistry";
-import type { CanvasContextMenuRegistry } from "./contextMenuRegistry";
-import type { CanvasDomEventGuardRegistry } from "./domEventGuards";
-import type { LandFeatureBundle } from "./extension";
-import type { CanvasOverlayRegistry } from "./overlayRegistry";
-import type { CanvasRendererRegistry } from "./rendererRegistry";
-import type { CanvasToolbarRegistry } from "./toolbarRegistry";
-export type CanvasRenderPluginHostSource = "built-in" | "dev-sample";
-export type CanvasRenderPluginHostVerdict = "pass" | "fail";
-export interface CreateCanvasRenderPluginHostRuntimeOptions {
-    knownHostActionIds?: readonly string[];
-    source?: CanvasRenderPluginHostSource;
-}
-export interface CanvasRenderPluginHostManifestEntry {
-    id: string;
-    extensionName: string;
-    source: CanvasRenderPluginHostSource;
-    editorRuntimePluginIds: string[];
-    canvasRenderPluginIds: string[];
-    interactionHandlerIds: string[];
-    canvasActionIds: string[];
-    toolbarContributionIds: string[];
-    toolbarContributions: CanvasRenderPluginHostManifestToolbarContributionEntry[];
-    contextMenuContributionIds: string[];
-    contextMenuContributions: CanvasRenderPluginHostManifestContextMenuContributionEntry[];
-    domEventGuardIds: string[];
-    canvasOverlayIds: string[];
-    selectionCustomHandleRendererTypes: string[];
-    canvasProviderIds: string[];
-    canvasComponentIds: string[];
-    shapeTypes: string[];
-}
-export interface CanvasRenderPluginHostManifestToolbarContributionEntry {
-    id: string;
-    surface: string;
-    placement: string;
-    actionIds: string[];
-}
-export interface CanvasRenderPluginHostManifestContextMenuContributionEntry {
-    id: string;
-    target: string;
-    actionIds: string[];
-}
-export interface CanvasRenderPluginHostRuntime {
-    editorRuntimePlugins: LandEditorRuntimePlugin[];
-    canvasRenderPlugins: LandCanvasRenderPlugin[];
-    canvasProviders: CanvasRenderPluginProvider[];
-    canvasComponents: CanvasRenderPluginComponent[];
-    actionRegistry: CanvasActionRegistry;
-    rendererRegistry: CanvasRendererRegistry;
-    overlayRegistry: CanvasOverlayRegistry;
-    domEventGuardRegistry: CanvasDomEventGuardRegistry;
-    toolbarRegistry: CanvasToolbarRegistry;
-    contextMenuRegistry: CanvasContextMenuRegistry;
-    manifest: CanvasRenderPluginHostManifestEntry[];
-    validation: CanvasRenderPluginHostValidationSummary;
-    externalPluginIds: string[];
-}
-export type CanvasRenderPluginHostValidationIssueSeverity = "error" | "warning";
-export interface CanvasRenderPluginHostValidationIssue {
-    severity: CanvasRenderPluginHostValidationIssueSeverity;
-    code: "duplicate-feature-id" | "duplicate-editor-runtime-plugin-id" | "duplicate-canvas-render-plugin-id" | "duplicate-interaction-handler-id" | "duplicate-canvas-action-id" | "duplicate-toolbar-contribution-id" | "duplicate-context-menu-contribution-id" | "duplicate-dom-event-guard-id" | "duplicate-canvas-overlay-id" | "duplicate-selection-custom-handle-renderer" | "duplicate-canvas-provider-id" | "duplicate-canvas-component-id" | "missing-canvas-action" | "missing-context-menu-action" | "missing-editor-runtime-plugin" | "missing-canvas-render-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 CanvasRenderPluginHostShapeValidationSummary {
-    featureId: string;
-    shapeType: string;
-    hasCapability: boolean;
-    hasShapeUtil: boolean;
-    hasSvgExporter: boolean;
-    hasCanvasRenderer: boolean;
-    exportSupport: ShapeCapabilitySupport | null;
-}
-export interface CanvasRenderPluginHostValidationSummary {
-    verdict: CanvasRenderPluginHostVerdict;
-    issueCount: number;
-    errorCount: number;
-    warningCount: number;
-    issues: CanvasRenderPluginHostValidationIssue[];
-    featureIds: string[];
-    editorRuntimePluginIds: string[];
-    canvasRenderPluginIds: string[];
-    interactionHandlerIds: string[];
-    canvasActionIds: string[];
-    toolbarContributionIds: string[];
-    contextMenuContributionIds: string[];
-    domEventGuardIds: string[];
-    canvasOverlayIds: string[];
-    selectionCustomHandleRendererTypes: string[];
-    canvasProviderIds: string[];
-    canvasComponentIds: string[];
-    registeredRendererTypes: string[];
-    shapeSummaries: CanvasRenderPluginHostShapeValidationSummary[];
-}
-export interface ResolvedCanvasFeature {
-    extensionName: string;
-    feature: LandFeatureBundle;
-    source: CanvasRenderPluginHostSource;
-}

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

@@ -1,11 +0,0 @@
-import type { LandEditorRuntimePlugin } from "../../canvas-core/index";
-import type { LandCanvasRenderPlugin } from "./canvasRenderPlugin";
-import type { CanvasRendererRegistry } from "./rendererRegistry";
-import type { CanvasRenderPluginHostValidationSummary, ResolvedCanvasFeature } from "./canvasRenderPluginHostTypes";
-export declare function validateCanvasRenderPluginHost({ editorRuntimePlugins, canvasRenderPlugins, knownHostActionIds, rendererRegistry, resolvedFeatures, }: {
-    editorRuntimePlugins: readonly LandEditorRuntimePlugin[];
-    canvasRenderPlugins: readonly LandCanvasRenderPlugin[];
-    knownHostActionIds: readonly string[];
-    rendererRegistry: CanvasRendererRegistry;
-    resolvedFeatures: readonly ResolvedCanvasFeature[];
-}): CanvasRenderPluginHostValidationSummary;

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

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

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

@@ -1,37 +0,0 @@
-import type { LandEditorRuntimePlugin, ShapeRecordBase } from "../../canvas-core/index";
-import type { LandCanvasRenderPlugin } from "./canvasRenderPlugin";
-type LandExtensionOptions = Record<string, unknown>;
-export interface LandFeatureBundle {
-    id: string;
-    editorRuntimePlugins: readonly LandEditorRuntimePlugin[];
-    canvasRenderPlugins: readonly LandCanvasRenderPlugin[];
-    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-react/host/toolbarRegistry.d.ts

@@ -1,20 +0,0 @@
-import type { LandEditorRuntimePlugin, CanvasActionContext, ToolbarContribution, ToolbarGroup, ToolbarPlacement, ToolbarSurface } from "../../canvas-core/index";
-export declare class CanvasToolbarRegistry {
-    private readonly contributions;
-    private readonly contributionsBySurface;
-    private readonly contributionsBySurfaceAndPlacement;
-    private readonly contributionIndexes;
-    private readonly duplicateContributionIds;
-    private nextContributionIndex;
-    registerContribution(contribution: ToolbarContribution, options?: {
-        replace?: boolean;
-    }): void;
-    registerEditorRuntimePlugins(plugins: readonly LandEditorRuntimePlugin[]): void;
-    getDuplicateContributionIds(): string[];
-    getGroups(surface: ToolbarSurface, context: CanvasActionContext, options?: {
-        placement?: ToolbarPlacement;
-    }): ToolbarGroup[];
-    private addToIndexes;
-    private removeFromIndexes;
-}
-export declare function createCanvasToolbarRegistry(plugins?: readonly LandEditorRuntimePlugin[]): CanvasToolbarRegistry;