@orbat-mapper/tactical-draw-adapter-maplibre 0.2.0-alpha.22 → 0.2.0-alpha.24

package/dist/index.d.mts

@@ -17,6 +17,10 @@ interface MapLibreGroupBundle {
   readonly sourceId: string;
   readonly layerIds: Map<PaintChannel, string>;
   features: readonly Feature[];
+  /** Features most recently submitted to the native source, after MapLibre-specific promotion. */
+  sourceFeatures: readonly Feature[];
+  /** Whether the native source has received its first complete dataset. */
+  sourceInitialized: boolean;
   /** Unset while the stored value describes older features than `features` holds. */
   featureSignature: string | undefined;
   /**

package/dist/index.mjs

@@ -28,6 +28,49 @@ function sameOrder(a, b) {
 	return true;
 }
 /**
+* Replace the contents of shared-id features while adding/removing ids that
+* entered or left a stable group bundle. Remove stale keys explicitly instead
+* of combining `removeAllProperties` with `addOrUpdateProperties`: MapLibre's
+* tile-index diff treats the former as exclusive and otherwise drops the
+* replacement properties, including the promoted feature id.
+*/
+function buildGeoJSONSourceDiff(previousFeatures, nextFeatures) {
+	const previousById = new Map(previousFeatures.map((feature) => [feature.id, feature]));
+	const nextById = new Map(nextFeatures.map((feature) => [feature.id, feature]));
+	const remove = previousFeatures.filter((feature) => !nextById.has(feature.id)).map((feature) => feature.id);
+	const add = [];
+	const update = [];
+	for (const feature of nextFeatures) {
+		const previous = previousById.get(feature.id);
+		if (!previous) {
+			add.push(feature);
+			continue;
+		}
+		if (feature.geometry === null) {
+			remove.push(feature.id);
+			add.push(feature);
+			continue;
+		}
+		const previousProperties = previous.properties ?? {};
+		const nextProperties = feature.properties ?? {};
+		const removeProperties = Object.keys(previousProperties).filter((key) => !Object.hasOwn(nextProperties, key));
+		update.push({
+			id: feature.id,
+			newGeometry: feature.geometry,
+			...removeProperties.length > 0 ? { removeProperties } : {},
+			addOrUpdateProperties: Object.entries(nextProperties).map(([key, value]) => ({
+				key,
+				value
+			}))
+		});
+	}
+	return {
+		...remove.length > 0 ? { remove } : {},
+		...add.length > 0 ? { add } : {},
+		...update.length > 0 ? { update } : {}
+	};
+}
+/**
 * Find the largest subset of bundles whose relative order already matches the
 * desired stack. Reorders then move only the remaining bundles.
 */
@@ -189,7 +232,7 @@ const WEB_MERCATOR_CIRCUMFERENCE = 40075016.686;
 * matching `getResolution`); the linear ramp between stops approximates the
 * exponential exactly closely enough at 1-zoom granularity.
 */
-function buildTextSizeExpression(text) {
+function textSizeAtZoom(text, zoom) {
 	const minPx = text.textSizeMinPixels ?? DEFAULT_TEXT_SIZE_MIN_PIXELS;
 	const maxPx = text.textSizeMaxPixels ?? DEFAULT_TEXT_SIZE_MAX_PIXELS;
 	const screenOrDefault = [
@@ -197,43 +240,53 @@ function buildTextSizeExpression(text) {
 		["get", "textSizePixels"],
 		14
 	];
-	const sizeAtZoom = (zoom) => {
-		const groundPx = [
-			"*",
-			["get", "textSizeMeters"],
-			Math.pow(2, zoom + 9) / WEB_MERCATOR_CIRCUMFERENCE
-		];
-		return [
+	const groundPx = [
+		"*",
+		["get", "textSizeMeters"],
+		Math.pow(2, zoom + 9) / WEB_MERCATOR_CIRCUMFERENCE
+	];
+	return [
+		"case",
+		["has", "textSizeMeters"],
+		[
 			"case",
-			["has", "textSizeMeters"],
+			["has", "textMaxSizePixels"],
 			[
-				"case",
-				["has", "textMaxSizePixels"],
+				"min",
+				["get", "textMaxSizePixels"],
+				groundPx
+			],
+			[
+				"min",
+				maxPx,
 				[
-					"min",
-					["get", "textMaxSizePixels"],
+					"max",
+					minPx,
 					groundPx
-				],
-				[
-					"min",
-					maxPx,
-					[
-						"max",
-						minPx,
-						groundPx
-					]
 				]
-			],
-			screenOrDefault
-		];
-	};
+			]
+		],
+		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, sizeAtZoom(zoom)]).flat()
+		...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
@@ -398,33 +451,72 @@ function buildTextHaloColorExpression(text) {
 * `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) {
-	return [
+	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,
 		[
-			"max",
-			1.5,
-			[
-				"/",
-				[
-					"coalesce",
-					["get", "textSizePixels"],
-					24
-				],
-				8
-			]
-		],
-		text.strokeColor ? text.strokeWidth ?? 1 : [
-			"case",
-			HAS_TEXT_BACKGROUND,
-			3,
-			0
+			"/",
+			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
@@ -525,6 +617,7 @@ function buildSymbolLayer(symbolId, sourceId, text) {
 			"text-color": textColor,
 			"text-halo-color": buildTextHaloColorExpression(text),
 			"text-halo-width": buildTextHaloWidthExpression(text),
+			"text-halo-blur": buildTextHaloBlurExpression(text),
 			"text-opacity": TEXT_OPACITY_EXPRESSION
 		}
 	};
@@ -831,6 +924,8 @@ var MapLibreAdapter = class extends BaseMapAdapter {
 			sourceId,
 			layerIds: /* @__PURE__ */ new Map(),
 			features: [],
+			sourceFeatures: [],
+			sourceInitialized: false,
 			featureSignature: "[]",
 			requiredIconIds: /* @__PURE__ */ new Set()
 		};
@@ -924,10 +1019,12 @@ var MapLibreAdapter = class extends BaseMapAdapter {
 		const source = this.map.getSource(bundle.sourceId);
 		if (!source) return;
 		const features = [...bundle.requiredIconIds].every((id) => this.map.hasImage(id)) ? bundle.features.map((feature) => this.promoteFeature(feature)) : [];
-		const result = source.setData({
+		const result = bundle.sourceInitialized && typeof source.updateData === "function" ? source.updateData(buildGeoJSONSourceDiff(bundle.sourceFeatures, features), true) : source.setData({
 			type: "FeatureCollection",
 			features
 		}, true);
+		bundle.sourceFeatures = features;
+		bundle.sourceInitialized = true;
 		if (isPromiseLike(result)) Promise.resolve(result).catch(() => {});
 	}
 	orderGroupBundles(handle, previousGroupIds, desiredGroupIds, forcedGroupIds) {
@@ -1220,7 +1317,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));
+				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));
+				}
 				break;
 		}
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbat-mapper/tactical-draw-adapter-maplibre",
-  "version": "0.2.0-alpha.22",
+  "version": "0.2.0-alpha.24",
   "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.2.0-alpha.26",
-    "@orbat-mapper/tactical-draw": "^0.2.0-alpha.38"
+    "@orbat-mapper/control-measures": "^0.2.0-alpha.28",
+    "@orbat-mapper/tactical-draw": "^0.2.0-alpha.39"
   },
   "peerDependencies": {
     "maplibre-gl": ">=5.8.0 <6.0.0"