@element-editor/adapter-leaflet 0.0.0-stage → 0.2.1

package/dist/components/featureLayers/MultiPolygonLayer.d.ts

@@ -0,0 +1,13 @@
+import { GeoJSONFeature } from '@element-editor/core';
+import { MapInteractionMachine } from '../../hooks/useMapInteractionMachine.js';
+import { OpenFeatureCtxMenu } from './shared.js';
+export declare const MultiPolygonLayer: import('react').NamedExoticComponent<{
+    feature: GeoJSONFeature;
+    selected: boolean;
+    isMultiSelected: boolean;
+    multiDragDelta: [number, number] | null;
+    onVertexEdit: () => void;
+    readonly: boolean;
+    interaction: MapInteractionMachine;
+    onContextMenu?: OpenFeatureCtxMenu;
+}>;

package/dist/components/featureLayers/POIMarker.d.cts

@@ -0,0 +1,13 @@
+import { GeoJSONFeature } from '@element-editor/core';
+import { MapInteractionMachine } from '../../hooks/useMapInteractionMachine.cjs';
+import { OpenFeatureCtxMenu } from './shared.cjs';
+export declare const POIMarker: import('react').NamedExoticComponent<{
+    feature: GeoJSONFeature;
+    selected: boolean;
+    isMultiSelected: boolean;
+    multiDragDelta: [number, number] | null;
+    multiDuplicateDrag: boolean;
+    readonly: boolean;
+    interaction: MapInteractionMachine;
+    onContextMenu?: OpenFeatureCtxMenu;
+}>;

package/dist/components/featureLayers/POIMarker.d.ts

@@ -0,0 +1,13 @@
+import { GeoJSONFeature } from '@element-editor/core';
+import { MapInteractionMachine } from '../../hooks/useMapInteractionMachine.js';
+import { OpenFeatureCtxMenu } from './shared.js';
+export declare const POIMarker: import('react').NamedExoticComponent<{
+    feature: GeoJSONFeature;
+    selected: boolean;
+    isMultiSelected: boolean;
+    multiDragDelta: [number, number] | null;
+    multiDuplicateDrag: boolean;
+    readonly: boolean;
+    interaction: MapInteractionMachine;
+    onContextMenu?: OpenFeatureCtxMenu;
+}>;

package/dist/components/featureLayers/PolygonLayer.d.cts

@@ -0,0 +1,14 @@
+import { GeoJSONFeature } from '@element-editor/core';
+import { MapInteractionMachine } from '../../hooks/useMapInteractionMachine.cjs';
+import { OpenFeatureCtxMenu } from './shared.cjs';
+export declare const PolygonLayer: import('react').NamedExoticComponent<{
+    feature: GeoJSONFeature;
+    selected: boolean;
+    isMultiSelected: boolean;
+    multiDragDelta: [number, number] | null;
+    multiDuplicateDrag: boolean;
+    onVertexEdit: () => void;
+    readonly: boolean;
+    interaction: MapInteractionMachine;
+    onContextMenu?: OpenFeatureCtxMenu;
+}>;

package/dist/components/featureLayers/PolygonLayer.d.ts

@@ -0,0 +1,14 @@
+import { GeoJSONFeature } from '@element-editor/core';
+import { MapInteractionMachine } from '../../hooks/useMapInteractionMachine.js';
+import { OpenFeatureCtxMenu } from './shared.js';
+export declare const PolygonLayer: import('react').NamedExoticComponent<{
+    feature: GeoJSONFeature;
+    selected: boolean;
+    isMultiSelected: boolean;
+    multiDragDelta: [number, number] | null;
+    multiDuplicateDrag: boolean;
+    onVertexEdit: () => void;
+    readonly: boolean;
+    interaction: MapInteractionMachine;
+    onContextMenu?: OpenFeatureCtxMenu;
+}>;

package/dist/components/featureLayers/mountQueue.d.cts

