canvu-react 0.3.5

package/dist/react.d.ts

@@ -0,0 +1,481 @@
+import * as react from 'react';
+import { CSSProperties, ReactNode, SVGProps } from 'react';
+import { C as Camera2D } from './camera-KwCYYPhm.js';
+import { S as StrokeStyle } from './shape-builders-DTYvub8W.js';
+import { V as VectorSceneItem } from './types-CB0TZZuk.js';
+import { V as VectorToolDefinition, C as CanvasPlugin } from './types--ALu1mF-.js';
+export { a as CanvasPluginComponentProps, b as CanvasPluginContribution, c as CanvasPluginItemsChangeMiddlewareContext, d as CanvasPluginRenderContext, e as CanvuPluginContext, f as CanvuPluginContextValue, g as CanvuPluginViewportSnapshot, h as CustomShapePlacementOptions, P as PlacementPreview, i as VectorViewport, j as VectorViewportHandle, k as VectorViewportProps, W as WorldPointerDownDetail, l as createCanvuPlugin, u as useCanvuDocumentContext, m as useCanvuPluginContext, n as useCanvuPluginContribution, o as useCanvuResolvedTools, p as useCanvuViewportContext } from './types--ALu1mF-.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { V as VectorCanvasPersistenceAdapter, a as VectorCanvasRemoteAdapter } from './types-DgEArHkA.js';
+export { b as VectorCanvasSnapshot } from './types-DgEArHkA.js';
+
+type CanvuChromeActiveToolStyle = StrokeStyle & {
+    toolKind: "draw" | "marker";
+    label?: string;
+};
+type CanvuChromeSelectionStyleChange = (patch: {
+    stroke: string;
+    strokeWidth: number;
+    strokeOpacity?: number;
+}) => void;
+/**
+ * Runtime data and handlers shared with floating board chrome (e.g. {@link NavMenu},
+ * {@link VectorSelectionInspector}). Populated by `VectorViewport` and consumed via
+ * {@link useCanvuChromeContext}.
+ */
+type CanvuChromeContextValue = {
+    camera: Camera2D | null;
+    viewportWidth: number;
+    viewportHeight: number;
+    items: readonly VectorSceneItem[];
+    selectedItems: readonly VectorSceneItem[];
+    interactive: boolean;
+    canEditSelection: boolean;
+    activeToolStyle: CanvuChromeActiveToolStyle | null;
+    onSelectionStyleChange: CanvuChromeSelectionStyleChange | null;
+    zoomPercent: number;
+    onZoomIn: () => void;
+    onZoomOut: () => void;
+    onUndo: () => void;
+    onRedo: () => void;
+    canUndo: boolean;
+    canRedo: boolean;
+    onRequestRender: () => void;
+};
+declare const CanvuChromeContext: react.Context<CanvuChromeContextValue | null>;
+/** Returns the current chrome context or `null` when used outside `VectorViewport`. */
+declare function useCanvuChromeContext(): CanvuChromeContextValue | null;
+
+type ActiveToolStyle = StrokeStyle & {
+    toolKind: "draw" | "marker";
+    label?: string;
+};
+/**
+ * Color + stroke-width inspector for the current selection (or active drawing tool style).
+ * When rendered inside `VectorViewport` (e.g. via the `selectionInspector` slot), `items`,
+ * `activeToolStyle`, and `onChange` default to values from {@link CanvuChromeContext};
+ * pass any prop to override.
+ */
+type VectorSelectionInspectorProps = {
+    /** Selected items that support stroke/fill styling (caller may filter). */
+    items?: readonly VectorSceneItem[];
+    /** Optional active tool style shown even without a selection. */
+    activeToolStyle?: ActiveToolStyle | null;
+    /** Apply stroke / width / opacity to every item in `items`. */
+    onChange?: CanvuChromeSelectionStyleChange;
+    /** Anchor preset. Defaults to top-left. */
+    position?: BoardComponentPosition;
+    /** Distance (px) from anchored edges. @default 12 */
+    inset?: number;
+    /** @default 24 */
+    zIndex?: number;
+    className?: string;
+    /** Merged on top of position-derived styles for custom tweaks. */
+    style?: CSSProperties;
+};
+/**
+ * Color + stroke width for the current selection. Supports multiple selected shapes: one change applies to all.
+ */
+declare function VectorSelectionInspector({ items: itemsProp, activeToolStyle: activeToolStyleProp, onChange: onChangeProp, position, inset, zIndex, className, style, }: VectorSelectionInspectorProps): react_jsx_runtime.JSX.Element | null;
+
+type VectorCanvasSlotProps = {
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+};
+/**
+ * Anchor presets for floating board components.
+ *
+ * Names are `<edge>-<position-along-edge>`:
+ * - `top-*` / `bottom-*` anchor to the top or bottom edge.
+ * - `left-*` / `right-*` anchor to the left or right edge.
+ *
+ * Corner aliases are equivalent (e.g. `top-left` and `left-top` resolve to the same anchor),
+ * but kept distinct so callers can pick whichever reads best in their layout (a vertical
+ * strip might prefer `left-top`; a horizontal strip prefers `top-left`).
+ */
+type BoardComponentPosition = "top-left" | "top-center" | "top-right" | "bottom-left" | "bottom-center" | "bottom-right" | "left-top" | "left-center" | "left-bottom" | "right-top" | "right-center" | "right-bottom" | "center" | "fill";
+/** @deprecated Use {@link BoardComponentPosition}. */
+type VectorCanvasSpacePosition = BoardComponentPosition;
+/**
+ * Compute absolute-position CSS for a board component anchor preset.
+ * Returns `position`, `zIndex`, and the relevant edge offsets / transforms.
+ * Callers merge the result with their own style/className overrides.
+ */
+declare function getBoardPositionStyle(position: BoardComponentPosition, inset?: number, zIndex?: number): 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: typeof NavMenu;
+    readonly SelectionInspector: typeof VectorSelectionInspector;
+};
+
+/**
+ * Floating bottom-bar combining zoom controls, undo/redo, and an expandable minimap.
+ * When rendered inside `VectorViewport` (e.g. via the `navMenu` slot), data props default
+ * to values from {@link CanvuChromeContext}; pass any prop to override.
+ */
+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;
+};
+declare function NavMenu({ camera: cameraProp, viewportWidth: viewportWidthProp, viewportHeight: viewportHeightProp, items: itemsProp, zoomPercent: zoomPercentProp, onZoomIn: onZoomInProp, onZoomOut: onZoomOutProp, onUndo: onUndoProp, onRedo: onRedoProp, canUndo: canUndoProp, canRedo: canRedoProp, onRequestRender: onRequestRenderProp, position, inset, zIndex, className, style, }: NavMenuProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Persistence adapter that stores the document JSON in IndexedDB and manages
+ * image blobs separately. Images are stored at original resolution in a dedicated
+ * `images` object store via {@link IndexedDbImageStore}, keeping the document JSON
+ * lightweight and enabling full-resolution zoom without blur.
+ *
+ * On load, blob URLs are created from the stored blobs and `childrenSvg` is
+ * rebuilt for each image item. Blob URLs are session-scoped and revoked on
+ * subsequent saves / cleanup.
+ */
+declare function createIndexedDbPersistenceAdapter(options?: {
+    dbName?: string;
+}): VectorCanvasPersistenceAdapter;
+
+declare const DEFAULT_VECTOR_CANVAS_STORAGE_KEY = "trazo.vector-canvas.v1";
+type CreateLocalStoragePersistenceAdapterOptions = {
+    /** Defaults to {@link DEFAULT_VECTOR_CANVAS_STORAGE_KEY} */
+    key?: string;
+    /** Defaults to `window.localStorage` when `typeof window !== "undefined"` */
+    storage?: Storage | null;
+};
+/**
+ * Default persistence: `JSON.stringify` snapshot under a single localStorage key.
+ * Pass the same `key` in every session to restore the board.
+ */
+declare function createLocalStoragePersistenceAdapter(options?: CreateLocalStoragePersistenceAdapterOptions): VectorCanvasPersistenceAdapter;
+declare function createNoopPersistenceAdapter(): VectorCanvasPersistenceAdapter;
+
+type UseVectorCanvasDocumentOptions = {
+    /**
+     * Storage key for the built-in localStorage adapter (ignored if `persistence` is set).
+     * @default {@link DEFAULT_VECTOR_CANVAS_STORAGE_KEY}
+     */
+    persistenceKey?: string;
+    /**
+     * Custom persistence (Postgres via API, IndexedDB, …).
+     * - `undefined` → default **localStorage** adapter with `persistenceKey`
+     * - `false` → no persistence (memory only)
+     */
+    persistence?: VectorCanvasPersistenceAdapter | false;
+    /** Debounce before writing to storage after edits. @default 400 */
+    debounceMs?: number;
+    /**
+     * Optional: WebSocket / server sync — `subscribe` receives remote `items`;
+     * `send` is called after local edits (after debounce) so you can push upstream.
+     */
+    remote?: VectorCanvasRemoteAdapter;
+};
+type UseVectorCanvasDocumentResult = {
+    items: VectorSceneItem[];
+    /** Pass to `VectorViewport` `onItemsChange` */
+    onItemsChange: (next: VectorSceneItem[]) => void;
+    /** Same as `onItemsChange`; included for flexibility */
+    setItems: (next: VectorSceneItem[]) => void;
+    /** `false` until the first `load()` finished (avoid SSR flash / empty overwrite) */
+    isHydrated: boolean;
+    /** Clear persisted snapshot (and reset state to `[]`) */
+    clearPersistedDocument: () => void;
+};
+/**
+ * Default **localStorage** persistence + optional **remote** sync hook.
+ *
+ * @example
+ * ```tsx
+ * const doc = useVectorCanvasDocument();
+ * return (
+ *   <VectorViewport
+ *     items={doc.items}
+ *     onItemsChange={doc.onItemsChange}
+ *     interactive
+ *     ariaLabel="Board"
+ *   />
+ * );
+ * ```
+ *
+ * @example Custom API
+ * ```ts
+ * const persistence = useMemo(() => ({
+ *   load: () => fetch("/api/board").then((r) => r.json()),
+ *   save: (snap) => fetch("/api/board", { method: "PUT", body: JSON.stringify(snap) }),
+ * }), []);
+ * useVectorCanvasDocument({ persistence });
+ * ```
+ */
+declare function useVectorCanvasDocument(options?: UseVectorCanvasDocumentOptions): UseVectorCanvasDocumentResult;
+
+/**
+ * CSS `cursor` for the active toolbar tool id (see default vector tools).
+ * SVG cursors matching Lucide toolbar glyphs are used for freehand tools only.
+ * Shape tools keep the old native crosshair cursor.
+ */
+declare function cursorForVectorToolId(toolId: string): string;
+
+type CreateToolPluginOptions = VectorToolDefinition & {
+    /**
+     * Optional custom placement factory for tools that create scene items directly.
+     *
+     * When provided, the resulting plugin contributes a `customPlacement` entry for this tool id.
+     */
+    createItem?: (args: {
+        id: string;
+        bounds: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+    }) => VectorSceneItem;
+    /**
+     * Optional tool list transform applied after this tool is merged.
+     *
+     * Use this when you need custom ordering or to replace an existing tool position.
+     */
+    toolTransform?: (tools: VectorToolDefinition[]) => VectorToolDefinition[];
+};
+/**
+ * Creates a lightweight plugin that contributes a single tool to `VectorViewport`.
+ *
+ * Use this for isolated tools such as custom shapes, review pins, or lightweight creation flows.
+ * For larger features that also need presence, panels, or network integration, prefer a dedicated
+ * feature plugin such as `realtimeCollaborationPlugin(...)`.
+ */
+declare function createToolPlugin(options: CreateToolPluginOptions): CanvasPlugin;
+
+type ShapeContextMenuProps = {
+    /** Viewport client coordinates (from `clientX` / `clientY`). */
+    x: number;
+    y: number;
+    /** When true, all selected items are locked — action is “unlock”. */
+    allSelectedLocked: boolean;
+    onClose: () => void;
+    onToggleLock: () => void;
+    onCut: () => void;
+    onCopy: () => void;
+    onBringToFront: () => void;
+    onBringForward: () => void;
+    onSendBackward: () => void;
+    onSendToBack: () => void;
+    onDuplicate: () => void;
+    onDelete: () => void;
+};
+/**
+ * Floating menu for shape actions (reorder, clipboard, lock, delete).
+ * Renders in a portal and closes on Escape or outside click.
+ */
+declare function ShapeContextMenu({ x, y, allSelectedLocked, onClose, onToggleLock, onCut, onCopy, onBringToFront, onBringForward, onSendBackward, onSendToBack, onDuplicate, onDelete, }: ShapeContextMenuProps): react.ReactPortal | null;
+
+/**
+ * Tool ids shown in the overflow menu at the end of the default toolbar (horizontal layout).
+ * Order: shapes, marker, laser, image.
+ */
+declare const DEFAULT_OVERFLOW_TOOL_IDS: readonly ["rect", "ellipse", "line", "marker", "laser", "image"];
+/**
+ * Opinionated default tool strip using [Lucide](https://lucide.dev) icons.
+ * Pass a subset or your own list via {@link VectorToolbarProps.tools}.
+ */
+declare const DEFAULT_VECTOR_TOOLS: VectorToolDefinition[];
+
+type IconProps = SVGProps<SVGSVGElement>;
+declare function IconHand(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function IconSelect(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function IconRect(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function IconEllipse(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function IconLine(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function IconArrow(props: IconProps): react_jsx_runtime.JSX.Element;
+declare function IconDraw(props: IconProps): react_jsx_runtime.JSX.Element;
+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 VectorToolbarRenderContext = {
+    tools: VectorToolDefinition[];
+    selectedId: string;
+    selectTool: (id: string) => void;
+    toolLocked: boolean;
+    setToolLocked: (locked: boolean) => void;
+};
+type VectorToolbarProps = {
+    /** Controlled selection. */
+    value: string;
+    onChange: (toolId: string) => void;
+    /** Defaults to {@link DEFAULT_VECTOR_TOOLS}. */
+    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.
+     */
+    overflowToolIds?: readonly string[];
+    /** Accessible name for the overflow trigger (menu button). Default: `"More tools"`. */
+    overflowMenuAriaLabel?: string;
+    /** Accessible name for the toolbar landmark. */
+    "aria-label"?: string;
+    className?: string;
+    /** Layout direction. */
+    orientation?: "horizontal" | "vertical";
+    /** Optional style for the outer `role="toolbar"` element. */
+    style?: CSSProperties;
+    /** Class names applied to every tool button. */
+    buttonClassName?: string;
+    /** Extra class names when that tool is selected. */
+    activeButtonClassName?: string;
+    /** Shows a lock toggle that keeps current tool active after use. */
+    showToolLockToggle?: boolean;
+    /** Controlled lock state for tool persistence. */
+    toolLocked?: boolean;
+    /** Called when lock state changes. */
+    onToolLockedChange?: (locked: boolean) => void;
+    /** `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.
+     */
+    children?: (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.
+     */
+    renderToolButton?: (props: {
+        tool: VectorToolDefinition;
+        selected: boolean;
+        onSelect: () => void;
+    }) => 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.
+ *
+ * @example
+ * ```tsx
+ * const [tool, setTool] = useState("hand");
+ * <VectorToolbar value={tool} onChange={setTool} aria-label="Canvas tools" />
+ * ```
+ */
+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;
+    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;
+};
+/**
+ * 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.
+ */
+declare function ViewportZoomControls({ zoomPercent, onZoomIn, onZoomOut, className, position, inset, zIndex, style, }: ViewportZoomControlsProps): react_jsx_runtime.JSX.Element;
+
+export { type BoardComponentPosition, CanvasPlugin, type CanvuChromeActiveToolStyle, CanvuChromeContext, type CanvuChromeContextValue, type CanvuChromeSelectionStyleChange, 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, NavMenu, type NavMenuProps, ShapeContextMenu, type ShapeContextMenuProps, type UseVectorCanvasDocumentOptions, type UseVectorCanvasDocumentResult, VectorCanvas, VectorCanvasBody, VectorCanvasHeader, VectorCanvasMain, VectorCanvasPersistenceAdapter, VectorCanvasRemoteAdapter, VectorCanvasRoot, type VectorCanvasSlotProps, type VectorCanvasSpacePosition, type VectorCanvasSpaceProps, VectorCanvasToolbar, type VectorCanvasToolbarProps, VectorCanvasViewportSurface, VectorSelectionInspector, type VectorSelectionInspectorProps, VectorToolDefinition, VectorToolbar, type VectorToolbarProps, type VectorToolbarRenderContext, ViewportZoomControls, type ViewportZoomControlsProps, createIndexedDbPersistenceAdapter, createLocalStoragePersistenceAdapter, createNoopPersistenceAdapter, createToolPlugin, cursorForVectorToolId, getBoardPositionStyle, useCanvuChromeContext, useVectorCanvasDocument };