@zwishing/emap 0.2.0 → 0.3.0

package/dist/geo/camera.d.ts

@@ -0,0 +1,100 @@
+export interface CameraOptions {
+    /** Target centre in projected/data coords (= P8 `mapCoord` space). */
+    center?: [number, number];
+    /** Target zoom (WebMercator convenience; converted via host.scaleFromZoom). */
+    zoom?: number;
+    /** Target scale (= |mx|); CRS-agnostic. Takes precedence over `zoom`. */
+    scale?: number;
+}
+export interface AnimationOptions {
+    /** ms. Default 1000 for ease/fly. Ignored when animate:false. */
+    duration?: number;
+    /** t∈[0,1] → eased t. Default Tween.sineInOut. */
+    easing?: (t: number) => number;
+    /** false (or duration:0) ⇒ jump (no animation). Default true. */
+    animate?: boolean;
+}
+export interface FlyToOptions extends CameraOptions, AnimationOptions {
+    /** van-Wijk curvature. Default 1.42. */
+    curve?: number;
+    /** Average flight speed (screenfuls/sec). Overrides duration if set. */
+    speed?: number;
+}
+export interface FitBoundsOptions extends AnimationOptions {
+    /** Pixels of inset on every side. Default 0. */
+    padding?: number;
+    /** Clamp the fitted scale to <= scale(maxZoom-equivalent). */
+    maxScale?: number;
+}
+export interface CameraState {
+    center: [number, number];
+    scale: number;
+}
+/** Minimal surface Camera needs (keeps it unit-testable, no Emap import). */
+export interface CameraHost {
+    getCameraState(): CameraState;
+    applyCameraState(center: [number, number], scale: number): void;
+    /** zoom→scale (NaN if not meaningful for the CRS). */
+    scaleFromZoom(zoom: number): number;
+    getViewportSize(): {
+        width: number;
+        height: number;
+    };
+    fire(type: string, e: {
+        center: [number, number];
+        zoom: number;
+        originalEvent: null;
+    }): void;
+    requestRender(): void;
+    /**
+     * Stop the viewport's kinetic zoomIn/zoomOut tween, if any. Optional so
+     * host stubs (and CRS-agnostic tests) need not implement it; the real
+     * Emap host wires it to `Viewport.cancelZoomAnimation`. Without this a
+     * `zoomIn()` tween still running when a camera method fires would keep
+     * overwriting the transform and fight the camera destination.
+     */
+    cancelZoomAnimation?(): void;
+}
+/**
+ * Camera — animated view controller (DX P9). Drives the host viewport via
+ * the existing `Tween`. State is `{center (data coords), scale}`; `zoom`
+ * is an optional WebMercator convenience. 2D only (no bearing/pitch).
+ * One active animation at a time (last-call-wins; see `easeTo`/`stop`).
+ */
+export declare class Camera {
+    private _host;
+    private _tween;
+    private _activeEnd;
+    constructor(_host: CameraHost);
+    /** Resolve a CameraOptions to a concrete target {center,scale}. */
+    private _resolve;
+    private _payload;
+    /** True while an animation is running. */
+    isMoving(): boolean;
+    /** Instant move. Fires the movestart/move/moveend (+zoom*) lifecycle synchronously. */
+    jumpTo(o: CameraOptions): void;
+    /**
+     * Animated move. Lerps centre linearly and scale in log space over
+     * `duration` ms with `easing`. `animate:false`/`duration:0` ⇒ jump.
+     * Last-call-wins: supersedes any running animation (its terminal
+     * events fire first, via `_cancel`).
+     */
+    easeTo(o: CameraOptions & AnimationOptions): void;
+    setCenter(center: [number, number]): void;
+    setZoom(zoom: number): void;
+    zoomTo(zoom: number, o?: AnimationOptions): void;
+    panTo(center: [number, number], o?: AnimationOptions): void;
+    /** Pan by a pixel offset (converted to a data-coord centre shift). */
+    panBy(offset: [number, number], o?: AnimationOptions): void;
+    /** Fit a Bounds (data coords) into the viewport with optional padding. */
+    fitBounds(b: import('./bounds').Bounds, o?: FitBoundsOptions): void;
+    /**
+     * van-Wijk (2004) parabolic flight: for a far move, zoom out, pan, zoom
+     * back in. Reduces to easeTo for near moves. `curve` default 1.42.
+     */
+    flyTo(o: FlyToOptions): void;
+    /** Cancel a running animation, firing its terminal events at the current state. */
+    private _cancel;
+    /** Public: stop any running animation (no-op when idle). */
+    stop(): void;
+}