@@ -0,0 +1,41 @@
+import { GeoJSONFeature } from '@element-editor/core';
+export type ViewBounds = {
+    w: number;
+    s: number;
+    e: number;
+    n: number;
+};
+/**
+ * What's left to mount progressively, in mount order. Built once per data /
+ * selection change (O(new features)); each mount tick then takes the next
+ * chunk from `pos` (O(chunk)).
+ */
+export type MountQueue = {
+    items: GeoJSONFeature[];
+    pos: number;
+    bounds: ViewBounds | null;
+};
+export declare const EMPTY_QUEUE: MountQueue;
+/** Mount order: features in the view first, each part keeping its given order. */
+export declare function viewportFirst(features: GeoJSONFeature[], bounds: ViewBounds | null): GeoJSONFeature[];
+/**
+ * Full pass: the features that need mounting (`fresh`, in render order) against the
+ * previous queue. Returns the first chunk to mount now and the queue of the rest.
+ * A big new batch (more features the previous queue didn't hold than one chunk,
+ * e.g. an import landing, even while an earlier batch is still mounting) mounts
+ * nothing in the render that brought it: that render is often the import's own
+ * long task. The first chunk then waits for the next tick.
+ */
+export declare function planMount(fresh: GeoJSONFeature[], prev: MountQueue, chunk: number, bounds: ViewBounds | null): {
+    now: GeoJSONFeature[];
+    queue: MountQueue;
+};
+/**
+ * Mount tick: the next `size` features of the queue, skipping any already mounted
+ * (e.g. selected meanwhile). A pan since the queue was built re-sorts what's left
+ * so the new view mounts first.
+ */
+export declare function nextChunk(q: MountQueue, size: number, bounds: ViewBounds | null, mounted: (id: string) => boolean): {
+    chunk: GeoJSONFeature[];
+    queue: MountQueue;
+};

package/dist/components/featureLayers/mountQueue.d.ts

@@ -0,0 +1,41 @@
+import { GeoJSONFeature } from '@element-editor/core';
+export type ViewBounds = {
+    w: number;
+    s: number;
+    e: number;
+    n: number;
+};
+/**
+ * What's left to mount progressively, in mount order. Built once per data /
+ * selection change (O(new features)); each mount tick then takes the next
+ * chunk from `pos` (O(chunk)).
+ */
+export type MountQueue = {
+    items: GeoJSONFeature[];
+    pos: number;
+    bounds: ViewBounds | null;
+};
+export declare const EMPTY_QUEUE: MountQueue;
+/** Mount order: features in the view first, each part keeping its given order. */
+export declare function viewportFirst(features: GeoJSONFeature[], bounds: ViewBounds | null): GeoJSONFeature[];
+/**
+ * Full pass: the features that need mounting (`fresh`, in render order) against the
+ * previous queue. Returns the first chunk to mount now and the queue of the rest.
+ * A big new batch (more features the previous queue didn't hold than one chunk,
+ * e.g. an import landing, even while an earlier batch is still mounting) mounts
+ * nothing in the render that brought it: that render is often the import's own
+ * long task. The first chunk then waits for the next tick.
+ */
+export declare function planMount(fresh: GeoJSONFeature[], prev: MountQueue, chunk: number, bounds: ViewBounds | null): {
+    now: GeoJSONFeature[];
+    queue: MountQueue;
+};
+/**
+ * Mount tick: the next `size` features of the queue, skipping any already mounted
+ * (e.g. selected meanwhile). A pan since the queue was built re-sorts what's left
+ * so the new view mounts first.
+ */
+export declare function nextChunk(q: MountQueue, size: number, bounds: ViewBounds | null, mounted: (id: string) => boolean): {
+    chunk: GeoJSONFeature[];
+    queue: MountQueue;
+};

package/dist/components/featureLayers/renderer.d.cts

@@ -0,0 +1,25 @@
+export type FeatureRenderer = 'canvas' | 'svg';
+/** Width of the invisible SVG hit path under a line: 8 px of slack each side of the cursor. */
+export declare const LINE_HIT_WEIGHT = 16;
+/** Casing under unselected lines: `width` px each side of the stroke, white at `opacity` (× the line's); none while the canvas holds more than `maxPaths` paths. */
+export declare const LINE_CASING: {
+    color: string;
+    width: number;
+    opacity: number;
+    maxPaths: number;
+};
+/** The renderer for unselected paths; undefined = the map's default (SVG). */
+export declare const IdleRendererContext: import('react').Context<import('leaflet').Renderer | undefined>;
+export declare function useIdleRenderer(map: L.Map, mode: FeatureRenderer): L.Renderer | undefined;
+/** DOM element to style for a path's cursor: its SVG element, or the shared canvas. */
+export declare function pathElement(layer: L.Path): Element | undefined;
+/**
+ * Puts a feature's layers on the idle canvas while unselected and on SVG (on top)
+ * while selected. Returns the renderer to mount with. On a flip it swaps the
+ * existing layers in place; `onSwap` lets the caller fix per-renderer options
+ * (set before the re-add) and re-target hover state afterwards.
+ */
+export declare function useFeatureRenderer(selected: boolean, getLayers: () => Iterable<L.Path | null | undefined>, onSwap?: {
+    before?: (l: L.Path, onCanvas: boolean) => void;
+    after?: () => void;
+}): L.Renderer | undefined;

