@zwishing/emap 0.1.3 → 0.3.0

package/dist/core/event-map.d.ts

@@ -0,0 +1,67 @@
+import type { EditMode } from '../map/edit-state-store';
+import type { HistoryStateSnapshot } from '../edit/edit-history';
+import type { FeatureRef } from '../map/types';
+import type { ValidatorResult } from '../validation/validator';
+import type { FeatureEvent } from './feature-event-dispatcher';
+import type { PointerMoveEvent } from './pointer-event-dispatcher';
+/**
+ * Camera lifecycle payload (P9). `zoom` is `log2(scale)` — meaningful for
+ * WebMercator, otherwise the documented log2 convention. `originalEvent`
+ * is `null` for programmatic camera moves.
+ */
+export interface CameraEvent {
+    center: [number, number];
+    zoom: number;
+    originalEvent: MouseEvent | null;
+}
+/**
+ * Typed payloads for every event emitted ON the `Emap` instance (P10).
+ * Scoped to `this.fire(…)` in `src/map/map.ts` + the camera lifecycle
+ * wired through the camera host. Handler-internal events (`pan`,
+ * `panstart`, `mousewheel*`) and sub-dispatcher events (`tick`, `change`,
+ * `workerjob*`, source `dataloading`) are intentionally excluded — they
+ * are not delivered via `map.on`.
+ *
+ * This is an `interface` (not a `type`) so consumers can augment it:
+ *
+ * ```ts
+ * declare module '@zwishing/emap' {
+ *   interface EmapEventMap { myCustomEvent: { detail: string } }
+ * }
+ * ```
+ */
+export interface EmapEventMap {
+    movestart: CameraEvent;
+    moveend: CameraEvent;
+    zoomstart: CameraEvent;
+    zoom: CameraEvent;
+    zoomend: CameraEvent;
+    move: Partial<CameraEvent>;
+    crschange: Record<never, never>;
+    resize: Record<never, never>;
+    data: {
+        sourceId?: string;
+        reason?: 'edit' | 'load' | 'replace' | 'reproject';
+    };
+    editmodechange: {
+        mode: EditMode;
+    };
+    error: {
+        error: Error;
+    };
+    historychange: Partial<HistoryStateSnapshot>;
+    selectionchange: {
+        selected: FeatureRef[];
+        added: FeatureRef[];
+        removed: FeatureRef[];
+    };
+    validationfailed: {
+        results: ValidatorResult[];
+        label: string;
+    };
+    mousemove: PointerMoveEvent;
+    'feature:click': FeatureEvent;
+    'feature:hover': FeatureEvent;
+    'feature:enter': FeatureEvent;
+    'feature:leave': FeatureEvent;
+}

package/dist/core/feature-event-dispatcher.d.ts

