@yuzhouu/canvas-kit 0.1.3 → 0.1.4

package/chrome/useCanvasKitChromeContext.d.ts

@@ -0,0 +1,19 @@
+import { type RefObject } from "react";
+import type { ActiveContextMenu } from "../_vendor/canvas-core/index";
+import type { CanvasKitBaseController } from "../controller/canvasKitController";
+import type { CanvasKitRuntime } from "../runtime/canvasKitRuntime";
+import type { CanvasKitHostExtension } from "../runtime/canvasKitHostExtensions";
+import type { ProductServiceRegistry } from "../core";
+import type { CanvasKitChromeContext, CanvasKitGridControls, CanvasKitPersistenceControls } from "./types";
+export declare function useCanvasKitChromeContext<TController extends CanvasKitBaseController>({ controller, activeContextMenu, editor, grid, hostExtensions, onActiveContextMenuChange, persistence, pluginHostRuntime, services, themeRootRef, }: {
+    controller: TController;
+    activeContextMenu: ActiveContextMenu | null;
+    editor: CanvasKitRuntime["editor"];
+    grid: CanvasKitGridControls;
+    hostExtensions: readonly CanvasKitHostExtension[];
+    onActiveContextMenuChange: (activeContextMenu: ActiveContextMenu | null) => void;
+    persistence: CanvasKitPersistenceControls;
+    pluginHostRuntime: CanvasKitRuntime["pluginHostRuntime"];
+    services: ProductServiceRegistry;
+    themeRootRef: RefObject<HTMLElement | null>;
+}): CanvasKitChromeContext<TController>;

package/controller/canvasKitController.d.ts

@@ -0,0 +1,36 @@
+import { type CanvasProductController, type CanvasProductControllerContext, type CanvasProductSessionSnapshot } from "../core/controller";
+import type { CanvasPluginHostRuntime } from "../_vendor/canvas-react/host/index";
+import { type BuiltInCanvasController, type BuiltInCanvasControllerSnapshot, type BuiltInCanvasFrameInput, type BuiltInCanvasShapeInput, type BuiltInCanvasTextInput } from "../builtins";
+import { type ImageProductController } from "../features/image";
+export type CanvasKitShapeInput = BuiltInCanvasShapeInput;
+export type CanvasKitTextInput = BuiltInCanvasTextInput;
+export type CanvasKitFrameInput = BuiltInCanvasFrameInput;
+export interface CanvasKitBaseController<TToolId extends string = string> extends CanvasProductController<TToolId> {
+}
+export declare const CANVAS_KIT_TOOL_IDS: readonly ["select", "hand", "rectangle", "ellipse", "diamond", "triangle", "hexagon", "star", "arrow", "draw", "text", "frame", "eraser", "laser"];
+export type CanvasKitToolId = (typeof CANVAS_KIT_TOOL_IDS)[number];
+export interface CanvasKitControllerSnapshot<TToolId extends string = CanvasKitToolId> extends BuiltInCanvasControllerSnapshot<TToolId> {
+    productId: string;
+    session: CanvasProductSessionSnapshot<TToolId>;
+}
+export interface CanvasKitController<TToolId extends string = CanvasKitToolId> extends BuiltInCanvasController<TToolId> {
+    image: ImageProductController | null;
+    snapshot(): CanvasKitControllerSnapshot<TToolId>;
+}
+export interface CanvasKitControllerRuntimeContext extends Omit<CanvasProductControllerContext, "pluginHostRuntime"> {
+    pluginHostRuntime: CanvasPluginHostRuntime;
+}
+export interface CanvasKitControllerOptions<TToolId extends string = CanvasKitToolId> extends CanvasKitControllerRuntimeContext {
+    assertToolId?: (toolId: string) => asserts toolId is TToolId;
+}
+export interface CanvasKitControllerWithToolsOptions<TToolId extends string> extends CanvasKitControllerRuntimeContext {
+    assertToolId: (toolId: string) => asserts toolId is TToolId;
+}
+export type CanvasKitControllerWithTools<TToolId extends string> = CanvasKitController<TToolId>;
+declare global {
+    interface Window {
+        landCanvasKit?: CanvasKitController;
+    }
+}
+export declare function createCanvasKitController(context: CanvasKitControllerOptions<CanvasKitToolId>): CanvasKitController;
+export declare function createCanvasKitControllerWithTools<TToolId extends string>(context: CanvasKitControllerWithToolsOptions<TToolId>): CanvasKitControllerWithTools<TToolId>;