package/dist/components/featureLayers/renderer.d.ts

@@ -0,0 +1,25 @@
+export type FeatureRenderer = 'canvas' | 'svg';
+/** Width of the invisible SVG hit path under a line: 8 px of slack each side of the cursor. */
+export declare const LINE_HIT_WEIGHT = 16;
+/** Casing under unselected lines: `width` px each side of the stroke, white at `opacity` (× the line's); none while the canvas holds more than `maxPaths` paths. */
+export declare const LINE_CASING: {
+    color: string;
+    width: number;
+    opacity: number;
+    maxPaths: number;
+};
+/** The renderer for unselected paths; undefined = the map's default (SVG). */
+export declare const IdleRendererContext: import('react').Context<import('leaflet').Renderer | undefined>;
+export declare function useIdleRenderer(map: L.Map, mode: FeatureRenderer): L.Renderer | undefined;
+/** DOM element to style for a path's cursor: its SVG element, or the shared canvas. */
+export declare function pathElement(layer: L.Path): Element | undefined;
+/**
+ * Puts a feature's layers on the idle canvas while unselected and on SVG (on top)
+ * while selected. Returns the renderer to mount with. On a flip it swaps the
+ * existing layers in place; `onSwap` lets the caller fix per-renderer options
+ * (set before the re-add) and re-target hover state afterwards.
+ */
+export declare function useFeatureRenderer(selected: boolean, getLayers: () => Iterable<L.Path | null | undefined>, onSwap?: {
+    before?: (l: L.Path, onCanvas: boolean) => void;
+    after?: () => void;
+}): L.Renderer | undefined;

package/dist/components/featureLayers/shared.d.cts

@@ -0,0 +1,44 @@
+import { GeoJSONFeature } from '@element-editor/core';
+import { LeafletMouseEvent, PathOptions } from 'leaflet';
+import { FeatureStyleFn } from '../../contexts/FeatureStyleContext.cjs';
+export declare const IDLE_LINE: PathOptions;
+export declare const IDLE_POLY: PathOptions;
+export declare const HOVER_POLY: PathOptions;
+/**
+ * The integrator's `getFeatureStyle` over `featureColor` (the unselected look), composed
+ * once per editor by FeatureInteractionLayer and provided through FeatureStyleContext.
+ * `fillColor` falls back to `color`, as on MapLibre. Keep the result referentially stable:
+ * every feature layer restyles when it changes.
+ */
+export declare function composeFeatureStyle(getFeatureStyle: FeatureStyleFn | undefined, featureColor: string | undefined): FeatureStyleFn | undefined;
+/** This feature's custom (unselected) style, from the composed FeatureStyleContext. */
+export declare function useCustomStyle(feature: GeoJSONFeature): PathOptions | undefined;
+/** Pin colour from the custom style: fill first, then outline (like MapLibre's circle). */
+export declare const pinColor: (custom: PathOptions | undefined) => string | undefined;
+/** Unselected look: defaults + custom style + optional hover boost. */
+export declare function idleStyle(base: PathOptions, custom: PathOptions | undefined, hover: PathOptions | null): PathOptions;
+/** Selected / dragging look. Leaflet's setStyle merges, so keys a custom style set
+ *  (dashArray, lineCap, …) are put back to Leaflet's defaults instead of leaking in. */
+export declare function litStyle(custom: PathOptions | undefined, polygon: boolean, lit: PathOptions): PathOptions;
+/** Accent palette for selected-feature Path styles (SVG attributes need concrete colours); provided once by FeatureInteractionLayer. */
+export declare const AccentContext: import('react').Context<import('@element-editor/core').AccentPalette>;
+export type OpenFeatureCtxMenu = (args: {
+    feature: GeoJSONFeature;
+    x: number;
+    y: number;
+    requestPreciseCoords?: () => void;
+}) => void;
+/** Build a Leaflet `contextmenu` handler that opens the shared feature context menu. */
+export declare function makeContextMenuHandler(feature: GeoJSONFeature, readonly: boolean, open: OpenFeatureCtxMenu | undefined): (e: LeafletMouseEvent) => void;
+/** `idle`: the pin's custom colour (featureColor / getFeatureStyle), undefined = default. */
+export declare function makePinIcon(selected: boolean, multiSelected?: boolean, idle?: string): import('leaflet').DivIcon;
+/**
+ * Hover tint: an uncoloured, unselected pin goes one step darker slate (a custom colour is kept,
+ * like MapLibre). Set on the marker's existing element, never by swapping the icon: a swapped-in
+ * element sits under the cursor without a mouseover, so it never gets the mouseout and the tint stuck.
+ */
+export declare function tintPin(layer: {
+    getElement?: () => Element | undefined;
+} | null | undefined, on: boolean): void;
+export declare function idlePin(color?: string): import('leaflet').DivIcon;
+export declare function makeDimmedPinIcon(color?: string): import('leaflet').DivIcon;