@@ -0,0 +1,70 @@
+import type { NormalizedPointerEvent } from './handler';
+import type { FeatureRef } from '../map/types';
+import type { Feature } from '../map/feature-accessor';
+/** Restrict which features a `feature:*` listener hears. Omitted = all visible. */
+export interface FeatureEventFilter {
+    source?: string;
+    layers?: string[];
+}
+export interface FeatureEvent {
+    type: string;
+    feature: Feature;
+    ref: FeatureRef;
+    point: {
+        x: number;
+        y: number;
+    };
+    lngLat: [number, number];
+    modifiers: {
+        shift: boolean;
+        ctrl: boolean;
+        alt: boolean;
+        meta: boolean;
+    };
+    /** The DOM event that produced this (typed `Event`; it is a PointerEvent/MouseEvent at runtime). */
+    originalEvent: Event;
+}
+type Cb = (e: FeatureEvent) => void;
+/** Minimal surface the dispatcher needs from Emap (keeps it unit-testable). */
+export interface FeatureEventMapHost {
+    queryFeatures(geom: [number, number], opts?: {
+        layers?: string[];
+    }): Array<{
+        source: string;
+        layer: string;
+        id: number;
+    }>;
+    unproject(x: number, y: number): [number, number];
+    features: {
+        get(ref: FeatureRef): Feature | null;
+    };
+}
+/**
+ * Delegated feature-event registry + enter/leave/hover state machine.
+ * Fed normalized pointer events by `HandlerManager`'s sink (click + non-
+ * gesture move). Reuses `host.queryFeatures` (existing FeatureQuery/LOD
+ * path) — no new hit-test. Decoupled from selection.
+ */
+export declare class FeatureEventDispatcher {
+    private _host;
+    private _reg;
+    private _lastKey;
+    private _lastRef;
+    /** Maps user-supplied cb → its once-wrapper so `off(type, userCb)` can resolve the wrap. */
+    private _onceWrap;
+    private _onChange?;
+    constructor(_host: FeatureEventMapHost);
+    /** Install a callback invoked whenever the registry changes (on/off/once auto-fire). */
+    setOnChange(fn: () => void): void;
+    hasListeners(): boolean;
+    /** `on(type, filter, cb)` or `on(type, cb)`. Non-feature types are rejected (Emap routes them). */
+    on(type: string, filter: FeatureEventFilter | undefined, cb: Cb): void;
+    /** Register a one-time listener. Cancellable via `off(type, cb)` using the original `cb`. */
+    once(type: string, filter: FeatureEventFilter | undefined, cb: Cb): void;
+    off(type: string, cb: Cb): void;
+    /** Topmost hit at a point, restricted to the union of all registered filters' layers. */
+    private _hit;
+    private _emit;
+    dispatch(ev: NormalizedPointerEvent): void;
+}
+export {};

package/dist/core/handler-manager.d.ts

@@ -0,0 +1,49 @@
+import { type Handler, type NormalizedPointerEvent } from './handler';
+/**
+ * Registry of named interaction handlers owned by Emap. Owns the
+ * single-DOM-listener pointer arbitration layer: installs one set of pointer
+ * listeners, normalizes events, and dispatches to enabled handlers in fixed
+ * priority order with an exclusive-gesture lock.
+ */
+export declare class HandlerManager {
+    private _handlers;
+    private _element;
+    private _exclusive;
+    private _pointerSink;
+    private _onDown;
+    private _onMove;
+    private _onUp;
+    private _onClick;
+    private _onContextMenu;
+    private _onDblClick;
+    /** Register a handler; re-registering the same `name` replaces the prior one. */
+    register(handler: Handler): void;
+    /** Is a sibling handler currently registered AND enabled? */
+    isEnabledByName(name: string): boolean;
+    get(name: string): Handler | undefined;
+    /** Legacy `interactive` shim: toggles the pan + zoom handlers together. */
+    applyInteractive(interactive: boolean): void;
+    /** Install the single pointer-listener set + start arbitrating. */
+    attach(element: HTMLElement): void;
+    /** Remove all listeners and clear any active exclusive gesture. */
+    detach(): void;
+    /** Install (or clear with `null`) a passive observer fed click + non-gesture move. */
+    setPointerSink(sink: ((ev: NormalizedPointerEvent) => void) | null): void;
+    private _norm;
+    private _orderedEnabled;
+    private _dispatch;
+    private _dispatchInner;
+    /**
+     * Resolve the effective cursor and write it to the attached element.
+     * Order: active exclusive handler's cursor → first enabled handler in
+     * PRIORITY with a non-empty cursor → '' (clear → CSS/page default).
+     * Idempotent: only writes when the value changes.
+     */
+    private _applyCursor;
+    /**
+     * Recompute the effective cursor. Call after a handler changes
+     * cursor-relevant state OUTSIDE a pointer event (e.g. enable()/disable()
+     * flipping a mode). No-op when not attached.
+     */
+    refreshCursor(): void;
+}

package/dist/core/handler.d.ts

