@fieldnotes/core 0.24.0 → 0.26.0

package/dist/index.d.cts

@@ -1,14 +1,3 @@
-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;
@@ -24,20 +13,6 @@ interface Size {
 }
 type Bounds = Point & Size;
 
-declare class Quadtree {
-    private root;
-    private _size;
-    private readonly worldBounds;
-    constructor(worldBounds: Bounds);
-    get size(): number;
-    insert(id: string, bounds: Bounds): void;
-    remove(id: string): void;
-    update(id: string, newBounds: Bounds): void;
-    query(rect: Bounds): string[];
-    queryPoint(point: Point): string[];
-    clear(): void;
-}
-
 interface BaseElement {
     id: string;
     type: string;
@@ -130,31 +105,6 @@ interface TemplateElement extends BaseElement {
 type CanvasElement = StrokeElement | NoteElement | ArrowElement | ImageElement | HtmlElement | TextElement | ShapeElement | GridElement | TemplateElement;
 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[];
-    activeLayerId?: string;
-}
-declare function exportState(elements: CanvasElement[], camera: {
-    position: Point;
-    zoom: number;
-}, layers?: Layer[], activeLayerId?: string): CanvasState;
-declare function parseState(json: string): CanvasState;
-
 interface CameraOptions {
     minZoom?: number;
     maxZoom?: number;
@@ -235,6 +185,7 @@ interface ToolContext {
     requestRender: () => void;
     switchTool?: (name: string) => void;
     editElement?: (id: string) => void;
+    fitNoteHeight?: (id: string) => void;
     setCursor?: (cursor: string) => void;
     snapToGrid?: boolean;
     gridSize?: number;
@@ -270,6 +221,26 @@ declare function snapPoint(point: Point, gridSize: number): Point;
 declare function snapToHexCenter(point: Point, cellSize: number, orientation: HexOrientation): Point;
 declare function smartSnap(point: Point, ctx: ToolContext): Point;
 
+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[];
+    activeLayerId?: string;
+}
+
 interface LayerManagerEvents {
     change: null;
     create: Layer;
@@ -343,25 +314,22 @@ interface BackgroundOptions {
     dotRadius?: number;
     lineWidth?: number;
 }
-declare class Background {
-    private readonly pattern;
-    private readonly spacing;
-    private readonly color;
-    private readonly dotRadius;
-    private readonly lineWidth;
-    private cachedCanvas;
-    private cachedCtx;
-    private lastZoom;
-    private lastOffsetX;
-    private lastOffsetY;
-    private lastWidth;
-    private lastHeight;
-    constructor(options?: BackgroundOptions);
-    render(ctx: CanvasRenderingContext2D, camera: Camera): void;
-    private ensureCachedCanvas;
-    private adaptSpacing;
-    private renderDots;
-    private renderGrid;
+
+type ShortcutBindings = Record<string, string | string[] | null>;
+interface ShortcutOptions {
+    scope?: 'focus' | 'window';
+    bindings?: ShortcutBindings;
+}
+interface ShortcutsApi {
+    rebind(action: string, bindings: string | string[] | null): void;
+    disable(action: string): void;
+    reset(action?: string): void;
+    getBindings(): Record<string, string[]>;
+}
+
+interface FontSizePreset {
+    label: string;
+    size: number;
 }
 
 declare class ToolManager {
@@ -405,161 +373,6 @@ declare class HistoryStack {
     private notifyChange;
 }
 
-declare class HistoryRecorder {
-    private readonly store;
-    private readonly stack;
-    private readonly layerManager?;
-    private recording;
-    private transaction;
-    private generation;
-    private updateSnapshots;
-    private unsubscribers;
-    constructor(store: ElementStore, stack: HistoryStack, layerManager?: LayerManager | undefined);
-    pause(): void;
-    resume(): void;
-    begin(): void;
-    get currentTransactionId(): number | null;
-    commit(): void;
-    rollback(): void;
-    destroy(): void;
-    private record;
-    private onAdd;
-    private onRemove;
-    private onUpdate;
-    private onLayerCreate;
-    private onLayerRemove;
-    private onLayerUpdate;
-    private flushUpdateSnapshots;
-}
-
-type ShortcutBindings = Record<string, string | string[] | null>;
-interface ShortcutOptions {
-    scope?: 'focus' | 'window';
-    bindings?: ShortcutBindings;
-}
-interface ShortcutsApi {
-    rebind(action: string, bindings: string | string[] | null): void;
-    disable(action: string): void;
-    reset(action?: string): void;
-    getBindings(): Record<string, string[]>;
-}
-
-interface InputHandlerOptions {
-    toolManager?: ToolManager;
-    toolContext?: ToolContext;
-    historyRecorder?: HistoryRecorder;
-    historyStack?: HistoryStack;
-    fitToContent?: () => void;
-    shortcuts?: ShortcutOptions;
-}
-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 lastPointerEvent;
-    private readonly inputFilter;
-    private deferredDown;
-    private readonly abortController;
-    private readonly actions;
-    private readonly shortcutMap;
-    private readonly scope;
-    constructor(element: HTMLElement, camera: Camera, options?: InputHandlerOptions);
-    setToolManager(toolManager: ToolManager, toolContext: ToolContext): void;
-    flushPendingHistory(): void;
-    get shortcuts(): ShortcutsApi;
-    destroy(): void;
-    private bind;
-    private onWheel;
-    private onPointerDown;
-    private onPointerMove;
-    private onPointerUp;
-    private onKeyDown;
-    private onKeyUp;
-    private runAction;
-    private startPinch;
-    private handlePinchMove;
-    private getPinchPoints;
-    private distance;
-    private midpoint;
-    private toPointerState;
-    private dispatchToolDown;
-    private dispatchToolMove;
-    private dispatchToolHover;
-    private dispatchToolUp;
-    private isInScope;
-    private focusSelf;
-    private cancelToolIfActive;
-}
-
-type FilterAction = 'dispatch' | 'suppress' | 'defer';
-interface FilteredEvent {
-    event: PointerEvent;
-    action: FilterAction;
-}
-interface FilteredUpEvent extends FilteredEvent {
-    pendingTap?: {
-        x: number;
-        y: number;
-    };
-}
-declare class InputFilter {
-    private activePenId;
-    private pendingTap;
-    static readonly MIN_MOVE_DISTANCE = 3;
-    filterDown(e: PointerEvent): FilteredEvent;
-    filterMove(e: PointerEvent): FilteredEvent;
-    filterUp(e: PointerEvent): FilteredUpEvent;
-    reset(): void;
-}
-
-interface DoubleTapDetectorOptions {
-    timeout?: number;
-    maxDistance?: number;
-}
-declare class DoubleTapDetector {
-    private readonly timeout;
-    private readonly maxDistance;
-    private lastTapTime;
-    private lastTapX;
-    private lastTapY;
-    private hasPendingTap;
-    constructor(options?: DoubleTapDetectorOptions);
-    feed(e: PointerEvent): boolean;
-    reset(): void;
-}
-
-interface FontSizePreset {
-    label: string;
-    size: number;
-}
-declare const DEFAULT_FONT_SIZE_PRESETS: FontSizePreset[];
-declare class NoteToolbar {
-    private el;
-    private anchor;
-    private selectionListener;
-    private readonly fontSizePresets;
-    constructor(fontSizePresets?: FontSizePreset[]);
-    show(anchor: HTMLElement): void;
-    hide(): void;
-    getElement(): HTMLDivElement | null;
-    updatePosition(anchor: HTMLElement): void;
-    private createToolbarElement;
-    private createFormatButton;
-    private createFontSizeSelect;
-    private positionToolbar;
-    private updateActiveStates;
-}
-
 interface ExportImageOptions {
     scale?: number;
     padding?: number;
@@ -685,6 +498,7 @@ declare class Viewport {
     logPerformance(intervalMs?: number): () => void;
     destroy(): void;
     private startEditingElement;
+    private fitNoteHeight;
     private onTextEditStop;
     private onTapDown;
     private onDoubleTap;
@@ -703,87 +517,6 @@ declare class Viewport {
     private observeResize;
 }
 
-declare class ElementRenderer {
-    private store;
-    private imageCache;
-    private onImageLoad;
-    private onImageError;
-    private camera;
-    private canvasSize;
-    private hexTileCache;
-    private hexTileCacheKey;
-    private gridBoundsOverride;
-    setStore(store: ElementStore): void;
-    setOnImageLoad(callback: () => void): void;
-    setOnImageError(callback: (src: string, cause?: unknown) => void): void;
-    setCamera(camera: Camera): void;
-    setCanvasSize(w: number, h: number): void;
-    setGridBoundsOverride(bounds: {
-        minX: number;
-        minY: number;
-        maxX: number;
-        maxY: number;
-    } | null): 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 renderTemplate;
-    private renderGeometricTemplate;
-    private renderHexTemplate;
-    private renderRadiusMarker;
-    private renderImage;
-    private renderImagePlaceholder;
-    private getHexTile;
-    private getImage;
-}
-
-interface NoteEditorOptions {
-    fontSizePresets?: FontSizePreset[];
-    toolbar?: boolean;
-    placeholder?: string;
-}
-declare class NoteEditor {
-    private editingId;
-    private editingNode;
-    private blurHandler;
-    private keyHandler;
-    private pointerHandler;
-    private inputHandler;
-    private pendingEditId;
-    private onStopCallback;
-    private toolbar;
-    private readonly placeholder;
-    constructor(options?: NoteEditorOptions);
-    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;
-    updateToolbarPosition(): void;
-    private activateEditing;
-}
-
-interface RunStyle {
-    bold: boolean;
-    italic: boolean;
-    underline: boolean;
-    strikethrough: boolean;
-    fontSize: number;
-}
-interface StyledRun extends RunStyle {
-    text: string;
-}
-declare function sanitizeNoteHtml(html: string): string;
-declare function isNoteContentEmpty(html: string): boolean;
-
 interface ActiveFormats {
     bold: boolean;
     italic: boolean;
@@ -797,8 +530,6 @@ declare function toggleStrikethrough(): void;
 declare function setFontSize(size: number): void;
 declare function getActiveFormats(): ActiveFormats;
 
-declare function createId(prefix: string): string;
-
 declare const DEFAULT_NOTE_FONT_SIZE = 18;
 interface BaseDefaults {
     position?: Point;
@@ -893,15 +624,6 @@ declare function getArrowTangentAngle(from: Point, to: Point, bend: number, t: n
 declare function isNearBezier(point: Point, from: Point, to: Point, bend: number, threshold: number): boolean;
 declare function getArrowBounds(from: Point, to: Point, bend: number): Bounds;
 
-declare function isBindable(element: CanvasElement): boolean;
-declare function getElementCenter(element: CanvasElement): Point;
-declare function getEdgeIntersection(bounds: Bounds, 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 function getElementBounds(element: CanvasElement): Bounds | null;
 declare function boundsIntersect(a: Bounds, b: Bounds): boolean;
 
@@ -914,33 +636,6 @@ declare function getHexCellsInLine(center: Point, angle: number, radiusCells: nu
 declare function getHexCellsInSquare(center: Point, radiusCells: number, cellSize: number, orientation: HexOrientation): Point[];
 declare function drawHexPath(ctx: CanvasRenderingContext2D, cx: number, cy: number, cellSize: number, orientation: HexOrientation): void;
 
-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;
@@ -1238,30 +933,6 @@ declare class TemplateTool implements Tool {
     private notifyOptionsChange;
 }
 
-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.24.0";
+declare const VERSION = "0.26.0";
 
-export { type ActiveFormats, AddElementCommand, type ArrowElement, ArrowTool, type ArrowToolOptions, AutoSave, type AutoSaveOptions, Background, type BackgroundOptions, type BackgroundPattern, BatchCommand, type Binding, type Bounds, Camera, type CameraChangeInfo, type CameraOptions, type CanvasElement, type CanvasState, type Command, CreateLayerCommand, DEFAULT_FONT_SIZE_PRESETS, DEFAULT_NOTE_FONT_SIZE, DoubleTapDetector, type DoubleTapDetectorOptions, ElementRenderer, ElementStore, type ElementType, type ElementUpdateEvent, EraserTool, type EraserToolOptions, EventBus, type ExportImageOptions, type FilterAction, type FilteredEvent, type FilteredUpEvent, type FontSizePreset, type GridElement, type GridInfo, HandTool, type HexOrientation, HistoryRecorder, HistoryStack, type HistoryStackOptions, type HtmlElement, type ImageElement, ImageTool, type ImageToolOptions, InputFilter, InputHandler, type InputHandlerOptions, type Layer, LayerManager, MeasureTool, type MeasureToolOptions, type Measurement, NoteEditor, type NoteEditorOptions, type NoteElement, NoteTool, type NoteToolOptions, NoteToolbar, PencilTool, type PencilToolOptions, type Point, type PointerState, Quadtree, RemoveElementCommand, RemoveLayerCommand, type RenderStatsSnapshot, SelectTool, type ShapeElement, type ShapeKind, ShapeTool, type ShapeToolOptions, type ShortcutBindings, type ShortcutOptions, type ShortcutsApi, type Size, type StrokeElement, type StrokePoint, type StyledRun, type TemplateElement, type TemplateShape, TemplateTool, type TemplateToolOptions, type TextElement, TextTool, type TextToolOptions, type Tool, type ToolContext, ToolManager, type ToolName, UpdateElementCommand, UpdateLayerCommand, VERSION, Viewport, type ViewportOptions, boundsIntersect, clearStaleBindings, createArrow, createGrid, createHtmlElement, createId, createImage, createNote, createShape, createStroke, createTemplate, createText, drawHexPath, exportImage, exportState, findBindTarget, findBoundArrows, getActiveFormats, getArrowBounds, getArrowControlPoint, getArrowMidpoint, getArrowTangentAngle, getBendFromPoint, getEdgeIntersection, getElementBounds, getElementCenter, getElementsBoundingBox, getHexCellsInCone, getHexCellsInLine, getHexCellsInRadius, getHexCellsInSquare, getHexDistance, isBindable, isNearBezier, isNoteContentEmpty, parseState, sanitizeNoteHtml, setFontSize, smartSnap, snapPoint, snapToHexCenter, toggleBold, toggleItalic, toggleStrikethrough, toggleUnderline, unbindArrow, updateBoundArrow };
+export { type ActiveFormats, type ArrowElement, ArrowTool, type ArrowToolOptions, AutoSave, type AutoSaveOptions, type BackgroundOptions, type BackgroundPattern, type Binding, type Bounds, Camera, type CameraChangeInfo, type CameraOptions, type CanvasElement, type CanvasState, type Command, DEFAULT_NOTE_FONT_SIZE, ElementStore, type ElementType, type ElementUpdateEvent, EraserTool, type EraserToolOptions, type ExportImageOptions, type FontSizePreset, type GridElement, type GridInfo, HandTool, type HexOrientation, HistoryStack, type HistoryStackOptions, type HtmlElement, type ImageElement, ImageTool, type ImageToolOptions, type Layer, LayerManager, MeasureTool, type MeasureToolOptions, type Measurement, type NoteElement, NoteTool, type NoteToolOptions, PencilTool, type PencilToolOptions, type Point, type PointerState, type RenderStatsSnapshot, SelectTool, type ShapeElement, type ShapeKind, ShapeTool, type ShapeToolOptions, type ShortcutBindings, type ShortcutOptions, type ShortcutsApi, type Size, type StrokeElement, type StrokePoint, type TemplateElement, type TemplateShape, TemplateTool, type TemplateToolOptions, type TextElement, TextTool, type TextToolOptions, type Tool, type ToolContext, ToolManager, type ToolName, VERSION, Viewport, type ViewportOptions, boundsIntersect, createArrow, createGrid, createHtmlElement, createImage, createNote, createShape, createStroke, createTemplate, createText, drawHexPath, exportImage, getActiveFormats, getArrowBounds, getArrowControlPoint, getArrowMidpoint, getArrowTangentAngle, getBendFromPoint, getElementBounds, getElementsBoundingBox, getHexCellsInCone, getHexCellsInLine, getHexCellsInRadius, getHexCellsInSquare, getHexDistance, isNearBezier, setFontSize, smartSnap, snapPoint, snapToHexCenter, toggleBold, toggleItalic, toggleStrikethrough, toggleUnderline };