package/dist/components/featureLayers/shared.d.ts

@@ -0,0 +1,44 @@
+import { GeoJSONFeature } from '@element-editor/core';
+import { LeafletMouseEvent, PathOptions } from 'leaflet';
+import { FeatureStyleFn } from '../../contexts/FeatureStyleContext.js';
+export declare const IDLE_LINE: PathOptions;
+export declare const IDLE_POLY: PathOptions;
+export declare const HOVER_POLY: PathOptions;
+/**
+ * The integrator's `getFeatureStyle` over `featureColor` (the unselected look), composed
+ * once per editor by FeatureInteractionLayer and provided through FeatureStyleContext.
+ * `fillColor` falls back to `color`, as on MapLibre. Keep the result referentially stable:
+ * every feature layer restyles when it changes.
+ */
+export declare function composeFeatureStyle(getFeatureStyle: FeatureStyleFn | undefined, featureColor: string | undefined): FeatureStyleFn | undefined;
+/** This feature's custom (unselected) style, from the composed FeatureStyleContext. */
+export declare function useCustomStyle(feature: GeoJSONFeature): PathOptions | undefined;
+/** Pin colour from the custom style: fill first, then outline (like MapLibre's circle). */
+export declare const pinColor: (custom: PathOptions | undefined) => string | undefined;
+/** Unselected look: defaults + custom style + optional hover boost. */
+export declare function idleStyle(base: PathOptions, custom: PathOptions | undefined, hover: PathOptions | null): PathOptions;
+/** Selected / dragging look. Leaflet's setStyle merges, so keys a custom style set
+ *  (dashArray, lineCap, …) are put back to Leaflet's defaults instead of leaking in. */
+export declare function litStyle(custom: PathOptions | undefined, polygon: boolean, lit: PathOptions): PathOptions;
+/** Accent palette for selected-feature Path styles (SVG attributes need concrete colours); provided once by FeatureInteractionLayer. */
+export declare const AccentContext: import('react').Context<import('@element-editor/core').AccentPalette>;
+export type OpenFeatureCtxMenu = (args: {
+    feature: GeoJSONFeature;
+    x: number;
+    y: number;
+    requestPreciseCoords?: () => void;
+}) => void;
+/** Build a Leaflet `contextmenu` handler that opens the shared feature context menu. */
+export declare function makeContextMenuHandler(feature: GeoJSONFeature, readonly: boolean, open: OpenFeatureCtxMenu | undefined): (e: LeafletMouseEvent) => void;
+/** `idle`: the pin's custom colour (featureColor / getFeatureStyle), undefined = default. */
+export declare function makePinIcon(selected: boolean, multiSelected?: boolean, idle?: string): import('leaflet').DivIcon;
+/**
+ * Hover tint: an uncoloured, unselected pin goes one step darker slate (a custom colour is kept,
+ * like MapLibre). Set on the marker's existing element, never by swapping the icon: a swapped-in
+ * element sits under the cursor without a mouseover, so it never gets the mouseout and the tint stuck.
+ */
+export declare function tintPin(layer: {
+    getElement?: () => Element | undefined;
+} | null | undefined, on: boolean): void;
+export declare function idlePin(color?: string): import('leaflet').DivIcon;
+export declare function makeDimmedPinIcon(color?: string): import('leaflet').DivIcon;

package/dist/components/featureLayers/useProgressiveMount.d.cts

