@yuzhouu/canvas-kit 0.1.10 → 0.1.12

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

@@ -1,39 +1,29 @@
-import type { EditorPlugin, KeyboardShortcutInput, ShapeRecordBase } from "../canvas-core/index";
+import type { EditorPlugin, Editor } from "../canvas-core/index";
 import type { CanvasRenderPlugin } from "../canvas-react/host/index";
-import type { CanvasAction } from "./actions";
-import type { ContextMenuContribution } from "./contextMenu";
-import type { ToolbarContribution } from "./toolbar";
-export interface CanvasActionShortcut {
-    actionId: string;
-    shortcut: KeyboardShortcutInput;
+import type { CanvasPluginCapabilityToken } from "./capability";
+import type { CanvasPluginSetupExtension } from "./setupExtension";
+export interface CanvasPluginSetupContext {
+    readonly editor: Editor;
+    readonly productId: string;
+    get<TValue>(extension: CanvasPluginSetupExtension<TValue>): TValue;
 }
-export interface CanvasProductContribution {
-    actions?: readonly CanvasAction[];
-    actionShortcuts?: readonly CanvasActionShortcut[];
-    toolbarContributions?: readonly ToolbarContribution[];
-    contextMenuContributions?: readonly ContextMenuContribution[];
-}
-export type CanvasProductFactory = () => CanvasProductContribution;
-type CanvasProductFactoryLike = (...args: never[]) => object;
+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 type CanvasPluginInput<TProductFactory extends CanvasProductFactoryLike = CanvasProductFactory> = CanvasPlugin<TProductFactory> | readonly CanvasPluginInput<TProductFactory>[];
-export interface CompiledCanvasPlugins<TProductFactory extends CanvasProductFactoryLike = CanvasProductFactory> {
-    readonly plugins: readonly CanvasPlugin<TProductFactory>[];
-    readonly pluginIds: readonly string[];
-    readonly editorPlugins: readonly EditorPlugin[];
-    readonly renderPlugins: readonly CanvasRenderPlugin[];
-    readonly productFactories: readonly TProductFactory[];
-    readonly shapeTypes: readonly ShapeRecordBase["type"][];
+export interface CanvasPlugin<TSetup extends CanvasPluginSetupLike = CanvasPluginSetup> extends CanvasPluginDefinition<TSetup>, CanvasPluginReference {
 }
-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 type CanvasPluginInput<TSetup extends CanvasPluginSetupLike = CanvasPluginSetup> = CanvasPlugin<TSetup> | readonly CanvasPluginInput<TSetup>[];
+export declare function defineCanvasPlugin<TSetup extends CanvasPluginSetupLike = CanvasPluginSetup>(plugin: CanvasPluginDefinition<TSetup>): CanvasPlugin<TSetup>;
 export {};

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

@@ -0,0 +1,5 @@
+export interface CanvasPluginSetupExtension<TValue> {
+    readonly id: string;
+    readonly __value?: TValue;
+}
+export declare function createCanvasPluginSetupExtension<TValue>(id: string): CanvasPluginSetupExtension<TValue>;

package/_vendor/canvas-product-contracts/actionRegistry.d.ts

@@ -0,0 +1,4 @@
+import type { CanvasAction } from "./actions";
+export interface CanvasActionRegistry {
+    getAction(actionId: string): CanvasAction | null;
+}

package/_vendor/{canvas-plugin-sdk → canvas-product-contracts}/actions.d.ts

@@ -1,10 +1,11 @@
-import type { Editor, ShapeColor, ShapeId, ShapeRecordBase } from "../canvas-core/index";
+import type { Editor, KeyboardShortcutInput, ShapeColor, ShapeId, ShapeRecordBase } from "../canvas-core/index";
 export interface CanvasSelectionSnapshot {
     selectedShapeIds: readonly ShapeId[];
     selectedShapes: readonly ShapeRecordBase[];
     count: number;
     singleShapeType: ShapeRecordBase["type"] | null;
     commonShapeType: ShapeRecordBase["type"] | null;
+    canFlip: boolean;
     canResetRotation: boolean;
     isMixedFrameAndPointHandleSelection: boolean;
 }
@@ -24,10 +25,20 @@ export interface CanvasActionRunInput<TValue extends CanvasActionValue> {
     context: CanvasActionContext;
     value: TValue;
 }
+export type CanvasActionAvailability = "inapplicable" | "disabled" | "enabled";
 export interface CanvasAction<TValue extends CanvasActionValue = CanvasActionValue> {
     id: string;
-    isVisible?(context: CanvasActionContext): boolean;
-    isEnabled?(context: CanvasActionContext): boolean;
+    getAvailability?(context: CanvasActionContext): CanvasActionAvailability;
     getValue?(context: CanvasActionContext): TValue;
     run(input: CanvasActionRunInput<TValue>): void;
 }
+export interface CanvasActionShortcut {
+    actionId: string;
+    shortcut: KeyboardShortcutInput;
+}
+export interface CanvasPluginActionSetup {
+    add(...actions: readonly CanvasAction[]): void;
+    addShortcuts(...shortcuts: readonly CanvasActionShortcut[]): void;
+}
+export declare const canvasActionsExtension: import("../canvas-plugin-sdk/index").CanvasPluginSetupExtension<CanvasPluginActionSetup>;
+export declare function resolveCanvasActionAvailability(action: CanvasAction, context: CanvasActionContext): CanvasActionAvailability;

package/_vendor/canvas-product-contracts/capability.d.ts

@@ -0,0 +1,8 @@
+import { type CanvasPluginValueToken } from "../canvas-plugin-sdk/index";
+export interface CanvasPluginCapabilityRegistry {
+    get<TValue>(token: CanvasPluginValueToken<TValue>): TValue | null;
+}
+export interface CanvasPluginCapabilitySetup extends CanvasPluginCapabilityRegistry {
+    provide<TValue>(token: CanvasPluginValueToken<TValue>, value: TValue): void;
+}
+export declare const canvasCapabilitiesExtension: import("../canvas-plugin-sdk/index").CanvasPluginSetupExtension<CanvasPluginCapabilitySetup>;

package/_vendor/canvas-product-contracts/chrome.d.ts

@@ -0,0 +1,53 @@
+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;
+}
+export declare const canvasChromeExtension: import("../canvas-plugin-sdk/index").CanvasPluginSetupExtension<CanvasPluginChromeSetup>;

package/_vendor/canvas-product-contracts/chromeRegistry.d.ts

@@ -0,0 +1,9 @@
+import type { Editor } from "../canvas-core/index";
+import type { CanvasActionContext } from "./actions";
+import type { ChromeChannel, ChromeSection } from "./chrome";
+export interface CanvasChromeRegistry {
+    getChannels(): readonly ChromeChannel[];
+    getStateRevision(): number;
+    subscribeToState(editor: Editor, listener: () => void): () => void;
+    getSections(channel: ChromeChannel, context: CanvasActionContext): ChromeSection[];
+}

package/_vendor/{canvas-plugin-sdk → canvas-product-contracts}/contextMenu.d.ts

@@ -57,3 +57,7 @@ export interface ContextMenuContribution {
     when?(context: ContextMenuContext): boolean;
     getSections(context: ContextMenuContext): readonly ContextMenuSection[];
 }
+export interface CanvasPluginContextMenuSetup {
+    add(...contributions: readonly ContextMenuContribution[]): void;
+}
+export declare const canvasContextMenuExtension: import("../canvas-plugin-sdk/index").CanvasPluginSetupExtension<CanvasPluginContextMenuSetup>;

package/_vendor/canvas-product-contracts/contextMenuRegistry.d.ts

@@ -0,0 +1,4 @@
+import type { ContextMenuContext, ContextMenuContributionTarget, ContextMenuSection } from "./contextMenu";
+export interface CanvasContextMenuRegistry {
+    getSections(target: ContextMenuContributionTarget, context: ContextMenuContext): ContextMenuSection[];
+}

package/_vendor/canvas-product-contracts/exportRegistry.d.ts

@@ -0,0 +1,6 @@
+import type { CanvasExportArtifact, CanvasExportFormat, CanvasExportProviderInput } from "./exports";
+export interface CanvasExportRegistry {
+    getFormats(): readonly CanvasExportFormat[];
+    hasFormat(format: string): boolean;
+    export(format: string, input: CanvasExportProviderInput): Promise<CanvasExportArtifact>;
+}

package/_vendor/canvas-product-contracts/exports.d.ts

@@ -0,0 +1,27 @@
+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;
+}
+export declare const canvasExportsExtension: import("../canvas-plugin-sdk/index").CanvasPluginSetupExtension<CanvasPluginExportSetup>;

