@yuzhouu/canvas-kit 0.1.2 → 0.1.4

package/core/controller/canvasProductController.d.ts

@@ -0,0 +1,114 @@
+import type { Camera, Editor, LayerOrderDirection, LayerOrderEdge, ReparentShapePlacementFailureReason, ShapeId } from "../../_vendor/canvas-core/index";
+import type { ProductServiceRegistry } from "../runtime/productServices";
+import type { ProductFeatureControllerRegistry } from "./featureControllerRegistry";
+export interface CanvasProductShapeRef {
+    id: ShapeId;
+    type: string;
+}
+export interface CanvasProductSessionPageState {
+    pageId: string;
+    selectedShapeIds: ShapeId[];
+    camera: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+export interface CanvasProductSessionSnapshot<TToolId extends string = string> {
+    currentPageId: string;
+    activeToolId: TToolId;
+    isToolLocked: boolean;
+    pages: CanvasProductSessionPageState[];
+}
+export interface CanvasProductControllerSnapshot<TToolId extends string = string> {
+    productId: string;
+    pageId: string;
+    activeToolId: TToolId;
+    selectedShapeIds: ShapeId[];
+    shapeCount: number;
+    session: CanvasProductSessionSnapshot<TToolId>;
+}
+export interface CanvasProductLayerNode {
+    id: ShapeId;
+    parentId: string;
+    pageId: string;
+    type: string;
+    childIds: ShapeId[];
+    siblingIndex: number;
+    depth: number;
+    displayName: string;
+    canReceiveChildren: boolean;
+    isHidden: boolean;
+    isLocked: boolean;
+    isEffectivelyHidden: boolean;
+    isEffectivelyLocked: boolean;
+}
+export interface CanvasProductLayerPlacement {
+    parentId: string;
+    beforeId?: ShapeId;
+}
+export type CanvasProductLayerPlacementFailureReason = ReparentShapePlacementFailureReason;
+export type CanvasProductLayerPlacementResult = {
+    ok: true;
+    movedIds: ShapeId[];
+} | {
+    ok: false;
+    reason: CanvasProductLayerPlacementFailureReason;
+};
+export interface CanvasProductLayerActionState {
+    canGroup: boolean;
+    canUngroup: boolean;
+    canMoveBackward: boolean;
+    canMoveForward: boolean;
+}
+export interface CanvasProductPageRef {
+    id: string;
+    name: string;
+    index: string;
+}
+export interface CanvasProductController<TToolId extends string = string> {
+    features: ProductFeatureControllerRegistry;
+    snapshot(): CanvasProductControllerSnapshot<TToolId>;
+    clearHistory(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    select(ids: ShapeId[]): void;
+    selectAll(): void;
+    deleteSelection(): void;
+    deleteShapes(ids: ShapeId[]): void;
+    duplicateSelection(): ShapeId[];
+    centerOnShape(id: ShapeId): boolean;
+    getLayerTree(pageId?: string): CanvasProductLayerNode[];
+    getLayerNode(id: ShapeId): CanvasProductLayerNode | null;
+    setShapesHidden(ids: ShapeId[], isHidden: boolean): ShapeId[];
+    setShapesLocked(ids: ShapeId[], isLocked: boolean): ShapeId[];
+    groupShapes(ids: ShapeId[]): ShapeId | null;
+    ungroupShapes(ids: ShapeId[]): ShapeId[];
+    moveShapesInParentOrder(ids: ShapeId[], direction: LayerOrderDirection): boolean;
+    moveShapesToParentOrderEdge(ids: ShapeId[], edge: LayerOrderEdge): boolean;
+    moveShapesToLayerPlacement(ids: ShapeId[], placement: CanvasProductLayerPlacement): CanvasProductLayerPlacementResult;
+    getLayerActionState(ids: ShapeId[]): CanvasProductLayerActionState;
+    setTool(toolId: TToolId): void;
+    setCamera(camera: Partial<Camera>, pageId?: string): void;
+    resetView(): void;
+    getPages(): CanvasProductPageRef[];
+    createPage(name?: string): CanvasProductPageRef;
+    renamePage(pageId: string, name: string): void;
+    deletePage(pageId: string): boolean;
+    selectPage(pageId: string): void;
+    exportSelectionSvg(): string | null;
+    exportPageSvg(): string | null;
+}
+export interface CanvasProductControllerContext {
+    editor: Editor;
+    services: ProductServiceRegistry;
+    pluginHostRuntime: unknown;
+    featureControllers: ProductFeatureControllerRegistry;
+    productId: string;
+}
+export interface CanvasProductControllerOptions<TToolId extends string = string> extends CanvasProductControllerContext {
+    assertToolId: (toolId: string) => asserts toolId is TToolId;
+}
+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/core/features/clipboard/clipboardService.d.ts

@@ -0,0 +1,10 @@
+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/core/features/export/svgExport.d.ts

@@ -0,0 +1,33 @@
+import type { Editor, ExportIntegrityReport, ShapeCapabilityManifest, ShapeId, SvgExportSkippedShape, SvgThemeColorResolver } from "../../../_vendor/canvas-core/index";
+export interface SvgAssetInliner {
+    inline(input: {
+        editor: Editor;
+        exportedShapeIds: readonly ShapeId[];
+        svg: string;
+    }): Promise<string>;
+}
+export type ExportStatus = {
+    tone: "success" | "warning" | "error";
+    title: string;
+    details: string;
+    integrity: ExportIntegrityReport;
+    capabilityManifest: ShapeCapabilityManifest;
+};
+export interface SvgExportResult {
+    status: ExportStatus;
+    svg: string | null;
+    exportedShapeIds: readonly ShapeId[];
+    skippedShapes: readonly SvgExportSkippedShape[];
+}
+export interface SvgExportOptions {
+    assetInliners?: readonly SvgAssetInliner[];
+    editor: Editor;
+    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/core/runtime/productServices.d.ts

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

package/features/image/ImageImportController.d.ts

@@ -0,0 +1,9 @@
+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;
+    flushSnapshot?: (editor: Editor) => Promise<void>;
+}>;

package/features/image/imageAssetService.d.ts

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

package/features/image/imageBlobStore.d.ts

@@ -0,0 +1,25 @@
+import type { AssetId, Editor } from "../../_vendor/canvas-core/index";
+export interface ImageBlobWriteResult {
+    storageKey: string;
+}
+export interface ImageObjectUrlStore {
+    preloadForEditor(editor: Editor): Promise<void>;
+    preload(storageKey: string): Promise<string | null>;
+    resolve(storageKey: string): string | null;
+    resolveAssetUrl(editor: Editor, assetId: AssetId): string | null;
+    release(storageKey: string): void;
+    releaseAll(): void;
+}
+export declare function createImageStorageKey(): string;
+export declare function writeImageBlob(blob: Blob): Promise<ImageBlobWriteResult>;
+export declare function readImageBlob(storageKey: string): Promise<Blob | null>;
+export declare function readImageBlobAsDataUrl(storageKey: string): Promise<string | null>;
+export declare function deleteImageBlob(storageKey: string): Promise<void>;
+export declare function getAllImageBlobStorageKeys(): Promise<string[]>;
+export declare function getImageAssetStorageKey(editor: Editor, assetId: AssetId): string | null;
+export declare function getReferencedImageStorageKeys(editor: Editor): Set<string>;
+export declare function cleanupUnreferencedImageBlobs({ editor, objectUrls, }: {
+    editor: Editor;
+    objectUrls?: ImageObjectUrlStore;
+}): Promise<string[]>;
+export declare function createImageObjectUrlStore(): ImageObjectUrlStore;

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/features/image/imageHostActions.d.ts

@@ -0,0 +1,36 @@
+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;
+    size?: ImageInsertSize;
+    flushSnapshot?: (editor: Editor) => Promise<void>;
+    source: ImageImportSource;
+}
+export interface ReplaceSelectedImageFileInput {
+    editor: Editor;
+    file: File;
+    imageObjectUrls: ImageObjectUrlStore;
+    flushSnapshot?: (editor: Editor) => 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;
+}): Promise<void>;
+export declare function registerImageToolbarActions({ hostBridge, imageObjectUrls, pluginHostRuntime, }: {
+    hostBridge: ImageToolbarHostBridge;
+    imageObjectUrls: ImageObjectUrlStore;
+    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;