@yuzhouu/canvas-kit 0.1.9 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yuzhouu/canvas-kit",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "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/product/standardCanvasKitPlugins.d.ts

@@ -0,0 +1,4 @@
+import type { CanvasPluginInput } from "../runtime/canvasKitPluginContracts";
+import { type BuiltInCanvasPluginOptions } from "../builtins";
+export type CanvasKitStandardPluginOptions = BuiltInCanvasPluginOptions;
+export declare function createStandardCanvasKitPlugins(options?: CanvasKitStandardPluginOptions): readonly CanvasPluginInput[];

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,79 @@
+import { type CanvasAction, type CanvasActionContext, type CanvasActionRegistry, type CanvasProductContribution as BaseCanvasProductContribution, type CanvasPlugin as SdkCanvasPlugin, type CanvasPluginInput as SdkCanvasPluginInput } from "../_vendor/canvas-plugin-sdk/index";
+import type { Editor } from "../_vendor/canvas-core/index";
+import type { ComponentType, ReactNode } from "react";
+import type { ProductApiRegistry, ProductApiToken, ProductAssetResolverService, ProductPersistenceAdapter, ProductServiceFactory, ProductServiceRegistry, ProductServiceToken } from "../core";
+import type { SvgAssetInliner } from "../features/export/svgExport";
+import type { ExecuteCanvasKitCommand } from "./canvasKitCommandExecutor";
+import type { CanvasKitStartupResult } from "./canvasKitRuntimeContracts";
+export interface CanvasProductFactoryContext {
+    persistence: ProductPersistenceAdapter | null;
+    productId: string;
+}
+export interface CanvasProductContribution extends BaseCanvasProductContribution {
+    services?: readonly ProductServiceFactory<unknown>[];
+    createActions?: (context: CanvasActionFactoryContext) => readonly CanvasAction[];
+    apis?: readonly CanvasPluginApi<unknown>[];
+    setup?(context: CanvasPluginContext): void | (() => void);
+    beforeReady?: CanvasPluginBeforeReady;
+    beforeCommand?: CanvasPluginBeforeCommand;
+    providers?: readonly CanvasPluginProvider[];
+    components?: readonly CanvasPluginComponent[];
+    assetResolverTokens?: readonly ProductServiceToken<ProductAssetResolverService>[];
+    svgAssetInliners?: (context: CanvasPluginSvgAssetInlinerContext) => readonly SvgAssetInliner[];
+    canShowToolbarDuringEditing?: (context: CanvasActionContext) => boolean;
+}
+export type CanvasProductFactory = (context: CanvasProductFactoryContext) => CanvasProductContribution;
+export type CanvasPlugin = SdkCanvasPlugin<CanvasProductFactory>;
+export type CanvasPluginInput = SdkCanvasPluginInput<CanvasProductFactory>;
+export declare function defineCanvasPlugin(plugin: CanvasPlugin): CanvasPlugin;
+export interface CanvasActionFactoryContext {
+    productId: string;
+    services: ProductServiceRegistry;
+}
+export interface CanvasPluginApi<TApi> {
+    token: ProductApiToken<TApi>;
+    create(context: CanvasPluginContext): TApi | null;
+}
+export interface CanvasPluginContext {
+    apis: ProductApiRegistry;
+    editor: Editor;
+    productId: string;
+    services: ProductServiceRegistry;
+}
+export interface CanvasPluginSvgAssetInlinerContext {
+    editor: Editor;
+    services: ProductServiceRegistry;
+}
+export interface CanvasPluginBeforeReadyContext {
+    editor: Editor;
+    persistence: ProductPersistenceAdapter | null;
+    productId: string;
+    signal: AbortSignal;
+    startup: CanvasKitStartupResult;
+    services: ProductServiceRegistry;
+}
+export interface CanvasPluginBeforeCommandContext {
+    commandId: string;
+    context?: CanvasActionContext;
+    editor: Editor;
+}
+export type CanvasPluginBeforeReady = (context: CanvasPluginBeforeReadyContext) => Promise<void> | void;
+export type CanvasPluginBeforeCommand = (context: CanvasPluginBeforeCommandContext) => void;
+export interface CanvasPluginComponentProps {
+    actionRegistry: CanvasActionRegistry;
+    editor: Editor;
+    executeCommand: ExecuteCanvasKitCommand;
+    services: ProductServiceRegistry;
+}
+export interface CanvasPluginProvider {
+    id: string;
+    order?: number;
+    component: ComponentType<{
+        children: ReactNode;
+    }>;
+}
+export interface CanvasPluginComponent {
+    id: string;
+    order?: number;
+    component: ComponentType<CanvasPluginComponentProps>;
+}

package/runtime/canvasKitPlugins.d.ts

