@yuzhouu/canvas-kit 0.1.9 → 0.1.11

package/_vendor/canvas-plugin-sdk/chrome.d.ts

@@ -0,0 +1,52 @@
+import type { CanvasActionContext, CanvasActionValue } from "./actions";
+import type { Editor } from "../canvas-core/index";
+export interface ChromeChannel<TId extends string = string> {
+    readonly id: TId;
+}
+export declare function createChromeChannel<const TId extends string>(id: TId): ChromeChannel<TId>;
+export declare const chromeChannels: {
+    readonly mainMenu: ChromeChannel<"land.chrome.main-menu">;
+    readonly commandPalette: ChromeChannel<"land.chrome.command-palette">;
+    readonly inspector: ChromeChannel<"land.chrome.inspector">;
+    readonly status: ChromeChannel<"land.chrome.status">;
+};
+export type ChromeItem = {
+    kind: "command";
+    id: string;
+    actionId: string;
+    label: string;
+    icon?: string;
+    value?: CanvasActionValue;
+    shortcut?: string;
+    tone?: "default" | "destructive";
+    dataUi?: string;
+} | {
+    kind: "separator";
+    id: string;
+} | {
+    kind: "badge";
+    id: string;
+    label: string;
+    dataUi?: string;
+};
+export type ChromeCommandItem = Extract<ChromeItem, {
+    kind: "command";
+}>;
+export interface ChromeSection {
+    id: string;
+    order?: number;
+    title?: string;
+    items: readonly ChromeItem[];
+}
+export interface ChromeContribution {
+    id: string;
+    channel: ChromeChannel;
+    order?: number;
+    actionIds: readonly string[];
+    subscribe?(editor: Editor, listener: () => void): () => void;
+    when?(context: CanvasActionContext): boolean;
+    getSections(context: CanvasActionContext): readonly ChromeSection[];
+}
+export interface CanvasPluginChromeSetup {
+    add(...contributions: readonly ChromeContribution[]): void;
+}

package/_vendor/canvas-plugin-sdk/chromeRegistry.d.ts

@@ -0,0 +1,15 @@
+import type { Editor } from "../canvas-core/index";
+import type { CanvasActionContext } from "./actions";
+import type { ChromeChannel, ChromeContribution, ChromeSection } from "./chrome";
+export declare class CanvasChromeRegistry {
+    private readonly contributions;
+    private readonly channels;
+    private readonly contributionsByChannel;
+    private stateRevision;
+    constructor(contributions?: readonly ChromeContribution[]);
+    getChannels(): readonly ChromeChannel[];
+    getStateRevision(): number;
+    subscribeToState(editor: Editor, listener: () => void): () => void;
+    getSections(channel: ChromeChannel, context: CanvasActionContext): ChromeSection[];
+}
+export declare function createCanvasChromeRegistry(contributions?: readonly ChromeContribution[]): CanvasChromeRegistry;

package/_vendor/{canvas-core/surfaces → canvas-plugin-sdk}/contextMenu.d.ts

@@ -1,32 +1,12 @@
-import type { Vec } from "../geometry";
-import type { ShapeId, ShapeRecordBase } from "../schema/records";
+import type { CanvasContextMenuRequest, CanvasContextMenuTarget } from "../canvas-react/index";
 import type { CanvasActionContext, CanvasActionValue } from "./actions";
-export interface ContextMenuCanvasTarget {
-    type: "canvas";
-}
-export interface ContextMenuShapeTarget {
-    type: "shape";
-    shapeId: ShapeId;
-    shapeType: ShapeRecordBase["type"];
-    selected: boolean;
-}
-export interface ContextMenuSelectionTarget {
-    type: "selection";
-    selectedShapeIds: readonly ShapeId[];
-}
-export type ContextMenuTarget = ContextMenuCanvasTarget | ContextMenuShapeTarget | ContextMenuSelectionTarget;
-export interface ActiveContextMenu {
-    anchor: {
-        screenPoint: Vec;
-        pagePoint: Vec;
-    };
-    target: ContextMenuTarget;
-}
+export type ContextMenuTarget = CanvasContextMenuTarget;
+export type ActiveContextMenu = CanvasContextMenuRequest;
 export interface ContextMenuContext extends CanvasActionContext {
     menu: ActiveContextMenu;
 }
 export type ContextMenuContributionTarget = "canvas" | "selection" | "shape" | "any";
