@yuzhouu/canvas-kit 0.1.3 → 0.1.5

package/builtins/controller/shapeCreationController.d.ts

@@ -0,0 +1,76 @@
+import type { Editor, ShapeColor, ShapeId } from "../../_vendor/canvas-core/index";
+import { type ArrowShapeProps } from "../../_vendor/plugin-arrow/index";
+import { type TextShapeProps } from "../../_vendor/plugin-text/index";
+import type { CanvasProductShapeRef } from "../../core/controller";
+export interface BuiltInCanvasShapeInput {
+    x: number;
+    y: number;
+    w?: number;
+    h?: number;
+    fill?: ShapeColor;
+    stroke?: ShapeColor;
+    strokeWidth?: number;
+}
+export interface BuiltInCanvasTextInput {
+    x: number;
+    y: number;
+    text: string;
+    w?: number;
+    h?: number;
+    font?: TextShapeProps["font"];
+    color?: ShapeColor;
+    size?: TextShapeProps["size"];
+    textAlign?: TextShapeProps["textAlign"];
+}
+export interface BuiltInCanvasFrameInput extends BuiltInCanvasShapeInput {
+    name?: string;
+}
+export interface BuiltInCanvasArrowBindingInput {
+    targetShapeId: ShapeId;
+    normalizedAnchor: {
+        x: number;
+        y: number;
+    };
+}
+export interface BuiltInCanvasArrowInput {
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+    bend?: number;
+    stroke?: ShapeColor;
+    strokeWidth?: number;
+    headStart?: ArrowShapeProps["headStart"];
+    headEnd?: ArrowShapeProps["headEnd"];
+    startBinding?: BuiltInCanvasArrowBindingInput | null;
+    endBinding?: BuiltInCanvasArrowBindingInput | null;
+}
+export interface BuiltInGeoController {
+    createRectangle(input: BuiltInCanvasShapeInput): CanvasProductShapeRef | null;
+    createEllipse(input: BuiltInCanvasShapeInput): CanvasProductShapeRef | null;
+    createDiamond(input: BuiltInCanvasShapeInput): CanvasProductShapeRef | null;
+    createTriangle(input: BuiltInCanvasShapeInput): CanvasProductShapeRef | null;
+    createHexagon(input: BuiltInCanvasShapeInput): CanvasProductShapeRef | null;
+    createStar(input: BuiltInCanvasShapeInput): CanvasProductShapeRef | null;
+}
+export interface BuiltInTextController {
+    create(input: BuiltInCanvasTextInput): CanvasProductShapeRef | null;
+}
+export interface BuiltInFrameController {
+    create(input: BuiltInCanvasFrameInput): CanvasProductShapeRef | null;
+    moveShapesToFrame(ids: ShapeId[], frameId: ShapeId): ShapeId[];
+}
+export interface BuiltInArrowController {
+    create(input: BuiltInCanvasArrowInput): CanvasProductShapeRef | null;
+}
+export interface BuiltInCanvasShapeCreationControllers {
+    arrow: BuiltInArrowController;
+    geo: BuiltInGeoController;
+    text: BuiltInTextController;
+    frame: BuiltInFrameController;
+}
+export declare function createBuiltInShapeCreationControllers(editor: Editor): BuiltInCanvasShapeCreationControllers;

package/builtins/extensions.d.ts

@@ -0,0 +1,17 @@
+import type { LandExtensionOptionsInput } from "../_vendor/canvas-react/host/index";
+import { type TextExtensionOptions } from "../_vendor/plugin-text/index";
+export interface BuiltInCanvasExtensionOptions {
+    arrow?: boolean;
+    draw?: boolean;
+    eraser?: boolean;
+    frame?: boolean;
+    geo?: boolean;
+    group?: boolean;
+    image?: boolean;
+    laser?: boolean;
+    text?: boolean | LandExtensionOptionsInput<TextExtensionOptions>;
+}
+export declare const builtInCanvasExtensions: readonly [import("../_vendor/canvas-react/host/index").ConfigurableLandExtension<Record<string, never>>, import("../_vendor/canvas-react/host/index").ConfigurableLandExtension<Record<string, never>>, import("../_vendor/canvas-react/host/index").ConfigurableLandExtension<Record<string, never>>, import("../_vendor/canvas-react/host/index").ConfigurableLandExtension<Record<string, never>>, import("../_vendor/canvas-react/host/index").ConfigurableLandExtension<Record<string, never>>, import("../_vendor/canvas-react/host/index").ConfigurableLandExtension<Record<string, never>>, import("../_vendor/canvas-react/host/index").ConfigurableLandExtension<TextExtensionOptions>, import("../_vendor/canvas-react/host/index").ConfigurableLandExtension<Record<string, never>>, import("../_vendor/canvas-react/host/index").ConfigurableLandExtension<Record<string, never>>];
+export type BuiltInCanvasExtension = (typeof builtInCanvasExtensions)[number];
+export declare function createBuiltInCanvasExtensions(options?: BuiltInCanvasExtensionOptions): readonly BuiltInCanvasExtension[];
+export declare function hasBuiltInCanvasExtension(extensions: readonly BuiltInCanvasExtension[], name: keyof BuiltInCanvasExtensionOptions): boolean;