@@ -0,0 +1,48 @@
+/** Outcome of a handler processing one normalized event. */
+export type HandlerResult = 'passthrough' | 'consumed' | 'exclusive';
+export interface PointerModifiers {
+    shift: boolean;
+    ctrl: boolean;
+    alt: boolean;
+    meta: boolean;
+}
+/** A DOM pointer/wheel event normalized to element-local coords + modifiers. */
+export interface NormalizedPointerEvent {
+    kind: 'down' | 'move' | 'up' | 'wheel' | 'click' | 'contextmenu' | 'dblclick';
+    /** Element-local pixel position. */
+    point: {
+        x: number;
+        y: number;
+    };
+    modifiers: PointerModifiers;
+    /** Mouse button for down/up/click; 0 otherwise. */
+    button: number;
+    /** Wheel delta (sign already normalized: +1 zoom-in direction). Absent if N/A. */
+    wheelDirection?: number;
+    originalEvent: Event;
+}
+/**
+ * A unit of interaction (pan, zoom, selection…). Every interaction on the map
+ * is one of these. Mirrors MapLibre's handler model.
+ */
+export interface Handler<Opts = unknown> {
+    readonly name: string;
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    setOptions(opts: Partial<Opts>): void;
+    getOptions(): Readonly<Opts>;
+    /** Process one normalized event; report whether it was consumed. */
+    handlePointer(ev: NormalizedPointerEvent): HandlerResult;
+    /**
+     * CSS cursor this handler wants for its CURRENT state, or `null` =
+     * no opinion (HandlerManager falls through to lower-priority handlers,
+     * then the page/CSS default). Optional — absent ⇒ no opinion.
+     * An empty string `''` is treated the same as `null` (no opinion);
+     * to clear to the page/CSS default, simply have no enabled handler
+     * with an opinion (HandlerManager writes `''` itself in that case).
+     */
+    getCursor?(): string | null;
+}
+/** Runtime guard — used by HandlerManager.register and by consumers. */
+export declare function isHandler(v: unknown): v is Handler;

package/dist/core/handlers/box-select.d.ts

@@ -0,0 +1,54 @@
+import { EventDispatcher } from '../events';
+import type { Handler, HandlerResult, NormalizedPointerEvent } from '../handler';
+import { type ModifierCombo } from './select-mode';
+import type { SelectHandlerOptions } from './click-select';
+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 interface BoxSelectHandlerOptions extends SelectHandlerOptions {
+    /** Min drag diagonal (px) before a release counts as a box. Default 4. */
+    dragThreshold?: number;
+    /** Combo that must be held at pointerdown to start. Default 'shift'. */
+    dragActivator?: ModifierCombo;
+    style?: BoxSelectStyle;
+}
+/**
+ * Named `boxSelect` handler. Disabled by default. On `dragActivator`+down
+ * it captures the gesture (`'exclusive'`), draws a rubber-band rectangle in
+ * `_canvasContainer`, and on release past `dragThreshold` runs
+ * `queryFeatures(bbox)` → `select(mode)`. Mode is resolved by stripping the
+ * activator then matching `modifiers` — reproducing the legacy
+ * `BoxSelectControl` behavior exactly. Mutually exclusive with `lassoSelect`
+ * (enforced in HandlerManager — a later task).
+ */
+export declare class BoxSelectHandler extends EventDispatcher implements Handler<BoxSelectHandlerOptions> {
+    private _map;
+    readonly name = "boxSelect";
+    private _enabled;
+    private _opts;
+    private _start;
+    private _overlay;
+    /** Set by HandlerManager.register. */
+    _manager?: {
+        isEnabledByName(name: string): boolean;
+    };
+    constructor(_map: Emap);
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    setOptions(opts: Partial<BoxSelectHandlerOptions>): void;
+    getOptions(): Readonly<BoxSelectHandlerOptions>;
+    getCursor(): string | null;
+    private get _threshold();
+    private get _activator();
+    private _ensureOverlay;
+    private _cancel;
+    handlePointer(ev: NormalizedPointerEvent): HandlerResult;
+}

package/dist/core/handlers/click-select.d.ts