@@ -0,0 +1,30 @@
+import { default as React } from 'react';
+import { GeoJSONFeature } from '@element-editor/core';
+import { ViewBounds } from './mountQueue.cjs';
+export type { ViewBounds } from './mountQueue.cjs';
+/**
+ * Progressive mounting: a batch of new features bigger than one tick's
+ * budget (initial load, import, a zoom-out) mounts a chunk per tick, the
+ * ones in the viewport first, instead of creating every Leaflet layer in one
+ * long task. `mountedIdsRef` is what the last commit rendered; features
+ * already in it, and the `alwaysMount` ones (selected / vertex-edit), always render.
+ *
+ * A data / selection change runs a full pass (O(culled)): it rebuilds the
+ * element list and the queue of features still to mount (see `planMount`:
+ * viewport first, reverse list order so the first in the list draws on top).
+ * A mount tick with nothing else changed is O(chunk): it takes the next chunk
+ * off the queue and appends it as one new group to the last commit's list.
+ * The chunk size adapts: an EMA of ms per mounted feature, measured on ticks
+ * only (render → layout effect, plus the layers' passive effects), sizes the
+ * next chunk to MOUNT_BUDGET_MS.
+ * Committed features also carry the group they mounted in: each group is a
+ * memoised <FeatureGroup>, so a commit re-reconciles only the groups whose
+ * elements changed, not every mounted feature. Render order doesn't affect
+ * z-order: Leaflet stacks layers in addLayer order.
+ *
+ * `build(list, mounts, partial)` returns one element per feature of `list`, or
+ * null to skip it (it must skip those `mounts` rejects). `partial` = a tick:
+ * `list` is just the new chunk. It runs inside a useMemo over `features`, `deps`
+ * and the mount tick only, so `viewBounds` (a pan) alone never rebuilds the list.
+ */
+export declare function useProgressiveMount(features: GeoJSONFeature[], alwaysMount: (f: GeoJSONFeature) => boolean, viewBounds: ViewBounds | null, build: (list: GeoJSONFeature[], mounts: (f: GeoJSONFeature) => boolean, partial: boolean) => (React.ReactElement | null)[], deps: unknown[]): React.ReactElement;

package/dist/components/featureLayers/useProgressiveMount.d.ts

@@ -0,0 +1,30 @@
+import { default as React } from 'react';
+import { GeoJSONFeature } from '@element-editor/core';
+import { ViewBounds } from './mountQueue.js';
+export type { ViewBounds } from './mountQueue.js';
+/**
+ * Progressive mounting: a batch of new features bigger than one tick's
+ * budget (initial load, import, a zoom-out) mounts a chunk per tick, the
+ * ones in the viewport first, instead of creating every Leaflet layer in one
+ * long task. `mountedIdsRef` is what the last commit rendered; features
+ * already in it, and the `alwaysMount` ones (selected / vertex-edit), always render.
+ *
+ * A data / selection change runs a full pass (O(culled)): it rebuilds the
+ * element list and the queue of features still to mount (see `planMount`:
+ * viewport first, reverse list order so the first in the list draws on top).
+ * A mount tick with nothing else changed is O(chunk): it takes the next chunk
+ * off the queue and appends it as one new group to the last commit's list.
+ * The chunk size adapts: an EMA of ms per mounted feature, measured on ticks
+ * only (render → layout effect, plus the layers' passive effects), sizes the
+ * next chunk to MOUNT_BUDGET_MS.
+ * Committed features also carry the group they mounted in: each group is a
+ * memoised <FeatureGroup>, so a commit re-reconciles only the groups whose
+ * elements changed, not every mounted feature. Render order doesn't affect
+ * z-order: Leaflet stacks layers in addLayer order.
+ *
+ * `build(list, mounts, partial)` returns one element per feature of `list`, or
+ * null to skip it (it must skip those `mounts` rejects). `partial` = a tick:
+ * `list` is just the new chunk. It runs inside a useMemo over `features`, `deps`
+ * and the mount tick only, so `viewBounds` (a pan) alone never rebuilds the list.
+ */
+export declare function useProgressiveMount(features: GeoJSONFeature[], alwaysMount: (f: GeoJSONFeature) => boolean, viewBounds: ViewBounds | null, build: (list: GeoJSONFeature[], mounts: (f: GeoJSONFeature) => boolean, partial: boolean) => (React.ReactElement | null)[], deps: unknown[]): React.ReactElement;

