canvu-react 0.3.17 → 0.3.20

package/dist/react.d.cts

@@ -3,14 +3,14 @@ export { H as HydratedSceneItemsWithAssetsResult, h as hydrateSceneItemsWithAsse
 import { V as VectorSceneItem } from './types-CB0TZZuk.cjs';
 import { V as VectorViewportAssetKind, u as VectorViewportAssetStore } from './shape-builders-DFudWDFI.cjs';
 export { v as VectorViewportAssetHydrationRequest, w as VectorViewportAssetResolveRequest, x as VectorViewportAssetResolveResult, y as VectorViewportAssetUploadRequest, z as VectorViewportAssetUploadResult } from './shape-builders-DFudWDFI.cjs';
-import { V as VectorToolDefinition, C as CanvasPlugin, B as BoardComponentPosition } from './types-CTyASYIm.cjs';
-export { a as CanvasPluginComponentProps, b as CanvasPluginContribution, c as CanvasPluginItemsChangeMiddlewareContext, d as CanvasPluginRenderContext, e as CanvuChromeActiveToolStyle, f as CanvuChromeContext, g as CanvuChromeContextValue, h as CanvuChromeSelectionStyleChange, i as CanvuPluginContext, j as CanvuPluginContextValue, k as CanvuPluginViewportSnapshot, l as CustomShapePlacementOptions, N as NavMenu, m as NavMenuProps, P as PlacementPreview, n as VectorCanvas, o as VectorCanvasBody, p as VectorCanvasHeader, q as VectorCanvasMain, r as VectorCanvasRoot, s as VectorCanvasSlotProps, t as VectorCanvasSpacePosition, u as VectorCanvasSpaceProps, v as VectorCanvasToolbar, w as VectorCanvasToolbarProps, x as VectorCanvasViewportSurface, y as VectorSelectionInspector, z as VectorSelectionInspectorProps, A as VectorViewport, D as VectorViewportHandle, E as VectorViewportProps, W as WorldPointerDownDetail, F as createCanvuPlugin, G as getBoardPositionStyle, H as useCanvuChromeContext, I as useCanvuDocumentContext, J as useCanvuPluginContext, K as useCanvuPluginContribution, L as useCanvuResolvedTools, M as useCanvuViewportContext } from './types-CTyASYIm.cjs';
+import { B as BoardComponentPosition, V as VectorToolDefinition, C as CanvasPlugin, a as VectorSelectionInspector } from './types-7kfWcm0L.cjs';
+export { b as CanvasPluginComponentProps, c as CanvasPluginContribution, d as CanvasPluginItemsChangeMiddlewareContext, e as CanvasPluginRenderContext, f as CanvuChromeActiveToolStyle, g as CanvuChromeContext, h as CanvuChromeContextValue, i as CanvuChromeSelectionStyleChange, j as CanvuPluginContext, k as CanvuPluginContextValue, l as CanvuPluginViewportSnapshot, m as CustomShapePlacementOptions, P as PlacementPreview, n as VectorCanvasSpacePosition, o as VectorSelectionInspectorProps, p as VectorViewport, q as VectorViewportHandle, r as VectorViewportProps, W as WorldPointerDownDetail, s as createCanvuPlugin, t as getBoardPositionStyle, u as useCanvuChromeContext, v as useCanvuDocumentContext, w as useCanvuPluginContext, x as useCanvuPluginContribution, y as useCanvuResolvedTools, z as useCanvuViewportContext } from './types-7kfWcm0L.cjs';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { CSSProperties, ReactNode, ReactElement, SVGProps } from 'react';
+import { C as Camera2D } from './camera-BwQjm5oh.cjs';
 import { V as VectorCanvasPersistenceAdapter, a as VectorCanvasRemoteAdapter } from './types-DNwjgs5U.cjs';
 export { b as VectorCanvasSnapshot } from './types-DNwjgs5U.cjs';
-import * as react from 'react';
-import { SVGProps, CSSProperties, ReactNode } from 'react';
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import './camera-BwQjm5oh.cjs';
 
 /**
  * Extra context for each item created by {@link ingestAssetFilesToSceneItems}.
@@ -154,6 +154,126 @@ type IngestAssetFilesToSceneItemsResult = {
  */
 declare function ingestAssetFilesToSceneItems(options: IngestAssetFilesToSceneItemsOptions): Promise<IngestAssetFilesToSceneItemsResult>;
 
+type ImagesMenuLabels = {
+    title?: string;
+    dragHandle?: string;
+    focus?: string;
+    copy?: string;
+    rotate?: string;
+    delete?: string;
+    collapse?: string;
+    expand?: string;
+};
+type ImagesMenuProps = {
+    items: readonly VectorSceneItem[];
+    onItemsChange: (items: VectorSceneItem[]) => void;
+    /**
+     * Fires when the user clicks an image's thumbnail/label area. Use this to
+     * pan/zoom the canvas to the item (e.g. `viewportRef.current?.fitWorldRect(item.bounds)`).
+     */
+    onFocusItem?: (item: VectorSceneItem) => void;
+    labels?: ImagesMenuLabels;
+};
+/**
+ * Floating side panel that lists images marked as "managed"
+ * (via `pluginData.managed === true`) and offers copy, rotate, delete, and
+ * drag-to-reorder actions. Managed images are also `locked`, so they do not
+ * respond to direct canvas interaction.
+ */
+declare function ImagesMenu({ items, onItemsChange, onFocusItem, labels, }: ImagesMenuProps): react_jsx_runtime.JSX.Element | null;
+
+type NavMenuMinimapProps = {
+    className?: string;
+    /** @default false */
+    defaultExpanded?: boolean;
+    camera?: Camera2D;
+    viewportWidth?: number;
+    viewportHeight?: number;
+    items?: readonly VectorSceneItem[];
+    onRequestRender?: () => void;
+};
+/**
+ * Chevron toggle plus the expandable minimap panel.
+ *
+ * The toggle button renders inline in the nav-menu strip; the SVG panel is portaled into a slot
+ * NavMenu provides below the strip. With a bottom-anchored NavMenu, expanding pushes the strip
+ * up to make room — matching the original `<NavMenu />` behaviour.
+ */
+declare function NavMenuMinimap({ className, defaultExpanded, camera: cameraProp, viewportWidth: viewportWidthProp, viewportHeight: viewportHeightProp, items: itemsProp, onRequestRender: onRequestRenderProp, }?: NavMenuMinimapProps): react_jsx_runtime.JSX.Element;
+
+type NavMenuUndoRedoProps = {
+    className?: string;
+    style?: CSSProperties;
+    onUndo?: () => void;
+    onRedo?: () => void;
+    canUndo?: boolean;
+    canRedo?: boolean;
+};
+/** Undo + Redo buttons, gated by `canUndo` / `canRedo`. */
+declare function NavMenuUndoRedo({ className, style, onUndo: onUndoProp, onRedo: onRedoProp, canUndo: canUndoProp, canRedo: canRedoProp, }?: NavMenuUndoRedoProps): react_jsx_runtime.JSX.Element;
+
+type NavMenuZoomControlsProps = {
+    className?: string;
+    style?: CSSProperties;
+    zoomPercent?: number;
+    onZoomIn?: () => void;
+    onZoomOut?: () => void;
+};
+/** Zoom-out button, percentage label, and zoom-in button. */
+declare function NavMenuZoomControls({ className, style, zoomPercent: zoomPercentProp, onZoomIn: onZoomInProp, onZoomOut: onZoomOutProp, }?: NavMenuZoomControlsProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Floating bottom-bar combining zoom controls, undo/redo, and an expandable minimap.
+ *
+ * Two rendering modes:
+ * - **Default** (no `children`): renders all three feature groups using `props` ?? context values.
+ * - **Composable** (JSX `children`): pick which features to render
+ *   (e.g. `<NavMenu.UndoRedo />`, `<NavMenu.Minimap />`). Each subcomponent reads its data from
+ *   {@link CanvuChromeContext} unless its own override props are supplied.
+ */
+type NavMenuProps = {
+    camera?: Camera2D;
+    viewportWidth?: number;
+    viewportHeight?: number;
+    items?: readonly VectorSceneItem[];
+    zoomPercent?: number;
+    onZoomIn?: () => void;
+    onZoomOut?: () => void;
+    onUndo?: () => void;
+    onRedo?: () => void;
+    canUndo?: boolean;
+    canRedo?: boolean;
+    onRequestRender?: () => void;
+    /** Anchor preset. Defaults to bottom-left. */
+    position?: BoardComponentPosition;
+    /** Distance (px) from anchored edges. @default 12 */
+    inset?: number;
+    /** @default 23 */
+    zIndex?: number;
+    className?: string;
+    /** Merged on top of position-derived styles for custom tweaks. */
+    style?: CSSProperties;
+    /**
+     * Composable contents. When omitted, renders the default trio
+     * (`NavMenu.ZoomControls`, `NavMenu.UndoRedo`, `NavMenu.Minimap`).
+     */
+    children?: ReactNode;
+};
+type NavMenuWithStatics = ((props: NavMenuProps) => ReactElement) & {
+    ZoomControls: typeof NavMenuZoomControls;
+    UndoRedo: typeof NavMenuUndoRedo;
+    Minimap: typeof NavMenuMinimap;
+};
+/**
+ * `NavMenu` is a function component with attached subcomponents
+ * (`NavMenu.ZoomControls`, `NavMenu.UndoRedo`, `NavMenu.Minimap`).
+ *
+ * The explicit type annotation is what makes the static properties survive
+ * `.d.ts` bundling — relying on TypeScript's expando-function inference loses
+ * them in tsup output.
+ */
+declare const NavMenu: NavMenuWithStatics;
+
 /**
  * Persistence adapter that stores the document JSON in IndexedDB and manages
  * image blobs separately. Images are stored at original resolution in a dedicated
@@ -324,6 +444,102 @@ declare function IconText(props: IconProps): react_jsx_runtime.JSX.Element;
 declare function IconImage(props: IconProps): react_jsx_runtime.JSX.Element;
 declare function IconLaser(props: IconProps): react_jsx_runtime.JSX.Element;
 
+type VectorCanvasSlotProps = {
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+};
+type VectorCanvasSpaceProps = VectorCanvasSlotProps & {
+    position?: BoardComponentPosition;
+    /** @default 12 */
+    inset?: number;
+    /** @default 40 */
+    zIndex?: number;
+    /** Pointer events value on the content wrapper. @default "auto" */
+    contentPointerEvents?: CSSProperties["pointerEvents"];
+};
+/**
+ * Full-viewport column shell for a vector canvas (header + body with stage).
+ * Use with {@link VectorCanvasBody}, {@link VectorCanvasMain}. Pass `toolbar` on {@link VectorViewport};
+ * Compose the floating tool strip with {@link VectorCanvasToolbar} around {@link VectorToolbar} (see example below).
+ */
+declare function VectorCanvasRoot({ children, className, style, }: VectorCanvasSlotProps): react_jsx_runtime.JSX.Element;
+/** Optional top chrome (title, hints, toggles). */
+declare function VectorCanvasHeader({ children, className, style, }: VectorCanvasSlotProps): react_jsx_runtime.JSX.Element;
+/** Fills remaining space below the header (typically one {@link VectorCanvasMain}). */
+declare function VectorCanvasBody({ children, className, style, }: VectorCanvasSlotProps): react_jsx_runtime.JSX.Element;
+/**
+ * Stretch area for {@link VectorViewport} (or any child that should fill the stage).
+ */
+declare function VectorCanvasMain({ children, className, style, }: VectorCanvasSlotProps): react_jsx_runtime.JSX.Element;
+/**
+ * Flex child that fills {@link VectorCanvasMain} and gives {@link VectorViewport} a bounded height
+ * (white surface by default). Omit if you set the background on `Main` or the viewport yourself.
+ */
+declare function VectorCanvasViewportSurface({ children, className, style, }: VectorCanvasSlotProps): react_jsx_runtime.JSX.Element;
+type VectorCanvasToolbarProps = {
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    /** Anchor preset. @default "bottom-center" */
+    position?: BoardComponentPosition;
+    /** Distance (px) from the anchored edge(s). @default 12 */
+    inset?: number;
+    /** @default 30 */
+    zIndex?: number;
+};
+/**
+ * Floating strip anchor for {@link VectorToolbar} or custom controls. Defaults to bottom-center.
+ * Renders `pointer-events: none` on the shell and `auto` on children so the canvas keeps receiving hits outside the bar.
+ * Pass as the `toolbar` prop of `VectorViewport`; pick a different `position` for top / side anchoring.
+ * Z-index defaults to 30 so the strip stays above zoom controls.
+ */
+declare function VectorCanvasToolbar({ children, className, style, position, inset, zIndex, }: VectorCanvasToolbarProps): react_jsx_runtime.JSX.Element;
+/**
+ * Absolute canvas-aligned space for floating UI such as chats, rosters, inspectors, and overlays.
+ * Use this instead of ad-hoc wrapper divs or plugin hosts when a feature can be expressed as React nodes.
+ */
+declare function VectorCanvasSpace({ children, className, style, position, inset, zIndex, contentPointerEvents, }: VectorCanvasSpaceProps): react_jsx_runtime.JSX.Element;
+/**
+ * Namespaced layout primitives for composing a vector canvas shell without ad-hoc wrapper divs.
+ *
+ * @example
+ * ```tsx
+ * <VectorCanvas.Root>
+ *   <VectorCanvas.Header>…</VectorCanvas.Header>
+ *   <VectorCanvas.Body>
+ *     <VectorCanvas.Main>
+ *       <VectorCanvas.ViewportSurface>
+ *         <VectorViewport
+ *           toolbar={
+ *             <VectorCanvas.Toolbar>
+ *               <VectorToolbar … />
+ *             </VectorCanvas.Toolbar>
+ *           }
+ *           …
+ *         />
+ *       </VectorCanvas.ViewportSurface>
+ *     </VectorCanvas.Main>
+ *   </VectorCanvas.Body>
+ * </VectorCanvas.Root>
+ * ```
+ */
+declare const VectorCanvas: {
+    readonly Root: typeof VectorCanvasRoot;
+    readonly Header: typeof VectorCanvasHeader;
+    readonly Body: typeof VectorCanvasBody;
+    readonly Main: typeof VectorCanvasMain;
+    readonly ViewportSurface: typeof VectorCanvasViewportSurface;
+    readonly Toolbar: typeof VectorCanvasToolbar;
+    readonly Space: typeof VectorCanvasSpace;
+    readonly NavMenu: ((props: NavMenuProps) => react.ReactElement) & {
+        ZoomControls: typeof NavMenuZoomControls;
+        UndoRedo: typeof NavMenuUndoRedo;
+        Minimap: typeof NavMenuMinimap;
+    };
+    readonly SelectionInspector: typeof VectorSelectionInspector;
+};
+
 type VectorToolbarRenderContext = {
     tools: VectorToolDefinition[];
     selectedId: string;
@@ -335,11 +551,12 @@ type VectorToolbarProps = {
     /** Controlled selection. */
     value: string;
     onChange: (toolId: string) => void;
-    /** Defaults to {@link DEFAULT_VECTOR_TOOLS}. */
+    /** Defaults to {@link DEFAULT_VECTOR_TOOLS}. Ignored when JSX `children` are provided. */
     tools?: VectorToolDefinition[];
     /**
      * Tool ids placed in the overflow menu at the end of the toolbar (horizontal) or bottom (vertical).
      * Defaults to {@link DEFAULT_OVERFLOW_TOOL_IDS}. Pass an empty array to show every tool in the main strip.
+     * Ignored when JSX `children` are provided.
      */
     overflowToolIds?: readonly string[];
     /** Accessible name for the overflow trigger (menu button). Default: `"More tools"`. */
@@ -355,7 +572,7 @@ type VectorToolbarProps = {
     buttonClassName?: string;
     /** Extra class names when that tool is selected. */
     activeButtonClassName?: string;
-    /** Shows a lock toggle that keeps current tool active after use. */
+    /** Shows a lock toggle that keeps current tool active after use. Ignored when JSX `children` are provided. */
     showToolLockToggle?: boolean;
     /** Controlled lock state for tool persistence. */
     toolLocked?: boolean;
@@ -364,10 +581,14 @@ type VectorToolbarProps = {
     /** `compact` = icon + tooltip only; `comfortable` = small caption under the icon. */
     density?: "compact" | "comfortable";
     /**
-     * Full control: render your own toolbar using the same tool list and selection API.
-     * When set, default buttons are not rendered.
+     * Toolbar contents.
+     *
+     * - **Render function**: full control via {@link VectorToolbarRenderContext}. Default buttons are not rendered.
+     * - **JSX nodes** (e.g. `<VectorToolbar.Hand />`, `<VectorToolbar.Tool id="…" />`): composable items.
+     *   Pick exactly which tools to render; default tool list and `showToolLockToggle` are ignored.
+     * - **Omitted**: render the default tool strip from `tools` / {@link DEFAULT_VECTOR_TOOLS}.
      */
-    children?: (ctx: VectorToolbarRenderContext) => ReactNode;
+    children?: ReactNode | ((ctx: VectorToolbarRenderContext) => ReactNode);
     /**
      * Partial customization: render the content of each tool button (icon + label layout).
      * Default: icon with optional label below on narrow toolbars, or icon-only if `icon` is set.
@@ -379,37 +600,107 @@ type VectorToolbarProps = {
     }) => ReactNode;
 };
 /**
- * Default floating-style toolbar for choosing vector tools (hand, shapes, draw, marker, text, …).
- * Supply your own `tools` array or `children` render prop for full customization.
+ * Props for {@link VectorToolbar.Tool}.
+ *
+ * Identical to {@link VectorToolDefinition} so any tool can be rendered as
+ * `<VectorToolbar.Tool {...def} />`. Use the pre-bound bindings (e.g. `<VectorToolbar.Hand />`)
+ * for the built-in tools and `<VectorToolbar.Tool />` for custom ones.
+ */
+type VectorToolbarToolProps = VectorToolDefinition & {
+    className?: string;
+};
+/** Props for {@link VectorToolbar.ToolLock}. */
+type VectorToolbarToolLockProps = {
+    className?: string;
+    /** Render the trailing visual divider that separates the lock from the tools. @default true */
+    divider?: boolean;
+};
+/** Props for {@link VectorToolbar.Overflow}. */
+type VectorToolbarOverflowProps = {
+    /** Tools rendered inside the dropdown (typically `<VectorToolbar.Tool />` items). */
+    children: ReactNode;
+    /** Accessible name for the overflow trigger. @default "More tools" */
+    ariaLabel?: string;
+};
+/**
+ * A single tool inside `<VectorToolbar>`. Use the pre-bound bindings for built-in tools
+ * (e.g. `<VectorToolbar.Hand />`) or this component for custom ones.
+ *
+ * Automatically adapts its layout based on whether it sits in the primary strip or inside
+ * an `<VectorToolbar.Overflow>` dropdown.
  *
  * @example
  * ```tsx
- * const [tool, setTool] = useState("hand");
- * <VectorToolbar value={tool} onChange={setTool} aria-label="Canvas tools" />
+ * <VectorToolbar value={toolId} onChange={setToolId}>
+ *   <VectorToolbar.Tool id="my-tool" label="Custom" icon={<MyIcon />} shortcutHint="C" />
+ * </VectorToolbar>
  * ```
  */
-declare function VectorToolbar({ value, onChange, tools, overflowToolIds, overflowMenuAriaLabel, "aria-label": ariaLabel, className, orientation, style, buttonClassName, activeButtonClassName, showToolLockToggle, toolLocked, onToolLockedChange, density, children, renderToolButton, }: VectorToolbarProps): react_jsx_runtime.JSX.Element;
-
-type ViewportZoomControlsProps = {
-    /** Current zoom for display, e.g. from `Math.round(camera.zoom * 100)`. */
-    zoomPercent: number;
-    onZoomIn: () => void;
-    onZoomOut: () => void;
+declare function VectorToolbarTool(props: VectorToolbarToolProps): ReactNode;
+/**
+ * Lock toggle button. When on, the active tool persists after each use instead of
+ * auto-reverting to the previous tool.
+ */
+declare function VectorToolbarToolLock({ className, divider, }?: VectorToolbarToolLockProps): react_jsx_runtime.JSX.Element;
+/**
+ * Composable overflow dropdown. Children render inside a 3-column grid revealed when the user
+ * clicks the chevron trigger. The trigger highlights itself when its currently active child is selected.
+ *
+ * @example
+ * ```tsx
+ * <VectorToolbar value={toolId} onChange={setToolId}>
+ *   <VectorToolbar.Hand />
+ *   <VectorToolbar.Overflow>
+ *     <VectorToolbar.Rect />
+ *     <VectorToolbar.Ellipse />
+ *   </VectorToolbar.Overflow>
+ * </VectorToolbar>
+ * ```
+ */
+declare function VectorToolbarOverflow({ children, ariaLabel, }: VectorToolbarOverflowProps): react_jsx_runtime.JSX.Element;
+type ToolBinding = ((props?: {
     className?: string;
-    /** Anchor preset. Pass to relocate the floating control. */
-    position?: BoardComponentPosition;
-    /** Distance (px) from anchored edges. @default 12 */
-    inset?: number;
-    /** @default 22 */
-    zIndex?: number;
-    /** Merged on top of position-derived styles for custom tweaks. */
-    style?: CSSProperties;
+}) => ReactNode) & {
+    toolId: string;
+    displayName: string;
+};
+declare const HandBinding: ToolBinding;
+declare const SelectBinding: ToolBinding;
+declare const RectBinding: ToolBinding;
+declare const EllipseBinding: ToolBinding;
+declare const LineBinding: ToolBinding;
+declare const ArrowBinding: ToolBinding;
+declare const DrawBinding: ToolBinding;
+declare const MarkerBinding: ToolBinding;
+declare const LaserBinding: ToolBinding;
+declare const EraserBinding: ToolBinding;
+declare const TextBinding: ToolBinding;
+declare const ImageBinding: ToolBinding;
+type VectorToolbarWithStatics = ((props: VectorToolbarProps) => ReactElement) & {
+    Tool: typeof VectorToolbarTool;
+    ToolLock: typeof VectorToolbarToolLock;
+    Overflow: typeof VectorToolbarOverflow;
+    Hand: typeof HandBinding;
+    Select: typeof SelectBinding;
+    Rect: typeof RectBinding;
+    Ellipse: typeof EllipseBinding;
+    Line: typeof LineBinding;
+    Arrow: typeof ArrowBinding;
+    Draw: typeof DrawBinding;
+    Marker: typeof MarkerBinding;
+    Laser: typeof LaserBinding;
+    Eraser: typeof EraserBinding;
+    Text: typeof TextBinding;
+    Image: typeof ImageBinding;
 };
 /**
- * Floating zoom +/- controls. Defaults to the bottom-left, above the minimap.
- * Place inside the viewport root (position relative). Pass `position` for any of the
- * {@link BoardComponentPosition} presets, or `className`/`style` to fully customize.
+ * `VectorToolbar` is a function component with attached subcomponents
+ * (`.Tool`, `.ToolLock`, `.Overflow`, and one binding per default tool).
+ *
+ * The explicit type annotation is what makes the static properties survive
+ * `.d.ts` bundling — relying on TypeScript's expando-function inference loses
+ * them in tsup output.
  */
-declare function ViewportZoomControls({ zoomPercent, onZoomIn, onZoomOut, className, position, inset, zIndex, style, }: ViewportZoomControlsProps): react_jsx_runtime.JSX.Element;
+declare const VectorToolbar: VectorToolbarWithStatics;
 
-export { BoardComponentPosition, CanvasPlugin, type CreateLocalStoragePersistenceAdapterOptions, type CreateToolPluginOptions, DEFAULT_OVERFLOW_TOOL_IDS, DEFAULT_VECTOR_CANVAS_STORAGE_KEY, DEFAULT_VECTOR_TOOLS, IconArrow, IconDraw, IconEllipse, IconHand, IconImage, IconLaser, IconLine, IconRect, IconSelect, IconText, type IngestAssetFileError, type IngestAssetFilesToSceneItemsOptions, type IngestAssetFilesToSceneItemsResult, type IngestedAssetItemContext, ShapeContextMenu, type ShapeContextMenuProps, type UseVectorCanvasDocumentOptions, type UseVectorCanvasDocumentResult, VectorCanvasPersistenceAdapter, VectorCanvasRemoteAdapter, VectorToolDefinition, VectorToolbar, type VectorToolbarProps, type VectorToolbarRenderContext, VectorViewportAssetKind, VectorViewportAssetStore, ViewportZoomControls, type ViewportZoomControlsProps, createIndexedDbPersistenceAdapter, createLocalStoragePersistenceAdapter, createNoopPersistenceAdapter, createToolPlugin, cursorForVectorToolId, ingestAssetFilesToSceneItems, useVectorCanvasDocument };
+export { BoardComponentPosition, CanvasPlugin, type CreateLocalStoragePersistenceAdapterOptions, type CreateToolPluginOptions, DEFAULT_OVERFLOW_TOOL_IDS, DEFAULT_VECTOR_CANVAS_STORAGE_KEY, DEFAULT_VECTOR_TOOLS, IconArrow, IconDraw, IconEllipse, IconHand, IconImage, IconLaser, IconLine, IconRect, IconSelect, IconText, ImagesMenu, type ImagesMenuLabels, type ImagesMenuProps, type IngestAssetFileError, type IngestAssetFilesToSceneItemsOptions, type IngestAssetFilesToSceneItemsResult, type IngestedAssetItemContext, NavMenu, type NavMenuMinimapProps, type NavMenuProps, type NavMenuUndoRedoProps, type NavMenuZoomControlsProps, ShapeContextMenu, type ShapeContextMenuProps, type UseVectorCanvasDocumentOptions, type UseVectorCanvasDocumentResult, VectorCanvas, VectorCanvasBody, VectorCanvasHeader, VectorCanvasMain, VectorCanvasPersistenceAdapter, VectorCanvasRemoteAdapter, VectorCanvasRoot, type VectorCanvasSlotProps, type VectorCanvasSpaceProps, VectorCanvasToolbar, type VectorCanvasToolbarProps, VectorCanvasViewportSurface, VectorSelectionInspector, VectorToolDefinition, VectorToolbar, type VectorToolbarOverflowProps, type VectorToolbarProps, type VectorToolbarRenderContext, type VectorToolbarToolLockProps, type VectorToolbarToolProps, VectorViewportAssetKind, VectorViewportAssetStore, createIndexedDbPersistenceAdapter, createLocalStoragePersistenceAdapter, createNoopPersistenceAdapter, createToolPlugin, cursorForVectorToolId, ingestAssetFilesToSceneItems, useVectorCanvasDocument };