@yuzhouu/canvas-kit 0.1.7 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yuzhouu/canvas-kit",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Land canvas packaged as an all-in-one React canvas kit and typed API surface.",
   "type": "module",
   "main": "./index.mjs",

package/product/canvasKitProduct.d.ts

@@ -1,10 +1,10 @@
-import type { CanvasPluginHostRuntime, LandExtension } from "../_vendor/canvas-react/host/index";
+import type { LandExtension } from "../_vendor/canvas-react/host/index";
 import type { ReactNode } from "react";
-import type { CanvasProductRuntimeInitializer, ProductAssetResolverService, ProductPersistenceAdapter, ProductServiceFactory, ProductServiceToken } from "../core";
+import type { ProductPersistenceAdapter } from "../core";
 import type { CanvasKitBaseController, CanvasKitController } from "../controller/canvasKitController";
 import { type BuiltInCanvasExtensionOptions } from "../builtins";
 import type { CanvasKitChromeContext } from "../chrome/types";
-import { type CanvasKitHostExtension } from "../runtime/canvasKitHostExtensions";
+import type { CanvasKitHostExtension } from "../runtime/canvasKitHostContracts";
 export declare const CANVAS_KIT_STORAGE_NAMESPACE = "land.canvasKit";
 declare const CANVAS_KIT_PRODUCT_BRAND: unique symbol;
 export type CanvasKitChromeRenderer<TController extends CanvasKitBaseController = CanvasKitController> = (context: CanvasKitChromeContext<TController>) => ReactNode;
@@ -13,6 +13,7 @@ export type CanvasKitExtensionOptions = BuiltInCanvasExtensionOptions;
 export interface CanvasKitProductOptions<TController extends CanvasKitBaseController = CanvasKitController> {
     id?: string;
     chrome?: CanvasKitChromeRenderer<TController>;
+    documentMeta?: Record<string, unknown>;
     exposeControllerOnWindow?: boolean;
     onControllerDispose?: () => void;
     onControllerReady?: (controller: TController) => void;
@@ -20,6 +21,7 @@ export interface CanvasKitProductOptions<TController extends CanvasKitBaseContro
     seedDocument?: CanvasKitDocumentSeed<TController>;
     shouldSkipStoredSnapshots?: () => boolean;
     builtInExtensions?: CanvasKitExtensionOptions;
+    hostExtensions?: readonly CanvasKitHostExtension[];
     storageNamespace?: string;
     warnOnPluginRegistrationConflicts?: boolean;
     windowKey?: string;
@@ -35,16 +37,15 @@ export interface CanvasKitProduct<TController extends CanvasKitBaseController =
     readonly [CANVAS_KIT_PRODUCT_BRAND]: TController;
 }
 export interface ResolvedCanvasKitProduct<TController extends CanvasKitBaseController = CanvasKitController> extends CanvasKitProduct<TController> {
-    readonly assetResolverTokens: readonly ProductServiceToken<ProductAssetResolverService>[];
     readonly canvasExtensions: readonly LandExtension[];
+    readonly documentMeta?: Record<string, unknown>;
     readonly id: string;
     readonly config: ResolvedCanvasKitConfig<TController>;
     readonly hostExtensions: readonly CanvasKitHostExtension[];
-    readonly initializeRuntime: CanvasProductRuntimeInitializer<CanvasPluginHostRuntime>;
     readonly persistence: ProductPersistenceAdapter | null;
-    readonly serviceFactories: readonly ProductServiceFactory<unknown>[];
+    readonly seedDocument?: CanvasKitDocumentSeed<TController>;
     readonly shouldSkipStoredSnapshots?: () => boolean;
+    readonly warnOnPluginRegistrationConflicts: boolean;
 }
 export declare function defineCanvasKit<TController extends CanvasKitBaseController = CanvasKitController>(options?: CanvasKitProductOptions<TController>): CanvasKitProduct<TController>;
-export declare function asResolvedCanvasKitProduct<TController extends CanvasKitBaseController = CanvasKitController>(product: CanvasKitProduct<TController>): ResolvedCanvasKitProduct<TController>;
 export {};

package/react/useCanvasKitController.d.ts