package/dist/geo/projection.d.ts

@@ -16,9 +16,16 @@ export declare class Projection {
     getCenter(cx: number, cy: number): [number, number];
     /**
      * Compute a zoom level from the scale factor.
-     * Only meaningful for Web Mercator.
+     * Only meaningful for Web Mercator — returns `0` for other CRS
+     * (not a sentinel; prefer the {@link getScale} round-trip to detect CRS).
      */
     getZoom(mx: number): number;
+    /**
+     * Inverse of `getZoom`: the scale factor (|mx|) for a given zoom.
+     * Only meaningful for Web Mercator — returns `NaN` otherwise so callers
+     * can detect "zoom not applicable for this CRS" and fall back to scale.
+     */
+    getScale(zoom: number): number;
     /**
      * Reproject all sources to a target CRS.
      * Returns the merged extent of all reprojected layers.

package/dist/geo/viewport.d.ts

@@ -26,6 +26,24 @@ export declare class Viewport {
     updateSize(width: number, height: number): void;
     setExtent(bounds: Bounds): void;
     reset(): void;
+    /**
+     * Current camera state in projected/data coordinates. `center` is the
+     * data point at the viewport centre (same space as `unproject` and
+     * `getExtent`, before any CRS/geographic mapping). `scale` is `|mx|`.
+     */
+    getCameraState(): {
+        center: [number, number];
+        scale: number;
+    };
+    /**
+     * Set the transform so `center` (data coords) sits at the viewport
+     * centre at `scale` (= |mx|), preserving the existing flipY (my<0)
+     * convention, then re-apply pan/zoom constraints. Additive primitive
+     * for the Camera; does not touch `setExtent`/`reset` state. Callers own
+     * the render / `onViewChange` trigger after this call (the Camera fires
+     * the move/zoom lifecycle itself).
+     */
+    applyCameraState(center: [number, number], scale: number): void;
     clearInitialState(): void;
     private _updateTransform;
     pan(dx: number, dy: number): void;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import './shim';
 import 'mapshaper';
 export { Emap } from './map/map';
-export type { MapOptions, ExpressionEvaluationPolicy, QueryFeaturesOptions, QueriedFeature, FeatureRef, HighlightFeatureRef, HighlightStyle, FeatureTranslateSession, FeatureAffineSession, ClipEraseOptions, DissolveOptions, CleanOptions, BufferOptions, ApplyExpressionOptions, ExplodeOptions, InnerlinesOptions, FilterOptions, FilterIslandsOptions, FilterSliversOptions, FilterGeomOptions, AffineLayerOptions, DataFillOptions, SnapOptions, MosaicOptions, UnionOptions, DivideOptions, PointsOptions, PointsMode, LinesOptions, PolygonsOptions, SimplifyOptions, SimplifyMethod, ProjectOptions, RebuildTopologyOptions, RenameLayerOptions, MergeLayersOptions, SplitLayerOptions, DropLayerOptions, SortFeaturesOptions, UniqueFeaturesOptions, FilterFieldsOptions, RenameFieldsOptions, JoinTableOptions, JoinTableData, CheckGeometryOptions, GeometryCheckReport, IntersectionPointsLayerOptions, ExportSnapshotOptions, LoadSnapshotOptions, } from './map/map';
+export type { MapOptions, ExpressionEvaluationPolicy, QueryFeaturesOptions, QueriedFeature, FeatureRef, HighlightFeatureRef, HighlightStyle, FeatureTranslateSession, FeatureAffineSession, DragSessionOptions, ClipEraseOptions, DissolveOptions, CleanOptions, BufferOptions, ApplyExpressionOptions, ExplodeOptions, InnerlinesOptions, FilterOptions, FilterIslandsOptions, FilterSliversOptions, FilterGeomOptions, AffineLayerOptions, DataFillOptions, SnapOptions, MosaicOptions, UnionOptions, DivideOptions, PointsOptions, PointsMode, LinesOptions, PolygonsOptions, SimplifyOptions, SimplifyMethod, ProjectOptions, RebuildTopologyOptions, RenameLayerOptions, MergeLayersOptions, SplitLayerOptions, DropLayerOptions, SortFeaturesOptions, UniqueFeaturesOptions, FilterFieldsOptions, RenameFieldsOptions, JoinTableOptions, JoinTableData, CheckGeometryOptions, GeometryCheckReport, IntersectionPointsLayerOptions, ExportSnapshotOptions, LoadSnapshotOptions, } from './map/map';
 export type { LayerSpecification, LayerType, LayerPaint, LayerLayout, FillPaint, LinePaint, CirclePaint, } from './map/layer';
 export { resolveStrokeStyle, resolvePointStyle } from './map/layer';
 export { HighlightManager } from './map/highlight-manager';
@@ -31,7 +31,31 @@ export { CanvasPainter } from './renderer/canvas-painter';
 export { EditOverlayRenderer } from './renderer/edit-overlay-renderer';
 export { EventDispatcher } from './core/events';
 export type { EventListener } from './core/events';
-export { DragPanHandler } from './core/drag-pan-handler';
+export type { EmapEventMap, CameraEvent } from './core/event-map';
+export type { CameraOptions, AnimationOptions, FlyToOptions, FitBoundsOptions } from './geo/camera';
+export { HandlerManager } from './core/handler-manager';
+export { isHandler } from './core/handler';
+export type { Handler, HandlerResult, NormalizedPointerEvent, PointerModifiers } from './core/handler';
+export { DragPanHandler } from './core/handlers/drag-pan';
+export type { DragPanOptions } from './core/handlers/drag-pan';
+export { ScrollZoomHandler } from './core/handlers/scroll-zoom';
+export type { ScrollZoomOptions } from './core/handlers/scroll-zoom';
+export { ClickSelectHandler } from './core/handlers/click-select';
+export type { SelectHandlerOptions } from './core/handlers/click-select';
+export { BoxSelectHandler } from './core/handlers/box-select';
+export type { BoxSelectHandlerOptions } from './core/handlers/box-select';
+export { LassoSelectHandler } from './core/handlers/lasso-select';
+export type { LassoSelectHandlerOptions, LassoStyle } from './core/handlers/lasso-select';
+export { resolveMode } from './core/handlers/select-mode';
+export type { ModifierCombo } from './core/handlers/select-mode';
+export type { FeatureEvent, FeatureEventFilter } from './core/feature-event-dispatcher';
+export type { PointerMoveEvent } from './core/pointer-event-dispatcher';
+export { VertexEditHandler } from './core/handlers/vertex-edit';
+export type { VertexEditOptions } from './core/handlers/vertex-edit';
+export { DrawFeatureHandler } from './core/handlers/draw-feature';
+export type { DrawFeatureOptions } from './core/handlers/draw-feature';
+export { TransformFeatureHandler } from './core/handlers/transform-feature';
+export type { TransformFeatureOptions } from './core/handlers/transform-feature';
 export type { EditCommand } from './edit/edit-command';
 export { EditHistory } from './edit/edit-history';
 export type { HistoryStateSnapshot, EditHistoryOptions } from './edit/edit-history';

package/dist/map/edit-state-store.d.ts

@@ -1,5 +1,5 @@
 import type { EditVertexState, EditDrawState } from './types';
-export type EditMode = 'none' | 'vertex' | 'draw';
+export type EditMode = 'none' | 'vertex' | 'draw' | 'transform';
 export interface EditStateSnapshot {
     mode: EditMode;
     vertex: EditVertexState | null;

package/dist/map/map.d.ts

@@ -1,6 +1,7 @@
 import { EventDispatcher } from '../core/events';
 import { Bounds } from '../geo/bounds';
 import { AffineTransform } from '../geo/transform';
+import { type CameraOptions, type AnimationOptions, type FlyToOptions, type FitBoundsOptions } from '../geo/camera';
 import { Painter } from '../renderer/painter';
 import { MapshaperOps } from './mapshaper-ops';
 import { EditSessions } from './edit-sessions';
@@ -8,10 +9,23 @@ import { AttributeOps } from './attribute-ops';
 import { type EditMode } from './edit-state-store';
 import { LayerRegistry } from './layer-registry';
 import { TopologySource } from '../source/source';
+import type { ScrollZoomOptions } from '../core/handlers/scroll-zoom';
+import type { DragPanOptions } from '../core/handlers/drag-pan';
+import { type SelectHandlerOptions } from '../core/handlers/click-select';
+import { type BoxSelectHandlerOptions } from '../core/handlers/box-select';
+import { type LassoSelectHandlerOptions } from '../core/handlers/lasso-select';
+import { type VertexEditOptions } from '../core/handlers/vertex-edit';
+import { type DrawFeatureOptions } from '../core/handlers/draw-feature';
+import { type TransformFeatureOptions } from '../core/handlers/transform-feature';
+import type { Handler } from '../core/handler';
 import { MapshaperWorkerPool } from '../core/mapshaper-worker-pool';
+import { type FeatureEvent, type FeatureEventFilter } from '../core/feature-event-dispatcher';
+import { type PointerMoveEvent } from '../core/pointer-event-dispatcher';
+import { type EventListener } from '../core/events';
+import type { EmapEventMap } from '../core/event-map';
 import { FeatureAccessor } from './feature-accessor';
 import { ValidatorRegistry } from '../validation/registry';
-import { Selection, SelectMode, SelectionDiff } from './selection';
+import { Selection, type SelectMode, SelectionDiff } from './selection';
 import { EditHistory } from '../edit/edit-history';
 import type { EditCommand } from '../edit/edit-command';
 import { Transaction, type TransactionInternal } from '../edit/transaction';
@@ -28,6 +42,7 @@ export declare class Emap extends EventDispatcher {
     private _editOverlay;
     private _viewport;
     private _projection;
+    private _camera;
     _sources: globalThis.Map<string, TopologySource>;
     /**
      * Single resolution surface for `(sourceId, layerId) → MapshaperLayer`.
@@ -44,8 +59,17 @@ export declare class Emap extends EventDispatcher {
     private _effectiveLayersCache;
     private _defaultLayersDirty;
     private _layerArcFlagsCache;
-    private _mouseWheel;
+    private _handlers;
+    private _featureEvents;
+    private _pointerEvents;
+    private _scrollZoom;
     private _dragPan;
+    private _clickSelect;
+    private _boxSelect;
+    private _lassoSelect;
+    private _vertexEdit;
+    private _drawFeature;
+    private _transformFeature;
     private _pendingRender;
     private _rafId;
     private _controlContainers;
@@ -117,6 +141,33 @@ export declare class Emap extends EventDispatcher {
     setExpressionPolicy(policy: ExpressionEvaluationPolicy): void;
     getExpressionPolicy(): ExpressionEvaluationPolicy;
     _allowExpressionEvaluation(values: Array<string | undefined>, operation: string): boolean;
+    on(type: 'mousemove', listener: (e: PointerMoveEvent) => void): this;
+    on<K extends keyof EmapEventMap>(type: K, listener: (e: {
+        type: K;
+    } & EmapEventMap[K]) => void): this;
+    on<T = Record<string, unknown>>(type: string, listener: EventListener<T>): this;
+    on(type: string, listener: (e: FeatureEvent) => void): this;
+    on(type: string, filter: FeatureEventFilter, listener: (e: FeatureEvent) => void): this;
+    off(type: 'mousemove', listener: (e: PointerMoveEvent) => void): this;
+    off<K extends keyof EmapEventMap>(type: K, listener: (e: {
+        type: K;
+    } & EmapEventMap[K]) => void): this;
+    off<T = Record<string, unknown>>(type: string, listener: EventListener<T>): this;
+    off(type: string, listener: (e: FeatureEvent) => void): this;
+    once(type: 'mousemove', listener: (e: PointerMoveEvent) => void): this;
+    once<K extends keyof EmapEventMap>(type: K, listener: (e: {
+        type: K;
+    } & EmapEventMap[K]) => void): this;
+    once<T = Record<string, unknown>>(type: string, listener: EventListener<T>): this;
+    once(type: string, listener: (e: FeatureEvent) => void): this;
+    once(type: string, filter: FeatureEventFilter, listener: (e: FeatureEvent) => void): this;
+    /**
+     * Install ONE HandlerManager sink while ≥1 feature OR pointer listener
+     * exists; it fans out to both dispatchers (feature events first, then
+     * pointer-move — independent, order fixed for determinism). Cleared when
+     * neither has listeners, so default `new Emap()` pays nothing.
+     */
+    private _syncPointerSink;
     getCanvasContainer(): HTMLElement;
     getEditMode(): EditMode;
     setEditMode(mode: EditMode): void;
@@ -186,6 +237,22 @@ export declare class Emap extends EventDispatcher {
     reproject(targetCrs: string): Promise<void>;
     getCenter(): [number, number];
     getZoom(): number;
+    /** The drag-to-pan interaction handler. */
+    get dragPan(): Handler<DragPanOptions>;
+    /** The scroll-wheel zoom interaction handler. */
+    get scrollZoom(): Handler<ScrollZoomOptions>;
+    /** The click-to-select interaction handler (disabled by default). */
+    get clickSelect(): Handler<SelectHandlerOptions>;
+    /** The box-select interaction handler (disabled by default). */
+    get boxSelect(): Handler<BoxSelectHandlerOptions>;
+    /** The lasso-select interaction handler (disabled by default). */
+    get lassoSelect(): Handler<LassoSelectHandlerOptions>;
+    /** The vertex-edit interaction handler (disabled by default). */
+    get vertexEdit(): Handler<VertexEditOptions>;
+    /** The draw-feature interaction handler (disabled by default). */
+    get drawFeature(): Handler<DrawFeatureOptions>;
+    /** The transform-feature interaction handler (disabled by default). */
+    get transformFeature(): Handler<TransformFeatureOptions>;
     getTransform(): AffineTransform;
     getExtent(): Bounds;
     setExtent(bounds: Bounds): void;
@@ -194,6 +261,26 @@ export declare class Emap extends EventDispatcher {
     removeControl(control: Control): void;
     zoomIn(): void;
     zoomOut(): void;
+    /** Instant camera move. Fires movestart/move/moveend (+zoom*). */
+    jumpTo(o: CameraOptions): this;
+    /** Set centre (projected/data coords) instantly. */
+    setCenter(center: [number, number]): this;
+    /** Set zoom (WebMercator) instantly. */
+    setZoom(zoom: number): this;
+    /** Animated move (centre+zoom/scale). */
+    easeTo(o: CameraOptions & AnimationOptions): this;
+    /** Animated pan to a centre. */
+    panTo(center: [number, number], o?: AnimationOptions): this;
+    /** Animated pan by a pixel offset. */
+    panBy(offset: [number, number], o?: AnimationOptions): this;
+    /** Animated zoom to a level. */
+    zoomTo(zoom: number, o?: AnimationOptions): this;
+    /** van-Wijk parabolic flight. */
+    flyTo(o: FlyToOptions): this;
+    /** Fit a Bounds into the viewport with optional padding. */
+    fitBounds(b: import('../geo/bounds').Bounds, o?: FitBoundsOptions): this;
+    /** Cancel any running camera animation (no-op when idle). */
+    stop(): this;
     _scheduleRender(): void;
     private _doRender;
     render(): void;

package/dist/map/selection.d.ts

@@ -1,6 +1,9 @@
 import type { FeatureRef } from './map';
-/** Mutation modes for {@link Selection.apply}. */
-export type SelectMode = 'replace' | 'add' | 'toggle';
+import type { SelectMode } from '../core/handlers/select-mode';
+/** Mutation modes for {@link Selection.apply}. Canonical declaration lives
+ *  in `core/handlers/select-mode.ts`; re-exported here for back-compat
+ *  (the public `@/map/selection` path is unchanged). */
+export type { SelectMode } from '../core/handlers/select-mode';
 /** Diff produced by every selection mutation. */
 export interface SelectionDiff {
     /** Refs newly present after the mutation */

package/dist/renderer/edit-overlay-renderer.d.ts

@@ -1,5 +1,6 @@
 import type { EditPainter } from './painter';
 import type { EditVertexState, EditDrawState } from '../map/types';
+import type { EditMode } from '../map/edit-state-store';
 /**
  * Draws edit-mode-only decorations on top of the regular layer pass:
  *   - polygon fill highlight while editing a polygon's vertices
@@ -17,6 +18,6 @@ export declare class EditOverlayRenderer {
      * Render the edit-mode overlay for the current frame. No-op when
      * `editMode === 'none'` or the relevant state object is `null`.
      */
-    render(editMode: 'none' | 'vertex' | 'draw', vertexState: EditVertexState | null, drawState: EditDrawState | null): void;
+    render(editMode: EditMode, vertexState: EditVertexState | null, drawState: EditDrawState | null): void;
     private _renderVertexOverlay;
 }

package/dist/source/source.d.ts

@@ -1,5 +1,5 @@
 import { EventDispatcher } from '../core/events';
-import type { ArcCollection, MapshaperDataset } from '../types/mapshaper-types';
+import type { ArcCollection, MapshaperDataset, MapshaperLayer } from '../types/mapshaper-types';
 import type { DisplayArcs } from './display-arcs';
 import type { Bounds } from '../geo/bounds';
 export interface Source extends EventDispatcher {
@@ -16,7 +16,7 @@ export interface ExportOptions {
 export interface TopologySource extends Source {
     type: 'topology';
     getArcs(): ArcCollection | undefined;
-    getLayers(): any[];
+    getLayers(): MapshaperLayer[];
     /**
      * Returns the live mapshaper dataset reference owned by this source.
      *

package/dist/source/topology-source.d.ts

@@ -115,11 +115,16 @@ export declare class TopologySource extends EventDispatcher implements ITopology
     setData(data: TopologySourceInput): Promise<TopologySource>;
     private _updateData;
     /**
-     * Settle the {@link setData} deferred for the given load version. Ignored
+     * Resolve the {@link setData} deferred for the given load version. Ignored
      * if a newer call has already replaced it (the superseding `setData`
      * resolved the old deferred early).
      */
-    private _settlePending;
+    private _resolvePending;
+    /**
+     * Reject the {@link setData} deferred for the given load version. Ignored
+     * if a newer call has already replaced it.
+     */
+    private _rejectPending;
     private _hasSupportedExtension;
     private _filenameFromContentType;
     getDataset(): MapshaperDataset | undefined;

package/dist/ui/box-select-control.d.ts

@@ -1,14 +1,7 @@
 import type { Control } from './control';
 import type { Emap } from '../map/map';
-/** Visual style for the rubber-band rectangle. */
-export interface BoxSelectStyle {
-    /** Stroke color. Default `'#0078ff'`. */
-    stroke?: string;
-    /** Stroke width in CSS pixels. Default `1.5`. */
-    strokeWidth?: number;
-    /** Fill color. Default `'rgba(0, 120, 255, 0.1)'`. */
-    fill?: string;
-}
+export type { BoxSelectStyle } from '../core/handlers/box-select';
+import type { BoxSelectStyle } from '../core/handlers/box-select';
 export interface BoxSelectControlOptions {
     /**
      * Restrict the selection to a subset of layer ids. When omitted, every
@@ -24,44 +17,27 @@ export interface BoxSelectControlOptions {
     dragThreshold?: number;
 }
 /**
- * Shift+drag rubber-band feature selection. Reuses
- * `Emap.queryFeatures(bbox)` for hit-testing and `Emap.select` for
- * selection state management.
- *
- * Modifier-key conventions (layered on top of shift):
- * - shift only → mode `'replace'`
- * - shift + ctrl/meta → mode `'add'`
- * - shift + alt → mode `'toggle'`
- *
- * Tiny drags (< `dragThreshold` px diagonal) cancel without selecting.
+ * Thin shell over the `map.boxSelect` handler (DX P2c). The handler owns
+ * the shift+drag gesture, the `.emap-box-select` rubber-band overlay,
+ * hit-testing, and selection; this control just forwards options and
+ * proxies enable/disable, returning a 0×0 anchor for `addControl`
+ * placement. Public class, options, anchor DOM, and selection behaviour
+ * are unchanged from the pre-P2c control.
  *
- * Coordinates with `DragPanHandler`: the handler now skips shift-modified
- * mousedowns, leaving shift+drag for this control.
+ * Modifier conventions (on top of shift): shift→`replace`,
+ * shift+ctrl/meta→`add`, shift+alt→`toggle`. Mutually exclusive with
+ * lasso-select — `onAdd` propagates the handler's throw if `lassoSelect`
+ * is already enabled.
  */
 export declare class BoxSelectControl implements Control {
     private _options;
-    private _dragThreshold;
     private _enabled;
-    private _map;
+    private _handler;
     private _container;
-    private _overlay;
-    private _canvasContainer;
-    private _startPx;
-    private _onMouseDownBound;
-    private _onMouseMoveBound;
-    private _onMouseUpBound;
     constructor(options?: BoxSelectControlOptions);
     onAdd(map: Emap): HTMLElement;
     onRemove(): void;
-    /** Disable the control — shift+drag becomes a no-op until re-enabled. */
     disable(): void;
     enable(): void;
     isEnabled(): boolean;
-    private _onMouseDown;
-    private _onMouseMove;
-    private _onMouseUp;
-    private _cancelDrag;
-    private _cleanupDrag;
-    private _eventToContainerPx;
-    private _modeFromEvent;
 }

package/dist/ui/draw-feature-control.d.ts

@@ -1,82 +1,17 @@
-import { Control } from './control';
-import { Emap } from '../map/map';
-export type DrawGeometryType = 'polygon' | 'polyline' | 'point';
-export interface DrawFeatureControlOptions {
-    /** Target source ID where new features will be added */
-    source: string;
-    /** Target layer name within the source (optional, defaults to first matching geometry layer) */
-    sourceLayer?: string;
-    /** Geometry type to draw */
-    type: DrawGeometryType;
-    /** Pixel threshold for vertex snapping (default: 10) */
-    snapThreshold?: number;
-    /**
-     * Sources to snap against. Defaults to `[options.source]` so the existing
-     * single-source behaviour is preserved when omitted. Pass `['a', 'b']` to
-     * also snap onto another source (e.g. drawing in source A while tracing
-     * along reference data in source B).
-     */
-    snapSources?: string[];
-    /** Enable vertex snap (default `true`). */
-    snapToVertex?: boolean;
-    /**
-     * Enable edge snap — perpendicular projection onto an arc segment
-     * (default `true`). Disable to restrict snap to existing vertices only.
-     */
-    snapToEdge?: boolean;
-    /** CSS color for the drawing line (default: '#0078ff') */
-    drawColor?: string;
-    /**
-     * Button icon. A `string` is rendered as text via `textContent` (safe;
-     * covers unicode glyphs like the defaults below). Pass a `Node` to render
-     * a pre-built DOM element such as an `<svg>` — caller is responsible for
-     * its own escaping.
-     */
+import type { DrawFeatureOptions } from '../core/handlers/draw-feature';
+import type { Control } from './control';
+import type { Emap } from '../map/map';
+export type { DrawGeometryType } from '../core/handlers/draw-feature';
+export interface DrawFeatureControlOptions extends DrawFeatureOptions {
     icon?: string | Node;
 }
 export declare class DrawFeatureControl implements Control {
-    private _options;
+    private _opts;
     private _map;
     private _container;
     private _btn;
-    private _active;
-    private _vertices;
-    private _cursorCoord;
-    private _snapCoord;
-    private _snapKind;
-    private _snapThreshold;
-    private _onMouseMoveBound;
-    private _onClickBound;
-    private _onDblClickBound;
-    private _onKeyDownBound;
-    private _onMoveHandlerBound;
     constructor(options: DrawFeatureControlOptions);
     onAdd(map: Emap): HTMLElement;
     onRemove(): void;
     private _toggle;
-    private _activate;
-    private _deactivate;
-    /** Deactivate UI without firing setEditMode (used when another mode takes over) */
-    private _deactivateQuiet;
-    private _clearDrawState;
-    private _onMapMove;
-    private _onMouseMove;
-    private _onClick;
-    private _onDblClick;
-    private _onKeyDown;
-    private _findSnapTarget;
-    private _commitFeature;
-    private _resolveTargetLayer;
-    private _appendArc;
-    private _updateDrawState;
 }
-/**
- * Closest point on segment `[a, b]` to point `p`, all in 2-D pixel space.
- * Parameter `t = ((p-a)·(b-a)) / |b-a|²` is clamped to `[0, 1]` so the
- * returned point is always on the segment (not its infinite line). For a
- * zero-length segment, returns endpoint `a` and `dist(p, a)`.
- */
-export declare function projectPointOnSegment(p: [number, number], a: [number, number], b: [number, number]): {
-    point: [number, number];
-    dist: number;
-};