@orbat-mapper/tactical-draw-adapter-maplibre 0.2.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Orbat Mapper
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,42 @@
+# @orbat-mapper/tactical-draw-adapter-maplibre
+
+The [MapLibre GL JS](https://maplibre.org/maplibre-gl-js/docs/) engine adapter for
+the `@orbat-mapper/tactical-draw` toolkit. It implements the `MapAdapter` contract
+from `@orbat-mapper/tactical-draw` on top of MapLibre, so the engine-agnostic
+draw/edit controllers — sessions, draw rules, gestures, handle rendering — run
+unchanged against a MapLibre map.
+
+`maplibre-gl` is declared as a **peer dependency**, so you bring your own single
+copy and never install an engine you don't use.
+
+## Installation
+
+```bash
+# npm
+npm install @orbat-mapper/tactical-draw-adapter-maplibre @orbat-mapper/tactical-draw maplibre-gl
+
+# pnpm
+pnpm add @orbat-mapper/tactical-draw-adapter-maplibre @orbat-mapper/tactical-draw maplibre-gl
+```
+
+## Usage
+
+```ts
+import maplibregl from "maplibre-gl";
+import { TacticalDraw } from "@orbat-mapper/tactical-draw";
+import { MapLibreAdapter } from "@orbat-mapper/tactical-draw-adapter-maplibre";
+
+const map = new maplibregl.Map({
+  /* … */
+});
+
+const adapter = new MapLibreAdapter(map);
+const draw = new TacticalDraw(adapter);
+```
+
+Hand the adapter to `TacticalDraw` and drive draw/edit exactly as with any other
+engine adapter in the family.
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,46 @@
+import { BaseMapAdapter, EditPointerDriver, FeatureOps, LayerId, MapCursor, NativeEventEntry, PickHandler, PickOptions, PixelCoordinate, StyleOptions } from "@orbat-mapper/tactical-draw";
+import maplibregl from "maplibre-gl";
+import { Position } from "geojson";
+
+//#region src/ml-adapter.d.ts
+interface MapLibreLayerHandle {
+  sourceId: string;
+  /** MapLibre layer ids created for this logical layer (fill, line, circle, symbol) */
+  mlLayerIds: string[];
+  style?: StyleOptions;
+}
+type MapLibreEventToken = (e: any) => void;
+interface MapLibreViewToken {
+  fn: () => void;
+}
+declare class MapLibreAdapter extends BaseMapAdapter<MapLibreLayerHandle, MapLibreEventToken, MapLibreViewToken> {
+  private map;
+  constructor(map: maplibregl.Map);
+  protected createLayer(layerId: LayerId, style?: StyleOptions): MapLibreLayerHandle;
+  protected destroyLayer(handle: MapLibreLayerHandle): void;
+  protected applyFeatureOps(layerId: LayerId, ops: FeatureOps): void;
+  protected attachNativeEvent(type: "click" | "pointermove" | "dblclick", onEvent: (lonLat: Position, pixel: PixelCoordinate, originalEvent: unknown) => void): NativeEventEntry<MapLibreEventToken>;
+  protected detachNativeEvent(entry: NativeEventEntry<MapLibreEventToken>): void;
+  protected attachViewChange(handler: () => void): MapLibreViewToken;
+  protected detachViewChange(token: MapLibreViewToken): void;
+  createEditPointerDriver(): EditPointerDriver;
+  setLayerStyle(layerId: LayerId, style: StyleOptions): void;
+  toLonLat(coordinate: number[]): Position;
+  fromLonLat(position: Position): number[];
+  getPixelFromCoordinate(position: Position): PixelCoordinate | null;
+  getViewportSize(): {
+    width: number;
+    height: number;
+  };
+  panByPixels(delta: PixelCoordinate, options?: {
+    durationMs?: number;
+  }): void;
+  setCursor(cursor: MapCursor): void;
+  setDoubleClickZoomEnabled(enabled: boolean): void;
+  getResolution(): number | undefined;
+  getZoom(): number | undefined;
+  onPick(layerId: LayerId, handler: PickHandler, opts?: PickOptions): () => void;
+  setGlobeMode(enabled: boolean): void;
+}
+//#endregion
+export { MapLibreAdapter };

package/dist/index.mjs

@@ -0,0 +1,548 @@
+import { project, unproject } from "@orbat-mapper/control-measures";
+import { BaseMapAdapter, PointerCallbackHub, TOUCH_HIT_TOLERANCE_PX, bindAbortable, pickHitTolerance, tryControlMeasureIdFromFeature } from "@orbat-mapper/tactical-draw";
+//#region src/ml-adapter.ts
+function emptyFC() {
+	return {
+		type: "FeatureCollection",
+		features: []
+	};
+}
+/**
+* Build the paint expression for a circle layer with per-feature
+* `properties.style` overlay (ADR-0006). Each property prefers a value
+* pulled from `properties.style.<field>`, falling back to the layer default.
+*/
+function buildCirclePaint(style) {
+	const radiusDefault = style?.pointRadius ?? 5;
+	const colorDefault = style?.pointFillColor ?? style?.fillColor ?? "white";
+	const strokeColorDefault = style?.strokeColor ?? "black";
+	const strokeWidthDefault = style?.strokeWidth ?? 1;
+	const styleObj = [
+		"coalesce",
+		["get", "style"],
+		["literal", {}]
+	];
+	const pick = (field, fallback) => [
+		"coalesce",
+		[
+			"get",
+			field,
+			styleObj
+		],
+		fallback
+	];
+	return {
+		"circle-radius": pick("pointRadius", radiusDefault),
+		"circle-color": pick("fillColor", colorDefault),
+		"circle-stroke-color": pick("strokeColor", strokeColorDefault),
+		"circle-stroke-width": pick("strokeWidth", strokeWidthDefault)
+	};
+}
+/**
+* Filter for the circle (Point) layer. Point features carrying label text are
+* drawn by the symbol/text layer only, so exclude them here — otherwise the
+* label would be ringed by a marker dot. Matches the OpenLayers adapter, which
+* draws a dot for a Point only when a point radius is set.
+*/
+function buildCirclePointFilter(style) {
+	return style?.text?.labelProperty ? [
+		"all",
+		[
+			"==",
+			"$type",
+			"Point"
+		],
+		["!has", style.text.labelProperty]
+	] : [
+		"==",
+		"$type",
+		"Point"
+	];
+}
+function buildTextSizeExpression() {
+	const size = [
+		"coalesce",
+		["get", "textSizePixels"],
+		14
+	];
+	const referenceZoom = [
+		"coalesce",
+		["get", "textSizeZoom"],
+		0
+	];
+	const sizeAtZoom = (zoom) => [
+		"min",
+		254,
+		[
+			"case",
+			["has", "textSizeZoom"],
+			[
+				"*",
+				size,
+				[
+					"^",
+					2,
+					[
+						"-",
+						zoom,
+						referenceZoom
+					]
+				]
+			],
+			size
+		]
+	];
+	return [
+		"interpolate",
+		["linear"],
+		["zoom"],
+		...Array.from({ length: 25 }, (_, zoom) => [zoom, sizeAtZoom(zoom)]).flat()
+	];
+}
+/**
+* Build the paint expression for a fill layer with per-feature
+* `properties.style.fillColor` overlay. Mirrors `buildCirclePaint`.
+*/
+/**
+* Build the layout and paint objects for a symbol (text) layer.
+* Centralises the rotation convention so `createLayer` and `setLayerStyle`
+* stay in sync. Rotation follows the OpenLayers convention: `π − r` radians
+* (converted to degrees for MapLibre).
+*/
+function buildSymbolLayer(symbolId, sourceId, text) {
+	const textRotate = text.labelProperty ? [
+		"-",
+		180,
+		[
+			"*",
+			[
+				"coalesce",
+				["get", "rotation"],
+				0
+			],
+			180 / Math.PI
+		]
+	] : text.rotation ? (Math.PI - text.rotation) * 180 / Math.PI : 0;
+	const textColor = text.fillColor ? text.fillColor : [
+		"coalesce",
+		[
+			"get",
+			"strokeColor",
+			[
+				"coalesce",
+				["get", "style"],
+				["literal", {}]
+			]
+		],
+		"#000"
+	];
+	return {
+		id: symbolId,
+		type: "symbol",
+		source: sourceId,
+		layout: {
+			"text-field": text.labelProperty ? ["get", text.labelProperty] : text.text ?? "",
+			"text-font": ["Open Sans Regular"],
+			"text-size": buildTextSizeExpression(),
+			"text-rotate": textRotate,
+			"text-rotation-alignment": "map",
+			"text-pitch-alignment": "map",
+			"text-allow-overlap": true
+		},
+		paint: {
+			"text-color": textColor,
+			...text.strokeColor ? {
+				"text-halo-color": text.strokeColor,
+				"text-halo-width": text.strokeWidth ?? 1
+			} : {}
+		}
+	};
+}
+function buildFillPaint(style) {
+	return {
+		"fill-color": [
+			"coalesce",
+			[
+				"get",
+				"fillColor",
+				[
+					"coalesce",
+					["get", "style"],
+					["literal", {}]
+				]
+			],
+			style?.fillColor ?? "rgba(0,0,0,0)"
+		],
+		"fill-opacity": 1
+	};
+}
+function buildLinePaint(style) {
+	const colorDefault = style?.strokeColor ?? "#000";
+	const widthDefault = style?.strokeWidth ?? 2;
+	const styleObj = [
+		"coalesce",
+		["get", "style"],
+		["literal", {}]
+	];
+	return {
+		"line-color": [
+			"coalesce",
+			[
+				"get",
+				"strokeColor",
+				styleObj
+			],
+			colorDefault
+		],
+		"line-width": [
+			"coalesce",
+			[
+				"get",
+				"strokeWidth",
+				styleObj
+			],
+			widthDefault
+		],
+		...style?.strokeDash ? { "line-dasharray": style.strokeDash } : {}
+	};
+}
+var MapLibreAdapter = class extends BaseMapAdapter {
+	map;
+	constructor(map) {
+		super();
+		this.map = map;
+	}
+	createLayer(layerId, style) {
+		const sourceId = `${layerId}-src`;
+		this.map.addSource(sourceId, {
+			type: "geojson",
+			data: emptyFC(),
+			promoteId: "_fid"
+		});
+		const mlLayerIds = [];
+		const fillId = `${layerId}-fill`;
+		this.map.addLayer({
+			id: fillId,
+			type: "fill",
+			source: sourceId,
+			filter: [
+				"==",
+				"$type",
+				"Polygon"
+			],
+			paint: buildFillPaint(style)
+		});
+		mlLayerIds.push(fillId);
+		const lineId = `${layerId}-line`;
+		this.map.addLayer({
+			id: lineId,
+			type: "line",
+			source: sourceId,
+			filter: [
+				"any",
+				[
+					"==",
+					"$type",
+					"LineString"
+				],
+				[
+					"==",
+					"$type",
+					"Polygon"
+				]
+			],
+			paint: buildLinePaint(style),
+			layout: {
+				"line-cap": "round",
+				"line-join": "round"
+			}
+		});
+		mlLayerIds.push(lineId);
+		const circleId = `${layerId}-circle`;
+		this.map.addLayer({
+			id: circleId,
+			type: "circle",
+			source: sourceId,
+			filter: buildCirclePointFilter(style),
+			paint: buildCirclePaint(style)
+		});
+		mlLayerIds.push(circleId);
+		if (style?.text) {
+			const symbolId = `${layerId}-symbol`;
+			this.map.addLayer(buildSymbolLayer(symbolId, sourceId, style.text));
+			mlLayerIds.push(symbolId);
+		}
+		return {
+			sourceId,
+			mlLayerIds,
+			style
+		};
+	}
+	destroyLayer(handle) {
+		for (const mlId of handle.mlLayerIds) if (this.map.getLayer(mlId)) this.map.removeLayer(mlId);
+		if (this.map.getSource(handle.sourceId)) this.map.removeSource(handle.sourceId);
+	}
+	applyFeatureOps(layerId, ops) {
+		const handle = this.layers.get(layerId);
+		if (!handle) return;
+		const source = this.map.getSource(handle.sourceId);
+		if (!source) return;
+		const features = ops.full.map((f) => f.id !== void 0 ? {
+			...f,
+			properties: {
+				...f.properties ?? {},
+				_fid: f.id
+			}
+		} : f);
+		source.setData({
+			type: "FeatureCollection",
+			features
+		});
+	}
+	attachNativeEvent(type, onEvent) {
+		const mlEvent = type === "pointermove" ? "mousemove" : type === "dblclick" ? "dblclick" : "click";
+		const fn = (e) => {
+			onEvent([e.lngLat.lng, e.lngLat.lat], [e.point.x, e.point.y], e);
+		};
+		this.map.on(mlEvent, fn);
+		return {
+			type: mlEvent,
+			token: fn
+		};
+	}
+	detachNativeEvent(entry) {
+		this.map.off(entry.type, entry.token);
+	}
+	attachViewChange(handler) {
+		const fn = () => handler();
+		this.map.on("moveend", fn);
+		this.map.on("zoomend", fn);
+		return { fn };
+	}
+	detachViewChange(token) {
+		this.map.off("moveend", token.fn);
+		this.map.off("zoomend", token.fn);
+	}
+	createEditPointerDriver() {
+		const map = this.map;
+		const hub = new PointerCallbackHub();
+		let dragPanWasEnabled = false;
+		let disposed = false;
+		let touchDragActive = false;
+		let multiTouchCancelled = false;
+		const TOUCH_INFO = { hitTolerance: TOUCH_HIT_TOLERANCE_PX };
+		const preventMapEventDefaults = (e) => {
+			e.preventDefault();
+			e.originalEvent.preventDefault?.();
+			e.originalEvent.stopPropagation?.();
+		};
+		const onDown = (e) => {
+			const px = [e.point.x, e.point.y];
+			const info = { altKey: e.originalEvent.altKey };
+			hub.fireDown(px, info);
+		};
+		const onMove = (e) => {
+			const px = [e.point.x, e.point.y];
+			hub.fireMove(px);
+		};
+		const onUp = (e) => {
+			const px = [e.point.x, e.point.y];
+			hub.fireUp(px);
+		};
+		const onTouchStart = (e) => {
+			if (e.points.length !== 1) return;
+			const before = dragPanWasEnabled;
+			const px = [e.point.x, e.point.y];
+			hub.fireDown(px, TOUCH_INFO);
+			touchDragActive = dragPanWasEnabled !== before;
+			if (touchDragActive) preventMapEventDefaults(e);
+		};
+		const onTouchMove = (e) => {
+			const touchCount = e.points.length;
+			const px = [e.point.x, e.point.y];
+			if (touchCount > 1 && touchDragActive && !multiTouchCancelled) {
+				multiTouchCancelled = true;
+				hub.fireUp(px, TOUCH_INFO);
+				touchDragActive = false;
+				preventMapEventDefaults(e);
+				return;
+			}
+			if (touchCount > 1) return;
+			if (touchCount === 1) multiTouchCancelled = false;
+			hub.fireMove(px, TOUCH_INFO);
+			if (touchDragActive) preventMapEventDefaults(e);
+		};
+		const onTouchEnd = (e) => {
+			multiTouchCancelled = false;
+			const px = [e.point.x, e.point.y];
+			hub.fireUp(px, TOUCH_INFO);
+			touchDragActive = false;
+		};
+		map.on("mousedown", onDown);
+		map.on("mousemove", onMove);
+		map.on("mouseup", onUp);
+		map.on("touchstart", onTouchStart);
+		map.on("touchmove", onTouchMove);
+		map.on("touchend", onTouchEnd);
+		map.on("touchcancel", onTouchEnd);
+		return {
+			onPointerDown: (cb) => hub.onPointerDown(cb),
+			onPointerMove: (cb) => hub.onPointerMove(cb),
+			onPointerUp: (cb) => hub.onPointerUp(cb),
+			setDragPanEnabled(enabled) {
+				if (enabled) {
+					if (dragPanWasEnabled) map.dragPan.enable();
+					dragPanWasEnabled = false;
+				} else {
+					dragPanWasEnabled = map.dragPan.isEnabled();
+					if (dragPanWasEnabled) map.dragPan.disable();
+				}
+			},
+			toPixel(lonLat) {
+				const p = map.project(lonLat);
+				return [p.x, p.y];
+			},
+			fromPixel(pixel) {
+				const ll = map.unproject(pixel);
+				return [ll.lng, ll.lat];
+			},
+			dispose() {
+				if (disposed) return;
+				disposed = true;
+				hub.clear();
+				map.off("mousedown", onDown);
+				map.off("mousemove", onMove);
+				map.off("mouseup", onUp);
+				map.off("touchstart", onTouchStart);
+				map.off("touchmove", onTouchMove);
+				map.off("touchend", onTouchEnd);
+				map.off("touchcancel", onTouchEnd);
+				if (dragPanWasEnabled) {
+					map.dragPan.enable();
+					dragPanWasEnabled = false;
+				}
+			}
+		};
+	}
+	setLayerStyle(layerId, style) {
+		const handle = this.layers.get(layerId);
+		if (!handle) return;
+		handle.style = style;
+		for (const mlId of handle.mlLayerIds) {
+			const layer = this.map.getLayer(mlId);
+			if (!layer) continue;
+			const type = layer.type;
+			if (type === "fill") this.map.setPaintProperty(mlId, "fill-color", buildFillPaint(style)["fill-color"]);
+			else if (type === "line") {
+				if (style.strokeColor !== void 0 || style.strokeWidth !== void 0) {
+					const paint = buildLinePaint(style);
+					if (style.strokeColor !== void 0) this.map.setPaintProperty(mlId, "line-color", paint["line-color"]);
+					if (style.strokeWidth !== void 0) this.map.setPaintProperty(mlId, "line-width", paint["line-width"]);
+				}
+				if (style.strokeDash) this.map.setPaintProperty(mlId, "line-dasharray", style.strokeDash);
+			} else if (type === "circle") {
+				const paint = buildCirclePaint(style);
+				this.map.setPaintProperty(mlId, "circle-radius", paint["circle-radius"]);
+				this.map.setPaintProperty(mlId, "circle-color", paint["circle-color"]);
+				this.map.setPaintProperty(mlId, "circle-stroke-color", paint["circle-stroke-color"]);
+				this.map.setPaintProperty(mlId, "circle-stroke-width", paint["circle-stroke-width"]);
+				this.map.setFilter(mlId, buildCirclePointFilter(style));
+			} else if (type === "symbol" && style.text) {
+				if (style.text.text) this.map.setLayoutProperty(mlId, "text-field", style.text.text);
+				else if (style.text.labelProperty) this.map.setLayoutProperty(mlId, "text-field", ["get", style.text.labelProperty]);
+				if (style.text.fillColor) this.map.setPaintProperty(mlId, "text-color", style.text.fillColor);
+				if (style.text.strokeColor) this.map.setPaintProperty(mlId, "text-halo-color", style.text.strokeColor);
+				if (style.text.strokeWidth !== void 0) this.map.setPaintProperty(mlId, "text-halo-width", style.text.strokeWidth);
+			}
+		}
+		if (style.text && !handle.mlLayerIds.some((id) => id.endsWith("-symbol"))) {
+			const symbolId = `${layerId}-symbol`;
+			this.map.addLayer(buildSymbolLayer(symbolId, handle.sourceId, style.text));
+			handle.mlLayerIds.push(symbolId);
+		}
+	}
+	toLonLat(coordinate) {
+		return unproject(coordinate[0], coordinate[1]);
+	}
+	fromLonLat(position) {
+		return project(position[0], position[1]);
+	}
+	getPixelFromCoordinate(position) {
+		const point = this.map.project(position);
+		return [point.x, point.y];
+	}
+	getViewportSize() {
+		const container = this.map.getContainer();
+		return {
+			width: container.clientWidth,
+			height: container.clientHeight
+		};
+	}
+	panByPixels(delta, options) {
+		const [dx, dy] = delta;
+		if (Math.abs(dx) < .5 && Math.abs(dy) < .5) return;
+		const center = this.map.getCenter();
+		this.map.easeTo({
+			center,
+			offset: [dx, dy],
+			duration: options?.durationMs ?? 240,
+			essential: true
+		});
+	}
+	setCursor(cursor) {
+		this.map.getContainer().classList.toggle("cm-map-cursor-crosshair", cursor === "crosshair");
+		this.map.getCanvas().style.cursor = cursor;
+		this.map.getCanvasContainer().style.cursor = cursor;
+		this.map.getContainer().style.cursor = cursor;
+	}
+	setDoubleClickZoomEnabled(enabled) {
+		if (enabled) this.map.doubleClickZoom.enable();
+		else this.map.doubleClickZoom.disable();
+	}
+	getResolution() {
+		const zoom = this.map.getZoom();
+		const center = this.map.getCenter();
+		return 40075016.686 * Math.cos(center.lat * Math.PI / 180) / Math.pow(2, zoom + 8);
+	}
+	getZoom() {
+		return this.map.getZoom();
+	}
+	onPick(layerId, handler, opts) {
+		const onMlClick = (e) => {
+			const handle = this.layers.get(layerId);
+			if (!handle) return;
+			const originalEvent = e.originalEvent;
+			const tol = pickHitTolerance(originalEvent);
+			const { x, y } = e.point;
+			const bbox = [[x - tol, y - tol], [x + tol, y + tol]];
+			const features = this.map.queryRenderedFeatures(bbox, { layers: handle.mlLayerIds });
+			if (features.length === 0) return;
+			const f = features[0];
+			const geojson = {
+				type: "Feature",
+				id: f.id,
+				geometry: f.geometry,
+				properties: f.properties
+			};
+			const cmId = tryControlMeasureIdFromFeature(geojson);
+			if (cmId == null) return;
+			handler({
+				id: cmId,
+				feature: geojson,
+				pixel: [x, y],
+				coordinate: [e.lngLat.lng, e.lngLat.lat],
+				originalEvent
+			});
+		};
+		return bindAbortable(opts?.signal, () => {
+			this.map.on("click", onMlClick);
+			return () => this.map.off("click", onMlClick);
+		});
+	}
+	setGlobeMode(enabled) {
+		if (enabled) this.map.setProjection({ type: "globe" });
+		else this.map.setProjection({ type: "mercator" });
+	}
+};
+//#endregion
+export { MapLibreAdapter };

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@orbat-mapper/tactical-draw-adapter-maplibre",
+  "version": "0.2.0-alpha.0",
+  "description": "MapLibre GL JS engine adapter for @orbat-mapper/tactical-draw. Draw and edit tactical control measures (MIL-STD-2525 / APP-6) on a MapLibre map.",
+  "license": "MIT",
+  "author": "Orbat Mapper",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/orbat-mapper/tactical-graphics.git",
+    "directory": "packages/tactical-draw-adapter-maplibre"
+  },
+  "keywords": [
+    "tactical-graphics",
+    "control-measures",
+    "mil-std-2525",
+    "app-6",
+    "gis",
+    "mapping",
+    "draw",
+    "edit",
+    "maplibre",
+    "maplibre-gl"
+  ],
+  "homepage": "https://github.com/orbat-mapper/tactical-graphics",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@orbat-mapper/control-measures": "^0.2.0-alpha.0",
+    "@orbat-mapper/tactical-draw": "^0.2.0-alpha.0"
+  },
+  "peerDependencies": {
+    "maplibre-gl": ">=4.0.0 <6.0.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/core": "^0.18.3",
+    "@types/geojson": "^7946.0.16",
+    "jsdom": "^27.4.0",
+    "maplibre-gl": "^5.18.0",
+    "publint": "^0.3.21",
+    "tsdown": "^0.22.2",
+    "typescript": "~5.9.3",
+    "vite": "^8.0.16",
+    "vitest": "^4.1.8"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "lint": "eslint . --fix"
+  }
+}