@@ -1,5 +1,5 @@
 import { type CanvasKitController, type CanvasKitControllerRuntimeContext, type CanvasKitBaseController } from "../controller/canvasKitController";
 import type { ResolvedCanvasKitConfig } from "../product/canvasKitProduct";
-export declare function useCanvasKitController<TController extends CanvasKitBaseController = CanvasKitController>({ featureControllers, config, editor, pluginHostRuntime, productId, services, }: CanvasKitControllerRuntimeContext & {
+export declare function useCanvasKitController<TController extends CanvasKitBaseController = CanvasKitController>({ apis, config, controllerSlots, editor, pluginHostRuntime, productId, services, }: CanvasKitControllerRuntimeContext & {
     config: ResolvedCanvasKitConfig<TController>;
 }): TController;

package/react/useCanvasKitRuntime.d.ts

@@ -1,4 +1,4 @@
 import type { CanvasKitController, CanvasKitBaseController } from "../controller/canvasKitController";
-import { type CanvasKitProduct } from "../product/canvasKitProduct";
+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;

package/runtime/canvasKitHostContracts.d.ts

@@ -0,0 +1,135 @@
+import type { CanvasAction, CanvasActionContext, ContextMenuContribution, Editor, KeyboardShortcutInput, ToolbarContribution } from "../_vendor/canvas-core/index";
+import type { CanvasRenderPluginHostRuntime } from "../_vendor/canvas-react/host/index";
+import type { ComponentType, ReactNode, RefObject } from "react";
+import type { ProductApiRegistryRuntime, ProductApiToken, ProductAssetResolverService, CanvasProductRuntimeInitializer, ProductPersistenceAdapter, ProductServiceFactory, ProductServiceRegistry, ProductServiceToken } from "../core";
+import type { SvgAssetInliner } from "../features/export/svgExport";
+import type { CanvasKitChromeContext, CanvasKitGridControls, CanvasKitPersistenceControls } from "../chrome/types";
+import type { CanvasKitBaseController } from "../controller/canvasKitController";
+export interface CanvasKitHostExtensionContext {
+    canvasExtensionNames: ReadonlySet<string>;
+    persistence: ProductPersistenceAdapter | null;
+    productId: string;
+}
+export interface CanvasKitHostExtension<TControllerSlots extends object = {}, TChromeSlots extends object = {}> {
+    id: string;
+    priority?: number;
+    configure?(options: unknown): CanvasKitHostExtension<TControllerSlots, TChromeSlots>;
+    getExtensions?(): readonly CanvasKitHostExtension[];
+    createFeature(context: CanvasKitHostExtensionContext): CanvasKitHostFeature | null;
+    readonly __controllerSlots?: TControllerSlots;
+    readonly __chromeSlots?: TChromeSlots;
+}
+export interface CanvasKitHostFeature {
+    id: string;
+    priority?: number;
+    requiresCanvasExtensions?: readonly string[];
+    services?: readonly ProductServiceFactory<unknown>[];
+    assetResolverTokens?: readonly ProductServiceToken<ProductAssetResolverService>[];
+    svgAssetInliners?: (context: CanvasKitSvgAssetInlinerContext) => readonly SvgAssetInliner[];
+    actions?: readonly CanvasAction[];
+    createActions?: (context: CanvasKitHostActionContext) => readonly CanvasAction[];
+    actionShortcuts?: readonly CanvasKitActionShortcut[];
+    toolbarContributions?: readonly ToolbarContribution[];
+    contextMenuContributions?: readonly ContextMenuContribution[];
+    canShowToolbarDuringEditing?: (context: CanvasActionContext) => boolean;
+    apis?: readonly CanvasKitHostApiContribution<unknown>[];
+    controllerSlots?: readonly CanvasKitControllerSlot<string, unknown>[];
+    chromeSlots?: readonly CanvasKitChromeSlot<string, unknown>[];
+    providers?: readonly CanvasKitHostProvider[];
+    components?: readonly CanvasKitHostComponent[];
+    onRuntimeInitialize?: CanvasProductRuntimeInitializer<CanvasRenderPluginHostRuntime>;
+    onBeforeStartup?: CanvasKitStartupHook;
+    onAfterRestore?: CanvasKitStartupHook;
+    onBeforeReady?: CanvasKitStartupHook;
+    onRuntimeDispose?: CanvasKitRuntimeDisposeHook;
+    onBeforeCommand?: CanvasKitCommandHook;
+    onAfterCommand?: CanvasKitCommandHook;
+}
+export interface CanvasKitHostActionContext {
+    productId: string;
+    services: ProductServiceRegistry;
+}
+export interface CanvasKitHostApiContribution<TApi> {
+    id: string;
+    token: ProductApiToken<TApi>;
+    create(context: CanvasKitHostApiContext): TApi | null;
+}
+export interface CanvasKitHostApiContext {
+    apis: ProductApiRegistryRuntime;
+    editor: Editor;
+    pluginHostRuntime: CanvasRenderPluginHostRuntime;
+    productId: string;
+    services: ProductServiceRegistry;
+}
+export interface CanvasKitControllerSlot<TKey extends string, TApi> {
+    key: TKey;
+    token: ProductApiToken<TApi>;
+}
+export interface CanvasKitChromeSlot<TKey extends string, TApi> {
+    key: TKey;
+    token: ProductApiToken<TApi>;
+}
+export interface CanvasKitActionShortcut {
+    actionId: string;
+    shortcut: KeyboardShortcutInput;
+}
+export interface CanvasKitSvgAssetInlinerContext {
+    editor: Editor;
+    services: ProductServiceRegistry;
+}
+export interface CanvasKitStartupHookContext {
+    editor: Editor;
+    persistence: ProductPersistenceAdapter | null;
+    productId: string;
+    services: ProductServiceRegistry;
+}
+export interface CanvasKitRuntimeDisposeHookContext {
+    editor: Editor;
+    productId: string;
+    services: ProductServiceRegistry;
+}
+export interface CanvasKitCommandHookContext {
+    commandId: string;
+    context?: CanvasActionContext;
+    editor: Editor;
+}
+export type CanvasKitStartupHook = (context: CanvasKitStartupHookContext) => Promise<void> | void;
+export type CanvasKitRuntimeDisposeHook = (context: CanvasKitRuntimeDisposeHookContext) => void;
+export type CanvasKitCommandHook = (context: CanvasKitCommandHookContext) => void;
+export interface CanvasKitControllerHostProps {
+    editor: Editor;
+    pluginHostRuntime: CanvasRenderPluginHostRuntime;
+    services: ProductServiceRegistry;
+}
+export interface CanvasKitWorkspaceHostProps extends CanvasKitControllerHostProps {
+    grid: CanvasKitGridControls;
+    isReady: boolean;
+    persistence: CanvasKitPersistenceControls;
+}
+export interface CanvasKitChromeHostProps extends CanvasKitControllerHostProps {
+    chrome: CanvasKitChromeContext<CanvasKitBaseController>;
+    themeRootRef: RefObject<HTMLElement | null>;
+}
+export interface CanvasKitHostProvider {
+    id: string;
+    order?: number;
+    component: ComponentType<{
+        children: ReactNode;
+    }>;
+}
+export type CanvasKitHostComponent = {
+    id: string;
+    slot: "controller";
+    order?: number;
+    component: ComponentType<CanvasKitControllerHostProps>;
+} | {
+    id: string;
+    slot: "workspace";
+    order?: number;
+    component: ComponentType<CanvasKitWorkspaceHostProps>;
+} | {
+    id: string;
+    slot: "chrome";
+    order?: number;
+    component: ComponentType<CanvasKitChromeHostProps>;
+};

package/runtime/canvasKitHostFeatureHooks.d.ts

@@ -0,0 +1,12 @@
+import type { CanvasActionContext, Editor } from "../_vendor/canvas-core/index";
+import type { ProductServiceRegistry } from "../core";
+import type { SvgAssetInliner } from "../features/export/svgExport";
+import type { CanvasKitCommandHookContext, CanvasKitHostFeature } from "./canvasKitHostContracts";
+export declare function getCanvasKitHostFeatureSvgAssetInliners({ editor, hostFeatures, services, }: {
+    editor: Editor;
+    hostFeatures: readonly CanvasKitHostFeature[];
+    services: ProductServiceRegistry;
+}): readonly SvgAssetInliner[];
+export declare function runCanvasKitHostFeaturesBeforeCommand(hostFeatures: readonly CanvasKitHostFeature[], input: CanvasKitCommandHookContext): void;
+export declare function runCanvasKitHostFeaturesAfterCommand(hostFeatures: readonly CanvasKitHostFeature[], input: CanvasKitCommandHookContext): void;
+export declare function canShowCanvasKitToolbarDuringEditing(hostFeatures: readonly CanvasKitHostFeature[], context: CanvasActionContext): boolean;

package/runtime/canvasKitRuntime.d.ts

@@ -1,17 +1,19 @@
 import type { Editor } from "../_vendor/canvas-core/index";
-import { type CanvasPluginHostRuntime } from "../_vendor/canvas-react/host/index";
-import { type ProductAssetResolverService, type ProductFeatureControllerRegistryRuntime, type ProductPersistenceAdapter, type ProductServiceRegistryRuntime, type ProductServiceToken } from "../core";
-import type { CanvasKitController, CanvasKitBaseController } from "../controller/canvasKitController";
+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 "./canvasKitHostExtensions";
+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;
-    featureControllers: ProductFeatureControllerRegistryRuntime;
     hostExtensions: readonly CanvasKitHostExtension[];
     persistence: ProductPersistenceAdapter | null;
-    pluginHostRuntime: CanvasPluginHostRuntime;
+    plan: CanvasKitRuntimePlan;
+    pluginHostRuntime: CanvasRenderPluginHostRuntime;
     productId: string;
     services: ProductServiceRegistryRuntime;
     shouldSkipStoredSnapshots?: () => boolean;

package/runtime/canvasKitRuntimePlan.d.ts

@@ -0,0 +1,50 @@
+import type { CanvasAction, ContextMenuContribution, ToolbarContribution } from "../_vendor/canvas-core/index";
+import type { CanvasRenderPluginHostRuntime, LandExtension } from "../_vendor/canvas-react/host/index";
+import type { ProductAssetResolverService, ProductServiceFactory, ProductServiceRegistry, ProductServiceToken, CanvasProductRuntimeInitializer } from "../core";
+import type { ResolvedCanvasKitProduct } from "../product/canvasKitProduct";
+import type { CanvasKitBaseController } from "../controller/canvasKitController";
+import type { CanvasKitActionShortcut, CanvasKitChromeSlot, CanvasKitControllerSlot, CanvasKitHostApiContribution, CanvasKitHostComponent, CanvasKitHostFeature, CanvasKitHostProvider, CanvasKitHostExtension, CanvasKitRuntimeDisposeHook, CanvasKitStartupHook } from "./canvasKitHostContracts";
+export interface CanvasKitRuntimePlanDraft {
+    readonly canvasExtensions: readonly LandExtension[];
+    readonly canvasExtensionNames: ReadonlySet<string>;
+    readonly hostExtensions: readonly CanvasKitHostExtension[];
+    readonly hostFeatures: readonly CanvasKitHostFeature[];
+    readonly services: readonly ProductServiceFactory<unknown>[];
+    readonly assetResolverTokens: readonly ProductServiceToken<ProductAssetResolverService>[];
+    readonly actions: readonly CanvasAction[];
+    readonly actionFactories: readonly NonNullable<CanvasKitHostFeature["createActions"]>[];
+    readonly actionShortcuts: readonly CanvasKitActionShortcut[];
+    readonly toolbarContributions: readonly ToolbarContribution[];
+    readonly contextMenuContributions: readonly ContextMenuContribution[];
+    readonly apis: readonly CanvasKitHostApiContribution<unknown>[];
+    readonly controllerSlots: readonly CanvasKitControllerSlot<string, unknown>[];
+    readonly chromeSlots: readonly CanvasKitChromeSlot<string, unknown>[];
+    readonly providers: readonly CanvasKitHostProvider[];
+    readonly components: readonly CanvasKitHostComponent[];
+    readonly componentsBySlot: CanvasKitHostComponentsBySlot;
+    readonly runtimeInitializers: readonly CanvasProductRuntimeInitializer<CanvasRenderPluginHostRuntime>[];
+    readonly beforeStartupHooks: readonly CanvasKitStartupHook[];
+    readonly afterRestoreHooks: readonly CanvasKitStartupHook[];
+    readonly beforeReadyHooks: readonly CanvasKitStartupHook[];
+    readonly runtimeDisposeHooks: readonly CanvasKitRuntimeDisposeHook[];
+}
+export interface CanvasKitRuntimePlan extends Omit<CanvasKitRuntimePlanDraft, "actionFactories"> {
+    readonly knownHostActionIds: readonly string[];
+}
+export interface CanvasKitHostComponentsBySlot {
+    readonly controller: readonly Extract<CanvasKitHostComponent, {
+        slot: "controller";
+    }>[];
+    readonly chrome: readonly Extract<CanvasKitHostComponent, {
+        slot: "chrome";
+    }>[];
+    readonly workspace: readonly Extract<CanvasKitHostComponent, {
+        slot: "workspace";
+    }>[];
+}
+export declare function createCanvasKitRuntimePlan<TController extends CanvasKitBaseController>(product: ResolvedCanvasKitProduct<TController>): CanvasKitRuntimePlanDraft;
+export declare function materializeCanvasKitRuntimePlan({ plan, productId, services, }: {
+    plan: CanvasKitRuntimePlanDraft;
+    productId: string;
+    services: ProductServiceRegistry;
+}): CanvasKitRuntimePlan;

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

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

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

@@ -1,2 +0,0 @@
-export { createCanvasPluginHostRuntime } from "./pluginHostRuntime";
-export type { CanvasPluginHostManifestContextMenuContributionEntry, CanvasPluginHostManifestEntry, CanvasPluginHostManifestToolbarContributionEntry, CanvasPluginHostRuntime, CanvasPluginHostShapeValidationSummary, CanvasPluginHostSource, CanvasPluginHostValidationIssue, CanvasPluginHostValidationIssueSeverity, CanvasPluginHostValidationSummary, CanvasPluginHostVerdict, CreateCanvasPluginHostRuntimeOptions, } from "./pluginHostTypes";

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

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

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

@@ -1,3 +0,0 @@
-import { type LandExtension } from "./extension";
-import type { CanvasPluginHostRuntime, CreateCanvasPluginHostRuntimeOptions } from "./pluginHostTypes";
-export declare function createCanvasPluginHostRuntime(extensions: readonly LandExtension[], options?: CreateCanvasPluginHostRuntimeOptions): CanvasPluginHostRuntime;

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

@@ -1,102 +0,0 @@
-import type { LandEditorPlugin, ShapeCapabilitySupport } from "../../canvas-core/index";
-import type { CanvasPluginComponent, CanvasPluginProvider, LandCanvasPlugin } from "./canvasPlugin";
-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 CanvasPluginHostSource = "built-in" | "dev-sample";
-export type CanvasPluginHostVerdict = "pass" | "fail";
-export interface CreateCanvasPluginHostRuntimeOptions {
-    knownHostActionIds?: readonly string[];
-    source?: CanvasPluginHostSource;
-}
-export interface CanvasPluginHostManifestEntry {
-    id: string;
-    extensionName: string;
-    source: CanvasPluginHostSource;
-    editorPluginIds: string[];
-    canvasPluginIds: string[];
-    interactionHandlerIds: string[];
-    canvasActionIds: string[];
-    toolbarContributionIds: string[];
-    toolbarContributions: CanvasPluginHostManifestToolbarContributionEntry[];
-    contextMenuContributionIds: string[];
-    contextMenuContributions: CanvasPluginHostManifestContextMenuContributionEntry[];
-    domEventGuardIds: string[];
-    canvasOverlayIds: string[];
-    selectionCustomHandleRendererTypes: 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 {
-    editorPlugins: LandEditorPlugin[];
-    canvasPlugins: LandCanvasPlugin[];
-    canvasProviders: CanvasPluginProvider[];
-    canvasComponents: CanvasPluginComponent[];
-    rendererRegistry: CanvasRendererRegistry;
-    overlayRegistry: CanvasOverlayRegistry;
-    domEventGuardRegistry: CanvasDomEventGuardRegistry;
-    toolbarRegistry: CanvasToolbarRegistry;
-    contextMenuRegistry: CanvasContextMenuRegistry;
-    manifest: CanvasPluginHostManifestEntry[];
-    validation: CanvasPluginHostValidationSummary;
-    externalPluginIds: string[];
-}
-export type CanvasPluginHostValidationIssueSeverity = "error" | "warning";
-export interface CanvasPluginHostValidationIssue {
-    severity: CanvasPluginHostValidationIssueSeverity;
-    code: "duplicate-feature-id" | "duplicate-editor-plugin-id" | "duplicate-canvas-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-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[];
-    editorPluginIds: string[];
-    canvasPluginIds: string[];
-    interactionHandlerIds: string[];
-    canvasActionIds: string[];
-    toolbarContributionIds: string[];
-    contextMenuContributionIds: string[];
-    domEventGuardIds: string[];
-    canvasOverlayIds: string[];
-    selectionCustomHandleRendererTypes: string[];
-    canvasProviderIds: string[];
-    canvasComponentIds: string[];
-    registeredRendererTypes: string[];
-    shapeSummaries: CanvasPluginHostShapeValidationSummary[];
-}
-export interface ResolvedCanvasFeature {
-    extensionName: string;
-    feature: LandFeatureBundle;
-    source: CanvasPluginHostSource;
-}

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

@@ -1,11 +0,0 @@
-import type { LandEditorPlugin } from "../../canvas-core/index";
-import type { LandCanvasPlugin } from "./canvasPlugin";
-import type { CanvasRendererRegistry } from "./rendererRegistry";
-import type { CanvasPluginHostValidationSummary, ResolvedCanvasFeature } from "./pluginHostTypes";
-export declare function validateCanvasPluginHost({ editorPlugins, canvasPlugins, knownHostActionIds, rendererRegistry, resolvedFeatures, }: {
-    editorPlugins: readonly LandEditorPlugin[];
-    canvasPlugins: readonly LandCanvasPlugin[];
-    knownHostActionIds: readonly string[];
-    rendererRegistry: CanvasRendererRegistry;
-    resolvedFeatures: readonly ResolvedCanvasFeature[];
-}): CanvasPluginHostValidationSummary;

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

@@ -1,2 +0,0 @@
-import { type LandCanvasPlugin } from "../canvas-react/host/index";
-export declare function createArrowCanvasPlugin(): LandCanvasPlugin;

package/_vendor/plugin-draw/canvas.d.ts

@@ -1,2 +0,0 @@
-import type { LandCanvasPlugin } from "../canvas-react/host/index";
-export declare function createDrawCanvasPlugin(): LandCanvasPlugin;

package/_vendor/plugin-eraser/canvas.d.ts

@@ -1,2 +0,0 @@
-import { type LandCanvasPlugin } from "../canvas-react/host/index";
-export declare function createEraserCanvasPlugin(): LandCanvasPlugin;

package/_vendor/plugin-eraser/editor.d.ts

@@ -1,2 +0,0 @@
-import { type LandEditorPlugin } from "../canvas-core/index";
-export declare function createEraserEditorPlugin(): LandEditorPlugin;

package/_vendor/plugin-image/canvas.d.ts

@@ -1,2 +0,0 @@
-import { type LandCanvasPlugin } from "../canvas-react/host/index";
-export declare function createImageCanvasPlugin(): LandCanvasPlugin;

package/_vendor/plugin-laser/canvas.d.ts

@@ -1,2 +0,0 @@
-import { type LandCanvasPlugin } from "../canvas-react/host/index";
-export declare function createLaserCanvasPlugin(): LandCanvasPlugin;

package/_vendor/plugin-laser/editor.d.ts

@@ -1,2 +0,0 @@
-import { type LandEditorPlugin } from "../canvas-core/index";
-export declare function createLaserEditorPlugin(): LandEditorPlugin;

package/_vendor/plugin-text/canvas.d.ts

@@ -1,5 +0,0 @@
-import { type TextFontCatalog } from "./textFonts";
-import { type LandCanvasPlugin } from "../canvas-react/host/index";
-export declare function createTextCanvasPlugin({ fontCatalog, }?: {
-    fontCatalog?: TextFontCatalog;
-}): LandCanvasPlugin;

package/_vendor/plugin-text/editor.d.ts

@@ -1,5 +0,0 @@
-import { type LandEditorPlugin } from "../canvas-core/index";
-import { type TextFontCatalog } from "./textFonts";
-export declare function createTextEditorPlugin({ fontCatalog, }?: {
-    fontCatalog?: TextFontCatalog;
-}): LandEditorPlugin;

package/chrome/bindings/useCanvasKitChromeControls.d.ts

@@ -1,27 +0,0 @@
-import type { Editor, PageId, PageRecord } from "../../_vendor/canvas-core/index";
-export interface HistoryControls {
-    canUndo: boolean;
-    canRedo: boolean;
-    undo(): void;
-    redo(): void;
-}
-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 interface ZoomControlsState {
-    zoom: number;
-    label: string;
-    zoomIn(): void;
-    zoomOut(): void;
-    resetZoom(): void;
-}
-export declare function useHistoryControls(editor: Editor): HistoryControls;
-export declare function usePageControls(editor: Editor): PageControls;
-export declare function useZoomControls(editor: Editor): ZoomControlsState;

package/core/controller/featureControllerRegistry.d.ts

@@ -1,12 +0,0 @@
-export interface ProductFeatureControllerToken<TController> {
-    readonly id: string;
-    readonly __controller?: TController;
-}
-export interface ProductFeatureControllerRegistry {
-    get<TController>(token: ProductFeatureControllerToken<TController>): TController | null;
-}
-export interface ProductFeatureControllerRegistryRuntime extends ProductFeatureControllerRegistry {
-    register<TController>(token: ProductFeatureControllerToken<TController>, controller: TController): void;
-}
-export declare function createProductFeatureControllerToken<TController>(id: string): ProductFeatureControllerToken<TController>;
-export declare function createProductFeatureControllerRegistry(): ProductFeatureControllerRegistryRuntime;

package/core/controller/index.d.ts

@@ -1,4 +0,0 @@
-export { createProductFeatureControllerRegistry, createProductFeatureControllerToken, } from "./featureControllerRegistry";
-export type { ProductFeatureControllerRegistry, ProductFeatureControllerRegistryRuntime, ProductFeatureControllerToken, } from "./featureControllerRegistry";
-export { createCanvasProductController } from "./canvasProductController";
-export type { CanvasProductController, CanvasProductControllerChange, CanvasProductControllerChangeKey, CanvasProductControllerChangeListener, CanvasProductControllerContext, CanvasProductControllerOptions, CanvasProductControllerSnapshot, CanvasProductLayerActionState, CanvasProductLayerNode, CanvasProductLayerPlacement, CanvasProductLayerPlacementFailureReason, CanvasProductLayerPlacementResult, CanvasProductPageRef, CanvasProductShapeData, CanvasProductSessionPageState, CanvasProductSessionSnapshot, CanvasProductShapeRef, CanvasProductShapeUpdate, } from "./canvasProductController";

package/core/features/clipboard/clipboardContribution.d.ts

@@ -1,19 +0,0 @@
-import type { Editor, CanvasAction, KeyboardShortcutInput } from "../../../_vendor/canvas-core/index";
-import type { CanvasProductRuntimeContribution } from "../../runtime/productContributions";
-import type { ProductPluginHostRuntime } from "../../runtime/productHost";
-import type { ProductServiceRegistry } from "../../runtime/productServices";
-export declare const SYSTEM_CLIPBOARD_COPY_ACTION_ID = "system.clipboard.copy";
-export declare const SYSTEM_CLIPBOARD_CUT_ACTION_ID = "system.clipboard.cut";
-export declare const SYSTEM_CLIPBOARD_PASTE_ACTION_ID = "system.clipboard.paste";
-export declare const SYSTEM_CLIPBOARD_PASTE_AT_POINT_ACTION_ID = "system.clipboard.paste-at-point";
-export declare const clipboardActionShortcuts: readonly {
-    actionId: string;
-    shortcut: KeyboardShortcutInput;
-}[];
-export declare function createClipboardProductContribution(): CanvasProductRuntimeContribution;
-export declare function registerClipboardActions({ editor, pluginHostRuntime, services, }: {
-    editor?: Editor;
-    pluginHostRuntime: ProductPluginHostRuntime;
-    services: ProductServiceRegistry;
-}): void;
-export declare function createClipboardActions(services: ProductServiceRegistry): readonly CanvasAction[];

package/core/features/context-menu/contextMenuActions.d.ts

@@ -1,12 +0,0 @@
-import type { ContextMenuContext, CanvasAction, CanvasActionValue } from "../../../_vendor/canvas-core/index";
-import type { ProductPluginHostRuntime } from "../../runtime/productHost";
-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 runContextMenuAction({ actionId, context, pluginHostRuntime, value, }: {
-    actionId: string;
-    context: ContextMenuContext;
-    pluginHostRuntime: ProductPluginHostRuntime;
-    value?: CanvasActionValue;
-}): void;
-export declare const contextMenuActions: readonly CanvasAction[];

package/core/features/context-menu/contextMenuContext.d.ts

@@ -1,6 +0,0 @@
-import type { ContextMenuContext, ContextMenuContributionTarget, ContextMenuTarget, Editor } from "../../../_vendor/canvas-core/index";
-export declare function createContextMenuContext({ editor, menu, }: {
-    editor: Editor;
-    menu: ContextMenuContext["menu"];
-}): ContextMenuContext;
-export declare function getContextMenuContributionTarget(target: ContextMenuTarget, editor: Editor): ContextMenuContributionTarget;

package/core/features/context-menu/contextMenuContribution.d.ts

@@ -1,4 +0,0 @@
-import type { ContextMenuContribution } from "../../../_vendor/canvas-core/index";
-import type { CanvasProductRuntimeContribution } from "../../runtime/productContributions";
-export declare const contextMenuContributions: readonly ContextMenuContribution[];
-export declare function createContextMenuProductContribution(): CanvasProductRuntimeContribution;

package/core/features/hostActionIds.d.ts

@@ -1 +0,0 @@
-export declare const CANVAS_KIT_HOST_ACTION_IDS: readonly ["editor.tool.set-active-tool", "editor.tool.toggle-locked", "system.clipboard.copy", "system.clipboard.cut", "system.clipboard.paste", "system.clipboard.paste-at-point", "system.selection.duplicate", "system.selection.select-all", "system.selection.delete", "system.selection.group", "system.selection.ungroup", "system.selection.reset-rotation", "system.selection.flip-horizontal", "system.selection.flip-vertical", "system.selection.send-to-back", "system.selection.send-backward", "system.selection.bring-forward", "system.selection.bring-to-front", "system.view.reset-zoom", "system.view.zoom-in", "system.view.zoom-out"];

package/core/features/toolbar/toolbarContribution.d.ts

@@ -1,4 +0,0 @@
-import { type ToolbarContribution } from "../../../_vendor/canvas-core/index";
-import type { CanvasProductRuntimeContribution } from "../../runtime/productContributions";
-export declare const toolbarContributions: readonly ToolbarContribution[];
-export declare function createToolbarProductContribution(): CanvasProductRuntimeContribution;

package/core/runtime/productContributions.d.ts

@@ -1,9 +0,0 @@
-import type { ProductAssetResolverService, ProductServiceFactory, ProductServiceToken } from "./productServices";
-import type { CanvasProductRuntimeInitializer } from "./productDefinition";
-import type { ProductPluginHostRuntime } from "./productHost";
-export interface CanvasProductRuntimeContribution<TPluginHostRuntime extends ProductPluginHostRuntime = ProductPluginHostRuntime> {
-    id: string;
-    services?: readonly ProductServiceFactory<unknown>[];
-    assetResolverTokens?: readonly ProductServiceToken<ProductAssetResolverService>[];
-    initializeRuntime?: CanvasProductRuntimeInitializer<TPluginHostRuntime>;
-}

package/features/image/imageAssetService.d.ts

@@ -1,7 +0,0 @@
-import { type ProductAssetResolverService, type ProductServiceFactory } from "../../core";
-import { type ImageObjectUrlStore } from "./imageBlobStore";
-export interface ImageAssetService extends ProductAssetResolverService {
-    objectUrls: ImageObjectUrlStore;
-}
-export declare const imageAssetServiceToken: import("../../core").ProductServiceToken<ImageAssetService>;
-export declare function localImageAssetService(): ProductServiceFactory<ImageAssetService>;