package/dist/components/previews/CirclePreview.d.cts

@@ -0,0 +1 @@
+export declare function CirclePreview(): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/previews/CirclePreview.d.ts

@@ -0,0 +1 @@
+export declare function CirclePreview(): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/previews/LinePreview.d.cts

@@ -0,0 +1 @@
+export declare function LinePreview(): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/previews/LinePreview.d.ts

@@ -0,0 +1 @@
+export declare function LinePreview(): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/previews/PolygonPreview.d.cts

@@ -0,0 +1 @@
+export declare function PolygonPreview(): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/previews/PolygonPreview.d.ts

@@ -0,0 +1 @@
+export declare function PolygonPreview(): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/previews/RectPreview.d.cts

@@ -0,0 +1 @@
+export declare function RectPreview(): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/previews/RectPreview.d.ts

@@ -0,0 +1 @@
+export declare function RectPreview(): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/tools/BoxSelectHandler.d.cts

@@ -0,0 +1,16 @@
+type BoxSelectHandlerProps = {
+    onSelect: (featureId: string, indices: number[]) => void;
+    onDragStart: () => void;
+    readonly: boolean;
+    /** Vertex-mode only: read the currently-selected vertex indices when the
+     *  shift+drag begins so live preview can show (initial ∪ in-box) without
+     *  losing previously additive picks. */
+    getInitialVertexIndices?: () => number[];
+    /** Vertex-mode only: per-tick preview of the rubber-band selection so the
+     *  parent can highlight vertices in real time as the user drags. Sends the
+     *  full target set (`initial ∪ in-box`); replace, don't merge. */
+    onVertexBoxPreview?: (featureId: string, indices: number[]) => void;
+};
+/** Handles Shift+drag rubber-band selection of points and line vertices. */
+export declare function BoxSelectHandler({ onSelect, onDragStart, readonly, getInitialVertexIndices, onVertexBoxPreview }: BoxSelectHandlerProps): null;
+export {};

package/dist/components/tools/BoxSelectHandler.d.ts

@@ -0,0 +1,16 @@
+type BoxSelectHandlerProps = {
+    onSelect: (featureId: string, indices: number[]) => void;
+    onDragStart: () => void;
+    readonly: boolean;
+    /** Vertex-mode only: read the currently-selected vertex indices when the
+     *  shift+drag begins so live preview can show (initial ∪ in-box) without
+     *  losing previously additive picks. */
+    getInitialVertexIndices?: () => number[];
+    /** Vertex-mode only: per-tick preview of the rubber-band selection so the
+     *  parent can highlight vertices in real time as the user drags. Sends the
+     *  full target set (`initial ∪ in-box`); replace, don't merge. */
+    onVertexBoxPreview?: (featureId: string, indices: number[]) => void;
+};
+/** Handles Shift+drag rubber-band selection of points and line vertices. */
+export declare function BoxSelectHandler({ onSelect, onDragStart, readonly, getInitialVertexIndices, onVertexBoxPreview }: BoxSelectHandlerProps): null;
+export {};

package/dist/components/tools/MapClickHandler.d.cts

@@ -0,0 +1,6 @@
+import { LeafletMouseEvent } from 'leaflet';
+type MapClickHandlerProps = {
+    onMapClick: (e: LeafletMouseEvent) => void;
+};
+export declare function MapClickHandler({ onMapClick }: MapClickHandlerProps): null;
+export {};

package/dist/components/tools/MapClickHandler.d.ts

@@ -0,0 +1,6 @@
+import { LeafletMouseEvent } from 'leaflet';
+type MapClickHandlerProps = {
+    onMapClick: (e: LeafletMouseEvent) => void;
+};
+export declare function MapClickHandler({ onMapClick }: MapClickHandlerProps): null;
+export {};

package/dist/components/tools/MultiDragHandler.d.cts

@@ -0,0 +1,9 @@
+type MultiDragHandlerProps = {
+    onDragDelta: (delta: [number, number]) => void;
+    onDragEnd: (delta: [number, number], isDuplicate: boolean) => void;
+    onDuplicateDragChange: (isDuplicate: boolean) => void;
+    readonly: boolean;
+};
+/** Handles Cmd/Ctrl+drag (move) or Alt+drag (duplicate) on multi-selected features. */
+export declare function MultiDragHandler({ onDragDelta, onDragEnd, onDuplicateDragChange, readonly }: MultiDragHandlerProps): null;
+export {};