@@ -0,0 +1,31 @@
+import { EventDispatcher } from '../events';
+import type { Handler, HandlerResult, NormalizedPointerEvent } from '../handler';
+import { type ModifierCombo, type SelectMode } from './select-mode';
+import type { Emap } from '../../map/map';
+export interface SelectHandlerOptions {
+    /** Restrict selectable layers; default = all visible. */
+    layers?: string[];
+    source?: string;
+    /** Modifier→mode table. Defaults reproduce a sensible click model. */
+    modifiers?: Partial<Record<SelectMode, ModifierCombo>>;
+}
+/**
+ * Named `clickSelect` handler. Acts only on `kind:'click'` (the arbiter
+ * synthesizes it from a non-dragging down/up, so it never fights a
+ * box/lasso drag). Hit → resolve mode → `Emap.select`; empty click whose
+ * resolved mode is `'replace'` clears the selection. Opt-in (disabled by
+ * default) so `new Emap()` behavior is unchanged.
+ */
+export declare class ClickSelectHandler extends EventDispatcher implements Handler<SelectHandlerOptions> {
+    private _map;
+    readonly name = "clickSelect";
+    private _enabled;
+    private _opts;
+    constructor(_map: Emap);
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    setOptions(opts: Partial<SelectHandlerOptions>): void;
+    getOptions(): Readonly<SelectHandlerOptions>;
+    handlePointer(ev: NormalizedPointerEvent): HandlerResult;
+}

package/dist/core/handlers/drag-pan.d.ts

@@ -0,0 +1,28 @@
+import { EventDispatcher } from '../events';
+import type { Handler, HandlerResult, NormalizedPointerEvent } from '../handler';
+export interface DragPanOptions {
+    /** Reserve shift+drag for higher-level handlers (P2b selection). Default true. */
+    skipShiftDrag: boolean;
+}
+/**
+ * Named `dragPan` handler. Phase 2a: pan logic lives in `handlePointer`,
+ * driven by HandlerManager's single pointer-listener arbiter — the handler
+ * owns no DOM listeners. Emits `panstart` / `pan {dx,dy}` / `panend` exactly
+ * as before so Emap's viewport wiring is unchanged.
+ */
+export declare class DragPanHandler extends EventDispatcher implements Handler<DragPanOptions> {
+    readonly name = "dragPan";
+    private _opts;
+    private _enabled;
+    private _dragging;
+    private _last;
+    private _onGestureStart?;
+    constructor(opts?: Partial<DragPanOptions>, onGestureStart?: () => void);
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    setOptions(opts: Partial<DragPanOptions>): void;
+    getOptions(): Readonly<DragPanOptions>;
+    getCursor(): string | null;
+    handlePointer(ev: NormalizedPointerEvent): HandlerResult;
+}

package/dist/core/handlers/draw-feature.d.ts