package/builtins/index.d.ts

@@ -0,0 +1,5 @@
+export { builtInCanvasExtensions, createBuiltInCanvasExtensions, hasBuiltInCanvasExtension, } from "./extensions";
+export type { BuiltInCanvasExtension, BuiltInCanvasExtensionOptions, } from "./extensions";
+export { createBuiltInCanvasController, useBuiltInCanvasController, } from "./controller/createBuiltInCanvasController";
+export type { BuiltInCanvasController, BuiltInCanvasControllerSnapshot, BuiltInCanvasLayerNode, } from "./controller/createBuiltInCanvasController";
+export type { BuiltInArrowController, BuiltInCanvasArrowBindingInput, BuiltInCanvasArrowInput, BuiltInCanvasFrameInput, BuiltInCanvasShapeCreationControllers, BuiltInCanvasShapeInput, BuiltInCanvasTextInput, BuiltInFrameController, BuiltInGeoController, BuiltInTextController, } from "./controller/shapeCreationController";

package/chrome/CanvasKitFloatingToolbarLayer.d.ts

@@ -0,0 +1,6 @@
+import type { ReactNode } from "react";
+export declare function CanvasKitFloatingToolbarLayer({ children, className, dataUi, }: {
+    children: ReactNode;
+    className?: string;
+    dataUi?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/chrome/FloatingSelectionToolbarPageSpace.d.ts

@@ -0,0 +1,9 @@
+import { type ReactNode } from "react";
+import type { ToolbarSurfaces } from "./bindings/useToolbarSurfaces";
+export declare function FloatingSelectionToolbarPageSpace({ children, className, dataUi, offset, surfaces, }: {
+    children: ReactNode;
+    className?: string;
+    dataUi?: string;
+    offset?: number;
+    surfaces: ToolbarSurfaces;
+}): import("react/jsx-runtime").JSX.Element | null;

package/chrome/bindings/useCanvasKitChromeControls.d.ts

@@ -0,0 +1,27 @@
+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/chrome/bindings/useContextMenuSurface.d.ts

@@ -0,0 +1,12 @@
+import type { ContextMenuContext, ActiveContextMenu, ContextMenuSection, Editor } from "../../_vendor/canvas-core/index";
+import type { CanvasPluginHostRuntime } from "../../_vendor/canvas-react/host/index";
+export interface ContextMenuSurface {
+    context: ContextMenuContext | null;
+    activeContextMenu: ActiveContextMenu | null;
+    sections: readonly ContextMenuSection[];
+}
+export declare function useContextMenuSurface({ editor, activeContextMenu, pluginHostRuntime, }: {
+    editor: Editor;
+    activeContextMenu: ActiveContextMenu | null;
+    pluginHostRuntime: CanvasPluginHostRuntime;
+}): ContextMenuSurface;

package/chrome/bindings/useSvgExport.d.ts

@@ -0,0 +1,15 @@
+import { type RefObject } from "react";
+import type { Editor, ShapeId } from "../../_vendor/canvas-core/index";
+import { type ExportStatus as ProductExportStatus, type SvgAssetInliner as ProductSvgAssetInliner, type SvgExportResult as ProductSvgExportResult } from "../../core";
+export type ExportStatus = ProductExportStatus;
+export type SvgAssetInliner = ProductSvgAssetInliner;
+export type SvgExportResult = ProductSvgExportResult;
+export interface SvgExportControls {
+    status: ExportStatus | null;
+    exportSvg(shapeIds: readonly ShapeId[]): Promise<SvgExportResult>;
+}
+export declare function useSvgExport({ assetInliners, editor, themeRootRef, }: {
+    assetInliners?: readonly SvgAssetInliner[];
+    editor: Editor;
+    themeRootRef?: RefObject<HTMLElement | null>;
+}): SvgExportControls;

package/chrome/bindings/useToolbarSurfaces.d.ts

@@ -0,0 +1,26 @@
+import type { Editor, CanvasActionContext, ToolbarGroup } from "../../_vendor/canvas-core/index";
+import type { CanvasPluginHostRuntime } from "../../_vendor/canvas-react/host/index";
+export interface FloatingSelectionToolbarPageAnchor {
+    x: number;
+    y: number;
+}
+export interface ToolbarSurfaces {
+    context: CanvasActionContext;
+    activeToolId: string;
+    activeToolLabel: string;
+    isToolLocked: boolean;
+    selectionCount: number;
+    hasMixedSelectionRotation: boolean;
+    toolChromeToolbarGroups: readonly ToolbarGroup[];
+    contextToolbarGroups: readonly ToolbarGroup[];
+    floatingSelectionToolbarGroups: readonly ToolbarGroup[];
+    floatingSelectionToolbarPageAnchor: FloatingSelectionToolbarPageAnchor | null;
+    contextToolbarTitle: string;
+    showContextToolbar: boolean;
+    showFloatingSelectionToolbar: boolean;
+}
+export declare function useToolbarSurfaces({ canShowContextToolbarDuringEditing, editor, pluginHostRuntime, }: {
+    canShowContextToolbarDuringEditing?: (context: CanvasActionContext) => boolean;
+    editor: Editor;
+    pluginHostRuntime: CanvasPluginHostRuntime;
+}): ToolbarSurfaces;

package/chrome/types.d.ts

@@ -0,0 +1,66 @@
+import type { CanvasKitController, CanvasKitBaseController } from "../controller/canvasKitController";
+import type { BuiltInCanvasLayerNode } from "../builtins";
+import type { ActiveContextMenu, EditorSelectionState, ShapeId, CanvasActionValue, CanvasActionContext } from "../_vendor/canvas-core/index";
+import type { HistoryControls, PageControls, ZoomControlsState } from "./bindings/useCanvasKitChromeControls";
+import type { ContextMenuSurface } from "./bindings/useContextMenuSurface";
+import type { SvgExportControls } from "./bindings/useSvgExport";
+import type { ToolbarSurfaces } from "./bindings/useToolbarSurfaces";
+import type { ProductPersistenceStatus } from "../core";
+export type { ContextMenuCommandItem, ContextMenuItem, ContextMenuSection, EditorSelectionState, ShapeId, CanvasActionValue, CanvasActionContext, ToolbarGroup, ToolbarItem, } from "../_vendor/canvas-core/index";
+export type { HistoryControls, PageControls, ZoomControlsState, } from "./bindings/useCanvasKitChromeControls";
+export type { ContextMenuSurface } from "./bindings/useContextMenuSurface";
+export type { SvgExportControls, } from "./bindings/useSvgExport";
+export type { ToolbarSurfaces, } from "./bindings/useToolbarSurfaces";
+export type CanvasKitLayerNode = BuiltInCanvasLayerNode;
+export interface CanvasKitToolbarActionState {
+    value: CanvasActionValue | undefined;
+    isEnabled: boolean;
+    isVisible: boolean;
+}
+export interface CanvasKitToolbarRuntime {
+    getActionState(input: {
+        actionId: string;
+        context: CanvasActionContext;
+    }): CanvasKitToolbarActionState | null;
+    runAction(input: {
+        actionId: string;
+        context: CanvasActionContext;
+        value?: CanvasActionValue;
+    }): void;
+}
+export interface CanvasKitGridControls {
+    isVisible: boolean;
+    setIsVisible(isVisible: boolean): void;
+}
+export interface CanvasKitPersistenceControls {
+    discardUnsupportedRecords: (() => Promise<void>) | null;
+    isDiscardingUnsupportedRecords: boolean;
+    status: ProductPersistenceStatus | null;
+}
+export interface CanvasKitChromeContext<TController extends CanvasKitBaseController = CanvasKitController> {
+    controller: TController;
+    contextMenu: CanvasKitContextMenuState;
+    currentPageId: string;
+    currentPageShapeIds: readonly ShapeId[];
+    history: HistoryControls;
+    layers: readonly BuiltInCanvasLayerNode[];
+    pages: PageControls;
+    selection: EditorSelectionState;
+    selectedShapeIds: readonly ShapeId[];
+    persistence: CanvasKitPersistenceControls;
+    svgExport: SvgExportControls;
+    toolbarRuntime: CanvasKitToolbarRuntime;
+    toolbarSurfaces: ToolbarSurfaces;
+    grid: CanvasKitGridControls;
+    zoom: ZoomControlsState;
+}
+export interface CanvasKitContextMenuState {
+    activeContextMenu: ActiveContextMenu | null;
+    onActiveContextMenuChange: (activeContextMenu: ActiveContextMenu | null) => void;
+    runAction(input: {
+        actionId: string;
+        context: NonNullable<ContextMenuSurface["context"]>;
+        value?: CanvasActionValue;
+    }): void;
+    surface: ContextMenuSurface;
+}

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";