package/dist/components/tools/MultiDragHandler.d.ts

@@ -0,0 +1,9 @@
+type MultiDragHandlerProps = {
+    onDragDelta: (delta: [number, number]) => void;
+    onDragEnd: (delta: [number, number], isDuplicate: boolean) => void;
+    onDuplicateDragChange: (isDuplicate: boolean) => void;
+    readonly: boolean;
+};
+/** Handles Cmd/Ctrl+drag (move) or Alt+drag (duplicate) on multi-selected features. */
+export declare function MultiDragHandler({ onDragDelta, onDragEnd, onDuplicateDragChange, readonly }: MultiDragHandlerProps): null;
+export {};

package/dist/components/tools/OsmTraceHandler.d.cts

@@ -0,0 +1 @@
+export declare function OsmTraceHandler(): import("react/jsx-runtime").JSX.Element;

package/dist/components/tools/OsmTraceHandler.d.ts

@@ -0,0 +1 @@
+export declare function OsmTraceHandler(): import("react/jsx-runtime").JSX.Element;

package/dist/components/tools/VertexEditor.d.cts

@@ -0,0 +1,13 @@
+import { GeoJSONFeature } from '@element-editor/core';
+type VertexEditorProps = {
+    feature: GeoJSONFeature;
+    selectedIndices: number[];
+    onExit: () => void;
+    onDeleteSelected: () => void;
+    /** Replace the point selection (FeatureInteractionLayer owns it). */
+    onSelectIndices: (indices: number[]) => void;
+    onFeatureClick: () => void;
+    readonly: boolean;
+};
+export declare function VertexEditor({ feature, selectedIndices, onExit, onDeleteSelected, onSelectIndices, onFeatureClick, readonly, }: VertexEditorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/tools/VertexEditor.d.ts

@@ -0,0 +1,13 @@
+import { GeoJSONFeature } from '@element-editor/core';
+type VertexEditorProps = {
+    feature: GeoJSONFeature;
+    selectedIndices: number[];
+    onExit: () => void;
+    onDeleteSelected: () => void;
+    /** Replace the point selection (FeatureInteractionLayer owns it). */
+    onSelectIndices: (indices: number[]) => void;
+    onFeatureClick: () => void;
+    readonly: boolean;
+};
+export declare function VertexEditor({ feature, selectedIndices, onExit, onDeleteSelected, onSelectIndices, onFeatureClick, readonly, }: VertexEditorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/contexts/FeatureStyleContext.d.cts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+import { PathOptions } from 'leaflet';
+import { FeatureStyle, GeoJSONFeature } from '@element-editor/core';
+export type { FeatureStyle };
+/**
+ * Per-feature style: the engine-neutral `FeatureStyle` plus any other Leaflet
+ * `PathOptions` (dashArray, lineCap, …). `fillColor` falls back to `color`;
+ * `undefined`/`null` = default look.
+ */
+export type FeatureStyleFn = (feature: GeoJSONFeature) => (FeatureStyle & PathOptions) | undefined | null;
+export declare function FeatureStyleProvider({ getFeatureStyle, children, }: {
+    getFeatureStyle?: FeatureStyleFn;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useFeatureStyle(): FeatureStyleFn | undefined;

package/dist/contexts/FeatureStyleContext.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+import { PathOptions } from 'leaflet';
+import { FeatureStyle, GeoJSONFeature } from '@element-editor/core';
+export type { FeatureStyle };
+/**
+ * Per-feature style: the engine-neutral `FeatureStyle` plus any other Leaflet
+ * `PathOptions` (dashArray, lineCap, …). `fillColor` falls back to `color`;
+ * `undefined`/`null` = default look.
+ */
+export type FeatureStyleFn = (feature: GeoJSONFeature) => (FeatureStyle & PathOptions) | undefined | null;
+export declare function FeatureStyleProvider({ getFeatureStyle, children, }: {
+    getFeatureStyle?: FeatureStyleFn;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useFeatureStyle(): FeatureStyleFn | undefined;

package/dist/contexts/MapControllerContext.d.cts

@@ -0,0 +1,2 @@
+export { MapControllerProvider, useMapController, useSetMapController } from '@element-editor/ui';
+export type { MapController } from '@element-editor/ui';

package/dist/contexts/MapControllerContext.d.ts

@@ -0,0 +1,2 @@
+export { MapControllerProvider, useMapController, useSetMapController } from '@element-editor/ui';
+export type { MapController } from '@element-editor/ui';

package/dist/hooks/lastPointer.d.cts

@@ -0,0 +1,13 @@
+import { default as L } from 'leaflet';
+export type PointerState = {
+    x: number;
+    y: number;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    altKey: boolean;
+};
+export declare function getLastPointer(): PointerState;
+export declare function isPointerOver(el: Element | null | undefined): boolean;
+/** Layout-free pre-check for isPointerOver: is the pointer within `px` of this map point?
+ *  Lets a bulk mount skip getBoundingClientRect on all but the marker under the cursor. */
+export declare function isPointerNear(map: L.Map, latlng: L.LatLngExpression, px?: number): boolean;

package/dist/hooks/lastPointer.d.ts

@@ -0,0 +1,13 @@
+import { default as L } from 'leaflet';
+export type PointerState = {
+    x: number;
+    y: number;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    altKey: boolean;
+};
+export declare function getLastPointer(): PointerState;
+export declare function isPointerOver(el: Element | null | undefined): boolean;
+/** Layout-free pre-check for isPointerOver: is the pointer within `px` of this map point?
+ *  Lets a bulk mount skip getBoundingClientRect on all but the marker under the cursor. */
+export declare function isPointerNear(map: L.Map, latlng: L.LatLngExpression, px?: number): boolean;

package/dist/hooks/useCursorWhileMode.d.cts

@@ -0,0 +1,23 @@
+/**
+ * Tracks the latest map cursor lat/lng while a caller-specified mode is active
+ * and resets on every `editingMode` transition so exiting-and-re-entering the
+ * same tool (e.g. press R → off → R from a new cursor position) doesn't leak
+ * the previous session's coordinates on the first frame.
+ *
+ * React's "set state during render" reset pattern is used intentionally — it
+ * produces a synchronous re-render with cleared state before the browser
+ * paints, so there's no stale-coord flash.
+ *
+ * Usage:
+ *
+ *   const mouse = useCursorWhileMode(editingMode, editingMode === 'draw-rect')
+ *
+ * Pass a predicate that's true whenever cursor updates should flow into state.
+ * On mouseout (cursor leaves the map container) the value resets to null, so
+ * tooltips / previews that depend on it disappear.
+ *
+ * Any component that captures cursor position during a drawing mode should use
+ * this hook rather than re-implementing the pattern — see
+ * `feedback_mode_gated_cursor_state.md` for the history of that bug class.
+ */
+export declare function useCursorWhileMode(editingMode: string, isActive: boolean): [number, number] | null;

package/dist/hooks/useCursorWhileMode.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Tracks the latest map cursor lat/lng while a caller-specified mode is active
+ * and resets on every `editingMode` transition so exiting-and-re-entering the
+ * same tool (e.g. press R → off → R from a new cursor position) doesn't leak
+ * the previous session's coordinates on the first frame.
+ *
+ * React's "set state during render" reset pattern is used intentionally — it
+ * produces a synchronous re-render with cleared state before the browser
+ * paints, so there's no stale-coord flash.
+ *
+ * Usage:
+ *
+ *   const mouse = useCursorWhileMode(editingMode, editingMode === 'draw-rect')
+ *
+ * Pass a predicate that's true whenever cursor updates should flow into state.
+ * On mouseout (cursor leaves the map container) the value resets to null, so
+ * tooltips / previews that depend on it disappear.
+ *
+ * Any component that captures cursor position during a drawing mode should use
+ * this hook rather than re-implementing the pattern — see
+ * `feedback_mode_gated_cursor_state.md` for the history of that bug class.
+ */
+export declare function useCursorWhileMode(editingMode: string, isActive: boolean): [number, number] | null;

package/dist/hooks/useDuplicateDrag.d.cts

@@ -0,0 +1,9 @@
+/**
+ * Manages the isDuplicateDrag ref for Alt+drag duplicate across geometry layer components.
+ * When local drag is active (dragDelta set), uses the local ref; otherwise uses multi-drag state.
+ */
+export declare function useDuplicateDrag(dragDelta: [number, number] | null, multiDuplicateDrag: boolean): {
+    isDupDrag: boolean;
+    setDuplicateDrag: (v: boolean) => void;
+    resetDuplicateDrag: () => void;
+};