@@ -0,0 +1,76 @@
+import type { Handler, HandlerResult, NormalizedPointerEvent } from '../handler';
+import { Emap } from '../../map/map';
+export type DrawGeometryType = 'polygon' | 'polyline' | 'point';
+export interface DrawFeatureOptions {
+    /** 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;
+}
+export declare class DrawFeatureHandler implements Handler<DrawFeatureOptions> {
+    readonly name = "drawFeature";
+    private readonly _map;
+    private _enabled;
+    private _opts;
+    /** Injected by HandlerManager.register (cursor recompute on mode flips). */
+    _manager?: {
+        refreshCursor(): void;
+    };
+    private _vertices;
+    private _cursorCoord;
+    private _snapCoord;
+    private _snapKind;
+    private _snapThreshold;
+    private _onMapMoveBound;
+    private _onKeyDownBound;
+    constructor(map: Emap, opts?: Partial<DrawFeatureOptions>);
+    isEnabled(): boolean;
+    setOptions(o: Partial<DrawFeatureOptions>): void;
+    getCursor(): string | null;
+    getOptions(): Readonly<DrawFeatureOptions>;
+    enable(): void;
+    disable(): void;
+    private _quietDisable;
+    handlePointer(ev: NormalizedPointerEvent): HandlerResult;
+    private _onMapMove;
+    private _onMouseMove;
+    private _onClick;
+    private _onDblClick;
+    private _onKeyDown;
+    private _findSnapTarget;
+    private _commitFeature;
+    private _resolveTargetLayer;
+    private _appendArc;
+    private _updateDrawState;
+    private _clearDrawState;
+}
+/**
+ * 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;
+};

package/dist/core/handlers/lasso-select.d.ts

@@ -0,0 +1,57 @@
+import { EventDispatcher } from '../events';
+import type { Handler, HandlerResult, NormalizedPointerEvent } from '../handler';
+import { type ModifierCombo } from './select-mode';
+import type { SelectHandlerOptions } from './click-select';
+import type { Emap } from '../../map/map';
+/** Visual style for the rubber-band lasso path. */
+export interface LassoSelectStyle {
+    /** Stroke color. Default `'#0078ff'`. */
+    stroke?: string;
+    /** Stroke width in CSS pixels. Default `1.5`. */
+    strokeWidth?: number;
+    /** Fill color of the closed shape preview. Default `'rgba(0, 120, 255, 0.1)'`. */
+    fill?: string;
+    /** SVG `stroke-dasharray`. Default `'4 3'` (subtly dashed). */
+    strokeDasharray?: string;
+}
+/** Back-compat alias — historically the handler-side name. */
+export type LassoStyle = LassoSelectStyle;
+export interface LassoSelectHandlerOptions extends SelectHandlerOptions {
+    dragThreshold?: number;
+    dragActivator?: ModifierCombo;
+    /** Loose hit (any part inside) vs strict containment. Default true. */
+    includeIntersecting?: boolean;
+    style?: LassoSelectStyle;
+}
+/**
+ * Named `lassoSelect` handler. Disabled by default. `dragActivator`+down →
+ * `'exclusive'`; each move appends to a pixel-space path drawn as an SVG
+ * polyline in `_canvasContainer`; release closes the polygon, bbox-prefilters
+ * via `queryFeatures`, then refines per-feature with the shared
+ * `featureMatchesLasso`. Mutually exclusive with `boxSelect` (a later task).
+ */
+export declare class LassoSelectHandler extends EventDispatcher implements Handler<LassoSelectHandlerOptions> {
+    private _map;
+    readonly name = "lassoSelect";
+    private _enabled;
+    private _opts;
+    private _path;
+    private _svg;
+    private _poly;
+    /** Set by HandlerManager.register. */
+    _manager?: {
+        isEnabledByName(name: string): boolean;
+    };
+    constructor(_map: Emap);
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    setOptions(opts: Partial<LassoSelectHandlerOptions>): void;
+    getOptions(): Readonly<LassoSelectHandlerOptions>;
+    getCursor(): string | null;
+    private get _threshold();
+    private get _activator();
+    private _ensureSvg;
+    private _cancel;
+    handlePointer(ev: NormalizedPointerEvent): HandlerResult;
+}

package/dist/core/handlers/scroll-zoom.d.ts

@@ -0,0 +1,24 @@
+import { EventDispatcher } from '../events';
+import type { Handler, HandlerResult, NormalizedPointerEvent } from '../handler';
+export interface ScrollZoomOptions {
+}
+/**
+ * Named `scrollZoom` handler. Phase 1: adapts the existing MouseWheel DOM
+ * primitive, re-emitting its 'mousewheel' event. When disabled, re-emission
+ * is suppressed (MouseWheel itself has no enable flag, so the handler gates
+ * at the boundary).
+ */
+export declare class ScrollZoomHandler extends EventDispatcher implements Handler<ScrollZoomOptions> {
+    readonly name = "scrollZoom";
+    private _wheel;
+    private _enabled;
+    private _onGestureStart?;
+    constructor(element: HTMLElement, onGestureStart?: () => void);
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    setOptions(_opts: Partial<ScrollZoomOptions>): void;
+    getOptions(): Readonly<ScrollZoomOptions>;
+    handlePointer(_ev: NormalizedPointerEvent): HandlerResult;
+    destroy(): void;
+}

package/dist/core/handlers/select-geometry.d.ts

