@sindicum/libre-draw 0.1.1 → 0.2.0

package/dist/modes/DrawMode.d.ts

@@ -1,32 +1,6 @@
 import type { Mode } from './Mode';
 import type { NormalizedInputEvent } from '../types/input';
-import type { LibreDrawFeature, Position, Action } from '../types/features';
-import type { LibreDrawEventMap } from '../types/events';
-/**
- * Callbacks that DrawMode needs from the host application.
- */
-export interface DrawModeCallbacks {
-    /** Add a feature to the store and return it with its assigned ID. */
-    addFeatureToStore(feature: LibreDrawFeature): LibreDrawFeature;
-    /** Push an action to the history manager. */
-    pushToHistory(action: Action): void;
-    /** Emit an event through the event bus. */
-    emitEvent<K extends keyof LibreDrawEventMap>(type: K, payload: LibreDrawEventMap[K]): void;
-    /** Render a preview of the polygon being drawn. */
-    renderPreview(coordinates: Position[]): void;
-    /** Clear the drawing preview. */
-    clearPreview(): void;
-    /** Re-render all features. */
-    renderFeatures(): void;
-    /** Convert a geographic coordinate to a screen point. */
-    getScreenPoint(lngLat: {
-        lng: number;
-        lat: number;
-    }): {
-        x: number;
-        y: number;
-    };
-}
+import type { ModeContext } from '../core/ModeContext';
 /**
  * Drawing mode for creating new polygons.
  *
@@ -40,8 +14,12 @@ export interface DrawModeCallbacks {
 export declare class DrawMode implements Mode {
     private vertices;
     private isActive;
-    private callbacks;
-    constructor(callbacks: DrawModeCallbacks);
+    private context;
+    constructor(context: ModeContext);
+    mapInteractions(): {
+        dragPan: boolean;
+        doubleClickZoom: boolean;
+    };
     activate(): void;
     deactivate(): void;
     onPointerDown(event: NormalizedInputEvent): void;

package/dist/modes/IdleMode.d.ts

@@ -5,6 +5,10 @@ import type { NormalizedInputEvent } from '../types/input';
  * All input handlers are no-ops.
  */
 export declare class IdleMode implements Mode {
+    mapInteractions(): {
+        dragPan: boolean;
+        doubleClickZoom: boolean;
+    };
     activate(): void;
     deactivate(): void;
     onPointerDown(_event: NormalizedInputEvent): void;

package/dist/modes/Mode.d.ts

@@ -1,4 +1,11 @@
 import type { NormalizedInputEvent } from '../types/input';
+/**
+ * Map interaction settings that a mode requires while active.
+ */
+export interface MapInteractionConfig {
+    dragPan: boolean;
+    doubleClickZoom: boolean;
+}
 /**
  * Interface that all drawing modes must implement.
  *
@@ -7,6 +14,8 @@ import type { NormalizedInputEvent } from '../types/input';
  * by the ModeManager during transitions.
  */
 export interface Mode {
+    /** Map interaction settings required by this mode. */
+    mapInteractions(): MapInteractionConfig;
     /** Called when the mode becomes active. */
     activate(): void;
     /** Called when the mode is deactivated. */

package/dist/modes/PolygonDragger.d.ts

@@ -0,0 +1,23 @@
+import type { ModeContext } from '../core/ModeContext';
+import type { LibreDrawFeature } from '../types/features';
+import type { NormalizedInputEvent } from '../types/input';
+/**
+ * Handles whole-polygon drag interactions.
+ */
+export declare class PolygonDragger {
+    private context;
+    private onFeatureMoved;
+    private dragging;
+    private dragStartFeature;
+    private dragStartLngLat;
+    constructor(context: ModeContext, onFeatureMoved: (feature: LibreDrawFeature) => void);
+    isDragging(): boolean;
+    getDragStartFeature(): LibreDrawFeature | null;
+    startDrag(feature: LibreDrawFeature, startLngLat: {
+        lng: number;
+        lat: number;
+    }): void;
+    handleDragMove(selectedId: string, event: NormalizedInputEvent): boolean;
+    endDrag(): void;
+    resetInteractionState(): void;
+}

package/dist/modes/SelectMode.d.ts

@@ -1,60 +1,20 @@
 import type { Mode } from './Mode';
 import type { NormalizedInputEvent } from '../types/input';
-import type { LibreDrawFeature, Position, Action } from '../types/features';
-import type { LibreDrawEventMap } from '../types/events';
-/**
- * Callbacks that SelectMode needs from the host application.
- */
-export interface SelectModeCallbacks {
-    /** Remove a feature from the store. */
-    removeFeatureFromStore(id: string): LibreDrawFeature | undefined;
-    /** Push an action to the history manager. */
-    pushToHistory(action: Action): void;
-    /** Emit an event through the event bus. */
-    emitEvent<K extends keyof LibreDrawEventMap>(type: K, payload: LibreDrawEventMap[K]): void;
-    /** Re-render all features. */
-    renderFeatures(): void;
-    /** Get a feature by ID. */
-    getFeatureById(id: string): LibreDrawFeature | undefined;
-    /** Get all features in the store. */
-    getAllFeatures(): LibreDrawFeature[];
-    /** Convert a geographic coordinate to a screen point. */
-    getScreenPoint(lngLat: {
-        lng: number;
-        lat: number;
-    }): {
-        x: number;
-        y: number;
-    };
-    /** Update a feature in the store. */
-    updateFeatureInStore(id: string, feature: LibreDrawFeature): void;
-    /** Render vertex and midpoint markers for editing. */
-    renderVertices(featureId: string, vertices: Position[], midpoints: Position[], highlightIndex?: number): void;
-    /** Clear vertex/midpoint markers. */
-    clearVertices(): void;
-    /** Enable or disable map drag panning. */
-    setDragPan(enabled: boolean): void;
-}
+import type { ModeContext } from '../core/ModeContext';
 /**
  * Selection and editing mode for existing polygons.
- *
- * Users click on a polygon to select it. Selected polygons display
- * vertex handles that can be dragged to reshape the polygon. Midpoint
- * handles appear between vertices and can be dragged to add new vertices.
- * Double-clicking a vertex removes it (minimum 3 vertices maintained).
  */
 export declare class SelectMode implements Mode {
-    private selectedIds;
+    private context;
+    private selection;
+    private vertexEditor;
+    private polygonDragger;
     private isActive;
-    private callbacks;
-    private onSelectionChange?;
-    private dragging;
-    private dragVertexIndex;
-    private dragStartFeature;
-    private draggingPolygon;
-    private dragPolygonStartLngLat;
-    private highlightedVertexIndex;
-    constructor(callbacks: SelectModeCallbacks, onSelectionChange?: (selectedIds: string[]) => void);
+    constructor(context: ModeContext, onSelectionChange?: (selectedIds: string[]) => void);
+    mapInteractions(): {
+        dragPan: boolean;
+        doubleClickZoom: boolean;
+    };
     activate(): void;
     deactivate(): void;
     /**
@@ -63,19 +23,11 @@ export declare class SelectMode implements Mode {
     getSelectedIds(): string[];
     /**
      * Programmatically select a feature by ID.
-     *
-     * Replaces any existing selection. Renders vertex handles and
-     * emits a selectionchange event. Cancels any in-progress drag.
-     *
-     * @param id - The feature ID to select.
-     * @returns `true` if the feature was found and selected, `false` otherwise.
      */
     selectFeature(id: string): boolean;
     /**
      * Programmatically clear the current selection.
-     *
-     * Removes vertex handles and emits a selectionchange event.
-     * No-op if nothing is selected or mode is not active.
+     * Public API keeps the active-mode guard.
      */
     clearSelection(): void;
     onPointerDown(event: NormalizedInputEvent): void;
@@ -85,74 +37,11 @@ export declare class SelectMode implements Mode {
     onLongPress(event: NormalizedInputEvent): void;
     onKeyDown(key: string, _event: KeyboardEvent): void;
     /**
-     * Get the hit-test threshold based on input type.
-     */
-    private getThreshold;
-    /**
-     * Get the unique vertices (excluding closing point) of a polygon.
-     */
-    private getVertices;
-    /**
-     * Find the nearest vertex within the hit threshold.
-     * @returns The vertex index, or -1 if none is close enough.
-     */
-    private findNearestVertex;
-    /**
-     * Find the nearest point (vertex or midpoint) within the hit threshold.
-     * @returns The index, or -1 if none is close enough.
-     */
-    private findNearestPoint;
-    /**
-     * Compute midpoints for each edge of the polygon.
-     */
-    private computeMidpoints;
-    /**
-     * Start a vertex drag operation.
-     */
-    private startDrag;
-    /**
-     * Start a polygon drag (whole-polygon move) operation.
-     */
-    private startPolygonDrag;
-    /**
-     * End a drag operation and restore map interactions.
-     */
-    private endDrag;
-    /**
-     * Create a new feature with a vertex moved to a new position.
-     */
-    private moveVertex;
-    /**
-     * Create a new feature with all vertices translated by the given delta.
-     */
-    private movePolygon;
-    /**
-     * Create a new feature with a vertex inserted at the given index.
-     */
-    private insertVertex;
-    /**
-     * Create a new feature with a vertex removed at the given index.
-     */
-    private removeVertex;
-    /**
-     * Refresh vertex/midpoint handles for the currently selected feature.
-     * Call this after external geometry changes (e.g. undo/redo).
+     * Refresh vertex/midpoint handles after external geometry changes.
      */
     refreshVertexHandles(): void;
-    /**
-     * Show vertex and midpoint handles for a selected feature.
-     */
-    private showVertexHandles;
-    /**
-     * Get the first selected feature ID.
-     */
-    private getFirstSelectedId;
-    /**
-     * Delete all currently selected features.
-     */
+    private forceClearSelectionState;
+    private commitDragUpdate;
     private deleteSelected;
-    /**
-     * Notify the host about selection changes.
-     */
-    private notifySelectionChange;
+    private hasGeometryChanged;
 }

package/dist/modes/SelectionManager.d.ts

@@ -0,0 +1,19 @@
+import type { ModeContext } from '../core/ModeContext';
+/**
+ * Handles selected feature IDs and selection change notifications.
+ */
+export declare class SelectionManager {
+    private selectedIds;
+    private context;
+    private onSelectionChange?;
+    constructor(context: ModeContext, onSelectionChange?: (selectedIds: string[]) => void);
+    getSelectedIds(): string[];
+    getFirstSelectedId(): string | undefined;
+    hasSelection(): boolean;
+    has(id: string): boolean;
+    selectOnly(id: string): void;
+    remove(id: string): void;
+    clear(): void;
+    clearAndNotify(): boolean;
+    notify(): void;
+}

package/dist/modes/VertexEditor.d.ts

@@ -0,0 +1,28 @@
+import type { ModeContext } from '../core/ModeContext';
+import type { LibreDrawFeature } from '../types/features';
+import type { NormalizedInputEvent } from '../types/input';
+/**
+ * Handles vertex/midpoint interactions for selected polygons.
+ */
+export declare class VertexEditor {
+    private context;
+    private dragging;
+    private dragVertexIndex;
+    private dragStartFeature;
+    private highlightedVertexIndex;
+    constructor(context: ModeContext);
+    isDragging(): boolean;
+    getDragStartFeature(): LibreDrawFeature | null;
+    resetInteractionState(): void;
+    clearHighlight(): void;
+    tryStartVertexDragOrInsert(feature: LibreDrawFeature, selectedId: string, event: NormalizedInputEvent): boolean;
+    handleDragMove(selectedId: string, event: NormalizedInputEvent): boolean;
+    updateHighlightIfNeeded(feature: LibreDrawFeature, event: NormalizedInputEvent): void;
+    deleteVertexAtPointer(selectedId: string, feature: LibreDrawFeature, event: NormalizedInputEvent): boolean;
+    renderHandles(feature: LibreDrawFeature): void;
+    endDrag(): void;
+    private startDrag;
+    private getThreshold;
+    private findNearestVertex;
+    private findNearestPoint;
+}

package/dist/rendering/RenderManager.d.ts

@@ -1,5 +1,6 @@
 import type { Map as MaplibreMap } from 'maplibre-gl';
 import type { LibreDrawFeature, Position } from '../types/features';
+import type { PartialStyleConfig } from '../types/style';
 import { SourceManager } from './SourceManager';
 /**
  * Layer IDs used by LibreDraw for rendering.
@@ -31,7 +32,12 @@ export declare class RenderManager {
     private pendingRender;
     private pendingFeatures;
     private initialized;
-    constructor(map: MaplibreMap, sourceManager: SourceManager);
+    private style;
+    constructor(map: MaplibreMap, sourceManager: SourceManager, style?: PartialStyleConfig);
+    /**
+     * Whether render layers and sources are ready on the current style.
+     */
+    isReadyForCurrentStyle(): boolean;
     /**
      * Initialize rendering layers on the map.
      * Should be called after the map style and sources are ready.
@@ -77,4 +83,8 @@ export declare class RenderManager {
      * with selection state embedded in properties.
      */
     private performRender;
+    /**
+     * Whether all draw layers exist on the current style.
+     */
+    private hasAllLayers;
 }

package/dist/rendering/SourceManager.d.ts

@@ -17,6 +17,10 @@ export declare class SourceManager {
     private map;
     private initialized;
     constructor(map: MaplibreMap);
+    /**
+     * Whether all required GeoJSON sources exist on the current style.
+     */
+    hasAllSources(): boolean;
     /**
      * Initialize the GeoJSON sources on the map.
      * Should be called after the map style has loaded.

package/dist/types/events.d.ts

@@ -1,4 +1,5 @@
 import type { LibreDrawFeature } from './features';
+import type { ModeName } from './mode';
 /**
  * Event payload for feature creation.
  */
@@ -28,8 +29,8 @@ export interface SelectionChangeEvent {
  * Event payload for mode changes.
  */
 export interface ModeChangeEvent {
-    mode: string;
-    previousMode: string;
+    mode: ModeName;
+    previousMode: ModeName;
 }
 /**
  * Map of all LibreDraw event types to their payloads.

package/dist/types/features.d.ts

@@ -57,8 +57,8 @@ export interface FeatureStoreInterface {
  * Action that represents the creation of a new feature.
  */
 export declare class CreateAction implements Action {
-    readonly feature: LibreDrawFeature;
     readonly type: ActionType;
+    readonly feature: LibreDrawFeature;
     constructor(feature: LibreDrawFeature);
     apply(store: FeatureStoreInterface): void;
     revert(store: FeatureStoreInterface): void;
@@ -67,10 +67,10 @@ export declare class CreateAction implements Action {
  * Action that represents the update of an existing feature.
  */
 export declare class UpdateAction implements Action {
+    readonly type: ActionType;
     readonly id: string;
     readonly oldFeature: LibreDrawFeature;
     readonly newFeature: LibreDrawFeature;
-    readonly type: ActionType;
     constructor(id: string, oldFeature: LibreDrawFeature, newFeature: LibreDrawFeature);
     apply(store: FeatureStoreInterface): void;
     revert(store: FeatureStoreInterface): void;
@@ -79,8 +79,8 @@ export declare class UpdateAction implements Action {
  * Action that represents the deletion of a feature.
  */
 export declare class DeleteAction implements Action {
-    readonly feature: LibreDrawFeature;
     readonly type: ActionType;
+    readonly feature: LibreDrawFeature;
     constructor(feature: LibreDrawFeature);
     apply(store: FeatureStoreInterface): void;
     revert(store: FeatureStoreInterface): void;

package/dist/types/index.d.ts

@@ -1,5 +1,8 @@
 export type { Position, PolygonGeometry, FeatureProperties, LibreDrawFeature, FeatureCollection, ActionType, Action, FeatureStoreInterface, } from './features';
+export type { ModeName } from './mode';
 export { CreateAction, UpdateAction, DeleteAction, } from './features';
 export type { CreateEvent, UpdateEvent, DeleteEvent, SelectionChangeEvent, ModeChangeEvent, LibreDrawEventMap, } from './events';
 export type { ToolbarPosition, ToolbarControls, ToolbarOptions, LibreDrawOptions, } from './options';
+export type { FillStyle, OutlineStyle, VertexStyle, PreviewStyle, EditVertexStyle, MidpointStyle, StyleConfig, PartialStyleConfig, } from './style';
+export { DEFAULT_STYLE_CONFIG, mergeStyleConfig, } from './style';
 export type { InputType, NormalizedInputEvent, } from './input';

package/dist/types/mode.d.ts

@@ -0,0 +1,4 @@
+/**
+ * The available drawing modes.
+ */
+export type ModeName = 'idle' | 'draw' | 'select';

package/dist/types/options.d.ts

@@ -1,3 +1,4 @@
+import type { PartialStyleConfig } from './style';
 /**
  * Position of the toolbar control on the map.
  */
@@ -27,4 +28,6 @@ export interface LibreDrawOptions {
     toolbar?: boolean | ToolbarOptions;
     /** Maximum number of undo/redo history entries. Defaults to 100. */
     historyLimit?: number;
+    /** Partial style overrides for map layer rendering. */
+    style?: PartialStyleConfig;
 }

package/dist/types/style.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Style for polygon fill rendering.
+ */
+export interface FillStyle {
+    color: string;
+    opacity: number;
+    selectedColor: string;
+    selectedOpacity: number;
+}
+/**
+ * Style for polygon outline rendering.
+ */
+export interface OutlineStyle {
+    color: string;
+    width: number;
+    selectedColor: string;
+}
+/**
+ * Style for feature vertex markers.
+ */
+export interface VertexStyle {
+    color: string;
+    strokeColor: string;
+    strokeWidth: number;
+    radius: number;
+}
+/**
+ * Style for draw preview line.
+ */
+export interface PreviewStyle {
+    color: string;
+    width: number;
+    dasharray: number[];
+}
+/**
+ * Style for edit vertex handles.
+ */
+export interface EditVertexStyle {
+    color: string;
+    strokeColor: string;
+    strokeWidth: number;
+    radius: number;
+    highlightedColor: string;
+    highlightedStrokeColor: string;
+    highlightedRadius: number;
+}
+/**
+ * Style for midpoint handles.
+ */
+export interface MidpointStyle {
+    color: string;
+    opacity: number;
+    radius: number;
+}
+/**
+ * Full render style configuration.
+ */
+export interface StyleConfig {
+    fill: FillStyle;
+    outline: OutlineStyle;
+    vertex: VertexStyle;
+    preview: PreviewStyle;
+    editVertex: EditVertexStyle;
+    midpoint: MidpointStyle;
+}
+/**
+ * Partial style overrides accepted from user options.
+ */
+export interface PartialStyleConfig {
+    fill?: Partial<FillStyle>;
+    outline?: Partial<OutlineStyle>;
+    vertex?: Partial<VertexStyle>;
+    preview?: Partial<PreviewStyle>;
+    editVertex?: Partial<EditVertexStyle>;
+    midpoint?: Partial<MidpointStyle>;
+}
+/**
+ * Built-in default style used when options.style is omitted.
+ */
+export declare const DEFAULT_STYLE_CONFIG: StyleConfig;
+/**
+ * Merge user style overrides with defaults.
+ */
+export declare function mergeStyleConfig(overrides?: PartialStyleConfig): StyleConfig;

package/dist/utils/featureSnapshot.d.ts

@@ -0,0 +1,21 @@
+import type { FeatureCollection, FeatureProperties, LibreDrawFeature, Position } from '../types/features';
+/**
+ * Deep-clone JSON-like values to prevent shared mutable references.
+ */
+export declare function deepCloneValue<T>(value: T): T;
+/**
+ * Clone coordinates deeply ([lng, lat][][]).
+ */
+export declare function cloneCoordinates(coordinates: Position[][]): Position[][];
+/**
+ * Clone arbitrary feature properties deeply.
+ */
+export declare function cloneProperties(properties: FeatureProperties): FeatureProperties;
+/**
+ * Create a deep snapshot of a feature.
+ */
+export declare function cloneFeature(feature: LibreDrawFeature): LibreDrawFeature;
+/**
+ * Create a deep snapshot of a FeatureCollection.
+ */
+export declare function cloneFeatureCollection(collection: FeatureCollection): FeatureCollection;

package/dist/utils/geometry.d.ts

@@ -0,0 +1,25 @@
+import type { LibreDrawFeature, Position } from '../types/features';
+/**
+ * Get the unique vertices (excluding the closing point) of a polygon.
+ */
+export declare function getVertices(feature: LibreDrawFeature): Position[];
+/**
+ * Compute midpoints for each edge of a polygon.
+ */
+export declare function computeMidpoints(vertices: Position[]): Position[];
+/**
+ * Create a new feature with a vertex moved to a new position.
+ */
+export declare function moveVertex(feature: LibreDrawFeature, vertexIndex: number, newPos: Position): LibreDrawFeature;
+/**
+ * Create a new feature with all vertices translated by the given delta.
+ */
+export declare function movePolygon(feature: LibreDrawFeature, dLng: number, dLat: number): LibreDrawFeature;
+/**
+ * Create a new feature with a vertex inserted at the given index.
+ */
+export declare function insertVertex(feature: LibreDrawFeature, insertIndex: number, pos: Position): LibreDrawFeature;
+/**
+ * Create a new feature with a vertex removed at the given index.
+ */
+export declare function removeVertex(feature: LibreDrawFeature, vertexIndex: number): LibreDrawFeature;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sindicum/libre-draw",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "MapLibre GL JS polygon drawing and editing library",
   "type": "module",
   "main": "./dist/libre-draw.cjs",
@@ -35,15 +35,13 @@
   },
   "dependencies": {
     "@turf/boolean-point-in-polygon": "^7.0.0",
-    "@turf/helpers": "^7.0.0",
-    "rbush": "^4.0.1"
+    "@turf/helpers": "^7.0.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.0.0",
-    "@types/rbush": "^4.0.0",
     "eslint": "^9.0.0",
     "eslint-config-prettier": "^10.0.0",
-    "happy-dom": "^17.0.0",
+    "happy-dom": "^20.7.0",
     "maplibre-gl": "^4.0.0",
     "prettier": "^3.0.0",
     "typescript": "~5.7.0",