@@ -0,0 +1,33 @@
+import { type CanvasAction, type ContextMenuContribution, type ToolbarContribution } from "../_vendor/canvas-plugin-sdk/index";
+import type { ProductServiceRegistry } from "../core";
+import type { CanvasPluginInput } from "./canvasKitPluginContracts";
+import type { CanvasKitRuntimeOptions } from "./canvasKitRuntimeContracts";
+export declare function collectCanvasKitContributions({ persistence, plugins, productId, }: {
+    persistence: CanvasKitRuntimeOptions["persistence"];
+    plugins: readonly CanvasPluginInput[];
+    productId: string;
+}): {
+    editorPlugins: readonly import("../_vendor/canvas-core/index").EditorPlugin[];
+    renderPlugins: readonly import("../_vendor/canvas-react/host/index").CanvasRenderPlugin[];
+    services: import("..").ProductServiceFactory<unknown>[];
+    actions: CanvasAction<import("../_vendor/canvas-plugin-sdk/index").CanvasActionValue>[];
+    createActions: ((context: import("./canvasKitPluginContracts").CanvasActionFactoryContext) => readonly CanvasAction[])[];
+    actionShortcuts: import("../_vendor/canvas-plugin-sdk/index").CanvasActionShortcut[];
+    toolbarContributions: ToolbarContribution[];
+    contextMenuContributions: ContextMenuContribution[];
+    apis: import("./canvasKitPluginContracts").CanvasPluginApi<unknown>[];
+    setup: ((context: import("./canvasKitPluginContracts").CanvasPluginContext) => void | (() => void))[];
+    beforeReady: import("./canvasKitPluginContracts").CanvasPluginBeforeReady[];
+    beforeCommand: import("./canvasKitPluginContracts").CanvasPluginBeforeCommand[];
+    providers: import("./canvasKitPluginContracts").CanvasPluginProvider[];
+    components: import("./canvasKitPluginContracts").CanvasPluginComponent[];
+    assetResolverTokens: import("..").ProductServiceToken<import("../core").ProductAssetResolverService>[];
+    svgAssetInliners: ((context: import("./canvasKitPluginContracts").CanvasPluginSvgAssetInlinerContext) => readonly import("../features/export/svgExport").SvgAssetInliner[])[];
+    canShowToolbarDuringEditing: ((context: import("../_vendor/canvas-plugin-sdk/index").CanvasActionContext) => boolean)[];
+};
+export type CanvasKitContributions = ReturnType<typeof collectCanvasKitContributions>;
+export declare function createCanvasKitActions({ contributions, productId, services, }: {
+    contributions: CanvasKitContributions;
+    productId: string;
+    services: ProductServiceRegistry;
+}): readonly CanvasAction[];

package/runtime/canvasKitRuntime.d.ts

@@ -1,21 +1,48 @@
 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 CanvasContextMenuRegistry, 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 { SvgAssetInliner } from "../features/export/svgExport";
+import { type CanvasKitController } from "../controller/canvasKitController";
+import { createCanvasKitCommandExecutor } from "./canvasKitCommandExecutor";
+import type { CanvasPluginBeforeReady, CanvasPluginComponent, CanvasPluginProvider } from "./canvasKitPluginContracts";
+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;
+    readonly setupDisposers: Array<() => void>;
+    readonly persistence: ProductPersistenceAdapter | null;
+    readonly productId: string;
+    readonly render: {
+        readonly canvasRuntime: CanvasRenderRuntime;
+        readonly actionRegistry: CanvasActionRegistry;
+        readonly toolbarRegistry: CanvasToolbarRegistry;
+        readonly contextMenuRegistry: CanvasContextMenuRegistry;
+        readonly executeCommand: ReturnType<typeof createCanvasKitCommandExecutor>;
+        readonly providers: readonly CanvasPluginProvider[];
+        readonly components: readonly CanvasPluginComponent[];
+        readonly chrome?: CanvasKitChromeRenderer;
+        readonly svgAssetInliners: readonly SvgAssetInliner[];
+        canShowToolbarDuringEditing(context: CanvasActionContext): boolean;
+    };
+    readonly seedDocument?: CanvasKitDocumentSeed;
+    readonly services: ProductServiceRegistryRuntime;
+    readonly shouldSkipStoredSnapshots?: () => boolean;
+    mountedOwner: object | null;
+    persistenceStop: (() => void) | null;
+    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,37 @@
+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";
+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 interface CanvasKitStartupResult {
+    documentSource: "restored" | "seeded" | "empty";
+    sessionRestored: boolean;
+    warnings: readonly unknown[];
+}
+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/_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-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;

package/_vendor/plugin-text/host/RichTextLinkPopover.d.ts

@@ -1,14 +0,0 @@
-export interface RichTextLinkHoverState {
-    href: string;
-    path: readonly number[];
-    rect: DOMRect;
-}
-export declare function RichTextLinkPopover({ link, onApply, onKeepVisible, onClear, }: {
-    link: RichTextLinkHoverState | null;
-    onApply(input: {
-        path: readonly number[];
-        href: string | null;
-    }): void;
-    onKeepVisible(): void;
-    onClear(): void;
-}): import("react").ReactPortal | null;

package/_vendor/plugin-text/host/RichTextToolbar.d.ts

@@ -1,8 +0,0 @@
-import type { Editor as LandEditor } from "../../canvas-core/index";
-import type { Editor as TiptapEditor } from "@tiptap/react";
-export declare function isRichTextToolbarTarget(target: EventTarget | null): boolean;
-export declare function RichTextToolbar({ editor, landEditor, version: _version, }: {
-    editor: TiptapEditor;
-    landEditor: LandEditor;
-    version: number;
-}): import("react/jsx-runtime").JSX.Element | null;

package/_vendor/plugin-text/host/richTextBubbleMenuPositionSync.d.ts

@@ -1,7 +0,0 @@
-import { type Editor as LandEditor } from "../../canvas-core/index";
-import type { Editor as TiptapEditor } from "@tiptap/react";
-export declare const RICH_TEXT_BUBBLE_MENU_PLUGIN_KEY = "land.rich-text-bubble-menu";
-export declare function useRichTextBubbleMenuPositionSync({ landEditor, textEditor, }: {
-    landEditor: LandEditor;
-    textEditor: TiptapEditor;
-}): void;