@yuzhouu/canvas-kit 0.1.10 → 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-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

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

@@ -1,39 +1,76 @@
-import type { EditorPlugin, KeyboardShortcutInput, ShapeRecordBase } from "../canvas-core/index";
+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 CanvasProductContribution {
-    actions?: readonly CanvasAction[];
-    actionShortcuts?: readonly CanvasActionShortcut[];
-    toolbarContributions?: readonly ToolbarContribution[];
-    contextMenuContributions?: readonly ContextMenuContribution[];
+export interface CanvasPluginActionSetup {
+    add(...actions: readonly CanvasAction[]): void;
+    addShortcuts(...shortcuts: readonly CanvasActionShortcut[]): void;
 }
-export type CanvasProductFactory = () => CanvasProductContribution;
-type CanvasProductFactoryLike = (...args: never[]) => object;
+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 interface CanvasPlugin<TProductFactory extends CanvasProductFactoryLike = CanvasProductFactory> extends CanvasPluginReference {
+export type CanvasPluginRequirement = CanvasPluginReference | CanvasPluginCapabilityToken;
+export interface CanvasPluginDefinition<TSetup extends CanvasPluginSetupLike = CanvasPluginSetup> {
     readonly id: string;
-    readonly requires?: readonly CanvasPluginReference[];
+    readonly provides?: readonly CanvasPluginCapabilityToken[];
+    readonly requires?: readonly CanvasPluginRequirement[];
     readonly editor?: EditorPlugin;
     readonly render?: CanvasRenderPlugin;
-    readonly product?: TProductFactory;
+    readonly setup?: TSetup;
+}
+export interface CanvasPlugin<TSetup extends CanvasPluginSetupLike = CanvasPluginSetup> extends CanvasPluginDefinition<TSetup>, CanvasPluginReference {
 }
-export type CanvasPluginInput<TProductFactory extends CanvasProductFactoryLike = CanvasProductFactory> = CanvasPlugin<TProductFactory> | readonly CanvasPluginInput<TProductFactory>[];
-export interface CompiledCanvasPlugins<TProductFactory extends CanvasProductFactoryLike = CanvasProductFactory> {
-    readonly plugins: readonly CanvasPlugin<TProductFactory>[];
+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 productFactories: readonly TProductFactory[];
     readonly shapeTypes: readonly ShapeRecordBase["type"][];
 }
-export declare function defineCanvasPlugin<TProductFactory extends CanvasProductFactoryLike = CanvasProductFactory>(plugin: CanvasPlugin<TProductFactory>): CanvasPlugin<TProductFactory>;
-export declare function compileCanvasPlugins<TProductFactory extends CanvasProductFactoryLike>(input: readonly CanvasPluginInput<TProductFactory>[]): CompiledCanvasPlugins<TProductFactory>;
+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-plugin-sdk/toolbar.d.ts

@@ -3,7 +3,17 @@ 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;
@@ -31,6 +41,8 @@ export interface ToolbarSegmentedItem {
     kind: "segmented";
     id: string;
     actionId: string;
+    label?: string;
+    icon?: string;
     options: readonly ToolbarSegmentedOption[];
 }
 export interface ToolbarSwatchOption {
@@ -75,6 +87,7 @@ export interface ToolbarTextInputItem {
     icon?: string;
     presentation?: "inline" | "popover";
     placeholder?: string;
+    suffix?: string;
     validate?(value: string): boolean;
     dataUi?: string;
 }
@@ -83,8 +96,10 @@ 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;
@@ -113,15 +128,22 @@ export type ToolbarItem = ToolbarButtonItem | ToolbarCheckboxItem | ToolbarSegme
 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

@@ -1,19 +1,18 @@
 import type { Editor } from "../canvas-core/index";
 import type { CanvasActionContext } from "./actions";
-import type { ToolbarContribution, ToolbarGroup, ToolbarPlacement, ToolbarSurface } from "./toolbar";
+import type { ToolbarChannel, ToolbarContribution, ToolbarGroup } from "./toolbar";
 export declare class CanvasToolbarRegistry {
     private readonly contributions;
-    private readonly contributionsBySurface;
-    private readonly contributionsBySurfaceAndPlacement;
+    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(surface: ToolbarSurface, context: CanvasActionContext, options?: {
-        placement?: ToolbarPlacement;
-    }): ToolbarGroup[];
+    getGroups(channel: ToolbarChannel, context: CanvasActionContext): ToolbarGroup[];
+    getChannels(): readonly ToolbarChannel[];
     private addToIndexes;
 }
 export declare function createCanvasToolbarRegistry(contributions?: readonly ToolbarContribution[]): CanvasToolbarRegistry;

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

@@ -1,17 +1,28 @@
 import type { ComponentType, ReactNode } from "react";
-import type { Editor, SelectionCustomHandle, ShapeColor, ShapeEditingSession, ShapeRecordBase } from "../../canvas-core/index";
+import type { Editor, SelectionCustomHandle, ShapeEditingSession, ShapeRecordBase } from "../../canvas-core/index";
 export interface ShapeRendererProps<S extends ShapeRecordBase = ShapeRecordBase> {
     shape: S;
     editor: Editor;
     isSelected: boolean;
-    isHovered: boolean;
     shapeEditingSession: ShapeEditingSession | null;
 }
-export declare const SHAPE_HOVER_STROKE = "var(--land-selection, #2563eb)";
-export declare function getShapeStrokeForHover(stroke: ShapeColor, isHovered: boolean): string;
+/**
+ * Rendered inside the shape's render-bounds host. SVG coordinates should match
+ * the shape util's `getRenderBounds()` coordinate space.
+ */
+export interface ShapeHoverRendererProps<S extends ShapeRecordBase = ShapeRecordBase> {
+    shape: S;
+    editor: Editor;
+    /** Local-space width that renders as the standard hover width on screen. */
+    strokeWidth: number;
+}
+export declare const SHAPE_HOVER_STROKE = "var(--land-shape-hover, var(--land-selection, #2563eb))";
+/** Standard hover stroke width in screen pixels. */
+export declare const SHAPE_HOVER_STROKE_WIDTH = 2;
 export interface RegisteredShapeRenderer<S extends ShapeRecordBase = ShapeRecordBase> {
     type: S["type"];
     component: ComponentType<ShapeRendererProps<S>>;
+    hoverComponent?: ComponentType<ShapeHoverRendererProps<S>>;
     foregroundComponent?: ComponentType<ShapeRendererProps<S>>;
 }
 export type AnyRegisteredShapeRenderer = RegisteredShapeRenderer<any>;

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

@@ -3,6 +3,6 @@ export { CanvasOverlayRegistryContext, useCanvasOverlayRegistry, } from "./canva
 export { CanvasDomEventGuardRegistry, createCanvasDomEventGuardRegistry, } from "./domEventGuards";
 export { CanvasOverlayRegistry, createCanvasOverlayRegistry, } from "./overlayRegistry";
 export { CanvasRendererRegistry, createCanvasRendererRegistry, } from "./rendererRegistry";
-export type { AnyRegisteredSelectionCustomHandleRenderer, AnyRegisteredShapeRenderer, CanvasOverlayContribution, CanvasOverlayLayer, CanvasDomEventGuard, CanvasDomEventGuardCursorInput, CanvasDomEventGuardDecision, CanvasDomEventGuardInput, CanvasDomEventGuardName, CanvasRenderPluginComponent, CanvasRenderPluginProvider, CanvasRenderPlugin, RegisteredSelectionCustomHandleRenderer, RegisteredShapeRenderer, SelectionCustomHandleRendererProps, ShapeRendererProps, ShapeOpacityModifier, } from "./canvasRenderPlugin";
-export { getShapeStrokeForHover, SHAPE_HOVER_STROKE, } from "./canvasRenderPlugin";
+export type { AnyRegisteredSelectionCustomHandleRenderer, AnyRegisteredShapeRenderer, CanvasOverlayContribution, CanvasOverlayLayer, CanvasDomEventGuard, CanvasDomEventGuardCursorInput, CanvasDomEventGuardDecision, CanvasDomEventGuardInput, CanvasDomEventGuardName, CanvasRenderPluginComponent, CanvasRenderPluginProvider, CanvasRenderPlugin, RegisteredSelectionCustomHandleRenderer, RegisteredShapeRenderer, SelectionCustomHandleRendererProps, ShapeHoverRendererProps, ShapeRendererProps, ShapeOpacityModifier, } from "./canvasRenderPlugin";
+export { SHAPE_HOVER_STROKE, SHAPE_HOVER_STROKE_WIDTH, } from "./canvasRenderPlugin";
 export { createCanvasRenderRuntime, type CanvasRenderRuntime, } from "./canvasRenderRuntime";

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

@@ -0,0 +1,33 @@
+import { type ShapeColor, type ShapeId } from "../canvas-core/index";
+import { type CanvasPluginApi, type CanvasShapeRef } from "../canvas-plugin-sdk/index";
+import type { ArrowShapeProps } from "./types";
+export interface ArrowBindingInput {
+    targetShapeId: ShapeId;
+    normalizedAnchor: {
+        x: number;
+        y: number;
+    };
+}
+export interface ArrowInput {
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+    bend?: number;
+    stroke?: ShapeColor;
+    strokeWidth?: number;
+    headStart?: ArrowShapeProps["headStart"];
+    headEnd?: ArrowShapeProps["headEnd"];
+    startBinding?: ArrowBindingInput | null;
+    endBinding?: ArrowBindingInput | null;
+    meta?: Record<string, unknown>;
+}
+export interface ArrowApi {
+    create(input: ArrowInput): CanvasShapeRef<"arrow"> | null;
+}
+export declare const arrowApiToken: import("../canvas-plugin-sdk/index").ProductApiToken<ArrowApi>;
+export declare const arrowPluginApi: CanvasPluginApi<ArrowApi>;

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

@@ -1,4 +1,4 @@
-import { Box, Vec, type Editor } from "../canvas-core/index";
+import { Box, Vec, type Editor, type ShapeLabelPathGeometry } from "../canvas-core/index";
 import type { ArrowShapeProps, ArrowShapeRecord, ArrowTerminal } from "./types";
 export declare const ARROW_CURVE_EPSILON = 0.000001;
 export interface ArrowInfoTerminal {
@@ -51,6 +51,7 @@ export declare function getArrowInfo(shape: ArrowShapeRecord): ArrowInfo;
 export declare function getArrowLocalInfo(shape: ArrowShapeRecord): ArrowInfo;
 export declare function getArrowBendFromMiddlePagePoint(start: Vec, end: Vec, point: Vec): number;
 export declare function getArrowHitDistance(info: ArrowInfo, point: Vec): number;
+export declare function getArrowLabelPathGeometry(info: ArrowInfo): ShapeLabelPathGeometry;
 export declare function getArrowInfoFromPoints(start: Vec, end: Vec, rawBend: unknown): ArrowInfo;
 export declare function getArrowInfoFromArc({ start, end, middle, bend, arc, startHandle, endHandle, }: {
     start: Vec;

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

@@ -0,0 +1,8 @@
+import { Vec } from "../canvas-core/index";
+import type { ArrowInfo } from "./arrowGeometry";
+import type { ArrowShapeProps } from "./types";
+export interface ArrowHeadPathGeometry {
+    path: string | null;
+    points: readonly Vec[];
+}
+export declare function getArrowHeadPathGeometry(info: ArrowInfo, input: Pick<ArrowShapeProps, "headStart" | "headEnd" | "strokeWidth">): ArrowHeadPathGeometry;

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

@@ -1,4 +1,4 @@
-import { Box, ShapeUtil, Vec, type ShapeBrushWrapInput, type ShapeGeometryInput, type ShapeSelectionHandleAnchorInput, type ShapeSelectionHandleAnchors, type ShapeSelectionFrameInput, type ShapeLineSegmentHitTestInput, type ShapeSelectionOverlayInfo, type ShapeSelectionOverlayInfoInput, type ShapeSelectionPagePointsInput, type ShapeSelectionPagePoints, type ShapePointHitTestInput, type ShapeUpdate } from "../canvas-core/index";
+import { Box, ShapeUtil, Vec, type ShapeBrushWrapInput, type ShapeGeometryInput, type ShapeSelectionHandleAnchorInput, type ShapeSelectionHandleAnchors, type ShapeSelectionFrameInput, type ShapeLineSegmentHitTestInput, type ShapeLabelPathGeometry, type ShapeSelectionOverlayInfo, type ShapeSelectionOverlayInfoInput, type ShapeSelectionPagePointsInput, type ShapeSelectionPagePoints, type ShapePointHitTestInput, type ShapeUpdate } from "../canvas-core/index";
 import { type ArrowShapeProps, type ArrowShapeRecord } from "./types";
 export declare class ArrowShapeUtil extends ShapeUtil<ArrowShapeRecord> {
     readonly type: "arrow";
@@ -19,6 +19,7 @@ export declare class ArrowShapeUtil extends ShapeUtil<ArrowShapeRecord> {
     canStartTranslateFromSelectionBounds(_shape: ArrowShapeRecord, input: ShapeSelectionFrameInput): boolean;
     getSelectionHandleAnchors(shape: ArrowShapeRecord, input: ShapeSelectionHandleAnchorInput): ShapeSelectionHandleAnchors;
     getSelectionOverlayInfo(shape: ArrowShapeRecord, input: ShapeSelectionOverlayInfoInput): ShapeSelectionOverlayInfo;
+    getLabelPathGeometry(shape: ArrowShapeRecord, input: ShapeSelectionOverlayInfoInput): ShapeLabelPathGeometry;
     hitTest(shape: ArrowShapeRecord, point: Vec, input?: ShapePointHitTestInput): boolean;
     hitTestLineSegment(shape: ArrowShapeRecord, input: ShapeLineSegmentHitTestInput): boolean;
 }

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

@@ -1,4 +1,3 @@
-import { type CanvasProductContribution } from "../canvas-plugin-sdk/index";
 import { type EditorPlugin, type ShapeSvgExporter, type SvgExportContext, type SvgNode } from "../canvas-core/index";
 import type { ArrowShapeRecord } from "./types";
 export declare class ArrowShapeSvgExporter implements ShapeSvgExporter<ArrowShapeRecord> {
@@ -6,4 +5,3 @@ export declare class ArrowShapeSvgExporter implements ShapeSvgExporter<ArrowShap
     toSvg(shape: ArrowShapeRecord, context: SvgExportContext): SvgNode;
 }
 export declare function createArrowEditorPlugin(): EditorPlugin;
-export declare function createArrowProductContribution(): CanvasProductContribution;

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

@@ -1,2 +1,2 @@
-import { createArrowProductContribution } from "./editorRuntime";
-export declare const Arrow: import("../canvas-plugin-sdk/index").CanvasPlugin<typeof createArrowProductContribution>;
+import { setupArrowProduct } from "./productRuntime";
+export declare const Arrow: import("../canvas-plugin-sdk/index").CanvasPlugin<typeof setupArrowProduct>;

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

@@ -1,7 +1,10 @@
 export { ArrowBindingUtil } from "./arrowBindingUtil";
+export { arrowApiToken } from "./api";
+export type { ArrowApi, ArrowBindingInput, ArrowInput, } from "./api";
 export { ArrowShapeUtil } from "./arrowShapeUtil";
 export { ArrowTool } from "./arrowTool";
-export { ArrowShapeSvgExporter, createArrowEditorPlugin, createArrowProductContribution } from "./editorRuntime";
+export { ArrowShapeSvgExporter, createArrowEditorPlugin } from "./editorRuntime";
+export { setupArrowProduct } from "./productRuntime";
 export { createArrowCanvasRenderPlugin } from "./canvasRender";
 export { Arrow } from "./feature";
 export { isArrowBindingRecord, isArrowShapeRecord, type ArrowBindingProps, type ArrowBindingRecord, type ArrowPoint, type ArrowShapeProps, type ArrowShapeRecord, type ArrowTerminal, } from "./types";

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

@@ -0,0 +1,2 @@
+import { type CanvasPluginSetupContext } from "../canvas-plugin-sdk/index";
+export declare function setupArrowProduct(context: CanvasPluginSetupContext): void;