@orbat-mapper/tactical-draw-adapter-maplibre 0.3.20 → 0.3.22

package/dist/index.d.mts

@@ -1,7 +1,17 @@
 import { BaseMapAdapter, EditPointerDriver, FeatureGroup, IconResource, LayerId, MapCursor, NativeEventEntry, PickHandler, PickOptions, PixelCoordinate, StyleOptions } from "@orbat-mapper/tactical-draw";
 import * as maplibregl from "maplibre-gl";
+import { DataDrivenPropertyValueSpecification } from "maplibre-gl";
 import { Feature, Position } from "geojson";
 
+//#region src/text-sizing.d.ts
+type SizeExpression = DataDrivenPropertyValueSpecification<number>;
+interface TextSizing {
+  size: SizeExpression;
+  haloWidth: SizeExpression;
+  haloBlur: SizeExpression;
+  opacity: SizeExpression;
+}
+//#endregion
 //#region src/ml-adapter.d.ts
 interface MapLibreLayerHandle {
   sourceId: string;
@@ -40,6 +50,9 @@ interface MapLibrePaintSurface {
   readonly layerId: string;
   readonly channel: PaintChannel;
   readonly featureId: string | number;
+  textSizing?: TextSizing;
+  /** Signature of the inputs `textSizing`/`icon-size` were derived from. */
+  sizingKey?: string;
 }
 /**
  * Last-applied scalar state for a rendered image overlay, used to skip
@@ -81,6 +94,7 @@ declare class MapLibreAdapter extends BaseMapAdapter<MapLibreLayerHandle, MapLib
   private clearGroupBundles;
   private requiredIconIds;
   private reconcileGroupPaintSurfaces;
+  private updateSurfaceSizing;
   private buildGroupLayer;
   private updateGroupBundleSource;
   private orderGroupBundles;

package/dist/index.mjs

@@ -1,5 +1,115 @@
+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, pickHitTolerance, pickPointerType, resolveTextHaloWidth } from "@orbat-mapper/tactical-draw";
 import { project, unproject } from "@orbat-mapper/control-measures";
-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, pickHitTolerance, pickPointerType } from "@orbat-mapper/tactical-draw";
+//#region src/mercator.ts
+/**
+* Web Mercator world circumference in meters (2π × 6378137). The single source
+* of truth for this package's meters↔pixels math: `getResolution`, the ground
+* text ramp, and the ground icon ramp all derive from it, so they cannot drift
+* apart.
+*/
+const WEB_MERCATOR_CIRCUMFERENCE = 40075016.686;
+/**
+* Pixels per ground meter at zoom 0. MapLibre's world is 512 px wide at zoom 0
+* and doubles each zoom level, so the size at any zoom `z` is this × 2^z —
+* which is exactly what an `["exponential", 2]` zoom interpolation computes.
+*/
+const PIXELS_PER_METER_AT_ZOOM_0 = 512 / WEB_MERCATOR_CIRCUMFERENCE;
+//#endregion
+//#region src/text-sizing.ts
+/** `text-halo-blur` as a fraction of the halo's outward depth (MapLibre only). */
+const TEXT_HALO_BLUR_RATIO = .25;
+/**
+* Exact clamped ground scaling, with only the two actual clamp boundaries as
+* stops. MapLibre's glyph renderer interpolates between stops covering the
+* tile's whole zoom interval, so inserting fractional stops into a composite
+* expression does NOT fix its rendering near a clamp. A graphic's own camera
+* expression has no interior kink: base-2 interpolation is exact even when
+* the covering interval spans many zoom levels. No zoom listener is needed.
+*
+* Shared by the ground text ramp and the ground icon ramp — both scale a
+* meters-derived size with zoom and pin it at two per-feature bounds.
+*/
+function groundRamp(pixelsAtZoom0, min, max) {
+	if (min >= max) return max;
+	return [
+		"interpolate",
+		["exponential", 2],
+		["zoom"],
+		Math.log2(min / pixelsAtZoom0),
+		min,
+		Math.log2(max / pixelsAtZoom0),
+		max
+	];
+}
+/** Each grouped text surface paints exactly one feature (ADR-0039). */
+function buildTextSizing(text, props) {
+	const meters = props?.textSizeMeters;
+	const pixels = props?.textSizePixels;
+	const maximum = props?.textMaxSizePixels;
+	const fixedHalo = resolveTextHaloWidth(pixels ?? 14);
+	let size = pixels ?? 14;
+	let scaledHalo = fixedHalo;
+	let scaledBlur = fixedHalo * TEXT_HALO_BLUR_RATIO;
+	let opacity = 1;
+	if (pixels === void 0 && typeof meters === "number" && meters > 0) {
+		const pixelsAtZoom0 = meters * PIXELS_PER_METER_AT_ZOOM_0;
+		const min = maximum !== void 0 ? pixelsAtZoom0 : Math.max(pixelsAtZoom0, text.textSizeMinPixels ?? DEFAULT_TEXT_SIZE_MIN_PIXELS);
+		const max = maximum ?? text.textSizeMaxPixels ?? DEFAULT_TEXT_SIZE_MAX_PIXELS;
+		const haloPixelsAtZoom0 = pixelsAtZoom0 / 8;
+		const minHalo = resolveTextHaloWidth(min);
+		const maxHalo = resolveTextHaloWidth(max);
+		size = groundRamp(pixelsAtZoom0, min, max);
+		scaledHalo = groundRamp(haloPixelsAtZoom0, minHalo, maxHalo);
+		scaledBlur = groundRamp(haloPixelsAtZoom0 * TEXT_HALO_BLUR_RATIO, minHalo * TEXT_HALO_BLUR_RATIO, maxHalo * TEXT_HALO_BLUR_RATIO);
+		if (maximum !== void 0) {
+			const hideZoom = Math.log2(maximum / pixelsAtZoom0);
+			opacity = maximum <= 0 ? 0 : [
+				"step",
+				["zoom"],
+				1,
+				hideZoom + Number.EPSILON * Math.max(1, Math.abs(hideZoom)),
+				0
+			];
+		}
+	}
+	if (pixels === void 0 && meters === 0) {
+		size = maximum !== void 0 ? 0 : Math.min(text.textSizeMaxPixels ?? DEFAULT_TEXT_SIZE_MAX_PIXELS, Math.max(0, text.textSizeMinPixels ?? DEFAULT_TEXT_SIZE_MIN_PIXELS));
+		scaledHalo = resolveTextHaloWidth(size);
+		scaledBlur = scaledHalo * TEXT_HALO_BLUR_RATIO;
+	}
+	const haloWidth = props?.textHalo ? scaledHalo : text.strokeColor ? text.strokeWidth ?? 1 : props?.textBackground ? 3 : 0;
+	return {
+		size,
+		haloWidth,
+		haloBlur: props?.textHalo ? scaledBlur : 0,
+		opacity
+	};
+}
+//#endregion
+//#region src/icon-sizing.ts
+/** Stand-in for "no upper bound", matching the unclamped icon default. */
+const UNBOUNDED_PIXELS = 1e9;
+/**
+* Exact per-feature `icon-size` for a ground-sized point symbol, the icon
+* counterpart of `buildTextSizing` (#522). `icon-size` is a *scale factor* —
+* rendered pixels ÷ the icon image's intrinsic octagon size — so the whole
+* ramp is divided by `iconOctagonSize`; dividing every stop by the same
+* constant leaves the clamp zooms unchanged.
+*
+* Returns `undefined` for a feature that is not ground-sized, so the caller
+* keeps the shared `iconScale` snapshot expression.
+*/
+function buildIconSizing(props) {
+	const meters = props?.iconSizeMeters;
+	if (typeof meters !== "number" || !(meters > 0)) return void 0;
+	const octagon = typeof props?.iconOctagonSize === "number" && props.iconOctagonSize > 0 ? props.iconOctagonSize : 1;
+	const pixelsAtZoom0 = meters * PIXELS_PER_METER_AT_ZOOM_0;
+	const min = Math.max(props?.iconMinPixels ?? 0, pixelsAtZoom0);
+	const max = props?.iconMaxPixels ?? UNBOUNDED_PIXELS;
+	if (max <= min) return min / octagon;
+	return groundRamp(pixelsAtZoom0 / octagon, min / octagon, max / octagon);
+}
+//#endregion
 //#region src/ml-adapter.ts
 /** Feature property key for the resolved hatch-pattern image id (see `promoteFeature`). */
 const FILL_PATTERN_IMAGE_ID_PROPERTY = "_fillPatternImageId";
@@ -8,6 +118,27 @@ const DEFAULT_LINE_WIDTH = 2;
 function isHatchPattern(value) {
 	return HATCH_PATTERNS.includes(value);
 }
+/**
+* The sizing-relevant inputs for a surface, joined into a comparable string.
+* `undefined` for channels whose size never varies per feature, which skips
+* the comparison entirely.
+*/
+function sizingSignature(channel, props, style) {
+	if (channel === "icon") return `${props?.iconSizeMeters}|${props?.iconOctagonSize}|${props?.iconMinPixels}|${props?.iconMaxPixels}`;
+	if (channel !== "text") return void 0;
+	const text = style?.text;
+	return [
+		props?.textSizeMeters,
+		props?.textSizePixels,
+		props?.textMaxSizePixels,
+		props?.textHalo,
+		props?.textBackground,
+		text?.textSizeMinPixels,
+		text?.textSizeMaxPixels,
+		text?.strokeColor,
+		text?.strokeWidth
+	].join("|");
+}
 function coordinatesEqual(a, b) {
 	for (let index = 0; index < 4; index++) {
 		const pa = a[index];
@@ -180,7 +311,7 @@ function buildCirclePointFilter(style) {
 		["!has", "iconId"]
 	];
 }
-function buildIconLayer(id, source) {
+function buildIconLayer(id, source, iconSize = buildIconSizeExpression()) {
 	return {
 		id,
 		type: "symbol",
@@ -196,7 +327,7 @@ function buildIconLayer(id, source) {
 		],
 		layout: {
 			"icon-image": ["get", "iconId"],
-			"icon-size": buildIconSizeExpression(),
+			"icon-size": iconSize,
 			"icon-rotate": [
 				"*",
 				[
@@ -227,120 +358,8 @@ function centeredSvg(resource) {
 	const height = halfHeight * 2;
 	return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}"><g transform="translate(${halfWidth - resource.anchor[0]} ${halfHeight - resource.anchor[1]})">${resource.svg}</g></svg>`;
 }
-/** Web Mercator world circumference in meters (2π × 6378137). */
-const WEB_MERCATOR_CIRCUMFERENCE = 40075016.686;
-/**
-* Per-feature text size (ADR-0028): a ground-anchored label carries
-* `textSizeMeters` and renders at `textSizeMeters / resolution`, clamped to
-* the layer's `textSizeMinPixels`/`textSizeMaxPixels` band; a screen-anchored
-* one carries `textSizePixels` and renders at that constant; neither renders
-* the 14px engine default. Layout properties only take zoom as an
-* `interpolate`/`step` input, so the ground conversion is evaluated at every
-* integer zoom stop (resolution = world circumference / 512·2^zoom pixels,
-* matching `getResolution`); the linear ramp between stops approximates the
-* exponential exactly closely enough at 1-zoom granularity.
-*/
-function textSizeAtZoom(text, zoom) {
-	const minPx = text.textSizeMinPixels ?? DEFAULT_TEXT_SIZE_MIN_PIXELS;
-	const maxPx = text.textSizeMaxPixels ?? DEFAULT_TEXT_SIZE_MAX_PIXELS;
-	const screenOrDefault = [
-		"coalesce",
-		["get", "textSizePixels"],
-		14
-	];
-	const groundPx = [
-		"*",
-		["get", "textSizeMeters"],
-		Math.pow(2, zoom + 9) / WEB_MERCATOR_CIRCUMFERENCE
-	];
-	return [
-		"case",
-		["has", "textSizeMeters"],
-		[
-			"case",
-			["has", "textMaxSizePixels"],
-			[
-				"min",
-				["get", "textMaxSizePixels"],
-				groundPx
-			],
-			[
-				"min",
-				maxPx,
-				[
-					"max",
-					minPx,
-					groundPx
-				]
-			]
-		],
-		screenOrDefault
-	];
-}
-/**
-* Wrap a per-zoom expression builder in the top-level zoom `interpolate` every
-* zoom-driven property here needs. MapLibre only accepts `["zoom"]` as the
-* input of a top-level `step`/`interpolate`, never nested inside a `case`, so
-* the ramp must be outermost and the per-feature branching evaluated at each
-* stop — not the other way round.
-*/
-function interpolateOverZoom(at) {
-	return [
-		"interpolate",
-		["linear"],
-		["zoom"],
-		...Array.from({ length: 25 }, (_, zoom) => [zoom, at(zoom)]).flat()
-	];
-}
-function buildTextSizeExpression(text) {
-	return interpolateOverZoom((zoom) => textSizeAtZoom(text, zoom));
-}
 /**
-* Companion to `buildTextSizeExpression` (ADR-0037): drives `text-opacity` to
-* 0 once a ground-anchored Text graphic's derived on-screen size exceeds its
-* `textMaxSizePixels` threshold, 1 otherwise (including every feature without
-* a threshold, e.g. amplifier labels). Layout properties like `text-size`
-* cannot represent "hidden", so hiding is a paint-property concern; `step`
-* (rather than `interpolate`) is enough since opacity only ever needs to
-* flip at a stop, evaluated at the same per-zoom granularity as the size
-* expression.
-*/
-const TEXT_OPACITY_EXPRESSION = (() => {
-	const opacityAtZoom = (zoom) => {
-		return [
-			"case",
-			[
-				"all",
-				["has", "textSizeMeters"],
-				["has", "textMaxSizePixels"]
-			],
-			[
-				"case",
-				[
-					">",
-					[
-						"*",
-						["get", "textSizeMeters"],
-						Math.pow(2, zoom + 9) / WEB_MERCATOR_CIRCUMFERENCE
-					],
-					["get", "textMaxSizePixels"]
-				],
-				0,
-				1
-			],
-			1
-		];
-	};
-	const stops = Array.from({ length: 25 }, (_, zoom) => zoom);
-	return [
-		"step",
-		["zoom"],
-		opacityAtZoom(0),
-		...stops.slice(1).flatMap((zoom) => [zoom, opacityAtZoom(zoom)])
-	];
-})();
-/**
-* Per-feature icon size, same zoom-stop scheme as `buildTextSizeExpression`:
+* Per-feature icon size, using integer zoom stops:
 * a ground-sized point symbol carries `iconSizeMeters`/`iconOctagonSize` (and
 * optional `iconMinPixels`/`iconMaxPixels`), so the meters→pixels clamp is
 * evaluated inside the style layer at every integer zoom stop and the symbol
@@ -453,84 +472,12 @@ function buildTextHaloColorExpression(text) {
 	];
 }
 /**
-* Per-feature `text-halo-width` value, mirroring
-* `buildTextHaloColorExpression`'s precedence. MapLibre's `text-halo-width`
-* already extends outward from the glyph edge, matching
-* `resolveTextHaloWidth`'s own outward-depth semantics, so the `textHalo`
-* case uses its formula directly (unlike OpenLayers's straddling canvas
-* stroke, which must double it).
-*
-* The width is derived from `textSizeAtZoom` — the same size `text-size`
-* renders at — not from `textSizePixels` alone. A ground-anchored label
-* (ADR-0028) carries only `textSizeMeters`, so reading the pixel size directly
-* would fall back to a constant and pin the halo at one width while the glyphs
-* grew and shrank with zoom: far too heavy on small text, hairline on large.
-* OL and Leaflet already halo off their resolved size; this brings MapLibre in
-* line. The ratio stays well under MapLibre's SDF halo ceiling (~¼ em), so the
-* halo never clips into blocky corners.
-*/
-function buildTextHaloWidthExpression(text) {
-	const fallback = text.strokeColor ? text.strokeWidth ?? 1 : [
-		"case",
-		HAS_TEXT_BACKGROUND,
-		3,
-		0
-	];
-	return interpolateOverZoom((zoom) => [
-		"case",
-		HAS_TEXT_HALO,
-		haloWidthAtZoom(text, zoom),
-		fallback
-	]);
-}
-/**
-* `text-halo-blur` as a fraction of the halo width. MapLibre's halo edge is
-* hard at blur 0, which reads harsher over a vector basemap than the basemap's
-* own labels — OpenFreeMap Liberty, the preview's default style, blurs nearly
-* every one of its halos. Scaled off the width rather than a flat pixel value
-* so the softness stays proportional as the halo grows with zoom.
-*
-* MapLibre-only: OpenLayers canvas strokes have no blur, and Leaflet's stacked
-* `text-shadow` halo would need a blur radius threaded through each shadow.
-* The three engines' halos therefore differ slightly at the edge.
-*/
-const TEXT_HALO_BLUR_RATIO = .25;
-/** The halo's outward depth at one zoom stop; shared by the width and blur builders. */
-function haloWidthAtZoom(text, zoom) {
-	return [
-		"max",
-		1.5,
-		[
-			"/",
-			textSizeAtZoom(text, zoom),
-			8
-		]
-	];
-}
-/**
-* Per-feature `text-halo-blur`, softening only a `textHalo` halo's edge.
-* Everything else stays at 0 so the `textBackground` backdrop and a
-* layer-level text stroke keep the crisp edge they render today.
-*/
-function buildTextHaloBlurExpression(text) {
-	return interpolateOverZoom((zoom) => [
-		"case",
-		HAS_TEXT_HALO,
-		[
-			"*",
-			TEXT_HALO_BLUR_RATIO,
-			haloWidthAtZoom(text, zoom)
-		],
-		0
-	]);
-}
-/**
 * 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) {
+function buildSymbolLayer(symbolId, sourceId, text, sizing = buildTextSizing(text, null)) {
 	const textRotate = text.labelProperty ? [
 		"-",
 		180,
@@ -611,7 +558,7 @@ function buildSymbolLayer(symbolId, sourceId, text) {
 				["literal", ["Open Sans Light"]],
 				["literal", ["Open Sans Regular"]]
 			] : ["Open Sans Regular"],
-			"text-size": buildTextSizeExpression(text),
+			"text-size": sizing.size,
 			"text-rotate": textRotate,
 			"text-anchor": textAnchor,
 			"text-justify": textJustify,
@@ -624,9 +571,9 @@ function buildSymbolLayer(symbolId, sourceId, text) {
 		paint: {
 			"text-color": textColor,
 			"text-halo-color": buildTextHaloColorExpression(text),
-			"text-halo-width": buildTextHaloWidthExpression(text),
-			"text-halo-blur": buildTextHaloBlurExpression(text),
-			"text-opacity": TEXT_OPACITY_EXPRESSION
+			"text-halo-width": sizing.haloWidth,
+			"text-halo-blur": sizing.haloBlur,
+			"text-opacity": sizing.opacity
 		}
 	};
 }
@@ -1019,7 +966,8 @@ var MapLibreAdapter = class extends BaseMapAdapter {
 		const desired = features.flatMap((feature) => featurePaintChannels(feature, handle.style).map((channel) => ({
 			key: `${typeof feature.id}:${JSON.stringify(feature.id)}:${channel}`,
 			featureId: feature.id,
-			channel
+			channel,
+			feature
 		})));
 		const desiredKeys = new Set(desired.map(({ key }) => key));
 		let structureChanged = false;
@@ -1029,11 +977,17 @@ var MapLibreAdapter = class extends BaseMapAdapter {
 			bundle.paintSurfaces.delete(key);
 			structureChanged = true;
 		}
-		for (const { key, featureId, channel } of desired) {
-			if (bundle.paintSurfaces.has(key)) continue;
+		for (const { key, featureId, channel, feature } of desired) {
+			const existing = bundle.paintSurfaces.get(key);
+			const sizingKey = sizingSignature(channel, feature.properties, handle.style);
+			if (existing) {
+				if (sizingKey !== void 0 && sizingKey !== existing.sizingKey) this.updateSurfaceSizing(existing, channel, feature.properties, handle.style, sizingKey);
+				continue;
+			}
 			const layerId = `${bundle.sourceId}-surface-${++bundle.nextPaintSurfaceId}-${channel}`;
+			const textSizing = channel === "text" ? buildTextSizing(handle.style.text, feature.properties) : void 0;
 			const layer = {
-				...this.buildGroupLayer(layerId, bundle.sourceId, channel, handle.style),
+				...this.buildGroupLayer(layerId, bundle.sourceId, channel, handle.style, textSizing, channel === "icon" ? buildIconSizing(feature.properties) : void 0),
 				filter: [
 					"==",
 					"_fid",
@@ -1044,7 +998,9 @@ var MapLibreAdapter = class extends BaseMapAdapter {
 			bundle.paintSurfaces.set(key, {
 				layerId,
 				channel,
-				featureId
+				featureId,
+				textSizing,
+				sizingKey
 			});
 			structureChanged = true;
 		}
@@ -1053,7 +1009,24 @@ var MapLibreAdapter = class extends BaseMapAdapter {
 		bundle.paintOrder = desiredOrder;
 		return structureChanged || orderChanged;
 	}
-	buildGroupLayer(id, sourceId, channel, style) {
+	updateSurfaceSizing(surface, channel, props, style, sizingKey) {
+		surface.sizingKey = sizingKey;
+		if (channel === "icon") {
+			const size = buildIconSizing(props);
+			if (size !== void 0) this.map.setLayoutProperty(surface.layerId, "icon-size", size);
+			return;
+		}
+		const next = buildTextSizing(style.text, props);
+		const previous = surface.textSizing;
+		if (JSON.stringify(previous?.size) !== JSON.stringify(next.size)) this.map.setLayoutProperty(surface.layerId, "text-size", next.size);
+		for (const [key, property] of [
+			["haloWidth", "text-halo-width"],
+			["haloBlur", "text-halo-blur"],
+			["opacity", "text-opacity"]
+		]) if (JSON.stringify(previous?.[key]) !== JSON.stringify(next[key])) this.map.setPaintProperty(surface.layerId, property, next[key]);
+		surface.textSizing = next;
+	}
+	buildGroupLayer(id, sourceId, channel, style, textSizing, iconSizing) {
 		switch (channel) {
 			case "fill": return {
 				id,
@@ -1099,10 +1072,10 @@ var MapLibreAdapter = class extends BaseMapAdapter {
 				filter: buildCirclePointFilter(style),
 				paint: buildCirclePaint(style)
 			};
-			case "icon": return buildIconLayer(id, sourceId);
+			case "icon": return buildIconLayer(id, sourceId, iconSizing);
 			case "text":
 				if (!style?.text) throw new Error("Cannot create a MapLibre text channel without text style");
-				return buildSymbolLayer(id, sourceId, style.text);
+				return buildSymbolLayer(id, sourceId, style.text, textSizing);
 		}
 	}
 	updateGroupBundleSource(bundle) {
@@ -1419,9 +1392,10 @@ var MapLibreAdapter = class extends BaseMapAdapter {
 				if (styleUpdate.text.text || styleUpdate.text.labelProperty) this.map.setLayoutProperty(layerId, "text-field", buildTextFieldExpression(resolvedStyle.text));
 				if (styleUpdate.text.fillColor) this.map.setPaintProperty(layerId, "text-color", resolvedStyle.text.fillColor);
 				if (styleUpdate.text.strokeColor) this.map.setPaintProperty(layerId, "text-halo-color", buildTextHaloColorExpression(resolvedStyle.text));
-				if (styleUpdate.text.strokeWidth !== void 0) {
-					this.map.setPaintProperty(layerId, "text-halo-width", buildTextHaloWidthExpression(resolvedStyle.text));
-					this.map.setPaintProperty(layerId, "text-halo-blur", buildTextHaloBlurExpression(resolvedStyle.text));
+				if (featureId === void 0) {
+					const sizing = buildTextSizing(resolvedStyle.text, null);
+					this.map.setPaintProperty(layerId, "text-halo-width", sizing.haloWidth);
+					this.map.setPaintProperty(layerId, "text-halo-blur", sizing.haloBlur);
 				}
 				break;
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbat-mapper/tactical-draw-adapter-maplibre",
-  "version": "0.3.20",
+  "version": "0.3.22",
   "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.24.0",
-    "@orbat-mapper/tactical-draw": "^0.8.0"
+    "@orbat-mapper/control-measures": "^0.26.0",
+    "@orbat-mapper/tactical-draw": "^0.8.2"
   },
   "peerDependencies": {
     "maplibre-gl": ">=5.8.0 <7.0.0"