@@ -0,0 +1,24 @@
+import type { Emap, FeatureRef } from '../../map/map';
+/**
+ * Even-odd ray-cast point-in-polygon test. The `polygon` may be open or
+ * closed (last point == first point) — we don't require either form,
+ * because we wrap via `j = (i - 1 + n) % n` modulo arithmetic. Self-
+ * intersecting polygons follow standard even-odd semantics (which usually
+ * matches the user's drawn intent).
+ */
+export declare function pointInPolygon(point: [number, number], polygon: Array<[number, number]>): boolean;
+/** [xmin, ymin, xmax, ymax] of a 2-D point sequence. */
+export declare function pathBBox(path: Array<[number, number]>): [number, number, number, number];
+export declare function featureMatchesLasso(map: Emap, ref: {
+    source: string;
+    layer: string;
+    id: number;
+    geometryType?: string;
+}, lasso: Array<[number, number]>, includeIntersecting: boolean): boolean;
+/** Dedupe `(source, layer, id)` triples — same feature can show up under
+ *  multiple visible layers when a source has e.g. fill + line styling. */
+export declare function dedupeRefs(features: ReadonlyArray<{
+    source: string;
+    layer: string;
+    id: number;
+}>): FeatureRef[];

package/dist/core/handlers/select-mode.d.ts

@@ -0,0 +1,14 @@
+import type { PointerModifiers } from '../handler';
+/** How a selection gesture combines with the existing selection. */
+export type SelectMode = 'replace' | 'add' | 'toggle';
+/** A canonical chord of modifier keys, '+'-joined in shift+ctrl+alt+meta order. */
+export type ModifierCombo = 'none' | 'shift' | 'ctrl' | 'alt' | 'meta' | 'shift+ctrl' | 'shift+alt' | 'shift+meta' | 'ctrl+alt' | 'ctrl+meta' | 'alt+meta' | 'shift+ctrl+alt' | 'shift+ctrl+meta' | 'shift+alt+meta' | 'ctrl+alt+meta' | 'shift+ctrl+alt+meta';
+/**
+ * Resolve a {@link SelectMode} from held modifiers.
+ *
+ * When `activator` is given (box/lasso drag gate), its keys are stripped
+ * from the held set first — the gesture-end chord is matched on whatever
+ * was held *beyond* the activator. With no `activator` (clickSelect) the
+ * full held chord is matched. Unmatched → `'replace'`.
+ */
+export declare function resolveMode(modifiers: PointerModifiers, table: Partial<Record<SelectMode, ModifierCombo>>, activator?: ModifierCombo): SelectMode;

package/dist/core/handlers/transform-feature.d.ts

@@ -0,0 +1,41 @@
+import type { Handler, HandlerResult, NormalizedPointerEvent } from '../handler';
+import type { Emap } from '../../map/map';
+import type { DragSessionOptions } from '../../map/types';
+export interface TransformFeatureOptions {
+    /** Active transform. Default 'translate'. */
+    mode?: 'translate' | 'rotate' | 'scale';
+    /** Forwarded to begin*Session (e.g. { splitSharedArcs }). */
+    session?: DragSessionOptions;
+}
+/**
+ * Named `transformFeature` handler. Modal (`enable()`→`setEditMode
+ * ('transform')`). On pointerdown over an **already-selected** feature it
+ * opens the matching editSession (selection itself is delegated to the
+ * modifier-aware `clickSelect`/`boxSelect`); pointermove streams the
+ * per-frame delta (translate dx/dy, or rotate/scale matrix vs the session
+ * origin); pointerup commits (one undo entry); Escape cancels. Absorbs the
+ * boilerplate previously hand-wired in the transform examples.
+ */
+export declare class TransformFeatureHandler implements Handler<TransformFeatureOptions> {
+    private _map;
+    readonly name = "transformFeature";
+    private _enabled;
+    private _opts;
+    private _translate;
+    private _affine;
+    private _lastMap;
+    private _prevAngle;
+    private _prevDist;
+    private _onKeyDownBound;
+    constructor(_map: Emap);
+    private get _mode();
+    enable(): void;
+    disable(): void;
+    private _quietDisable;
+    isEnabled(): boolean;
+    setOptions(o: Partial<TransformFeatureOptions>): void;
+    getOptions(): Readonly<TransformFeatureOptions>;
+    private _cancelSession;
+    private _onKeyDown;
+    handlePointer(ev: NormalizedPointerEvent): HandlerResult;
+}