leaflet-tual 0.1.0 → 1.0.0

package/dist/react.d.ts

@@ -12,7 +12,7 @@ type ScreenPoint = {
 };
 type ArrowStyle = 'linear' | 'curved' | 'bi' | 'elbow' | 's-curve';
 type ShapeKind = 'square' | 'circle' | 'star' | 'actor' | 'triangle' | 'diamond' | 'hexagon' | 'marker';
-type CanvasTool = 'select' | 'freedraw' | 'arrow-linear' | 'arrow-curved' | 'arrow-bi' | 'arrow-elbow' | 'arrow-s-curve' | 'shape' | 'ruler' | 'note' | 'text';
+type TualTool = 'select' | 'freedraw' | 'arrow-linear' | 'arrow-curved' | 'arrow-bi' | 'arrow-elbow' | 'arrow-s-curve' | 'shape' | 'ruler' | 'note' | 'text';
 type ToolbarToolGroupId = 'select' | 'freedraw' | 'arrow' | 'shape' | 'ruler' | 'note' | 'text';
 type ArrowHeadStyle = 'triangle' | 'open' | 'both' | 'none';
 interface ArrowItem {
@@ -95,11 +95,11 @@ interface RulerItem {
     unit?: 'metric' | 'imperial';
     createdAt: number;
 }
-type CanvasItem = ArrowItem | FreeDrawItem | ShapeItem | NoteItem | TextItem | RulerItem;
+type TualItem = ArrowItem | FreeDrawItem | ShapeItem | NoteItem | TextItem | RulerItem;
 
 type ToolbarPosition = 'top' | 'bottom' | 'left' | 'right' | 'top-center' | 'bottom-center' | 'left-center' | 'right-center';
 type ToolbarOrientation = 'horizontal' | 'vertical';
-interface CanvasLabels {
+interface TualLabels {
     select?: string;
     freedraw?: string;
     arrowGroup?: string;
@@ -153,7 +153,7 @@ interface CanvasLabels {
     collapseToolbar?: string;
     expandToolbar?: string;
 }
-interface CanvasAnnotationTheme {
+interface TualAnnotationTheme {
     selectionGlowColor?: string;
     selectionGlowWidth?: number;
     guideLineDash?: readonly number[];
@@ -183,8 +183,8 @@ interface CanvasAnnotationTheme {
     labelMaxTextWidth?: number;
     fitLabelsToShape?: boolean;
 }
-type ArrowRenderTheme = CanvasAnnotationTheme;
-interface LeafletCanvasClassNames {
+type ArrowRenderTheme = TualAnnotationTheme;
+interface LeafletTualClassNames {
     overlay?: string;
     canvas?: string;
     drawingSurface?: string;
@@ -250,7 +250,7 @@ interface DraftRulerState {
     startGeo: GeoPoint;
     currentGeo: GeoPoint;
 }
-interface CanvasOverlayOptions {
+interface TualOverlayOptions {
     interactive?: boolean;
     readOnly?: boolean;
     zIndex?: number;
@@ -260,29 +260,29 @@ interface CanvasOverlayOptions {
     defaultFontSize?: number;
     defaultShape?: ShapeKind;
 }
-interface UseLeafletCanvasOptions extends CanvasOverlayOptions {
-    initialItems?: CanvasItem[];
-    items?: CanvasItem[];
+interface UseLeafletTualOptions extends TualOverlayOptions {
+    initialItems?: TualItem[];
+    items?: TualItem[];
     maxHistory?: number;
-    onItemsChange?: (items: CanvasItem[]) => void;
-    onChange?: (items: CanvasItem[]) => void;
-    onChangeComplete?: (items: CanvasItem[], targetItem?: CanvasItem | null) => void;
-    onItemsChangeComplete?: (items: CanvasItem[], targetItem?: CanvasItem | null) => void;
-    onEditEnd?: (items: CanvasItem[], targetItem?: CanvasItem | null) => void;
-    onEditComplete?: (items: CanvasItem[], targetItem?: CanvasItem | null) => void;
-    onItemSelect?: (item: CanvasItem | null) => void;
-    onItemCreate?: (item: CanvasItem) => void;
-    onItemChange?: (item: CanvasItem) => void;
+    onItemsChange?: (items: TualItem[]) => void;
+    onChange?: (items: TualItem[]) => void;
+    onChangeComplete?: (items: TualItem[], targetItem?: TualItem | null) => void;
+    onItemsChangeComplete?: (items: TualItem[], targetItem?: TualItem | null) => void;
+    onEditEnd?: (items: TualItem[], targetItem?: TualItem | null) => void;
+    onEditComplete?: (items: TualItem[], targetItem?: TualItem | null) => void;
+    onItemSelect?: (item: TualItem | null) => void;
+    onItemCreate?: (item: TualItem) => void;
+    onItemChange?: (item: TualItem) => void;
     onItemDelete?: (id: string) => void;
-    onItemChangeComplete?: (item: CanvasItem) => void;
-    initialTool?: CanvasTool;
-    onToolChange?: (tool: CanvasTool) => void;
-}
-type LeafletCanvasOptions = UseLeafletCanvasOptions;
-interface LeafletCanvasController {
-    items: CanvasItem[];
-    activeTool: CanvasTool;
-    setActiveTool: (tool: CanvasTool) => void;
+    onItemChangeComplete?: (item: TualItem) => void;
+    initialTool?: TualTool;
+    onToolChange?: (tool: TualTool) => void;
+}
+type LeafletTualOptions = UseLeafletTualOptions;
+interface LeafletTualController {
+    items: TualItem[];
+    activeTool: TualTool;
+    setActiveTool: (tool: TualTool) => void;
     readOnly: boolean;
     setReadOnly: (readOnly: boolean) => void;
     activeShape: ShapeKind;
@@ -291,7 +291,7 @@ interface LeafletCanvasController {
     setShapeFilled: (filled: boolean) => void;
     selectedId: string | null;
     setSelectedId: (id: string | null) => void;
-    selectedItem: CanvasItem | null;
+    selectedItem: TualItem | null;
     isEditingLabel?: boolean;
     setEditingLabel?: (editing: boolean) => void;
     labelEditMode?: boolean;
@@ -308,20 +308,20 @@ interface LeafletCanvasController {
     setFontSize: (size: number) => void;
     fontWeight: 'normal' | 'bold';
     setFontWeight: (weight: 'normal' | 'bold') => void;
-    addItem: (item: CanvasItem) => void;
-    updateItem: (id: string, patch: Partial<CanvasItem>) => void;
+    addItem: (item: TualItem) => void;
+    updateItem: (id: string, patch: Partial<TualItem>) => void;
     removeItem: (id: string) => void;
     deleteSelected: () => void;
     clearAll: () => void;
     clear: () => void;
     deleteItem: (id: string) => void;
-    setTool: (tool: CanvasTool) => void;
+    setTool: (tool: TualTool) => void;
     selectItem: (id: string | null) => void;
     undo: () => void;
     redo: () => void;
     canUndo: boolean;
     canRedo: boolean;
-    notifyChangeComplete: (targetItem?: CanvasItem | null) => void;
+    notifyChangeComplete: (targetItem?: TualItem | null) => void;
     exportJSON: () => string;
     importJSON: (json: string) => boolean;
 }
@@ -348,7 +348,7 @@ declare const FONT_SIZE_OPTIONS: readonly number[];
 /**
  * Super simple unified annotation default theme matching basic HTML element appearance.
  */
-declare const DEFAULT_ANNOTATION_THEME: Readonly<CanvasAnnotationTheme>;
+declare const DEFAULT_ANNOTATION_THEME: Readonly<TualAnnotationTheme>;
 
 declare function createId(prefix?: string): string;
 declare function geoToScreen(map: L.Map, point: GeoPoint): ScreenPoint;
@@ -364,7 +364,7 @@ declare function getMapDimensions(map: L.Map | null | undefined): {
     width: number;
     height: number;
 } | null;
-declare function truncateCanvasText(ctx: CanvasRenderingContext2D, text: string, maxWidth: number): string;
+declare function truncateTualText(ctx: CanvasRenderingContext2D, text: string, maxWidth: number): string;
 declare function calculateZoomFontSize(initialFontSize: number | undefined, currentZoom: number | null, baseZoom?: number, options?: {
     min?: number;
     max?: number;
@@ -374,8 +374,8 @@ declare function calculateGeodesicDistance(p1: GeoPoint, p2: GeoPoint): number;
 declare function formatRealWorldDistance(meters: number, unit?: 'metric' | 'imperial'): string;
 declare function calculateLineDistance(points: GeoPoint[]): number;
 
-declare function drawCanvasHandle(ctx: CanvasRenderingContext2D, pt: ScreenPoint, strokeColor: string, fillColor: string, radius: number, strokeWidth?: number): void;
-declare function drawCanvasLabelPill(ctx: CanvasRenderingContext2D, label: string, midX: number, midY: number, strokeColor: string, maxAllowedBoxWidth: number, theme?: CanvasAnnotationTheme): void;
+declare function drawTualHandle(ctx: CanvasRenderingContext2D, pt: ScreenPoint, strokeColor: string, fillColor: string, radius: number, strokeWidth?: number): void;
+declare function drawTualLabelPill(ctx: CanvasRenderingContext2D, label: string, midX: number, midY: number, strokeColor: string, maxAllowedBoxWidth: number, theme?: TualAnnotationTheme): void;
 
 type ArrowHandleType = 'start' | 'end' | 'control';
 interface ProjectedArrow {
@@ -399,7 +399,7 @@ declare function projectFreeDraw(map: L.Map, item: Pick<FreeDrawItem, 'points'>)
 declare function renderFreeDrawOnCanvas(ctx: CanvasRenderingContext2D, screenPoints: ScreenPoint[], item: Pick<FreeDrawItem, 'color' | 'strokeWidth' | 'dashed'>, options?: {
     isSelected?: boolean;
     isPreview?: boolean;
-    theme?: CanvasAnnotationTheme;
+    theme?: TualAnnotationTheme;
 }): void;
 declare function hitTestFreeDraw(point: ScreenPoint, screenPoints: ScreenPoint[], item: FreeDrawItem, tolerance?: number): boolean;
 
@@ -420,12 +420,12 @@ declare function projectShape(map: L.Map, shape: ShapeItem): ProjectedShape;
 declare function renderShapeOnCanvas(ctx: CanvasRenderingContext2D, projected: ProjectedShape, shape: Pick<ShapeItem, 'shape' | 'color' | 'fillColor' | 'filled' | 'strokeWidth' | 'dashed' | 'label'>, options?: {
     isSelected?: boolean;
     isPreview?: boolean;
-    theme?: CanvasAnnotationTheme;
+    theme?: TualAnnotationTheme;
 }): void;
 declare function hitTestShapeHandle(point: ScreenPoint, projected: ProjectedShape, tolerance?: number): ShapeHandleType | null;
 declare function hitTestShape(point: ScreenPoint, projected: ProjectedShape, tolerance?: number): boolean;
 
-declare function tracePolygonShape(ctx: CanvasRenderingContext2D, proj: ProjectedShape, kind: ShapeKind, theme?: CanvasAnnotationTheme): void;
+declare function tracePolygonShape(ctx: CanvasRenderingContext2D, proj: ProjectedShape, kind: ShapeKind, theme?: TualAnnotationTheme): void;
 
 type RulerHandleType = 'start' | 'end';
 interface ProjectedRuler {
@@ -439,7 +439,7 @@ declare function projectRuler(map: L.Map, ruler: Pick<RulerItem, 'start' | 'end'
 declare function renderRulerOnCanvas(ctx: CanvasRenderingContext2D, projected: ProjectedRuler, ruler: Pick<RulerItem, 'start' | 'end' | 'color' | 'strokeWidth' | 'dashed' | 'label' | 'unit'>, options?: {
     isSelected?: boolean;
     isPreview?: boolean;
-    theme?: CanvasAnnotationTheme;
+    theme?: TualAnnotationTheme;
 }): void;
 declare function hitTestRulerHandle(point: ScreenPoint, projected: ProjectedRuler, tolerance?: number): RulerHandleType | null;
 declare function hitTestRuler(point: ScreenPoint, projected: ProjectedRuler, ruler: RulerItem, tolerance?: number): boolean;
@@ -482,7 +482,7 @@ declare function startFreeDrawBodyDrag(map: L.Map, fd: FreeDrawItem, initialScre
 declare function startRulerHandleDrag(map: L.Map, ruler: RulerItem, projected: ProjectedRuler, handle: RulerHandleType, getLocalPoint: (e: PointerEvent) => ScreenPoint, updateItem: (id: string, patch: Partial<RulerItem>) => void): void;
 declare function startRulerBodyDrag(map: L.Map, ruler: RulerItem, projected: ProjectedRuler, originPt: ScreenPoint, getLocalPoint: (e: PointerEvent) => ScreenPoint, updateItem: (id: string, patch: Partial<RulerItem>) => void): void;
 
-interface PaintLeafletCanvasOptions {
+interface PaintLeafletTualOptions {
     map: L.Map | null;
     canvas: HTMLCanvasElement | null;
     width: number;
@@ -503,11 +503,11 @@ interface PaintLeafletCanvasOptions {
     strokeWidth: number;
     dashed: boolean;
     shapeFilled: boolean;
-    annotationTheme?: CanvasAnnotationTheme;
+    annotationTheme?: TualAnnotationTheme;
     arrowTheme?: ArrowRenderTheme;
     isReadOnly: boolean;
 }
-declare function paintLeafletCanvas({ map, canvas, width, height, arrowItems, shapeItems, freeDrawItems, rulerItems, selectedId, draftShape, draftArrow, draftRuler, draftFreeDraw, activeColor, strokeWidth, dashed, shapeFilled, annotationTheme, arrowTheme, isReadOnly, }: PaintLeafletCanvasOptions): void;
+declare function paintLeafletTual({ map, canvas, width, height, arrowItems, shapeItems, freeDrawItems, rulerItems, selectedId, draftShape, draftArrow, draftRuler, draftFreeDraw, activeColor, strokeWidth, dashed, shapeFilled, annotationTheme, arrowTheme, isReadOnly, }: PaintLeafletTualOptions): void;
 
 interface MapViewportDimensions {
     width: number;
@@ -516,29 +516,27 @@ interface MapViewportDimensions {
 declare function bindLeafletSync(map: L.Map, onSync: (dimensions: MapViewportDimensions) => void): () => void;
 declare function bindBlockMapDblClick(map: L.Map): () => void;
 
-interface LeafletCanvasStore extends LeafletCanvasController {
-    subscribe: (listener: (controller: LeafletCanvasController) => void) => () => void;
-    getState: () => LeafletCanvasController;
+interface LeafletTualStore extends LeafletTualController {
+    subscribe: (listener: (controller: LeafletTualController) => void) => () => void;
+    getState: () => LeafletTualController;
     destroy: () => void;
 }
-declare function createLeafletCanvasController(options?: UseLeafletCanvasOptions): LeafletCanvasStore;
-declare const createLeafletTualController: typeof createLeafletCanvasController;
+declare function createLeafletTualController(options?: UseLeafletTualOptions): LeafletTualStore;
 
-interface CreateLeafletCanvasOptions extends UseLeafletCanvasOptions {
-    controller?: LeafletCanvasStore;
-    annotationTheme?: CanvasAnnotationTheme;
+interface CreateLeafletTualOptions extends UseLeafletTualOptions {
+    controller?: LeafletTualStore;
+    annotationTheme?: TualAnnotationTheme;
     arrowTheme?: ArrowRenderTheme;
-    labels?: CanvasLabels;
+    labels?: TualLabels;
 }
-interface LeafletCanvasInstance {
-    controller: LeafletCanvasStore;
+interface LeafletTualInstance {
+    controller: LeafletTualStore;
     container: HTMLDivElement;
     canvas: HTMLCanvasElement;
     repaint: () => void;
     destroy: () => void;
 }
-declare function createLeafletCanvas(map: L.Map, options?: CreateLeafletCanvasOptions): LeafletCanvasInstance;
-declare const createLeafletTual: typeof createLeafletCanvas;
+declare function createLeafletTual(map: L.Map, options?: CreateLeafletTualOptions): LeafletTualInstance;
 
 /**
  * leaflet-tual — core (framework-agnostic)
@@ -552,13 +550,13 @@ declare const createLeafletTual: typeof createLeafletCanvas;
  * dependency on React or any UI framework, so it can be used directly from
  * vanilla JavaScript, TypeScript, Vue, Svelte, Angular, or a plain `<script>` tag.
  *
- * React users: see `leaflet-tual/react` for `<LeafletCanvas>`, `<CanvasToolbar>`,
- * `useLeafletCanvas`, and `useLeafletSync`.
+ * React users: see `leaflet-tual/react` for `<LeafletTual>`, `<TualToolbar>`,
+ * `useLeafletTual`, and `useLeafletSync`.
  */
 
 declare const VERSION: string;
 
-interface CanvasIcons {
+interface TualIcons {
     select?: React__default.ReactNode;
     freedraw?: React__default.ReactNode;
     arrowGroup?: React__default.ReactNode;
@@ -598,8 +596,8 @@ interface CanvasIcons {
     collapseToolbar?: React__default.ReactNode;
     expandToolbar?: React__default.ReactNode;
 }
-type LeafletCanvasStyles = {
-    [K in keyof LeafletCanvasClassNames]?: React__default.CSSProperties;
+type LeafletTualStyles = {
+    [K in keyof LeafletTualClassNames]?: React__default.CSSProperties;
 };
 
 interface CustomToolbarItem {
@@ -609,8 +607,8 @@ interface CustomToolbarItem {
     icon?: React__default.ReactNode;
     isActive?: boolean;
     disabled?: boolean;
-    onClick?: (controller: LeafletCanvasController) => void;
-    render?: (controller: LeafletCanvasController) => React__default.ReactNode;
+    onClick?: (controller: LeafletTualController) => void;
+    render?: (controller: LeafletTualController) => React__default.ReactNode;
 }
 interface DragHandleTriggerProps {
     onPointerDown: (e: React__default.PointerEvent<HTMLElement>) => void;
@@ -644,9 +642,9 @@ interface RenderTextProps {
     onUpdate: (patch: Partial<TextItem>) => void;
     onDelete: () => void;
 }
-interface LeafletCanvasProps extends UseLeafletCanvasOptions {
+interface LeafletTualProps extends UseLeafletTualOptions {
     map?: L.Map | null;
-    controller?: LeafletCanvasController;
+    controller?: LeafletTualController;
     readOnly?: boolean;
     showToolbar?: boolean;
     toolbarPosition?: ToolbarPosition;
@@ -663,17 +661,17 @@ interface LeafletCanvasProps extends UseLeafletCanvasOptions {
     showDeleteButton?: boolean;
     showClearButton?: boolean;
     showToolLabels?: boolean;
-    labels?: CanvasLabels;
-    icons?: CanvasIcons;
+    labels?: TualLabels;
+    icons?: TualIcons;
     unstyled?: boolean;
-    classNames?: LeafletCanvasClassNames;
-    styles?: LeafletCanvasStyles;
-    annotationTheme?: CanvasAnnotationTheme;
+    classNames?: LeafletTualClassNames;
+    styles?: LeafletTualStyles;
+    annotationTheme?: TualAnnotationTheme;
     arrowTheme?: ArrowRenderTheme;
     strokeColors?: readonly string[];
     strokeWidthOptions?: readonly number[];
     fontSizeOptions?: readonly number[];
-    renderToolbar?: (controller: LeafletCanvasController) => React__default.ReactNode;
+    renderToolbar?: (controller: LeafletTualController) => React__default.ReactNode;
     renderNote?: (props: RenderNoteProps) => React__default.ReactNode;
     renderText?: (props: RenderTextProps) => React__default.ReactNode;
     clampOverlaysToViewport?: boolean;
@@ -686,7 +684,7 @@ interface LeafletCanvasProps extends UseLeafletCanvasOptions {
 interface InlineShapeLabelEditorProps {
     shape: ShapeItem;
     map: L.Map;
-    labels?: CanvasLabels;
+    labels?: TualLabels;
     onUpdate: (id: string, patch: Partial<ShapeItem>) => void;
     onClose: () => void;
 }
@@ -698,11 +696,11 @@ interface NoteOverlayProps {
     isSelected: boolean;
     map: L.Map;
     readOnly?: boolean;
-    labels?: CanvasLabels;
-    icons?: CanvasIcons;
+    labels?: TualLabels;
+    icons?: TualIcons;
     unstyled?: boolean;
-    classNames?: LeafletCanvasClassNames;
-    styles?: LeafletCanvasStyles;
+    classNames?: LeafletTualClassNames;
+    styles?: LeafletTualStyles;
     clampToViewport?: boolean;
     autoMinimizeZoomThreshold?: number;
     renderNote?: (props: RenderNoteProps) => React__default.ReactNode;
@@ -721,11 +719,11 @@ interface TextOverlayProps {
     isEditingLabel?: boolean;
     map: L.Map;
     readOnly?: boolean;
-    labels?: CanvasLabels;
-    icons?: CanvasIcons;
+    labels?: TualLabels;
+    icons?: TualIcons;
     unstyled?: boolean;
-    classNames?: LeafletCanvasClassNames;
-    styles?: LeafletCanvasStyles;
+    classNames?: LeafletTualClassNames;
+    styles?: LeafletTualStyles;
     clampToViewport?: boolean;
     autoMinimizeZoomThreshold?: number;
     renderText?: (props: RenderTextProps) => React__default.ReactNode;
@@ -747,11 +745,10 @@ interface MapViewportState {
  */
 declare function useLeafletSync(map: L.Map | null): MapViewportState;
 
-declare function useLeafletCanvas(options?: UseLeafletCanvasOptions): LeafletCanvasController;
-declare const useLeafletTual: typeof useLeafletCanvas;
+declare function useLeafletTual(options?: UseLeafletTualOptions): LeafletTualController;
 
-interface CanvasToolbarProps {
-    controller: LeafletCanvasController;
+interface TualToolbarProps {
+    controller: LeafletTualController;
     position?: ToolbarPosition;
     orientation?: ToolbarOrientation;
     collapsible?: boolean;
@@ -766,11 +763,11 @@ interface CanvasToolbarProps {
     showDeleteButton?: boolean;
     showClearButton?: boolean;
     showToolLabels?: boolean;
-    labels?: CanvasLabels;
-    icons?: CanvasIcons;
+    labels?: TualLabels;
+    icons?: TualIcons;
     unstyled?: boolean;
-    classNames?: LeafletCanvasClassNames;
-    styles?: LeafletCanvasStyles;
+    classNames?: LeafletTualClassNames;
+    styles?: LeafletTualStyles;
     strokeColors?: readonly string[];
     strokeWidthOptions?: readonly number[];
     fontSizeOptions?: readonly number[];
@@ -778,7 +775,7 @@ interface CanvasToolbarProps {
     style?: React__default.CSSProperties;
 }
 
-declare function CanvasToolbar({ controller, position, orientation: propOrientation, collapsible, defaultCollapsed, collapsed: propCollapsed, onCollapsedChange, showCollapseButton, readOnly: propReadOnly, enabledTools, customTools, showHistoryControls, showDeleteButton, showClearButton, showToolLabels: explicitShowToolLabels, labels, icons, unstyled, classNames, styles, strokeColors, strokeWidthOptions, fontSizeOptions, className, style, }: CanvasToolbarProps): React.JSX.Element;
+declare function TualToolbar({ controller, position, orientation: propOrientation, collapsible, defaultCollapsed, collapsed: propCollapsed, onCollapsedChange, showCollapseButton, readOnly: propReadOnly, enabledTools, customTools, showHistoryControls, showDeleteButton, showClearButton, showToolLabels: explicitShowToolLabels, labels, icons, unstyled, classNames, styles, strokeColors, strokeWidthOptions, fontSizeOptions, className, style, }: TualToolbarProps): React.JSX.Element;
 
 interface PixelSelectProps {
     /** Visible label and accessible name. */
@@ -791,9 +788,9 @@ interface PixelSelectProps {
     /** Optional data attribute to distinguish multiple selects. */
     control?: string;
     unstyled?: boolean;
-    classNames?: LeafletCanvasClassNames;
-    styles?: LeafletCanvasStyles;
-    icons?: CanvasIcons;
+    classNames?: LeafletTualClassNames;
+    styles?: LeafletTualStyles;
+    icons?: TualIcons;
 }
 /**
  * Labeled `<select>` listing pixel values (e.g. `1px`, `2px`, ...).
@@ -818,6 +815,6 @@ declare function getCollapseChevronRotation(position?: ToolbarPosition, orientat
  */
 declare function getExpandChevronRotation(position?: ToolbarPosition, orientation?: ToolbarOrientation): string;
 
-declare function LeafletCanvas(props: LeafletCanvasProps): React.JSX.Element;
+declare function LeafletTual(props: LeafletTualProps): React.JSX.Element;
 
-export { type ArrowHandleType, type ArrowHeadStyle, type ArrowItem, type ArrowRenderTheme, type ArrowStyle, type CanvasAnnotationTheme, type CanvasIcons, type CanvasItem, type CanvasLabels, type CanvasOverlayOptions, type CanvasTool, CanvasToolbar, type CanvasToolbarProps, type CreateLeafletCanvasOptions, type CustomToolbarItem, DEFAULT_ANNOTATION_THEME, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE_OPTIONS, DEFAULT_NOTE_BG, DEFAULT_NOTE_TEXT, DEFAULT_STROKE_COLOR, DEFAULT_STROKE_WIDTH, DEFAULT_STROKE_WIDTH_OPTIONS, type DraftArrowState, type DraftRulerState, type DraftShapeState, type DragHandleTriggerProps, FONT_SIZE_OPTIONS, type FreeDrawItem, type GeoPoint, InlineShapeLabelEditor, type InlineShapeLabelEditorProps, LeafletCanvas, type LeafletCanvasClassNames, type LeafletCanvasController, type LeafletCanvasInstance, type LeafletCanvasOptions, type LeafletCanvasProps, type LeafletCanvasStore, type LeafletCanvasStyles, type MapViewportDimensions, type MapViewportState, NOTE_COLOR_THEMES, type NoteCollapseState, type NoteColorTheme, type NoteItem, NoteOverlay, type NoteOverlayProps, type PaintLeafletCanvasOptions, PixelSelect, type PixelSelectProps, type ProjectedArrow, type ProjectedRuler, type ProjectedShape, type RenderNoteProps, type RenderTextProps, type ResolvedNoteTheme, type RulerHandleType, type RulerItem, STROKE_COLORS, STROKE_WIDTH_OPTIONS, type ScreenPoint, type ShapeHandleType, type ShapeItem, type ShapeKind, TOOL_TO_ARROW_STYLE, type TextItem, TextOverlay, type TextOverlayProps, type ToolbarOrientation, type ToolbarPosition, type ToolbarToolGroupId, type UseLeafletCanvasOptions, VERSION, bindBlockMapDblClick, bindLeafletSync, buildArrowItem, buildRulerItem, calculateGeodesicDistance, calculateLineDistance, calculateZoomFontSize, clampNotePosition, clampTextPosition, computeDefaultControlGeoPoint, constrainAngleTo45Degrees, constrainToAspectRatio, createDraftNote, createDraftText, createId, createLeafletCanvas, createLeafletCanvasController, createLeafletTual, createLeafletTualController, distanceToQuadraticBezier, distanceToSegment, drawArrowHead, drawCanvasHandle, drawCanvasLabelPill, formatRealWorldDistance, geoToScreen, getCollapseChevronRotation, getDropdownChevronRotation, getExpandChevronRotation, getMapDimensions, getQuadraticBezierPoint, getQuadraticEndAngle, hitTestArrow, hitTestArrowHandle, hitTestFreeDraw, hitTestRuler, hitTestRulerHandle, hitTestShape, hitTestShapeHandle, paintLeafletCanvas, projectArrow, projectFreeDraw, projectRuler, projectShape, renderArrowOnCanvas, renderFreeDrawOnCanvas, renderRulerOnCanvas, renderShapeOnCanvas, resolveNoteTheme, screenToGeo, startArrowBodyDrag, startArrowDrag, startArrowHandleDrag, startFreeDrawBodyDrag, startFreeDrawDrag, startRulerBodyDrag, startRulerDrag, startRulerHandleDrag, startShapeBodyDrag, startShapeDrag, startShapeHandleDrag, traceArrowPath, tracePolygonShape, truncateCanvasText, useLeafletCanvas, useLeafletSync, useLeafletTual };
+export { type ArrowHandleType, type ArrowHeadStyle, type ArrowItem, type ArrowRenderTheme, type ArrowStyle, type CreateLeafletTualOptions, type CustomToolbarItem, DEFAULT_ANNOTATION_THEME, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE_OPTIONS, DEFAULT_NOTE_BG, DEFAULT_NOTE_TEXT, DEFAULT_STROKE_COLOR, DEFAULT_STROKE_WIDTH, DEFAULT_STROKE_WIDTH_OPTIONS, type DraftArrowState, type DraftRulerState, type DraftShapeState, type DragHandleTriggerProps, FONT_SIZE_OPTIONS, type FreeDrawItem, type GeoPoint, InlineShapeLabelEditor, type InlineShapeLabelEditorProps, LeafletTual, type LeafletTualClassNames, type LeafletTualController, type LeafletTualInstance, type LeafletTualOptions, type LeafletTualProps, type LeafletTualStore, type LeafletTualStyles, type MapViewportDimensions, type MapViewportState, NOTE_COLOR_THEMES, type NoteCollapseState, type NoteColorTheme, type NoteItem, NoteOverlay, type NoteOverlayProps, type PaintLeafletTualOptions, PixelSelect, type PixelSelectProps, type ProjectedArrow, type ProjectedRuler, type ProjectedShape, type RenderNoteProps, type RenderTextProps, type ResolvedNoteTheme, type RulerHandleType, type RulerItem, STROKE_COLORS, STROKE_WIDTH_OPTIONS, type ScreenPoint, type ShapeHandleType, type ShapeItem, type ShapeKind, TOOL_TO_ARROW_STYLE, type TextItem, TextOverlay, type TextOverlayProps, type ToolbarOrientation, type ToolbarPosition, type ToolbarToolGroupId, type TualAnnotationTheme, type TualIcons, type TualItem, type TualLabels, type TualOverlayOptions, type TualTool, TualToolbar, type TualToolbarProps, type UseLeafletTualOptions, VERSION, bindBlockMapDblClick, bindLeafletSync, buildArrowItem, buildRulerItem, calculateGeodesicDistance, calculateLineDistance, calculateZoomFontSize, clampNotePosition, clampTextPosition, computeDefaultControlGeoPoint, constrainAngleTo45Degrees, constrainToAspectRatio, createDraftNote, createDraftText, createId, createLeafletTual, createLeafletTualController, distanceToQuadraticBezier, distanceToSegment, drawArrowHead, drawTualHandle, drawTualLabelPill, formatRealWorldDistance, geoToScreen, getCollapseChevronRotation, getDropdownChevronRotation, getExpandChevronRotation, getMapDimensions, getQuadraticBezierPoint, getQuadraticEndAngle, hitTestArrow, hitTestArrowHandle, hitTestFreeDraw, hitTestRuler, hitTestRulerHandle, hitTestShape, hitTestShapeHandle, paintLeafletTual, projectArrow, projectFreeDraw, projectRuler, projectShape, renderArrowOnCanvas, renderFreeDrawOnCanvas, renderRulerOnCanvas, renderShapeOnCanvas, resolveNoteTheme, screenToGeo, startArrowBodyDrag, startArrowDrag, startArrowHandleDrag, startFreeDrawBodyDrag, startFreeDrawDrag, startRulerBodyDrag, startRulerDrag, startRulerHandleDrag, startShapeBodyDrag, startShapeDrag, startShapeHandleDrag, traceArrowPath, tracePolygonShape, truncateTualText, useLeafletSync, useLeafletTual };