package/_vendor/canvas-product-contracts/importRegistry.d.ts

@@ -0,0 +1,7 @@
+import type { CanvasImportContext, CanvasImportContribution, CanvasImportPreview, CanvasImportRequest, CanvasImportResult } from "./imports";
+export interface CanvasImportRegistry {
+    getContributions(): readonly CanvasImportContribution[];
+    canImport(request: CanvasImportRequest): boolean;
+    canImportPreview(preview: CanvasImportPreview): boolean;
+    import(request: CanvasImportRequest, context: CanvasImportContext): Promise<CanvasImportResult>;
+}

package/_vendor/canvas-product-contracts/imports.d.ts

@@ -0,0 +1,39 @@
+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;
+}
+export declare const canvasImportsExtension: import("../canvas-plugin-sdk/index").CanvasPluginSetupExtension<CanvasPluginImportSetup>;

package/_vendor/canvas-product-contracts/index.d.ts

@@ -0,0 +1,15 @@
+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 "./productApi";
+export * from "./services";
+export * from "./toolbar";
+export * from "./toolbarRegistry";

package/_vendor/canvas-product-contracts/productApi.d.ts

@@ -0,0 +1,29 @@
+import type { Editor, ShapeId } from "../canvas-core/index";
+import { type CanvasPluginCapabilityToken } from "../canvas-plugin-sdk/index";
+import type { CanvasPluginCapabilityRegistry } 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 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 interface CanvasPluginApiSetup<TContext extends CanvasPluginApiContext = CanvasPluginApiContext> {
+    add<TApi>(api: CanvasPluginApi<TApi, TContext>): void;
+}
+export declare const canvasApisExtension: import("../canvas-plugin-sdk/index").CanvasPluginSetupExtension<CanvasPluginApiSetup<CanvasPluginApiContext>>;
+export declare function createProductApiToken<TApi>(id: string): ProductApiToken<TApi>;