package/{_vendor/canvas-product-react/api/canvasProductApi.d.ts → core/controller/canvasProductController.d.ts}

@@ -1,7 +1,6 @@
-import type { Camera, Editor, LayerOrderDirection, LayerOrderEdge, ReparentShapePlacementFailureReason, ShapeId } from "../../canvas-core/index";
-import type { CanvasPluginHostRuntime } from "../../canvas-react/host/index";
+import type { Camera, Editor, LayerOrderDirection, LayerOrderEdge, ReparentShapePlacementFailureReason, ShapeId } from "../../_vendor/canvas-core/index";
 import type { ProductServiceRegistry } from "../runtime/productServices";
-import type { ProductApiRegistry } from "./apiRegistry";
+import type { ProductFeatureControllerRegistry } from "./featureControllerRegistry";
 export interface CanvasProductShapeRef {
     id: ShapeId;
     type: string;
@@ -21,7 +20,7 @@ export interface CanvasProductSessionSnapshot<TToolId extends string = string> {
     isToolLocked: boolean;
     pages: CanvasProductSessionPageState[];
 }
-export interface CanvasProductApiSnapshot<TToolId extends string = string> {
+export interface CanvasProductControllerSnapshot<TToolId extends string = string> {
     productId: string;
     pageId: string;
     activeToolId: TToolId;
@@ -67,9 +66,9 @@ export interface CanvasProductPageRef {
     name: string;
     index: string;
 }
-export interface CanvasProductApi<TToolId extends string = string> {
-    plugins: ProductApiRegistry;
-    snapshot(): CanvasProductApiSnapshot<TToolId>;
+export interface CanvasProductController<TToolId extends string = string> {
+    features: ProductFeatureControllerRegistry;
+    snapshot(): CanvasProductControllerSnapshot<TToolId>;
     clearHistory(): void;
     canUndo(): boolean;
     canRedo(): boolean;
@@ -102,23 +101,14 @@ export interface CanvasProductApi<TToolId extends string = string> {
     exportSelectionSvg(): string | null;
     exportPageSvg(): string | null;
 }
-export interface CanvasProductApiContext {
+export interface CanvasProductControllerContext {
     editor: Editor;
     services: ProductServiceRegistry;
-    pluginHostRuntime: CanvasPluginHostRuntime;
-    apiRegistry: ProductApiRegistry;
+    pluginHostRuntime: unknown;
+    featureControllers: ProductFeatureControllerRegistry;
     productId: string;
 }
-export interface CanvasProductApiOptions<TToolId extends string = string> extends CanvasProductApiContext {
+export interface CanvasProductControllerOptions<TToolId extends string = string> extends CanvasProductControllerContext {
     assertToolId: (toolId: string) => asserts toolId is TToolId;
 }
-export interface CanvasProductApiLifecycleOptions<TApi> {
-    api: TApi;
-    exposeOnWindow?: boolean;
-    windowKey?: string;
-    onDispose?: () => void;
-    onReady?: (api: TApi) => void;
-}
-export declare function createCanvasProductApi<TToolId extends string = string>(options: CanvasProductApiOptions<TToolId>): CanvasProductApi<TToolId>;
-export declare function useCanvasProductApi<TToolId extends string = string>(options: CanvasProductApiOptions<TToolId>): CanvasProductApi<TToolId>;
-export declare function useCanvasProductApiLifecycle<TApi>({ api, exposeOnWindow, windowKey, onDispose, onReady, }: CanvasProductApiLifecycleOptions<TApi>): void;
+export declare function createCanvasProductController<TToolId extends string = string>(options: CanvasProductControllerOptions<TToolId>): CanvasProductController<TToolId>;

package/core/controller/featureControllerRegistry.d.ts

@@ -0,0 +1,12 @@
+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

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

package/core/controller/productLayerTree.d.ts

@@ -0,0 +1,10 @@
+import type { Editor, PageId, ShapeId } from "../../_vendor/canvas-core/index";
+import type { CanvasProductLayerNode } from "./canvasProductController";
+export declare function getCanvasProductLayerTree({ editor, pageId, }: {
+    editor: Editor;
+    pageId?: PageId;
+}): CanvasProductLayerNode[];
+export declare function getCanvasProductLayerNode({ editor, id, }: {
+    editor: Editor;
+    id: ShapeId;
+}): CanvasProductLayerNode | null;

package/core/features/actions/canvasActionContext.d.ts

@@ -0,0 +1,15 @@
+import type { Editor, CanvasActionContext } from "../../../_vendor/canvas-core/index";
+export declare function createCanvasActionContext({ editor, toolState, selectionState, }: {
+    editor: Editor;
+    toolState: {
+        activeToolId: string;
+        isToolLocked: boolean;
+    };
+    selectionState: {
+        count: number;
+        singleShapeType: CanvasActionContext["selection"]["singleShapeType"];
+        commonShapeType: CanvasActionContext["selection"]["commonShapeType"];
+        canResetSelectionRotation: boolean;
+        isMixedFrameAndPointHandleSelection: boolean;
+    };
+}): CanvasActionContext;

package/core/features/actions/canvasActions.d.ts

@@ -0,0 +1,26 @@
+import { type CanvasAction, type CanvasActionContext, type KeyboardShortcutInput } from "../../../_vendor/canvas-core/index";
+import type { ProductPluginHostRuntime } from "../../runtime/productHost";
+export declare const SYSTEM_SELECTION_DELETE_ACTION_ID = "system.selection.delete";
+export declare const SYSTEM_SELECTION_DUPLICATE_ACTION_ID = "system.selection.duplicate";
+export declare const SYSTEM_SELECTION_GROUP_ACTION_ID = "system.selection.group";
+export declare const SYSTEM_SELECTION_SELECT_ALL_ACTION_ID = "system.selection.select-all";
+export declare const SYSTEM_SELECTION_UNGROUP_ACTION_ID = "system.selection.ungroup";
+export declare const SYSTEM_SELECTION_RESET_ROTATION_ACTION_ID = "system.selection.reset-rotation";
+export declare const SYSTEM_SELECTION_FLIP_HORIZONTAL_ACTION_ID = "system.selection.flip-horizontal";
+export declare const SYSTEM_SELECTION_FLIP_VERTICAL_ACTION_ID = "system.selection.flip-vertical";
+export declare const SYSTEM_SELECTION_SEND_TO_BACK_ACTION_ID = "system.selection.send-to-back";
+export declare const SYSTEM_SELECTION_SEND_BACKWARD_ACTION_ID = "system.selection.send-backward";
+export declare const SYSTEM_SELECTION_BRING_FORWARD_ACTION_ID = "system.selection.bring-forward";
+export declare const SYSTEM_SELECTION_BRING_TO_FRONT_ACTION_ID = "system.selection.bring-to-front";
+export declare const SYSTEM_SELECTION_SET_OPACITY_ACTION_ID = "system.selection.set-opacity";
+export declare const canvasActionShortcuts: readonly {
+    actionId: string;
+    shortcut: KeyboardShortcutInput;
+}[];
+export declare function runCanvasAction({ context, pluginHostRuntime, actionId, }: {
+    context: CanvasActionContext;
+    pluginHostRuntime: ProductPluginHostRuntime;
+    actionId: string;
+}): void;
+export declare function isSingleSelectedFrameChild(context: CanvasActionContext): boolean;
+export declare const canvasActions: readonly CanvasAction[];

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

@@ -0,0 +1,2 @@
+import type { ContextMenuContribution } from "../../../_vendor/canvas-core/index";
+export declare const clipboardContextMenuContributions: readonly ContextMenuContribution[];

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

@@ -0,0 +1,19 @@
+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/{_vendor/canvas-product-react/capabilities → core/features}/clipboard/clipboardService.d.ts

@@ -1,9 +1,10 @@
-import type { EditorClipboardPayload } from "../../../canvas-core/index";
-import { type ProductServiceFactory } from "../../runtime/productServices";
+import type { EditorClipboardPayload } from "../../../_vendor/canvas-core/index";
+import { type ProductServiceFactory, type ProductServiceRegistry } from "../../runtime/productServices";
 export interface CanvasClipboardService {
     write(payload: EditorClipboardPayload): Promise<void>;
     read(): Promise<EditorClipboardPayload | null>;
     getMemoryPayload(): EditorClipboardPayload | null;
 }
 export declare const canvasClipboardServiceToken: import("../..").ProductServiceToken<CanvasClipboardService>;
+export declare function getCanvasClipboardService(services: ProductServiceRegistry): CanvasClipboardService | null;
 export declare function memoryCanvasClipboardService(): ProductServiceFactory<CanvasClipboardService>;

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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,4 @@
+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/context-menu/viewContextMenuContributions.d.ts

@@ -0,0 +1,2 @@
+import type { ContextMenuContribution } from "../../../_vendor/canvas-core/index";
+export declare const viewContextMenuContributions: readonly ContextMenuContribution[];

package/{_vendor/canvas-product-react/capabilities/export/useSvgExport.d.ts → core/features/export/svgExport.d.ts}

@@ -1,4 +1,4 @@
-import type { Editor, ExportIntegrityReport, ShapeCapabilityManifest, ShapeId, SvgExportSkippedShape } from "../../../canvas-core/index";
+import type { Editor, ExportIntegrityReport, ShapeCapabilityManifest, ShapeId, SvgExportSkippedShape, SvgThemeColorResolver } from "../../../_vendor/canvas-core/index";
 export interface SvgAssetInliner {
     inline(input: {
         editor: Editor;
@@ -19,11 +19,15 @@ export interface SvgExportResult {
     exportedShapeIds: readonly ShapeId[];
     skippedShapes: readonly SvgExportSkippedShape[];
 }
-export interface SvgExportControls {
-    status: ExportStatus | null;
-    exportSvg(shapeIds: readonly ShapeId[]): Promise<SvgExportResult>;
-}
-export declare function useSvgExport({ assetInliners, editor, }: {
+export interface SvgExportOptions {
     assetInliners?: readonly SvgAssetInliner[];
     editor: Editor;
-}): SvgExportControls;
+    padding?: number;
+    resolveThemeColor?: SvgThemeColorResolver;
+    shapeIds: readonly ShapeId[];
+}
+export declare function exportEditorSvg({ assetInliners, editor, padding, resolveThemeColor, shapeIds, }: SvgExportOptions): Promise<SvgExportResult>;
+export declare function getSvgExportStatus({ capabilityManifest, integrity, }: {
+    capabilityManifest: ShapeCapabilityManifest;
+    integrity: ExportIntegrityReport;
+}): ExportStatus;

package/core/features/hostActionIds.d.ts

@@ -0,0 +1 @@
+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/selectionContextMenuContributions.d.ts

@@ -0,0 +1,2 @@
+import type { ContextMenuContribution } from "../../../_vendor/canvas-core/index";
+export declare const selectionContextMenuContributions: readonly ContextMenuContribution[];

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

@@ -0,0 +1,2 @@
+import { type ContextMenuContribution } from "../../../_vendor/canvas-core/index";
+export declare const toolContextMenuContributions: readonly ContextMenuContribution[];

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

@@ -0,0 +1,4 @@
+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/features/toolbar/toolbarLabels.d.ts

@@ -0,0 +1,8 @@
+import { type ToolbarGroup } from "../../../_vendor/canvas-core/index";
+export declare function getActiveToolLabel(groups: readonly ToolbarGroup[], activeToolId: string): string;
+export declare function getSelectionToolbarTitle({ commonShapeType, count, isMixedFrameAndPointHandleSelection, singleShapeType, }: {
+    commonShapeType: string | null;
+    count: number;
+    isMixedFrameAndPointHandleSelection: boolean;
+    singleShapeType: string | null;
+}): string;

package/core/index.d.ts

@@ -0,0 +1,23 @@
+export { createDefaultCanvasProductEditor } from "./runtime/productEditor";
+export { cleanupProductAssetsAfterRestore, preloadProductAssets, resolveProductAssetUrl, } from "./runtime/productAssets";
+export { createProductFeatureControllerRegistry, createProductFeatureControllerToken, } from "./controller/featureControllerRegistry";
+export { createProductServiceRegistry, createProductServiceToken, requireProductService, } from "./runtime/productServices";
+export { CANVAS_KIT_HOST_ACTION_IDS } from "./features/hostActionIds";
+export type { CanvasProductRuntimeInitializer, CanvasProductRuntimeInitializerContext, CreateCanvasProductEditorOptions, ProductPersistenceAdapter, ProductPersistenceRestoreResult, ProductPersistenceStatus, } from "./runtime/productDefinition";
+export type { CanvasProductRuntimeContribution, } from "./runtime/productContributions";
+export type { ProductContextMenuRegistry, ProductPluginHostRuntime, ProductToolbarRegistry, } from "./runtime/productHost";
+export type { ProductAssetResolverService, ProductServiceFactory, ProductServiceFactoryContext, ProductServiceRegistry, ProductServiceRegistryRuntime, ProductServiceToken, } from "./runtime/productServices";
+export type { ProductFeatureControllerRegistry, ProductFeatureControllerRegistryRuntime, ProductFeatureControllerToken, } from "./controller/featureControllerRegistry";
+export { SYSTEM_SELECTION_BRING_FORWARD_ACTION_ID, SYSTEM_SELECTION_BRING_TO_FRONT_ACTION_ID, SYSTEM_SELECTION_DELETE_ACTION_ID, SYSTEM_SELECTION_DUPLICATE_ACTION_ID, SYSTEM_SELECTION_FLIP_HORIZONTAL_ACTION_ID, SYSTEM_SELECTION_FLIP_VERTICAL_ACTION_ID, SYSTEM_SELECTION_GROUP_ACTION_ID, SYSTEM_SELECTION_RESET_ROTATION_ACTION_ID, SYSTEM_SELECTION_SELECT_ALL_ACTION_ID, SYSTEM_SELECTION_SEND_BACKWARD_ACTION_ID, SYSTEM_SELECTION_SEND_TO_BACK_ACTION_ID, SYSTEM_SELECTION_UNGROUP_ACTION_ID, runCanvasAction, } from "./features/actions/canvasActions";
+export { createToolbarProductContribution } from "./features/toolbar/toolbarContribution";
+export { createCanvasActionContext } from "./features/actions/canvasActionContext";
+export { getActiveToolLabel, getSelectionToolbarTitle, } from "./features/toolbar/toolbarLabels";
+export { SYSTEM_VIEW_RESET_ZOOM_ACTION_ID, SYSTEM_VIEW_ZOOM_IN_ACTION_ID, SYSTEM_VIEW_ZOOM_OUT_ACTION_ID, runContextMenuAction, } from "./features/context-menu/contextMenuActions";
+export { createContextMenuProductContribution } from "./features/context-menu/contextMenuContribution";
+export { createContextMenuContext, getContextMenuContributionTarget, } from "./features/context-menu/contextMenuContext";
+export { canvasClipboardServiceToken, memoryCanvasClipboardService, } from "./features/clipboard/clipboardService";
+export type { CanvasClipboardService } from "./features/clipboard/clipboardService";
+export { SYSTEM_CLIPBOARD_COPY_ACTION_ID, SYSTEM_CLIPBOARD_CUT_ACTION_ID, SYSTEM_CLIPBOARD_PASTE_ACTION_ID, SYSTEM_CLIPBOARD_PASTE_AT_POINT_ACTION_ID, createClipboardProductContribution, registerClipboardActions, } from "./features/clipboard/clipboardContribution";
+export { getCanvasClipboardService, } from "./features/clipboard/clipboardService";
+export { exportEditorSvg, getSvgExportStatus, } from "./features/export/svgExport";
+export type { ExportStatus, SvgAssetInliner, SvgExportOptions, SvgExportResult, } from "./features/export/svgExport";

package/core/runtime/productAssets.d.ts

@@ -0,0 +1,18 @@
+import type { AssetId, Editor } from "../../_vendor/canvas-core/index";
+import type { ProductAssetResolverService, ProductServiceRegistry, ProductServiceToken } from "./productServices";
+export declare function resolveProductAssetUrl({ assetResolverTokens, assetId, editor, services, }: {
+    assetResolverTokens: readonly ProductServiceToken<ProductAssetResolverService>[];
+    assetId: AssetId;
+    editor: Editor;
+    services: ProductServiceRegistry;
+}): string | null;
+export declare function preloadProductAssets({ assetResolverTokens, editor, services, }: {
+    assetResolverTokens: readonly ProductServiceToken<ProductAssetResolverService>[];
+    editor: Editor;
+    services: ProductServiceRegistry;
+}): Promise<void>;
+export declare function cleanupProductAssetsAfterRestore({ assetResolverTokens, editor, services, }: {
+    assetResolverTokens: readonly ProductServiceToken<ProductAssetResolverService>[];
+    editor: Editor;
+    services: ProductServiceRegistry;
+}): Promise<void>;

package/core/runtime/productContributions.d.ts

@@ -0,0 +1,9 @@
+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/core/runtime/productDefinition.d.ts

@@ -0,0 +1,32 @@
+import type { AssetId, Editor, LandEditorPlugin } from "../../_vendor/canvas-core/index";
+import type { ProductFeatureControllerRegistryRuntime } from "../controller/featureControllerRegistry";
+import type { ProductPluginHostRuntime } from "./productHost";
+import type { ProductServiceRegistry } from "./productServices";
+export interface ProductPersistenceRestoreResult {
+    autoPersistence: "enabled" | "disabled";
+    status?: ProductPersistenceStatus | null;
+}
+export interface ProductPersistenceStatus {
+    kind: "preserving-unsupported-records";
+    preservedRecordCount: number;
+    unsupportedBindingTypes: readonly string[];
+    unsupportedShapeTypes: readonly string[];
+}
+export interface ProductPersistenceAdapter {
+    restore?(editor: Editor): Promise<ProductPersistenceRestoreResult | void>;
+    start?(editor: Editor): () => void;
+    flushSnapshot?(editor: Editor): Promise<void>;
+    discardUnsupportedRecords?(editor: Editor): Promise<ProductPersistenceRestoreResult | void>;
+}
+export interface CreateCanvasProductEditorOptions {
+    editorPlugins: readonly LandEditorPlugin[];
+    resolveAssetUrl?: (assetId: AssetId) => string | null;
+}
+export interface CanvasProductRuntimeInitializerContext<TPluginHostRuntime extends ProductPluginHostRuntime = ProductPluginHostRuntime> {
+    productId: string;
+    featureControllers: ProductFeatureControllerRegistryRuntime;
+    editor: Editor;
+    pluginHostRuntime: TPluginHostRuntime;
+    services: ProductServiceRegistry;
+}
+export type CanvasProductRuntimeInitializer<TPluginHostRuntime extends ProductPluginHostRuntime = ProductPluginHostRuntime> = (context: CanvasProductRuntimeInitializerContext<TPluginHostRuntime>) => void;

package/core/runtime/productEditor.d.ts

@@ -0,0 +1,3 @@
+import { type Editor } from "../../_vendor/canvas-core/index";
+import type { CreateCanvasProductEditorOptions } from "./productDefinition";
+export declare function createDefaultCanvasProductEditor(options: CreateCanvasProductEditorOptions): Editor;

package/core/runtime/productHost.d.ts

@@ -0,0 +1,17 @@
+import type { ContextMenuContribution, CanvasAction, ToolbarContribution } from "../../_vendor/canvas-core/index";
+export interface ProductToolbarRegistry {
+    registerAction(action: CanvasAction): void;
+    registerHostAction(action: CanvasAction): void;
+    registerContribution(contribution: ToolbarContribution): void;
+    getAction(actionId: string): CanvasAction | null;
+    getDuplicateActionIds(): string[];
+    getDuplicateContributionIds(): string[];
+}
+export interface ProductContextMenuRegistry {
+    registerContribution(contribution: ContextMenuContribution): void;
+    getDuplicateContributionIds(): string[];
+}
+export interface ProductPluginHostRuntime {
+    toolbarRegistry: ProductToolbarRegistry;
+    contextMenuRegistry: ProductContextMenuRegistry;
+}

package/{_vendor/canvas-product-react → core}/runtime/productServices.d.ts

@@ -1,4 +1,4 @@
-import type { AssetId, Editor } from "../../canvas-core/index";
+import type { AssetId, Editor } from "../../_vendor/canvas-core/index";
 export interface ProductServiceToken<TService> {
     readonly id: string;
     readonly __service?: TService;
@@ -15,7 +15,6 @@ export interface ProductServiceRegistry {
     get<TService>(token: ProductServiceToken<TService>): TService | null;
 }
 export interface ProductServiceRegistryRuntime extends ProductServiceRegistry {
-    register<TService>(factory: ProductServiceFactory<TService>, context: ProductServiceFactoryContext): TService;
     dispose(): void;
 }
 export interface ProductAssetResolverService {

package/{_vendor/plugin-image-product-react → features/image}/ImageImportController.d.ts

@@ -1,9 +1,9 @@
-import type { Editor } from "../canvas-core/index";
+import type { Editor } from "../../_vendor/canvas-core/index";
 import type { ImageAssetService } from "./imageAssetService";
 import type { ImageToolbarHostBridge } from "./imageToolbarHostBridge";
 export declare const ImageImportController: import("react").NamedExoticComponent<{
     editor: Editor;
     hostBridge?: ImageToolbarHostBridge;
     imageAssetService: ImageAssetService;
-    persistEditorSnapshot?: (editor: Editor) => Promise<void>;
+    flushSnapshot?: (editor: Editor) => Promise<void>;
 }>;

package/{_vendor/plugin-image-product-react → features/image}/imageAssetService.d.ts

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

package/{_vendor/plugin-image-product-react → features/image}/imageBlobStore.d.ts

@@ -1,4 +1,4 @@
-import type { AssetId, Editor } from "../canvas-core/index";
+import type { AssetId, Editor } from "../../_vendor/canvas-core/index";
 export interface ImageBlobWriteResult {
     storageKey: string;
 }

package/features/image/imageFileHelpers.d.ts

@@ -0,0 +1,35 @@
+import type { Editor } from "../../_vendor/canvas-core/index";
+import { isEditableEventTarget } from "../../_vendor/canvas-react/index";
+export { isEditableEventTarget };
+export interface LocalImageAssetInput {
+    name: string;
+    storageKey: string;
+    mimeType: string;
+    fileSize: number;
+    width: number;
+    height: number;
+}
+export declare function decodeImageSize(src: string): Promise<{
+    width: number;
+    height: number;
+}>;
+export declare function getLocalImageAssetInput(file: File): Promise<LocalImageAssetInput>;
+export declare function fitLocalImageSize({ height, width, }: {
+    height: number;
+    width: number;
+}): {
+    w: number;
+    h: number;
+};
+export declare function getFirstImageFile(files: Iterable<File>): File | null;
+export declare function getFirstImageFileFromDataTransfer(dataTransfer: DataTransfer | null): File | null;
+export declare function hasImageFileItem(dataTransfer: DataTransfer | null): boolean;
+export declare function getDropPagePoint(editor: Editor, event: DragEvent): import("../../_vendor/canvas-core/index").Vec;
+export declare function downloadObjectUrl({ filename, url, }: {
+    filename: string;
+    url: string;
+}): void;
+export declare function downloadBlob({ blob, filename, }: {
+    blob: Blob;
+    filename: string;
+}): Promise<void>;

package/{_vendor/plugin-image-product-react → features/image}/imageHostActions.d.ts

@@ -1,29 +1,30 @@
-import { type Editor, type ShapeId, Vec } from "../canvas-core/index";
-import type { CanvasPluginHostRuntime } from "../canvas-react/host/index";
+import { type Editor, type ShapeId, Vec } from "../../_vendor/canvas-core/index";
+import type { ProductPluginHostRuntime } from "../../core";
 import { type ImageObjectUrlStore } from "./imageBlobStore";
 import type { ImageToolbarHostBridge } from "./imageToolbarHostBridge";
+export { getDropPagePoint, getFirstImageFile, getFirstImageFileFromDataTransfer, hasImageFileItem, isEditableEventTarget, } from "./imageFileHelpers";
 export type ImageImportSource = "file-picker" | "paste" | "drop";
+export interface ImageInsertSize {
+    w: number;
+    h: number;
+}
 export interface InsertImageFileInput {
     editor: Editor;
     file: File;
     imageObjectUrls: ImageObjectUrlStore;
     pagePoint?: Vec;
-    persistEditorSnapshot?: (editor: Editor) => Promise<void>;
+    size?: ImageInsertSize;
+    flushSnapshot?: (editor: Editor) => Promise<void>;
     source: ImageImportSource;
 }
 export interface ReplaceSelectedImageFileInput {
     editor: Editor;
     file: File;
     imageObjectUrls: ImageObjectUrlStore;
-    persistEditorSnapshot?: (editor: Editor) => Promise<void>;
+    flushSnapshot?: (editor: Editor) => Promise<void>;
 }
-export declare function getFirstImageFile(files: Iterable<File>): File | null;
-export declare function getFirstImageFileFromDataTransfer(dataTransfer: DataTransfer | null): File | null;
-export declare function hasImageFileItem(dataTransfer: DataTransfer | null): boolean;
-export declare function isEditableEventTarget(target: EventTarget | null): boolean;
-export declare function getDropPagePoint(editor: Editor, event: DragEvent): Vec;
-export declare function insertImageFileIntoEditor({ editor, file, imageObjectUrls, pagePoint, persistEditorSnapshot, source, }: InsertImageFileInput): Promise<ShapeId | null>;
-export declare function replaceSelectedImageFromFile({ editor, file, imageObjectUrls, persistEditorSnapshot, }: ReplaceSelectedImageFileInput): Promise<void>;
+export declare function insertImageFileIntoEditor({ editor, file, imageObjectUrls, pagePoint, size: requestedSize, flushSnapshot, source, }: InsertImageFileInput): Promise<ShapeId | null>;
+export declare function replaceSelectedImageFromFile({ editor, file, imageObjectUrls, flushSnapshot, }: ReplaceSelectedImageFileInput): Promise<void>;
 export declare function downloadSelectedImageOriginal({ editor, imageObjectUrls, }: {
     editor: Editor;
     imageObjectUrls: ImageObjectUrlStore;
@@ -31,5 +32,5 @@ export declare function downloadSelectedImageOriginal({ editor, imageObjectUrls,
 export declare function registerImageToolbarActions({ hostBridge, imageObjectUrls, pluginHostRuntime, }: {
     hostBridge: ImageToolbarHostBridge;
     imageObjectUrls: ImageObjectUrlStore;
-    pluginHostRuntime: CanvasPluginHostRuntime;
+    pluginHostRuntime: ProductPluginHostRuntime;
 }): void;

package/features/image/imageHostExtension.d.ts

@@ -0,0 +1,5 @@
+import type { ProductPersistenceAdapter } from "../../core";
+import type { CanvasKitHostExtension } from "../../runtime/canvasKitHostExtensions";
+export declare function createImageHostExtension({ flushSnapshot, }: {
+    flushSnapshot?: ProductPersistenceAdapter["flushSnapshot"];
+}): CanvasKitHostExtension;

package/features/image/imageProductController.d.ts

@@ -0,0 +1,22 @@
+import type { Editor, ShapeId, Vec } from "../../_vendor/canvas-core/index";
+import { type CanvasProductRuntimeInitializer } from "../../core";
+import { type ImageImportSource, type ImageInsertSize } from "./imageHostActions";
+export interface ImageInsertInput {
+    file: File;
+    pagePoint?: Vec;
+    size?: ImageInsertSize;
+    source?: ImageImportSource;
+}
+export interface ImageReplaceInput {
+    file: File;
+}
+export interface ImageProductController {
+    insertImage(input: ImageInsertInput): Promise<ShapeId | null>;
+    replaceSelectedImage(input: ImageReplaceInput): Promise<boolean>;
+    downloadSelectedImageOriginal(): Promise<void>;
+}
+export declare const imageProductControllerToken: import("../../core").ProductFeatureControllerToken<ImageProductController>;
+export interface ImageProductControllerRuntimeOptions {
+    flushSnapshot?: (editor: Editor) => Promise<void>;
+}
+export declare function registerImageProductController({ flushSnapshot, }?: ImageProductControllerRuntimeOptions): CanvasProductRuntimeInitializer;

package/features/image/imageProductToolbarActions.d.ts

@@ -0,0 +1,2 @@
+import type { CanvasProductRuntimeInitializerContext } from "../../core";
+export declare function registerImageProductToolbarActions({ pluginHostRuntime, services, }: CanvasProductRuntimeInitializerContext): void;