@orbat-mapper/tactical-draw-adapter-maplibre 0.7.3 → 0.8.0

package/dist/index.d.mts

@@ -78,6 +78,18 @@ declare class PinLayer implements CustomLayerInterface {
   private sortDirty;
   /** View-wide far-to-near paint order; `false` restores canonical layer order. */
   private depthSorted;
+  /** View-wide presentation while zoom or distance scaling is on, else undefined. */
+  private scaling;
+  /**
+   * Pin scaling reference, derived from the camera pose rather than MapLibre's center
+   * point: after a terrain gesture MapLibre re-seats the center on the terrain and
+   * recomputes zoom with the camera fixed, which would otherwise snap pin sizes.
+   */
+  private reference;
+  /** Per-frame scratch, so the reference update allocates nothing in flat mode. */
+  private cameraScratch;
+  private rayScratch;
+  private positionScratch;
   /** Hoisted out of the per-frame sort so no comparator is allocated while panning. */
   private comparePaintOrder;
   private version;
@@ -103,6 +115,8 @@ declare class PinLayer implements CustomLayerInterface {
   private status;
   private refreshTerrain;
   private elevation;
+  /** Uncached DEM read; NaN while the DEM tile is missing or changing. */
+  private sampleElevation;
   has(id: string): boolean;
   constructor(id: string, resources: PinResources, onStatus?: ((event: PinPresentationStatusEvent) => void) | undefined);
   private restoreContext;
@@ -127,6 +141,45 @@ declare class PinLayer implements CustomLayerInterface {
    * — those stay at the call site, as they aren't part of the shared matrix math.
    */
   private projectToPixel;
+  /** View-wide, so any pin's value describes the layer (like depthSort). */
+  private zoomScale;
+  /**
+   * Per frame: move the reference elevation toward the terrain under the view-center
+   * ray, then take the clip w where that ray crosses it. Pin sizes then depend only
+   * on the camera and that plane. The plane adapts only in proportion to camera
+   * motion, never over time: MapLibre re-seats its center (and zoom) on the terrain
+   * after a gesture with the camera fixed, and a stationary camera must not resize
+   * pins. The effective zoom is the zoom that plane would give, invariant under that
+   * re-seat (camera fixed, zoom and pixel units rescaled).
+   */
+  private updateScaleReference;
+  /**
+   * Camera position as [Mercator x, Mercator y, meters up] written into `out`,
+   * independent of zoom and of the layer origin, so it is unchanged when MapLibre
+   * re-seats its center. It is the point where clip x, y and w all vanish: rows 0, 1
+   * and 3 of the column-major matrix, solved by Cramer's rule. False if singular.
+   */
+  private cameraPosition;
+  private rayDepth;
+  /**
+   * Where the view-center ray meets elevation `z`: world x, y (layer pixels from the
+   * origin) and clip w, in a reused scratch object. Flat projection only; the globe
+   * falls back to the origin.
+   */
+  private rayHit;
+  /**
+   * Terrain height where the view-center ray meets the current reference plane. Unlike
+   * MapLibre's center elevation, which is frozen during gestures and re-seated after
+   * them, this follows the camera continuously and is unchanged while it is still.
+   */
+  private rayTerrainElevation;
+  /** Elevation of the distance-scaling reference plane; sea level until one is set. */
+  private referenceElevation;
+  /**
+   * Combined zoom and distance scale for a pin anchored at world (x, y), mirroring the
+   * shader: distance is horizontal, the anchor's clip w at the reference elevation.
+   */
+  private pinScale;
   footprint(id: string): PinFootprint | null;
   moveFromPixel(id: string, attachment: PixelCoordinate): number[] | null;
   onRemove(_map: Map$1, context: WebGLRenderingContext | WebGL2RenderingContext): void;

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import * as maplibregl from "maplibre-gl";
 import { LngLat, MercatorCoordinate } from "maplibre-gl";
-import { BaseMapAdapter, DEFAULT_TEXT_SIZE_MAX_PIXELS, DEFAULT_TEXT_SIZE_MIN_PIXELS, HATCH_PATTERNS, PointerCallbackHub, TEXT_HALO_COLOR, TOUCH_HIT_TOLERANCE_PX, bindAbortable, evaluatePickCandidates, fillPatternImageId, makeFillPatternImage, mergeNativeAndCachedPickFeatures, nearestWorldCopyLng, parseColor, pickHitTolerance, pickPointerType, resolveTextHaloWidth } from "@orbat-mapper/tactical-draw";
+import { BaseMapAdapter, DEFAULT_TEXT_SIZE_MAX_PIXELS, DEFAULT_TEXT_SIZE_MIN_PIXELS, HATCH_PATTERNS, PointerCallbackHub, TEXT_HALO_COLOR, TOUCH_HIT_TOLERANCE_PX, bindAbortable, combinePinScale, evaluatePickCandidates, fillPatternImageId, makeFillPatternImage, mergeNativeAndCachedPickFeatures, nearestWorldCopyLng, parseColor, pickHitTolerance, pickPointerType, pinDistanceScale, pinZoomScale, resolveTextHaloWidth } from "@orbat-mapper/tactical-draw";
 import { EARTH_RADIUS, project, unproject } from "@orbat-mapper/control-measures";
 //#region src/pin-atlas.ts
 /**
@@ -219,6 +219,16 @@ vec4 projectPin(vec3 position, out float horizon) {
   return mix(flatClip,globe,u_globeTransition);
 }
 uniform vec2 u_view;
+// Zoom-out shrink for screen-space pixel dimensions (lift, dot, plate, symbol, halos).
+// Stem width is left alone; fragment shading stays in unscaled local units.
+uniform float u_scale;
+// Perspective sizing, mirroring pinDistanceScale(): the exponent, 0 when off;
+// u_depthRef is the reference clip w at u_refElevation.
+uniform float u_distanceStrength;
+uniform float u_depthRef;
+uniform float u_refElevation;
+// Bounds on zoom × distance (sizeLimits in combinePinScale); (0, huge) when both are off.
+uniform vec2 u_sizeLimits;
 out vec2 v_local;
 out vec2 v_uv;
 flat out vec4 v_bounds;
@@ -232,14 +242,26 @@ void main() {
   float groundHorizon, targetHorizon;
   vec4 ground = projectPin(a_ground.xyz, groundHorizon);
   vec4 target = projectPin(a_target.xyz, targetHorizon);
-  if(a_flags.y < .5) { target = ground; targetHorizon = groundHorizon; target.y += a_ground.w * 2. / u_view.y * target.w; }
+  float scale = u_scale;
+  if(u_distanceStrength > 0.) {
+    // Horizontal distance: measure the anchor at the reference elevation, so relief
+    // (a unit in a valley below the reference) never resizes pins while zooming.
+    // Flat clip w is affine in z, so only the globe needs another projection.
+    float refHorizon, depth;
+    if(u_globeTransition == 0.) depth = ground.w + (u_refElevation - a_ground.z) * u_matrix[2][3];
+    else depth = projectPin(vec3(a_ground.xy, u_refElevation), refHorizon).w;
+    if(depth > 0.)
+      scale *= pow(u_depthRef / depth, u_distanceStrength);
+  }
+  scale = clamp(scale, u_sizeLimits.x, u_sizeLimits.y);
+  if(a_flags.y < .5) { target = ground; targetHorizon = groundHorizon; target.y += a_ground.w * scale * 2. / u_view.y * target.w; }
   v_horizon = a_flags.x < .5 ? groundHorizon : (a_flags.x < 1.5 ? mix(groundHorizon,targetHorizon,c.y) : targetHorizon);
   vec2 gp = ground.xy / ground.w * u_view * .5;
   vec2 tp = target.xy / target.w * u_view * .5;
   float kind = a_flags.x;
   vec4 clip = target;
   vec2 offset;
-  if(kind < .5) { clip = ground; offset = (c - .5) * a_shape.xy; }
+  if(kind < .5) { clip = ground; offset = (c - .5) * a_shape.xy * scale; }
   else if(kind < 1.5) {
     vec2 delta = tp-gp; float len = length(delta);
     vec2 dir = len > .0001 ? delta/len : vec2(0,1);
@@ -247,7 +269,7 @@ void main() {
     vec2 p = mix(gp,tp,c.y) + vec2(-dir.y,dir.x) * (c.x-.5)*(a_shape.x+1.);
     clip = vec4(p/u_view*2., mix(ground.z/ground.w,target.z/target.w,c.y), 1.);
     offset = vec2(0);
-  } else { offset = (c - vec2(.5,0)) * a_shape.xy + a_shape.zw; }
+  } else { offset = ((c - vec2(.5,0)) * a_shape.xy + a_shape.zw) * scale; }
   clip.xy += offset * 2. / u_view * clip.w;
   if (ground.w <= 0. || target.w <= 0.) clip = vec4(2,2,2,1);
   gl_Position=clip;
@@ -336,6 +358,10 @@ const PIN_GLOBE_RADIUS = EARTH_RADIUS;
 function pinMercator(position) {
 	return MercatorCoordinate.fromLngLat([position[0], Math.max(-89.999999, Math.min(89.999999, position[1]))]);
 }
+/** Latitude in radians of Mercator `y`; allocation-free, unlike MercatorCoordinate.toLngLat. */
+function mercatorLatitude(y) {
+	return Math.atan(Math.sinh(Math.PI * (1 - 2 * y)));
+}
 /** Scratch sphere position reused by the per-pin, per-frame depth() path. */
 const depthSphere = [
 	0,
@@ -555,6 +581,42 @@ var PinLayer = class {
 	sortDirty = true;
 	/** View-wide far-to-near paint order; `false` restores canonical layer order. */
 	depthSorted = false;
+	/** View-wide presentation while zoom or distance scaling is on, else undefined. */
+	scaling;
+	/**
+	* Pin scaling reference, derived from the camera pose rather than MapLibre's center
+	* point: after a terrain gesture MapLibre re-seats the center on the terrain and
+	* recomputes zoom with the camera fixed, which would otherwise snap pin sizes.
+	*/
+	reference = {
+		elevation: NaN,
+		/**
+		* Clip w where distance scaling is 1. It tracks the terrain height at the center
+		* (see updateScaleReference): a sea-level reference drifts from the terrain by an
+		* offset that doubles in pixels each zoom level, making pins pulse while zooming.
+		*/
+		depth: NaN,
+		zoom: NaN,
+		camera: [
+			NaN,
+			NaN,
+			NaN
+		],
+		bearing: 0,
+		pitch: 0
+	};
+	/** Per-frame scratch, so the reference update allocates nothing in flat mode. */
+	cameraScratch = [
+		NaN,
+		NaN,
+		NaN
+	];
+	rayScratch = {
+		x: 0,
+		y: 0,
+		depth: NaN
+	};
+	positionScratch = [0, 0];
 	/** Hoisted out of the per-frame sort so no comparator is allocated while panning. */
 	comparePaintOrder = (a, b) => (this.depthSorted ? this.depths[b] - this.depths[a] : 0) || a - b;
 	version = 0;
@@ -589,6 +651,13 @@ var PinLayer = class {
 		const key = `${position[0]}/${position[1]}`;
 		const cached = this.elevationCache.get(key);
 		if (cached !== void 0) return cached;
+		const value = this.sampleElevation(position);
+		if (Number.isFinite(value)) this.elevationCache.set(key, value);
+		return value;
+	}
+	/** Uncached DEM read; NaN while the DEM tile is missing or changing. */
+	sampleElevation(position) {
+		if (!this.map.getTerrain() || Math.abs(position[1]) >= 85.051129) return 0;
 		let value;
 		try {
 			const terrain = this.map.terrain;
@@ -609,7 +678,6 @@ var PinLayer = class {
 		} catch {
 			return NaN;
 		}
-		this.elevationCache.set(key, value);
 		return value;
 	}
 	has(id) {
@@ -679,6 +747,11 @@ var PinLayer = class {
 			globeTransition: gl.getUniformLocation(program, "u_globeTransition"),
 			world: gl.getUniformLocation(program, "u_world"),
 			view: gl.getUniformLocation(program, "u_view"),
+			scale: gl.getUniformLocation(program, "u_scale"),
+			distanceStrength: gl.getUniformLocation(program, "u_distanceStrength"),
+			depthRef: gl.getUniformLocation(program, "u_depthRef"),
+			refElevation: gl.getUniformLocation(program, "u_refElevation"),
+			sizeLimits: gl.getUniformLocation(program, "u_sizeLimits"),
 			buffer: gl.getUniformLocation(program, "u_buffer"),
 			pick: gl.getUniformLocation(program, "u_pick"),
 			atlas: gl.getUniformLocation(program, "u_atlas"),
@@ -711,6 +784,8 @@ var PinLayer = class {
 		this.pins = pins;
 		this.prioritizesSelection = pins[0]?.presentation.prioritizePins ?? false;
 		this.depthSorted = pins[0]?.presentation.depthSort ?? false;
+		const view = pins[0]?.presentation;
+		this.scaling = view && (view.zoomScale.enabled || view.distanceScale.enabled) ? view : void 0;
 		if (this.elevationCache.size > pins.length * 60 + 1e3) this.elevationCache.clear();
 		if (!this.program) {
 			this.onStatus?.({
@@ -965,6 +1040,8 @@ var PinLayer = class {
 		if (this.status.status !== "supported") return;
 		this.frame = input;
 		this.projection.update(input, this.origin, this.map.getCenter(), 512 * 2 ** this.map.getZoom(), this.map.getProjection()?.type === "globe");
+		if (this.scaling) this.updateScaleReference();
+		else this.reference.elevation = this.reference.depth = this.reference.zoom = NaN;
 		this.updatePaintOrder();
 		this.draw(context, false);
 	}
@@ -1034,6 +1111,12 @@ var PinLayer = class {
 		gl.uniform1f(u.globeTransition, this.projection.transition);
 		gl.uniform1f(u.world, 512 * 2 ** this.map.getZoom());
 		gl.uniform2f(u.view, width, height);
+		gl.uniform1f(u.scale, this.zoomScale());
+		const distance = this.scaling?.distanceScale, limits = this.scaling?.sizeLimits;
+		gl.uniform1f(u.distanceStrength, distance?.enabled ? distance.strength : 0);
+		gl.uniform2f(u.sizeLimits, limits ? Math.min(limits.minScale, limits.maxScale) : 0, limits?.maxScale ?? 1e30);
+		gl.uniform1f(u.depthRef, this.reference.depth);
+		gl.uniform1f(u.refElevation, this.referenceElevation());
 		gl.uniform2f(u.buffer, gl.drawingBufferWidth, gl.drawingBufferHeight);
 		gl.uniform1i(u.pick, pick ? 1 : 0);
 		gl.uniform1i(u.atlas, 0);
@@ -1123,6 +1206,123 @@ var PinLayer = class {
 		const width = this.map.getContainer().clientWidth, height = this.map.getContainer().clientHeight;
 		return [(c[0] / c[3] + 1) * width / 2, (1 - c[1] / c[3]) * height / 2];
 	}
+	/** View-wide, so any pin's value describes the layer (like depthSort). */
+	zoomScale() {
+		if (!this.scaling) return 1;
+		const zoom = Number.isFinite(this.reference.zoom) ? this.reference.zoom : this.map.getZoom();
+		return pinZoomScale(this.scaling, zoom);
+	}
+	/**
+	* Per frame: move the reference elevation toward the terrain under the view-center
+	* ray, then take the clip w where that ray crosses it. Pin sizes then depend only
+	* on the camera and that plane. The plane adapts only in proportion to camera
+	* motion, never over time: MapLibre re-seats its center (and zoom) on the terrain
+	* after a gesture with the camera fixed, and a stationary camera must not resize
+	* pins. The effective zoom is the zoom that plane would give, invariant under that
+	* re-seat (camera fixed, zoom and pixel units rescaled).
+	*/
+	updateScaleReference() {
+		const target = this.rayTerrainElevation();
+		const ref = this.reference;
+		const camera = this.cameraPosition(this.cameraScratch) ? this.cameraScratch : ref.camera;
+		const bearing = this.map.getBearing(), pitch = this.map.getPitch();
+		if (!Number.isFinite(ref.elevation)) ref.elevation = target;
+		else {
+			const height = camera[2] - ref.elevation;
+			const lat = mercatorLatitude(camera[1]);
+			const metersPerMercator = 2 * Math.PI * PIN_GLOBE_RADIUS * Math.cos(lat);
+			const travel = Math.hypot((camera[0] - ref.camera[0]) * metersPerMercator, (camera[1] - ref.camera[1]) * metersPerMercator, camera[2] - ref.camera[2]);
+			const turn = Math.abs((bearing - ref.bearing + 540) % 360 - 180) / 90;
+			const motion = (height > 0 ? travel / height : 1) + turn + Math.abs(pitch - ref.pitch) / 30;
+			if (Number.isFinite(motion)) ref.elevation += (target - ref.elevation) * Math.min(1, motion * 2);
+		}
+		if (camera !== ref.camera) {
+			ref.camera[0] = camera[0];
+			ref.camera[1] = camera[1];
+			ref.camera[2] = camera[2];
+		}
+		ref.bearing = bearing;
+		ref.pitch = pitch;
+		const centerDepth = this.rayDepth(this.map.getCenterElevation());
+		const depth = this.rayDepth(ref.elevation);
+		ref.depth = depth > 0 ? depth : centerDepth;
+		ref.zoom = this.map.getZoom() + Math.log2(centerDepth / ref.depth);
+	}
+	/**
+	* Camera position as [Mercator x, Mercator y, meters up] written into `out`,
+	* independent of zoom and of the layer origin, so it is unchanged when MapLibre
+	* re-seats its center. It is the point where clip x, y and w all vanish: rows 0, 1
+	* and 3 of the column-major matrix, solved by Cramer's rule. False if singular.
+	*/
+	cameraPosition(out) {
+		const m = this.projection.matrix;
+		const a0 = m[0], a1 = m[4], a2 = m[8], t0 = -m[12];
+		const b0 = m[1], b1 = m[5], b2 = m[9], t1 = -m[13];
+		const c0 = m[3], c1 = m[7], c2 = m[11], t2 = -m[15];
+		const det = a0 * (b1 * c2 - b2 * c1) - a1 * (b0 * c2 - b2 * c0) + a2 * (b0 * c1 - b1 * c0);
+		if (!det || !Number.isFinite(det)) return false;
+		const x = (t0 * (b1 * c2 - b2 * c1) - a1 * (t1 * c2 - b2 * t2) + a2 * (t1 * c1 - b1 * t2)) / det;
+		const y = (a0 * (t1 * c2 - b2 * t2) - t0 * (b0 * c2 - b2 * c0) + a2 * (b0 * t2 - t1 * c0)) / det;
+		const z = (a0 * (b1 * t2 - t1 * c1) - a1 * (b0 * t2 - t1 * c0) + t0 * (b0 * c1 - b1 * c0)) / det;
+		out[0] = x / this.projection.world + this.origin[0];
+		out[1] = y / this.projection.world + this.origin[1];
+		out[2] = z;
+		return true;
+	}
+	rayDepth(z) {
+		return this.rayHit(z)?.depth ?? NaN;
+	}
+	/**
+	* Where the view-center ray meets elevation `z`: world x, y (layer pixels from the
+	* origin) and clip w, in a reused scratch object. Flat projection only; the globe
+	* falls back to the origin.
+	*/
+	rayHit(z) {
+		const hit = this.rayScratch;
+		if (this.projection.transition !== 0) {
+			hit.x = hit.y = 0;
+			hit.depth = this.projection.project(0, 0, z).clip[3];
+			return hit;
+		}
+		const m = this.projection.matrix;
+		const a = m[0], b = m[4], c = m[1], d = m[5];
+		const e = -(m[8] * z + m[12]), f = -(m[9] * z + m[13]);
+		const det = a * d - b * c;
+		if (Math.abs(det) < 1e-12) return null;
+		hit.x = (e * d - b * f) / det;
+		hit.y = (a * f - e * c) / det;
+		hit.depth = m[3] * hit.x + m[7] * hit.y + m[11] * z + m[15];
+		return hit;
+	}
+	/**
+	* Terrain height where the view-center ray meets the current reference plane. Unlike
+	* MapLibre's center elevation, which is frozen during gestures and re-seated after
+	* them, this follows the camera continuously and is unchanged while it is still.
+	*/
+	rayTerrainElevation() {
+		const ref = this.reference.elevation;
+		const fallback = this.map.getCenterElevation();
+		if (!this.map.getTerrain() || !Number.isFinite(ref)) return fallback;
+		const hit = this.rayHit(ref);
+		if (!hit || !(hit.depth > 0)) return fallback;
+		const world = this.projection.world, position = this.positionScratch;
+		position[0] = (hit.x / world + this.origin[0]) * 360 - 180;
+		position[1] = mercatorLatitude(hit.y / world + this.origin[1]) * 180 / Math.PI;
+		const value = this.sampleElevation(position);
+		return Number.isFinite(value) ? value : fallback;
+	}
+	/** Elevation of the distance-scaling reference plane; sea level until one is set. */
+	referenceElevation() {
+		return Number.isFinite(this.reference.elevation) ? this.reference.elevation : 0;
+	}
+	/**
+	* Combined zoom and distance scale for a pin anchored at world (x, y), mirroring the
+	* shader: distance is horizontal, the anchor's clip w at the reference elevation.
+	*/
+	pinScale(presentation, worldX, worldY) {
+		const depth = this.projection.project(worldX, worldY, this.referenceElevation()).clip[3];
+		return combinePinScale(presentation, this.zoomScale(), pinDistanceScale(presentation, depth, this.reference.depth));
+	}
 	footprint(id) {
 		const i = this.pins.findIndex((p) => p.id === id);
 		const pin = this.pins[i];
@@ -1130,10 +1330,13 @@ var PinLayer = class {
 		const p = pin.presentation, coord = pinMercator(pin.position);
 		coord.x += Math.round(this.origin[0] - coord.x);
 		const world = 512 * 2 ** this.map.getZoom();
-		const project = (z) => this.projectToPixel((coord.x - this.origin[0]) * world, (coord.y - this.origin[1]) * world, z);
-		const ground = project(this.elevations[i] ?? 0), attachment = p.mode === "world" ? project((this.elevations[i] ?? 0) + p.heightMeters) : [ground[0], ground[1] - p.liftPixels];
+		const x = (coord.x - this.origin[0]) * world, y = (coord.y - this.origin[1]) * world;
+		const project = (z) => this.projectToPixel(x, y, z);
+		const ground = project(this.elevations[i] ?? 0);
+		const pinScale = this.pinScale(p, x, y);
+		const attachment = p.mode === "world" ? project((this.elevations[i] ?? 0) + p.heightMeters) : [ground[0], ground[1] - p.liftPixels * pinScale];
 		if (!attachment.every(Number.isFinite)) return null;
-		const scale = p.sizePixels / pin.octagonSize, padding = p.plate.enabled ? p.plate.padding : 0, halo = p.symbolHalo.opacity > 0 ? p.symbolHalo.width : 0, overhang = Math.max(0, halo - padding);
+		const scale = p.sizePixels / pin.octagonSize * pinScale, padding = (p.plate.enabled ? p.plate.padding : 0) * pinScale, halo = (p.symbolHalo.opacity > 0 ? p.symbolHalo.width : 0) * pinScale, overhang = Math.max(0, halo - padding);
 		return {
 			ground,
 			attachment,
@@ -1149,8 +1352,9 @@ var PinLayer = class {
 			const c = pinMercator(ll);
 			c.x += Math.round(this.origin[0] - c.x);
 			const world = 512 * 2 ** this.map.getZoom();
-			const [px, py] = this.projectToPixel((c.x - this.origin[0]) * world, (c.y - this.origin[1]) * world, elevationOrSeaLevel(this.elevation(ll)) + (p.mode === "world" ? p.heightMeters : 0));
-			return [px, py - (p.mode === "screen" ? p.liftPixels : 0)];
+			const x = (c.x - this.origin[0]) * world, y = (c.y - this.origin[1]) * world;
+			const [px, py] = this.projectToPixel(x, y, elevationOrSeaLevel(this.elevation(ll)) + (p.mode === "world" ? p.heightMeters : 0));
+			return [px, py - (p.mode === "screen" ? p.liftPixels * this.pinScale(p, x, y) : 0)];
 		};
 		return invertPinProjection(project, pin.position, attachment, this.map.getProjection()?.type === "globe" ? 90 : void 0);
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbat-mapper/tactical-draw-adapter-maplibre",
-  "version": "0.7.3",
+  "version": "0.8.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",
@@ -37,8 +37,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@orbat-mapper/control-measures": "^0.30.0",
-    "@orbat-mapper/tactical-draw": "^0.11.1"
+    "@orbat-mapper/control-measures": "^0.30.1",
+    "@orbat-mapper/tactical-draw": "^0.12.0"
   },
   "peerDependencies": {
     "maplibre-gl": ">=5.8.0 <7.0.0"