@fieldnotes/core 0.8.0 → 0.8.2

package/dist/index.d.ts

@@ -1,875 +0,0 @@
-type Listener<T> = (data: T) => void;
-declare class EventBus<TEvents extends {
-    [K in keyof TEvents]: TEvents[K];
-}> {
-    private listeners;
-    on<K extends keyof TEvents>(event: K, listener: Listener<TEvents[K]>): () => void;
-    off<K extends keyof TEvents>(event: K, listener: Listener<TEvents[K]>): void;
-    emit<K extends keyof TEvents>(event: K, data: TEvents[K]): void;
-    clear(): void;
-}
-
-interface Point {
-    x: number;
-    y: number;
-}
-interface StrokePoint {
-    x: number;
-    y: number;
-    pressure: number;
-}
-interface Size {
-    w: number;
-    h: number;
-}
-type Bounds = Point & Size;
-
-interface BaseElement {
-    id: string;
-    type: string;
-    position: Point;
-    zIndex: number;
-    locked: boolean;
-    layerId: string;
-}
-interface StrokeElement extends BaseElement {
-    type: 'stroke';
-    points: StrokePoint[];
-    color: string;
-    width: number;
-    opacity: number;
-}
-interface NoteElement extends BaseElement {
-    type: 'note';
-    size: Size;
-    text: string;
-    backgroundColor: string;
-    textColor: string;
-}
-interface Binding {
-    elementId: string;
-}
-interface ArrowElement extends BaseElement {
-    type: 'arrow';
-    from: Point;
-    to: Point;
-    bend: number;
-    color: string;
-    width: number;
-    fromBinding?: Binding;
-    toBinding?: Binding;
-}
-interface ImageElement extends BaseElement {
-    type: 'image';
-    size: Size;
-    src: string;
-}
-interface HtmlElement extends BaseElement {
-    type: 'html';
-    size: Size;
-    domId?: string;
-}
-interface TextElement extends BaseElement {
-    type: 'text';
-    size: Size;
-    text: string;
-    fontSize: number;
-    color: string;
-    textAlign: 'left' | 'center' | 'right';
-}
-type ShapeKind = 'rectangle' | 'ellipse';
-interface ShapeElement extends BaseElement {
-    type: 'shape';
-    shape: ShapeKind;
-    size: Size;
-    strokeColor: string;
-    strokeWidth: number;
-    fillColor: string;
-}
-type HexOrientation = 'pointy' | 'flat';
-interface GridElement extends BaseElement {
-    type: 'grid';
-    gridType: 'square' | 'hex';
-    hexOrientation: HexOrientation;
-    cellSize: number;
-    strokeColor: string;
-    strokeWidth: number;
-    opacity: number;
-}
-type CanvasElement = StrokeElement | NoteElement | ArrowElement | ImageElement | HtmlElement | TextElement | ShapeElement | GridElement;
-type ElementType = CanvasElement['type'];
-
-interface Layer {
-    id: string;
-    name: string;
-    visible: boolean;
-    locked: boolean;
-    order: number;
-    opacity: number;
-}
-
-interface CanvasState {
-    version: number;
-    camera: {
-        position: Point;
-        zoom: number;
-    };
-    elements: CanvasElement[];
-    layers?: Layer[];
-}
-declare function exportState(elements: CanvasElement[], camera: {
-    position: Point;
-    zoom: number;
-}, layers?: Layer[]): CanvasState;
-declare function parseState(json: string): CanvasState;
-
-declare function snapPoint(point: Point, gridSize: number): Point;
-
-interface ElementUpdateEvent {
-    previous: CanvasElement;
-    current: CanvasElement;
-}
-interface ElementStoreEvents {
-    add: CanvasElement;
-    remove: CanvasElement;
-    update: ElementUpdateEvent;
-    clear: null;
-}
-declare class ElementStore {
-    private elements;
-    private bus;
-    private layerOrderMap;
-    get count(): number;
-    setLayerOrder(order: Map<string, number>): void;
-    getAll(): CanvasElement[];
-    getById(id: string): CanvasElement | undefined;
-    getElementsByType<T extends ElementType>(type: T): Extract<CanvasElement, {
-        type: T;
-    }>[];
-    add(element: CanvasElement): void;
-    update(id: string, partial: Partial<CanvasElement>): void;
-    remove(id: string): void;
-    clear(): void;
-    snapshot(): CanvasElement[];
-    loadSnapshot(elements: CanvasElement[]): void;
-    on<K extends keyof ElementStoreEvents>(event: K, listener: (data: ElementStoreEvents[K]) => void): () => void;
-}
-
-interface CameraOptions {
-    minZoom?: number;
-    maxZoom?: number;
-}
-declare class Camera {
-    private x;
-    private y;
-    private z;
-    private readonly minZoom;
-    private readonly maxZoom;
-    private changeListeners;
-    constructor(options?: CameraOptions);
-    get position(): Point;
-    get zoom(): number;
-    pan(dx: number, dy: number): void;
-    moveTo(x: number, y: number): void;
-    setZoom(level: number): void;
-    zoomAt(level: number, screenPoint: Point): void;
-    screenToWorld(screen: Point): Point;
-    worldToScreen(world: Point): Point;
-    toCSSTransform(): string;
-    onChange(listener: () => void): () => void;
-    private notifyChange;
-}
-
-declare class LayerManager {
-    private readonly store;
-    private layers;
-    private _activeLayerId;
-    private bus;
-    constructor(store: ElementStore);
-    get activeLayer(): Layer;
-    get activeLayerId(): string;
-    getLayers(): Layer[];
-    getLayer(id: string): Layer | undefined;
-    isLayerVisible(id: string): boolean;
-    isLayerLocked(id: string): boolean;
-    createLayer(name?: string): Layer;
-    removeLayer(id: string): void;
-    renameLayer(id: string, name: string): void;
-    reorderLayer(id: string, newOrder: number): void;
-    setLayerVisible(id: string, visible: boolean): boolean;
-    setLayerLocked(id: string, locked: boolean): boolean;
-    setActiveLayer(id: string): void;
-    moveElementToLayer(elementId: string, layerId: string): void;
-    snapshot(): Layer[];
-    loadSnapshot(layers: Layer[]): void;
-    on(event: 'change', callback: () => void): () => void;
-    addLayerDirect(layer: Layer): void;
-    removeLayerDirect(id: string): void;
-    updateLayerDirect(id: string, props: Omit<Partial<Layer>, 'id'>): void;
-    private syncLayerOrder;
-    private findFallbackLayer;
-}
-
-interface AutoSaveOptions {
-    key?: string;
-    debounceMs?: number;
-    layerManager?: LayerManager;
-}
-declare class AutoSave {
-    private readonly store;
-    private readonly camera;
-    private readonly key;
-    private readonly debounceMs;
-    private readonly layerManager?;
-    private timerId;
-    private unsubscribers;
-    constructor(store: ElementStore, camera: Camera, options?: AutoSaveOptions);
-    start(): void;
-    stop(): void;
-    load(): CanvasState | null;
-    clear(): void;
-    private scheduleSave;
-    private cancelPending;
-    private save;
-}
-
-type BackgroundPattern = 'dots' | 'grid' | 'none';
-interface BackgroundOptions {
-    pattern?: BackgroundPattern;
-    spacing?: number;
-    color?: string;
-    dotRadius?: number;
-    lineWidth?: number;
-}
-declare class Background {
-    private readonly pattern;
-    private readonly spacing;
-    private readonly color;
-    private readonly dotRadius;
-    private readonly lineWidth;
-    constructor(options?: BackgroundOptions);
-    render(ctx: CanvasRenderingContext2D, camera: Camera): void;
-    private adaptSpacing;
-    private renderDots;
-    private renderGrid;
-}
-
-interface ToolContext {
-    camera: Camera;
-    store: ElementStore;
-    requestRender: () => void;
-    switchTool?: (name: string) => void;
-    editElement?: (id: string) => void;
-    setCursor?: (cursor: string) => void;
-    snapToGrid?: boolean;
-    gridSize?: number;
-    activeLayerId?: string;
-    isLayerVisible?: (layerId: string) => boolean;
-    isLayerLocked?: (layerId: string) => boolean;
-}
-interface PointerState {
-    x: number;
-    y: number;
-    pressure: number;
-}
-interface Tool {
-    readonly name: string;
-    onPointerDown(state: PointerState, ctx: ToolContext): void;
-    onPointerMove(state: PointerState, ctx: ToolContext): void;
-    onPointerUp(state: PointerState, ctx: ToolContext): void;
-    onHover?(state: PointerState, ctx: ToolContext): void;
-    onActivate?(ctx: ToolContext): void;
-    onDeactivate?(ctx: ToolContext): void;
-    renderOverlay?(ctx: CanvasRenderingContext2D): void;
-}
-type ToolName = 'hand' | 'select' | 'pencil' | 'eraser' | 'arrow' | 'note' | 'image' | 'text' | 'shape';
-
-declare class ToolManager {
-    private tools;
-    private current;
-    private changeListeners;
-    get activeTool(): Tool | null;
-    get toolNames(): string[];
-    register(tool: Tool): void;
-    getTool<T extends Tool = Tool>(name: string): T | undefined;
-    setTool(name: string, ctx: ToolContext): void;
-    handlePointerDown(state: PointerState, ctx: ToolContext): void;
-    handlePointerMove(state: PointerState, ctx: ToolContext): void;
-    handlePointerUp(state: PointerState, ctx: ToolContext): void;
-    onChange(listener: (name: string) => void): () => void;
-}
-
-interface Command {
-    execute(store: ElementStore): void;
-    undo(store: ElementStore): void;
-}
-
-interface HistoryStackOptions {
-    maxSize?: number;
-}
-declare class HistoryStack {
-    private undoStack;
-    private redoStack;
-    private readonly maxSize;
-    private changeListeners;
-    constructor(options?: HistoryStackOptions);
-    get canUndo(): boolean;
-    get canRedo(): boolean;
-    get undoCount(): number;
-    get redoCount(): number;
-    push(command: Command): void;
-    undo(store: ElementStore): boolean;
-    redo(store: ElementStore): boolean;
-    clear(): void;
-    onChange(listener: () => void): () => void;
-    private notifyChange;
-}
-
-declare class HistoryRecorder {
-    private readonly store;
-    private readonly stack;
-    private recording;
-    private transaction;
-    private updateSnapshots;
-    private unsubscribers;
-    constructor(store: ElementStore, stack: HistoryStack);
-    pause(): void;
-    resume(): void;
-    begin(): void;
-    commit(): void;
-    rollback(): void;
-    destroy(): void;
-    private record;
-    private onAdd;
-    private onRemove;
-    private onUpdate;
-    private flushUpdateSnapshots;
-}
-
-interface InputHandlerOptions {
-    toolManager?: ToolManager;
-    toolContext?: ToolContext;
-    historyRecorder?: HistoryRecorder;
-    historyStack?: HistoryStack;
-}
-declare class InputHandler {
-    private readonly element;
-    private readonly camera;
-    private isPanning;
-    private lastPointer;
-    private spaceHeld;
-    private activePointers;
-    private lastPinchDistance;
-    private lastPinchCenter;
-    private toolManager;
-    private toolContext;
-    private historyRecorder;
-    private historyStack;
-    private isToolActive;
-    private readonly abortController;
-    constructor(element: HTMLElement, camera: Camera, options?: InputHandlerOptions);
-    setToolManager(toolManager: ToolManager, toolContext: ToolContext): void;
-    destroy(): void;
-    private bind;
-    private onWheel;
-    private onPointerDown;
-    private onPointerMove;
-    private onPointerUp;
-    private onKeyDown;
-    private onKeyUp;
-    private startPinch;
-    private handlePinchMove;
-    private getPinchPoints;
-    private distance;
-    private midpoint;
-    private toPointerState;
-    private dispatchToolDown;
-    private dispatchToolMove;
-    private dispatchToolHover;
-    private dispatchToolUp;
-    private deleteSelected;
-    private handleUndo;
-    private handleRedo;
-    private cancelToolIfActive;
-}
-
-interface ExportImageOptions {
-    scale?: number;
-    padding?: number;
-    background?: string;
-    filter?: (element: CanvasElement) => boolean;
-}
-declare function exportImage(store: ElementStore, options?: ExportImageOptions, layerManager?: LayerManager): Promise<Blob | null>;
-
-interface ViewportOptions {
-    camera?: CameraOptions;
-    background?: BackgroundOptions;
-}
-declare class Viewport {
-    private readonly container;
-    readonly camera: Camera;
-    readonly store: ElementStore;
-    readonly layerManager: LayerManager;
-    readonly toolManager: ToolManager;
-    readonly history: HistoryStack;
-    readonly domLayer: HTMLDivElement;
-    private readonly canvasEl;
-    private readonly wrapper;
-    private readonly unsubCamera;
-    private readonly unsubStore;
-    private readonly inputHandler;
-    private readonly background;
-    private readonly renderer;
-    private readonly noteEditor;
-    private readonly historyRecorder;
-    readonly toolContext: ToolContext;
-    private resizeObserver;
-    private animFrameId;
-    private _snapToGrid;
-    private readonly _gridSize;
-    private needsRender;
-    private domNodes;
-    private htmlContent;
-    private interactingElementId;
-    constructor(container: HTMLElement, options?: ViewportOptions);
-    get ctx(): CanvasRenderingContext2D | null;
-    get snapToGrid(): boolean;
-    setSnapToGrid(enabled: boolean): void;
-    requestRender(): void;
-    exportState(): CanvasState;
-    exportJSON(): string;
-    exportImage(options?: ExportImageOptions): Promise<Blob | null>;
-    loadState(state: CanvasState): void;
-    loadJSON(json: string): void;
-    undo(): boolean;
-    redo(): boolean;
-    addImage(src: string, position: {
-        x: number;
-        y: number;
-    }, size?: {
-        w: number;
-        h: number;
-    }): string;
-    addHtmlElement(dom: HTMLElement, position: {
-        x: number;
-        y: number;
-    }, size?: {
-        w: number;
-        h: number;
-    }): string;
-    addGrid(input: {
-        gridType?: 'square' | 'hex';
-        hexOrientation?: 'pointy' | 'flat';
-        cellSize?: number;
-        strokeColor?: string;
-        strokeWidth?: number;
-        opacity?: number;
-    }): string;
-    updateGrid(updates: Partial<Pick<GridElement, 'gridType' | 'hexOrientation' | 'cellSize' | 'strokeColor' | 'strokeWidth' | 'opacity'>>): void;
-    removeGrid(): void;
-    destroy(): void;
-    private startRenderLoop;
-    private render;
-    private startEditingElement;
-    private onTextEditStop;
-    private onDblClick;
-    private hitTestWorld;
-    private startInteracting;
-    stopInteracting(): void;
-    private onInteractNodePointerDown;
-    private onInteractKeyDown;
-    private onInteractPointerDown;
-    private onDragOver;
-    private onDrop;
-    private syncDomNode;
-    private renderDomContent;
-    private unbindArrowsFrom;
-    private hideDomNode;
-    private removeDomNode;
-    private clearDomNodes;
-    private reattachHtmlContent;
-    private createWrapper;
-    private createCanvas;
-    private createDomLayer;
-    private applyCameraTransform;
-    private syncCanvasSize;
-    private observeResize;
-}
-
-declare class ElementRenderer {
-    private store;
-    private imageCache;
-    private onImageLoad;
-    private camera;
-    private canvasSize;
-    setStore(store: ElementStore): void;
-    setOnImageLoad(callback: () => void): void;
-    setCamera(camera: Camera): void;
-    setCanvasSize(w: number, h: number): void;
-    isDomElement(element: CanvasElement): boolean;
-    renderCanvasElement(ctx: CanvasRenderingContext2D, element: CanvasElement): void;
-    private renderStroke;
-    private renderArrow;
-    private renderArrowhead;
-    private getVisualEndpoints;
-    private renderShape;
-    private fillShapePath;
-    private strokeShapePath;
-    private renderGrid;
-    private renderImage;
-    private getImage;
-}
-
-declare class NoteEditor {
-    private editingId;
-    private editingNode;
-    private blurHandler;
-    private keyHandler;
-    private pointerHandler;
-    private pendingEditId;
-    private onStopCallback;
-    get isEditing(): boolean;
-    get editingElementId(): string | null;
-    setOnStop(callback: (elementId: string) => void): void;
-    startEditing(node: HTMLDivElement, elementId: string, store: ElementStore): void;
-    stopEditing(store: ElementStore): void;
-    destroy(store: ElementStore): void;
-    private activateEditing;
-}
-
-declare function createId(prefix: string): string;
-
-interface BaseDefaults {
-    position?: Point;
-    zIndex?: number;
-    locked?: boolean;
-    layerId?: string;
-}
-interface StrokeInput extends BaseDefaults {
-    points: StrokePoint[];
-    color?: string;
-    width?: number;
-    opacity?: number;
-}
-interface NoteInput extends BaseDefaults {
-    position: Point;
-    size?: Size;
-    text?: string;
-    backgroundColor?: string;
-    textColor?: string;
-}
-interface ArrowInput extends BaseDefaults {
-    from: Point;
-    to: Point;
-    bend?: number;
-    color?: string;
-    width?: number;
-    fromBinding?: Binding;
-    toBinding?: Binding;
-}
-interface ImageInput extends BaseDefaults {
-    position: Point;
-    size: Size;
-    src: string;
-}
-interface HtmlInput extends BaseDefaults {
-    position: Point;
-    size: Size;
-    domId?: string;
-}
-interface TextInput extends BaseDefaults {
-    position: Point;
-    size?: Size;
-    text?: string;
-    fontSize?: number;
-    color?: string;
-    textAlign?: 'left' | 'center' | 'right';
-}
-declare function createStroke(input: StrokeInput): StrokeElement;
-declare function createNote(input: NoteInput): NoteElement;
-declare function createArrow(input: ArrowInput): ArrowElement;
-declare function createImage(input: ImageInput): ImageElement;
-declare function createHtmlElement(input: HtmlInput): HtmlElement;
-interface ShapeInput extends BaseDefaults {
-    position: Point;
-    size: Size;
-    shape?: ShapeKind;
-    strokeColor?: string;
-    strokeWidth?: number;
-    fillColor?: string;
-}
-declare function createShape(input: ShapeInput): ShapeElement;
-interface GridInput extends BaseDefaults {
-    gridType?: 'square' | 'hex';
-    hexOrientation?: HexOrientation;
-    cellSize?: number;
-    strokeColor?: string;
-    strokeWidth?: number;
-    opacity?: number;
-}
-declare function createGrid(input: GridInput): GridElement;
-declare function createText(input: TextInput): TextElement;
-
-interface Rect {
-    x: number;
-    y: number;
-    w: number;
-    h: number;
-}
-declare function getArrowControlPoint(from: Point, to: Point, bend: number): Point;
-declare function getArrowMidpoint(from: Point, to: Point, bend: number): Point;
-declare function getBendFromPoint(from: Point, to: Point, dragPoint: Point): number;
-declare function getArrowTangentAngle(from: Point, to: Point, bend: number, t: number): number;
-declare function isNearBezier(point: Point, from: Point, to: Point, bend: number, threshold: number): boolean;
-declare function getArrowBounds(from: Point, to: Point, bend: number): Rect;
-
-declare function isBindable(element: CanvasElement): boolean;
-declare function getElementCenter(element: CanvasElement): Point;
-declare function getElementBounds(element: CanvasElement): Rect | null;
-declare function getEdgeIntersection(bounds: Rect, outsidePoint: Point): Point;
-declare function findBindTarget(point: Point, store: ElementStore, threshold: number, excludeId?: string, filter?: (el: CanvasElement) => boolean): CanvasElement | null;
-declare function findBoundArrows(elementId: string, store: ElementStore): ArrowElement[];
-declare function updateBoundArrow(arrow: ArrowElement, store: ElementStore): Partial<ArrowElement> | null;
-declare function clearStaleBindings(arrow: ArrowElement, store: ElementStore): Partial<ArrowElement> | null;
-declare function unbindArrow(arrow: ArrowElement, store: ElementStore): Partial<ArrowElement>;
-
-declare class AddElementCommand implements Command {
-    private readonly element;
-    constructor(element: CanvasElement);
-    execute(store: ElementStore): void;
-    undo(store: ElementStore): void;
-}
-declare class RemoveElementCommand implements Command {
-    private readonly element;
-    constructor(element: CanvasElement);
-    execute(store: ElementStore): void;
-    undo(store: ElementStore): void;
-}
-declare class UpdateElementCommand implements Command {
-    private readonly id;
-    private readonly previous;
-    private readonly current;
-    constructor(id: string, previous: CanvasElement, current: CanvasElement);
-    execute(store: ElementStore): void;
-    undo(store: ElementStore): void;
-}
-declare class BatchCommand implements Command {
-    readonly commands: readonly Command[];
-    constructor(commands: Command[]);
-    execute(store: ElementStore): void;
-    undo(store: ElementStore): void;
-}
-
-declare class HandTool implements Tool {
-    readonly name = "hand";
-    private panning;
-    private lastScreen;
-    onActivate(ctx: ToolContext): void;
-    onDeactivate(ctx: ToolContext): void;
-    onPointerDown(state: PointerState, ctx: ToolContext): void;
-    onPointerMove(state: PointerState, ctx: ToolContext): void;
-    onPointerUp(_state: PointerState, ctx: ToolContext): void;
-}
-
-interface PencilToolOptions {
-    color?: string;
-    width?: number;
-    smoothing?: number;
-}
-declare class PencilTool implements Tool {
-    readonly name = "pencil";
-    private drawing;
-    private points;
-    private color;
-    private width;
-    private smoothing;
-    constructor(options?: PencilToolOptions);
-    onActivate(ctx: ToolContext): void;
-    onDeactivate(ctx: ToolContext): void;
-    setOptions(options: PencilToolOptions): void;
-    onPointerDown(state: PointerState, ctx: ToolContext): void;
-    onPointerMove(state: PointerState, ctx: ToolContext): void;
-    onPointerUp(_state: PointerState, ctx: ToolContext): void;
-    renderOverlay(ctx: CanvasRenderingContext2D): void;
-}
-
-interface EraserToolOptions {
-    radius?: number;
-}
-declare class EraserTool implements Tool {
-    readonly name = "eraser";
-    private erasing;
-    private readonly radius;
-    private readonly cursor;
-    constructor(options?: EraserToolOptions);
-    onActivate(ctx: ToolContext): void;
-    onDeactivate(ctx: ToolContext): void;
-    onPointerDown(state: PointerState, ctx: ToolContext): void;
-    onPointerMove(state: PointerState, ctx: ToolContext): void;
-    onPointerUp(_state: PointerState, _ctx: ToolContext): void;
-    private eraseAt;
-    private strokeIntersects;
-}
-
-declare class SelectTool implements Tool {
-    readonly name = "select";
-    private _selectedIds;
-    private mode;
-    private lastWorld;
-    private currentWorld;
-    private ctx;
-    get selectedIds(): string[];
-    get isMarqueeActive(): boolean;
-    onActivate(ctx: ToolContext): void;
-    onDeactivate(ctx: ToolContext): void;
-    private snap;
-    onPointerDown(state: PointerState, ctx: ToolContext): void;
-    onPointerMove(state: PointerState, ctx: ToolContext): void;
-    onPointerUp(_state: PointerState, ctx: ToolContext): void;
-    onHover(state: PointerState, ctx: ToolContext): void;
-    renderOverlay(canvasCtx: CanvasRenderingContext2D): void;
-    private updateHoverCursor;
-    private handleResize;
-    private hitTestResizeHandle;
-    private getHandlePositions;
-    private renderMarquee;
-    private renderSelectionBoxes;
-    private renderBindingHighlights;
-    private getMarqueeRect;
-    private findElementsInRect;
-    private rectsOverlap;
-    private getElementBounds;
-    private hitTest;
-    private isInsideBounds;
-}
-
-interface ArrowToolOptions {
-    color?: string;
-    width?: number;
-}
-declare class ArrowTool implements Tool {
-    readonly name = "arrow";
-    private drawing;
-    private start;
-    private end;
-    private color;
-    private width;
-    private fromBinding;
-    private fromTarget;
-    private toTarget;
-    constructor(options?: ArrowToolOptions);
-    setOptions(options: ArrowToolOptions): void;
-    private layerFilter;
-    onPointerDown(state: PointerState, ctx: ToolContext): void;
-    onPointerMove(state: PointerState, ctx: ToolContext): void;
-    onPointerUp(_state: PointerState, ctx: ToolContext): void;
-    renderOverlay(ctx: CanvasRenderingContext2D): void;
-}
-
-interface NoteToolOptions {
-    backgroundColor?: string;
-    textColor?: string;
-    size?: Size;
-}
-declare class NoteTool implements Tool {
-    readonly name = "note";
-    private backgroundColor;
-    private textColor;
-    private size;
-    constructor(options?: NoteToolOptions);
-    setOptions(options: NoteToolOptions): void;
-    onPointerDown(_state: PointerState, _ctx: ToolContext): void;
-    onPointerMove(_state: PointerState, _ctx: ToolContext): void;
-    onPointerUp(state: PointerState, ctx: ToolContext): void;
-}
-
-interface TextToolOptions {
-    fontSize?: number;
-    color?: string;
-    textAlign?: 'left' | 'center' | 'right';
-}
-declare class TextTool implements Tool {
-    readonly name = "text";
-    private fontSize;
-    private color;
-    private textAlign;
-    constructor(options?: TextToolOptions);
-    setOptions(options: TextToolOptions): void;
-    onActivate(ctx: ToolContext): void;
-    onDeactivate(ctx: ToolContext): void;
-    onPointerDown(_state: PointerState, _ctx: ToolContext): void;
-    onPointerMove(_state: PointerState, _ctx: ToolContext): void;
-    onPointerUp(state: PointerState, ctx: ToolContext): void;
-}
-
-interface ImageToolOptions {
-    size?: Size;
-}
-declare class ImageTool implements Tool {
-    readonly name = "image";
-    private size;
-    private src;
-    constructor(options?: ImageToolOptions);
-    setSrc(src: string): void;
-    onPointerDown(_state: PointerState, _ctx: ToolContext): void;
-    onPointerMove(_state: PointerState, _ctx: ToolContext): void;
-    onPointerUp(state: PointerState, ctx: ToolContext): void;
-}
-
-interface ShapeToolOptions {
-    shape?: ShapeKind;
-    strokeColor?: string;
-    strokeWidth?: number;
-    fillColor?: string;
-}
-declare class ShapeTool implements Tool {
-    readonly name = "shape";
-    private drawing;
-    private start;
-    private end;
-    private shiftHeld;
-    private shape;
-    private strokeColor;
-    private strokeWidth;
-    private fillColor;
-    constructor(options?: ShapeToolOptions);
-    setOptions(options: ShapeToolOptions): void;
-    onActivate(_ctx: ToolContext): void;
-    onDeactivate(_ctx: ToolContext): void;
-    onPointerDown(state: PointerState, ctx: ToolContext): void;
-    onPointerMove(state: PointerState, ctx: ToolContext): void;
-    onPointerUp(_state: PointerState, ctx: ToolContext): void;
-    renderOverlay(ctx: CanvasRenderingContext2D): void;
-    private computeRect;
-    private snap;
-    private onKeyDown;
-    private onKeyUp;
-}
-
-declare class CreateLayerCommand implements Command {
-    private readonly manager;
-    private readonly layer;
-    constructor(manager: LayerManager, layer: Layer);
-    execute(_store: ElementStore): void;
-    undo(_store: ElementStore): void;
-}
-declare class RemoveLayerCommand implements Command {
-    private readonly manager;
-    private readonly layer;
-    constructor(manager: LayerManager, layer: Layer);
-    execute(_store: ElementStore): void;
-    undo(_store: ElementStore): void;
-}
-declare class UpdateLayerCommand implements Command {
-    private readonly manager;
-    private readonly layerId;
-    private readonly previous;
-    private readonly current;
-    constructor(manager: LayerManager, layerId: string, previous: Layer, current: Layer);
-    execute(_store: ElementStore): void;
-    undo(_store: ElementStore): void;
-}
-
-declare const VERSION = "0.8.0";
-
-export { AddElementCommand, type ArrowElement, ArrowTool, type ArrowToolOptions, AutoSave, type AutoSaveOptions, Background, type BackgroundOptions, type BackgroundPattern, BatchCommand, type Binding, type Bounds, Camera, type CameraOptions, type CanvasElement, type CanvasState, type Command, CreateLayerCommand, ElementRenderer, ElementStore, type ElementType, type ElementUpdateEvent, EraserTool, type EraserToolOptions, EventBus, type ExportImageOptions, type GridElement, HandTool, type HexOrientation, HistoryRecorder, HistoryStack, type HistoryStackOptions, type HtmlElement, type ImageElement, ImageTool, type ImageToolOptions, InputHandler, type Layer, LayerManager, NoteEditor, type NoteElement, NoteTool, type NoteToolOptions, PencilTool, type PencilToolOptions, type Point, type PointerState, RemoveElementCommand, RemoveLayerCommand, SelectTool, type ShapeElement, type ShapeKind, ShapeTool, type ShapeToolOptions, type Size, type StrokeElement, type StrokePoint, type TextElement, TextTool, type TextToolOptions, type Tool, type ToolContext, ToolManager, type ToolName, UpdateElementCommand, UpdateLayerCommand, VERSION, Viewport, type ViewportOptions, clearStaleBindings, createArrow, createGrid, createHtmlElement, createId, createImage, createNote, createShape, createStroke, createText, exportImage, exportState, findBindTarget, findBoundArrows, getArrowBounds, getArrowControlPoint, getArrowMidpoint, getArrowTangentAngle, getBendFromPoint, getEdgeIntersection, getElementBounds, getElementCenter, isBindable, isNearBezier, parseState, snapPoint, unbindArrow, updateBoundArrow };