-export interface ContextMenuCommandItem {
+export type ContextMenuItem = {
     kind: "command";
     id: string;
     actionId: string;
@@ -36,18 +16,33 @@ export interface ContextMenuCommandItem {
     shortcut?: string;
     tone?: "default" | "destructive";
     dataUi?: string;
-}
-export interface ContextMenuSeparatorItem {
+} | {
     kind: "separator";
     id: string;
-}
-export interface ContextMenuBadgeItem {
+} | {
     kind: "badge";
     id: string;
     label: string;
     dataUi?: string;
-}
-export type ContextMenuItem = ContextMenuCommandItem | ContextMenuSeparatorItem | ContextMenuBadgeItem;
+};
+export type ContextMenuCommandItem = Extract<ContextMenuItem, {
+    kind: "command";
+}>;
+export type ContextMenuSeparatorItem = Extract<ContextMenuItem, {
+    kind: "separator";
+}>;
+export type ContextMenuBadgeItem = Extract<ContextMenuItem, {
+    kind: "badge";
+}>;
+export type ContextMenuCanvasTarget = Extract<ContextMenuTarget, {
+    type: "canvas";
+}>;
+export type ContextMenuShapeTarget = Extract<ContextMenuTarget, {
+    type: "shape";
+}>;
+export type ContextMenuSelectionTarget = Extract<ContextMenuTarget, {
+    type: "selection";
+}>;
 export interface ContextMenuSection {
     id: string;
     order?: number;

package/_vendor/canvas-plugin-sdk/contextMenuRegistry.d.ts

@@ -0,0 +1,11 @@
+import type { ContextMenuContext, ContextMenuContribution, ContextMenuContributionTarget, ContextMenuSection } from "./contextMenu";
+export declare class CanvasContextMenuRegistry {
+    private readonly contributions;
+    private readonly contributionsByTarget;
+    private readonly contributionIndexes;
+    private nextContributionIndex;
+    registerContribution(contribution: ContextMenuContribution): void;
+    getSections(target: ContextMenuContributionTarget, context: ContextMenuContext): ContextMenuSection[];
+    private addToIndex;
+}
+export declare function createCanvasContextMenuRegistry(contributions?: readonly ContextMenuContribution[]): CanvasContextMenuRegistry;

package/_vendor/canvas-plugin-sdk/exportRegistry.d.ts

@@ -0,0 +1,9 @@
+import type { CanvasExportArtifact, CanvasExportContribution, CanvasExportFormat, CanvasExportProviderInput } from "./exports";
+export declare class CanvasExportRegistry {
+    private readonly contributionsByFormat;
+    constructor(contributions?: readonly CanvasExportContribution[]);
+    getFormats(): readonly CanvasExportFormat[];
+    hasFormat(format: string): boolean;
+    export(format: string, input: CanvasExportProviderInput): Promise<CanvasExportArtifact>;
+}
+export declare function createCanvasExportRegistry(contributions?: readonly CanvasExportContribution[]): CanvasExportRegistry;

package/_vendor/canvas-plugin-sdk/exports.d.ts

@@ -0,0 +1,26 @@
+import type { Editor, ShapeId } from "../canvas-core/index";
+export interface CanvasExportFormat {
+    format: string;
+    label: string;
+    mimeType: string;
+    fileExtension: string;
+}
+export interface CanvasExportProviderInput {
+    editor: Editor;
+    shapeIds: readonly ShapeId[];
+    options?: unknown;
+}
+export interface CanvasExportPayload {
+    data: Blob | string | Uint8Array | null;
+    result?: unknown;
+    status?: unknown;
+}
+export interface CanvasExportArtifact extends CanvasExportFormat, CanvasExportPayload {
+}
+export interface CanvasExportContribution extends CanvasExportFormat {
+    id: string;
+    export(input: CanvasExportProviderInput): CanvasExportPayload | Promise<CanvasExportPayload>;
+}
+export interface CanvasPluginExportSetup {
+    add(...contributions: readonly CanvasExportContribution[]): void;
+}

package/_vendor/canvas-plugin-sdk/importRegistry.d.ts

@@ -0,0 +1,10 @@
+import type { CanvasImportContext, CanvasImportContribution, CanvasImportPreview, CanvasImportRequest, CanvasImportResult } from "./imports";
+export declare class CanvasImportRegistry {
+    private readonly contributions;
+    constructor(contributions?: readonly CanvasImportContribution[]);
+    getContributions(): readonly CanvasImportContribution[];
+    canImport(request: CanvasImportRequest): boolean;
+    canImportPreview(preview: CanvasImportPreview): boolean;
+    import(request: CanvasImportRequest, context: CanvasImportContext): Promise<CanvasImportResult>;
+}
+export declare function createCanvasImportRegistry(contributions?: readonly CanvasImportContribution[]): CanvasImportRegistry;

package/_vendor/canvas-plugin-sdk/imports.d.ts

@@ -0,0 +1,38 @@
+import type { Editor, Vec } from "../canvas-core/index";
+export type CanvasImportSource = "clipboard" | "drop" | "file-picker";
+export interface CanvasImportRequest {
+    source: CanvasImportSource;
+    files: readonly File[];
+    text?: string;
+    html?: string;
+    urls?: readonly string[];
+    pagePoint?: Vec;
+}
+export interface CanvasImportPreview {
+    source: "drop";
+    dataTypes: readonly string[];
+    fileTypes: readonly string[];
+}
+export type CanvasImportResult = "handled" | "ignored";
+export interface CanvasImportContext {
+    editor: Editor;
+}
+export interface CanvasImportContribution {
+    id: string;
+    order?: number;
+    /**
+     * A synchronous, payload-free check used during dragover, when browsers may
+     * hide file and URL values until drop.
+     */
+    acceptsPreview?(preview: CanvasImportPreview): boolean;
+    /**
+     * Returning true claims the native paste/drop event. If import() later
+     * returns ignored, later contributions may run, but browser default handling
+     * remains suppressed for that claimed event.
+     */
+    accepts(request: CanvasImportRequest): boolean;
+    import(request: CanvasImportRequest, context: CanvasImportContext): CanvasImportResult | Promise<CanvasImportResult>;
+}
+export interface CanvasPluginImportSetup {
+    add(...contributions: readonly CanvasImportContribution[]): void;
+}

package/_vendor/canvas-plugin-sdk/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./actions";
+export * from "./actionRegistry";
+export * from "./capability";
+export * from "./chrome";
+export * from "./chromeRegistry";
+export * from "./contextMenu";
+export * from "./contextMenuRegistry";
+export * from "./exports";
+export * from "./exportRegistry";
+export * from "./imports";
+export * from "./importRegistry";
+export * from "./lifecycle";
+export * from "./plugin";
+export * from "./pluginUi";
+export * from "./productApi";
+export * from "./services";
+export * from "./toolbar";
+export * from "./toolbarRegistry";

package/_vendor/canvas-plugin-sdk/lifecycle.d.ts

@@ -0,0 +1,31 @@
+import type { Editor } from "../canvas-core/index";
+import type { CanvasActionContext } from "./actions";
+import type { ProductServiceRegistry } from "./services";
+export interface CanvasPluginPersistence {
+    flush(): Promise<void>;
+}
+export interface CanvasPluginStartupResult {
+    documentSource: "restored" | "seeded" | "empty";
+    sessionRestored: boolean;
+    warnings: readonly unknown[];
+}
+export interface CanvasPluginBeforeReadyContext {
+    editor: Editor;
+    persistence: CanvasPluginPersistence | null;
+    productId: string;
+    signal: AbortSignal;
+    startup: CanvasPluginStartupResult;
+    services: ProductServiceRegistry;
+}
+export interface CanvasPluginBeforeCommandContext {
+    commandId: string;
+    context?: CanvasActionContext;
+    editor: Editor;
+}
+export type CanvasPluginBeforeReady = (context: CanvasPluginBeforeReadyContext) => Promise<void> | void;
+export type CanvasPluginBeforeCommand = (context: CanvasPluginBeforeCommandContext) => void;
+export interface CanvasPluginLifecycleSetup {
+    beforeCommand(hook: CanvasPluginBeforeCommand): void;
+    beforeReady(hook: CanvasPluginBeforeReady): void;
+    defer(dispose: () => void): void;
+}

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

@@ -0,0 +1,76 @@
+import type { EditorPlugin, Editor, KeyboardShortcutInput, ShapeRecordBase } from "../canvas-core/index";
+import type { CanvasRenderPlugin } from "../canvas-react/host/index";
+import type { CanvasAction } from "./actions";
+import type { ContextMenuContribution } from "./contextMenu";
+import type { CanvasPluginChromeSetup } from "./chrome";
+import type { CanvasPluginImportSetup } from "./imports";
+import type { CanvasPluginExportSetup } from "./exports";
+import type { CanvasPluginLifecycleSetup, CanvasPluginPersistence } from "./lifecycle";
+import type { CanvasPluginUiSetup } from "./pluginUi";
+import type { ProductServiceSetup } from "./services";
+import type { ToolbarContribution } from "./toolbar";
+import type { CanvasPluginApi, CanvasPluginApiContext } from "./productApi";
+import { type CanvasPluginCapabilitySetup, type CanvasPluginCapabilityToken } from "./capability";
+export interface CanvasActionShortcut {
+    actionId: string;
+    shortcut: KeyboardShortcutInput;
+}
+export interface CanvasPluginActionSetup {
+    add(...actions: readonly CanvasAction[]): void;
+    addShortcuts(...shortcuts: readonly CanvasActionShortcut[]): void;
+}
+export interface CanvasPluginToolbarSetup {
+    add(...contributions: readonly ToolbarContribution[]): void;
+}
+export interface CanvasPluginContextMenuSetup {
+    add(...contributions: readonly ContextMenuContribution[]): void;
+}
+export interface CanvasPluginApiSetup<TApiContext extends CanvasPluginApiContext = CanvasPluginApiContext> {
+    add<TApi>(api: CanvasPluginApi<TApi, TApiContext>): void;
+}
+export interface CanvasPluginSetupContext<TApiContext extends CanvasPluginApiContext = CanvasPluginApiContext> {
+    readonly actions: CanvasPluginActionSetup;
+    readonly apis: CanvasPluginApiSetup<TApiContext>;
+    readonly capabilities: CanvasPluginCapabilitySetup;
+    readonly chrome: CanvasPluginChromeSetup;
+    readonly contextMenu: CanvasPluginContextMenuSetup;
+    readonly editor: Editor;
+    readonly exports: CanvasPluginExportSetup;
+    readonly imports: CanvasPluginImportSetup;
+    readonly lifecycle: CanvasPluginLifecycleSetup;
+    readonly persistence: CanvasPluginPersistence | null;
+    readonly productId: string;
+    readonly services: ProductServiceSetup;
+    readonly toolbar: CanvasPluginToolbarSetup;
+    readonly ui: CanvasPluginUiSetup;
+}
+export type CanvasPluginSetup<TContext extends CanvasPluginSetupContext = CanvasPluginSetupContext> = (context: TContext) => void;
+type CanvasPluginSetupLike = (context: never) => unknown;
+export interface CanvasPluginReference {
+    readonly id: string;
+    readonly __canvasPluginReferenceBrand: "CanvasPluginReference";
+}
+export type CanvasPluginRequirement = CanvasPluginReference | CanvasPluginCapabilityToken;
+export interface CanvasPluginDefinition<TSetup extends CanvasPluginSetupLike = CanvasPluginSetup> {
+    readonly id: string;
+    readonly provides?: readonly CanvasPluginCapabilityToken[];
+    readonly requires?: readonly CanvasPluginRequirement[];
+    readonly editor?: EditorPlugin;
+    readonly render?: CanvasRenderPlugin;
+    readonly setup?: TSetup;
+}
+export interface CanvasPlugin<TSetup extends CanvasPluginSetupLike = CanvasPluginSetup> extends CanvasPluginDefinition<TSetup>, CanvasPluginReference {
+}
+export type CanvasPluginInput<TSetup extends CanvasPluginSetupLike = CanvasPluginSetup> = CanvasPlugin<TSetup> | readonly CanvasPluginInput<TSetup>[];
+export interface CompiledCanvasPlugins<TSetup extends CanvasPluginSetupLike = CanvasPluginSetup> {
+    readonly plugins: readonly CanvasPlugin<TSetup>[];
+    readonly pluginIds: readonly string[];
+    readonly editorPlugins: readonly EditorPlugin[];
+    readonly renderPlugins: readonly CanvasRenderPlugin[];
+    readonly shapeTypes: readonly ShapeRecordBase["type"][];
+}
+export declare function defineCanvasPlugin<TSetup extends CanvasPluginSetupLike = CanvasPluginSetup>(plugin: CanvasPluginDefinition<TSetup>): CanvasPlugin<TSetup>;
+export declare function compileCanvasPlugins<TSetup extends CanvasPluginSetupLike>(input: readonly CanvasPluginInput<TSetup>[]): CompiledCanvasPlugins<TSetup>;
+export declare function assertValidCanvasPluginGraph<TSetup extends CanvasPluginSetupLike>(input: readonly CanvasPluginInput<TSetup>[]): void;
+export declare function hasCanvasPluginCapabilityProvider<TSetup extends CanvasPluginSetupLike>(input: readonly CanvasPluginInput<TSetup>[], token: CanvasPluginCapabilityToken): boolean;
+export {};

package/_vendor/canvas-plugin-sdk/pluginUi.d.ts

@@ -0,0 +1,37 @@
+import type { Editor } from "../canvas-core/index";
+import type { ComponentType, ReactNode } from "react";
+import type { CanvasActionContext } from "./actions";
+import type { CanvasActionRegistry } from "./actionRegistry";
+import type { CanvasImportRegistry } from "./importRegistry";
+import type { ProductServiceRegistry } from "./services";
+export interface CanvasCommandInput<TResult> {
+    commandId: string;
+    context?: CanvasActionContext;
+    run(): TResult;
+}
+export type ExecuteCanvasCommand = <TResult>(input: CanvasCommandInput<TResult>) => TResult;
+export interface CanvasPluginComponentProps {
+    actionRegistry: CanvasActionRegistry;
+    editor: Editor;
+    executeCommand: ExecuteCanvasCommand;
+    getHostElement(): HTMLElement | null;
+    imports: CanvasImportRegistry;
+    services: ProductServiceRegistry;
+}
+export interface CanvasPluginProvider {
+    id: string;
+    order?: number;
+    component: ComponentType<{
+        children: ReactNode;
+    }>;
+}
+export interface CanvasPluginComponent {
+    id: string;
+    order?: number;
+    component: ComponentType<CanvasPluginComponentProps>;
+}
+export interface CanvasPluginUiSetup {
+    addComponents(...components: readonly CanvasPluginComponent[]): void;
+    addProviders(...providers: readonly CanvasPluginProvider[]): void;
+    allowPropertiesDuringEditing(predicate: (context: CanvasActionContext) => boolean): void;
+}

package/_vendor/canvas-plugin-sdk/productApi.d.ts

@@ -0,0 +1,28 @@
+import type { Editor, ShapeId } from "../canvas-core/index";
+import type { CanvasPluginCapabilityRegistry, CanvasPluginCapabilityToken } from "./capability";
+import type { CanvasExportRegistry } from "./exportRegistry";
+export interface ProductApiToken<TApi> extends CanvasPluginCapabilityToken<TApi, "api"> {
+    readonly __api?: TApi;
+}
+export interface ProductApiRegistry {
+    get<TApi>(token: ProductApiToken<TApi>): TApi | null;
+}
+export interface ProductApiRegistryRuntime extends ProductApiRegistry {
+    register<TApi>(token: ProductApiToken<TApi>, api: TApi): void;
+}
+export interface CanvasShapeRef<TType extends string = string> {
+    id: ShapeId;
+    type: TType;
+}
+export interface CanvasPluginApiContext {
+    apis: ProductApiRegistry;
+    capabilities: CanvasPluginCapabilityRegistry;
+    editor: Editor;
+    exportRegistry: CanvasExportRegistry;
+}
+export interface CanvasPluginApi<TApi, TContext extends CanvasPluginApiContext = CanvasPluginApiContext> {
+    token: ProductApiToken<TApi>;
+    create(context: TContext): TApi | null;
+}
+export declare function createProductApiToken<TApi>(id: string): ProductApiToken<TApi>;
+export declare function createProductApiRegistry(): ProductApiRegistryRuntime;

package/_vendor/canvas-plugin-sdk/services.d.ts

@@ -0,0 +1,20 @@
+import type { CanvasPluginCapabilityToken } from "./capability";
+export interface ProductServiceToken<TService> extends CanvasPluginCapabilityToken<TService, "service"> {
+    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 ProductServiceSetup extends ProductServiceRegistry {
+    add<TService>(factory: ProductServiceFactory<TService>): TService;
+}
+export declare function createProductServiceToken<TService>(id: string): ProductServiceToken<TService>;
+export declare function requireProductService<TService>(services: ProductServiceRegistry, token: ProductServiceToken<TService>): TService;

package/_vendor/{canvas-core/surfaces → canvas-plugin-sdk}/toolbar.d.ts

@@ -1,8 +1,19 @@
+import type { Editor } from "../canvas-core/index";
 import type { CanvasActionContext, CanvasActionValue } from "./actions";
 export declare const SET_ACTIVE_TOOL_TOOLBAR_ACTION_ID = "editor.tool.set-active-tool";
 export declare const TOGGLE_TOOL_LOCKED_TOOLBAR_ACTION_ID = "editor.tool.toggle-locked";
 export type ToolbarSurface = "selection" | "tool";
-export type ToolbarPlacement = "chrome" | "context" | "floating";
+export type ToolbarGroupPresentation = "primary" | "overflow";
+export interface ToolbarChannel<TId extends string = string> {
+    readonly id: TId;
+}
+export declare function createToolbarChannel<const TId extends string>(id: TId): ToolbarChannel<TId>;
+export declare const toolbarChannels: {
+    readonly toolSwitcher: ToolbarChannel<"land.toolbar.tool-switcher">;
+    readonly toolOptions: ToolbarChannel<"land.toolbar.tool-options">;
+    readonly selectionProperties: ToolbarChannel<"land.toolbar.selection-properties">;
+    readonly selectionQuickActions: ToolbarChannel<"land.toolbar.selection-quick-actions">;
+};
 export interface ToolbarButtonItem {
     kind: "button";
     id: string;
@@ -13,6 +24,13 @@ export interface ToolbarButtonItem {
     shortcut?: string;
     dataUi?: string;
 }
+export interface ToolbarCheckboxItem {
+    kind: "checkbox";
+    id: string;
+    actionId: string;
+    label: string;
+    dataUi?: string;
+}
 export interface ToolbarSegmentedOption {
     value: string;
     label: string;
@@ -23,6 +41,8 @@ export interface ToolbarSegmentedItem {
     kind: "segmented";
     id: string;
     actionId: string;
+    label?: string;
+    icon?: string;
     options: readonly ToolbarSegmentedOption[];
 }
 export interface ToolbarSwatchOption {
@@ -38,6 +58,14 @@ export interface ToolbarSwatchesItem {
     label: string;
     options: readonly ToolbarSwatchOption[];
 }
+export interface ToolbarColorPresetOption {
+    id: string;
+    label: string;
+    hexColor: string;
+    opacity?: number;
+    value?: CanvasActionValue;
+    dataUi?: string;
+}
 export interface ToolbarStepperOption {
     value: number;
     label: string;
@@ -56,7 +84,11 @@ export interface ToolbarTextInputItem {
     id: string;
     actionId: string;
     label: string;
+    icon?: string;
+    presentation?: "inline" | "popover";
     placeholder?: string;
+    suffix?: string;
+    validate?(value: string): boolean;
     dataUi?: string;
 }
 export interface ToolbarColorInputItem {
@@ -64,9 +96,12 @@ export interface ToolbarColorInputItem {
     id: string;
     actionId: string;
     label: string;
+    previewStyle?: "solid" | "outline";
     fallback?: string;
-    includeAlpha?: boolean;
+    /** Embed opacity in the color value by default, or send it separately. */
+    opacityMode?: "embedded" | "separate";
     opacityFallback?: number;
+    presets?: readonly ToolbarColorPresetOption[];
     dataUi?: string;
 }
 export interface ToolbarSliderItem {
@@ -89,18 +124,26 @@ export interface ToolbarSeparatorItem {
     kind: "separator";
     id: string;
 }
-export type ToolbarItem = ToolbarButtonItem | ToolbarSegmentedItem | ToolbarSwatchesItem | ToolbarStepperItem | ToolbarTextInputItem | ToolbarColorInputItem | ToolbarSliderItem | ToolbarBadgeItem | ToolbarSeparatorItem;
+export type ToolbarItem = ToolbarButtonItem | ToolbarCheckboxItem | ToolbarSegmentedItem | ToolbarSwatchesItem | ToolbarStepperItem | ToolbarTextInputItem | ToolbarColorInputItem | ToolbarSliderItem | ToolbarBadgeItem | ToolbarSeparatorItem;
 export interface ToolbarGroup {
     id: string;
     order?: number;
+    presentation?: ToolbarGroupPresentation;
     items: readonly ToolbarItem[];
 }
 export interface ToolbarContribution {
     id: string;
-    surface: ToolbarSurface;
-    placement?: ToolbarPlacement;
+    channel: ToolbarChannel;
     order?: number;
     actionIds: readonly string[];
+    subscribe?(editor: Editor, listener: () => void): () => void;
     when?(context: CanvasActionContext): boolean;
     getGroups(context: CanvasActionContext): readonly ToolbarGroup[];
 }
+export interface ToolbarGroupSource {
+    groups: readonly ToolbarGroup[];
+    groupIdPrefix?: string;
+}
+export declare function mergeToolbarGroups(sources: readonly ToolbarGroupSource[], options?: {
+    dedupeActionIdsAcrossSources?: boolean;
+}): ToolbarGroup[];

package/_vendor/canvas-plugin-sdk/toolbarRegistry.d.ts

@@ -0,0 +1,18 @@
+import type { Editor } from "../canvas-core/index";
+import type { CanvasActionContext } from "./actions";
+import type { ToolbarChannel, ToolbarContribution, ToolbarGroup } from "./toolbar";
+export declare class CanvasToolbarRegistry {
+    private readonly contributions;
+    private readonly channels;
+    private readonly contributionsByChannel;
+    private readonly contributionIndexes;
+    private nextContributionIndex;
+    private stateRevision;
+    registerContribution(contribution: ToolbarContribution): void;
+    getStateRevision(): number;
+    subscribeToState(editor: Editor, listener: () => void): () => void;
+    getGroups(channel: ToolbarChannel, context: CanvasActionContext): ToolbarGroup[];
+    getChannels(): readonly ToolbarChannel[];
+    private addToIndexes;
+}
+export declare function createCanvasToolbarRegistry(contributions?: readonly ToolbarContribution[]): CanvasToolbarRegistry;

package/_vendor/canvas-react/components/CanvasView.d.ts

@@ -1,4 +1,4 @@
-import { type ActiveContextMenu } from "../../canvas-core/index";
+import type { CanvasContextMenuRequest } from "../contextMenuRequest";
 import type { CanvasRenderPluginComponent, CanvasRenderPluginProvider } from "../host/canvasRenderPlugin";
 import { type CanvasRendererRegistry } from "../host/rendererRegistry";
 import { type CanvasOverlayRegistry } from "../host/overlayRegistry";
@@ -7,7 +7,7 @@ export declare function Canvas({ canvasComponents, canvasProviders, domEventGuar
     canvasComponents?: readonly CanvasRenderPluginComponent[];
     canvasProviders?: readonly CanvasRenderPluginProvider[];
     domEventGuardRegistry?: CanvasDomEventGuardRegistry;
-    onContextMenuRequest?: (activeContextMenu: ActiveContextMenu) => void;
+    onContextMenuRequest?: (request: CanvasContextMenuRequest) => void;
     overlayRegistry?: CanvasOverlayRegistry;
     rendererRegistry?: CanvasRendererRegistry;
     showGrid?: boolean;

package/_vendor/canvas-react/components/canvasKeyboardEvents.d.ts

@@ -0,0 +1,13 @@
+import type { Editor, KeyboardEditorEvent } from "../../canvas-core/index";
+export declare function createKeyboardEvent(name: KeyboardEditorEvent["name"], event: KeyboardEvent): KeyboardEditorEvent;
+export declare function routeCanvasKeyUp(editor: Editor, event: KeyboardEvent, isEditableTarget: boolean): void;
+export declare function getKeyboardShortcutEvent(event: KeyboardEvent): {
+    key: string;
+    shiftKey: boolean;
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    accelKey: boolean;
+};
+export declare function isCanvasPanKey(event: Pick<KeyboardEvent, "code">): boolean;
+export declare function isCanvasPanKeyEventTarget(target: EventTarget | null, container: HTMLElement): boolean;

package/_vendor/canvas-react/components/useCanvasDomEvents.d.ts

@@ -1,5 +1,6 @@
 import { type MouseEvent as ReactMouseEvent, type PointerEvent as ReactPointerEvent, type RefObject } from "react";
-import { type ActiveContextMenu, type Editor, type ShapeEditingSession } from "../../canvas-core/index";
+import { type Editor, type ShapeEditingSession } from "../../canvas-core/index";
+import type { CanvasContextMenuRequest } from "../contextMenuRequest";
 import type { CanvasDomEventGuardRegistry } from "../host/domEventGuards";
 export interface CanvasDomEventHandlers {
     onPointerDown: (event: ReactPointerEvent<HTMLDivElement>) => void;
@@ -10,13 +11,13 @@ export interface CanvasDomEventState {
     containerRef: RefObject<HTMLDivElement | null>;
     handlers: CanvasDomEventHandlers;
     isPointerActive: boolean;
-    isMiddleButtonPanning: boolean;
+    isCameraPanning: boolean;
     surfaceCursor: string | undefined;
 }
 export declare function useCanvasDomEvents({ activeDomEventGuards, activeToolId, editor, onContextMenuRequest, shapeEditingSession, }: {
     activeDomEventGuards: CanvasDomEventGuardRegistry;
     activeToolId: string;
     editor: Editor;
-    onContextMenuRequest?: (activeContextMenu: ActiveContextMenu) => void;
+    onContextMenuRequest?: (request: CanvasContextMenuRequest) => void;
     shapeEditingSession: ShapeEditingSession | null;
 }): CanvasDomEventState;