package/_vendor/canvas-product-contracts/services.d.ts

@@ -0,0 +1,21 @@
+import { type CanvasPluginCapabilityToken } from "../canvas-plugin-sdk/index";
+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 const canvasServicesExtension: import("../canvas-plugin-sdk/index").CanvasPluginSetupExtension<ProductServiceSetup>;
+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 → canvas-product-contracts}/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,19 @@ 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 CanvasPluginToolbarSetup {
+    add(...contributions: readonly ToolbarContribution[]): void;
+}
+export declare const canvasToolbarExtension: import("../canvas-plugin-sdk/index").CanvasPluginSetupExtension<CanvasPluginToolbarSetup>;

package/_vendor/canvas-product-contracts/toolbarRegistry.d.ts

@@ -0,0 +1,9 @@
+import type { Editor } from "../canvas-core/index";
+import type { CanvasActionContext } from "./actions";
+import type { ToolbarChannel, ToolbarGroup } from "./toolbar";
+export interface CanvasToolbarRegistry {
+    getStateRevision(): number;
+    subscribeToState(editor: Editor, listener: () => void): () => void;
+    getGroups(channel: ToolbarChannel, context: CanvasActionContext): ToolbarGroup[];
+    getChannels(): readonly ToolbarChannel[];
+}

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-product-contracts/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-product-contracts/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;

package/_vendor/plugin-draw/DrawShapeRenderer.d.ts

@@ -2,9 +2,12 @@ import { type ShapeColor } from "../canvas-core/index";
 import type { DrawShapeRecord } from "./types";
 interface DrawShapeSvgProps {
     shape: DrawShapeRecord;
-    isHovered?: boolean;
     stroke?: ShapeColor;
     strokeWidth?: number;
 }
-export declare function DrawShapeSvg({ shape, isHovered, stroke, strokeWidth, }: DrawShapeSvgProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function DrawShapeSvg({ shape, stroke, strokeWidth, }: DrawShapeSvgProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function DrawShapeHoverSvg({ shape, strokeWidth, }: {
+    shape: DrawShapeRecord;
+    strokeWidth: number;
+}): import("react/jsx-runtime").JSX.Element | null;
 export {};

package/_vendor/plugin-draw/drawPath.d.ts

@@ -13,6 +13,10 @@ export interface DrawInputPointGuardOptions {
     hardMaxPointCount: number;
     maxDistanceMultiplier: number;
 }
+export interface DrawInputPointGuardState {
+    anchorPoint: DrawShapePoint;
+    hasProvisionalPoint: boolean;
+}
 export interface DrawPointSamplingResult {
     points: DrawShapePoint[];
     rawPointCount: number;
@@ -29,7 +33,9 @@ export declare function cloneDrawSegment(segment: DrawShapeSegment): DrawShapeSe
 export declare function getFlattenedDrawSegmentPoints(segments: readonly DrawShapeSegment[]): DrawShapePoint[];
 export declare function getDrawSegmentsFromPoints(points: readonly DrawShapePoint[]): DrawShapeSegment[];
 export declare function getDrawInputPointGuardOptions(strokeWidth: number, isPen: boolean): DrawInputPointGuardOptions;
-export declare function appendGuardedDrawPoint(points: DrawShapePoint[], point: DrawShapePoint, options: DrawInputPointGuardOptions): void;
+export declare function appendGuardedDrawPoint(points: DrawShapePoint[], point: DrawShapePoint, options: DrawInputPointGuardOptions, state: DrawInputPointGuardState, appendOptions?: {
+    force?: boolean;
+}): DrawInputPointGuardState;
 export declare function sampleDrawPoints(points: readonly DrawShapePoint[], options: DrawPointSamplingOptions): DrawPointSamplingResult;
 export declare function getDrawCenterlinePathFromPoints(points: readonly DrawShapePoint[]): string | null;
 export declare function getClosedDrawCenterlinePathFromPoints(points: readonly DrawShapePoint[]): string | null;