@orbat-mapper/tactical-draw-adapter-maplibre 0.2.0-alpha.11 → 0.2.0-alpha.13

package/dist/index.d.mts

@@ -25,12 +25,34 @@ declare class MapLibreAdapter extends BaseMapAdapter<MapLibreLayerHandle, MapLib
   private map;
   private readonly viewChangeMode;
   private readonly pendingIconImages;
+  private readonly pendingLayerUpdates;
+  private readonly deferredLayerRemovals;
   readonly scalesGroundPointSymbolsNatively = true;
   constructor(map: maplibregl.Map, options?: MapLibreAdapterOptions);
   private toContinuousLng;
   protected createLayer(layerId: LayerId, style?: StyleOptions): MapLibreLayerHandle;
   protected destroyLayer(handle: MapLibreLayerHandle): void;
   protected applyFeatureOps(layerId: LayerId, ops: FeatureOps): void;
+  private updateSourceData;
+  private flushDeferredLayerRemoval;
+  deferLayerRemovalUntilLayerUpdate(layerId: LayerId, updatedLayerId: LayerId): void;
+  /**
+   * Promote a source feature for MapLibre: stamp `_fid` (so data-driven paint
+   * and picks can key on the caller's feature id) and, for a hatch-patterned
+   * Polygon, `_fillPatternImageId` (registering the tile image on demand). At
+   * most one object spread — a feature needing neither passes through
+   * untouched.
+   */
+  private promoteFeature;
+  /**
+   * Resolve a hatch-patterned Polygon's `style.fillPattern`/`fillColor` to its
+   * hatch-tile image id, registering the image on demand. Returns `undefined`
+   * for features without a hatch pattern, so `fillPatternImageId` stays the
+   * single source of truth for the id baked into `_fillPatternImageId`.
+   */
+  private resolveFillPatternImage;
+  /** Register a hatch-tile image once per (color, pattern) pair, keyed by `fillPatternImageId`. */
+  private ensureFillPatternImage;
   protected applyIconResources(resources: readonly IconResource[]): void;
   protected removeIconResource(id: string): void;
   protected attachNativeEvent(type: "click" | "pointermove" | "dblclick", onEvent: (lonLat: Position, pixel: PixelCoordinate, originalEvent: unknown) => void): NativeEventEntry<MapLibreEventToken>;

package/dist/index.mjs

@@ -1,6 +1,14 @@
 import { project, unproject } from "@orbat-mapper/control-measures";
-import { BaseMapAdapter, DEFAULT_TEXT_SIZE_MAX_PIXELS, DEFAULT_TEXT_SIZE_MIN_PIXELS, PointerCallbackHub, TOUCH_HIT_TOLERANCE_PX, bindAbortable, nearestWorldCopyLng, pickHitTolerance, tryControlMeasureIdFromFeature } from "@orbat-mapper/tactical-draw";
+import { BaseMapAdapter, DEFAULT_TEXT_SIZE_MAX_PIXELS, DEFAULT_TEXT_SIZE_MIN_PIXELS, HATCH_PATTERNS, PointerCallbackHub, TOUCH_HIT_TOLERANCE_PX, bindAbortable, fillPatternImageId, makeFillPatternImage, nearestWorldCopyLng, pickHitTolerance, tryControlMeasureIdFromFeature } from "@orbat-mapper/tactical-draw";
 //#region src/ml-adapter.ts
+/** Feature property key for the resolved hatch-pattern image id (see `promoteFeature`). */
+const FILL_PATTERN_IMAGE_ID_PROPERTY = "_fillPatternImageId";
+function isHatchPattern(value) {
+	return HATCH_PATTERNS.includes(value);
+}
+function isPromiseLike(value) {
+	return (typeof value === "object" || typeof value === "function") && value !== null && typeof value.then === "function";
+}
 function emptyFC() {
 	return {
 		type: "FeatureCollection",
@@ -306,6 +314,60 @@ function buildFillPaint(style) {
 		"fill-opacity": 1
 	};
 }
+/**
+* `properties.style.fillPattern` read as a GL expression, defaulting to
+* `"solid"`. `fillPattern` is a per-feature-only field (ADR-0007) — unlike
+* `fillColor`/`strokeColor` it has no layer-level `StyleOptions` default, so
+* this expression takes no `style` argument.
+*/
+function fillPatternField() {
+	return [
+		"coalesce",
+		[
+			"get",
+			"fillPattern",
+			[
+				"coalesce",
+				["get", "style"],
+				["literal", {}]
+			]
+		],
+		"solid"
+	];
+}
+/**
+* Filter for one of the two mutually-exclusive Polygon fill layers, keyed on
+* whether the feature's resolved `fillPattern` is a hatch pattern. The solid
+* `-fill` layer takes `hatched: false` (every Polygon except hatched ones);
+* the `-fill-pattern` layer takes `hatched: true`. Split because MapLibre's
+* `fill-color` and `fill-pattern` paints cannot coexist on one fill layer.
+*/
+function buildFillFilter(hatched) {
+	const isHatched = [
+		"in",
+		fillPatternField(),
+		["literal", [...HATCH_PATTERNS]]
+	];
+	return [
+		"all",
+		[
+			"==",
+			["geometry-type"],
+			"Polygon"
+		],
+		hatched ? isHatched : ["!", isHatched]
+	];
+}
+/**
+* Paint for the hatch-pattern fill layer. The image id is baked per-feature
+* into `properties._fillPatternImageId` (see `promoteFeature`), so the paint
+* is a plain `["get", ...]` rather than re-deriving the id as a GL expression,
+* keeping `fillPatternImageId` the single source of truth for the id string.
+*/
+const FILL_PATTERN_PAINT = {
+	"fill-pattern": ["get", FILL_PATTERN_IMAGE_ID_PROPERTY],
+	"fill-opacity": 1
+};
 function buildLinePaint(style) {
 	const colorDefault = style?.strokeColor ?? "#000";
 	const widthDefault = style?.strokeWidth ?? 2;
@@ -340,6 +402,8 @@ var MapLibreAdapter = class extends BaseMapAdapter {
 	map;
 	viewChangeMode;
 	pendingIconImages = /* @__PURE__ */ new Set();
+	pendingLayerUpdates = /* @__PURE__ */ new Map();
+	deferredLayerRemovals = /* @__PURE__ */ new Map();
 	scalesGroundPointSymbolsNatively = true;
 	constructor(map, options = {}) {
 		super();
@@ -362,14 +426,19 @@ var MapLibreAdapter = class extends BaseMapAdapter {
 			id: fillId,
 			type: "fill",
 			source: sourceId,
-			filter: [
-				"==",
-				"$type",
-				"Polygon"
-			],
+			filter: buildFillFilter(false),
 			paint: buildFillPaint(style)
 		});
 		mlLayerIds.push(fillId);
+		const fillPatternId = `${layerId}-fill-pattern`;
+		this.map.addLayer({
+			id: fillPatternId,
+			type: "fill",
+			source: sourceId,
+			filter: buildFillFilter(true),
+			paint: FILL_PATTERN_PAINT
+		});
+		mlLayerIds.push(fillPatternId);
 		const lineId = `${layerId}-line`;
 		this.map.addLayer({
 			id: lineId,
@@ -419,25 +488,109 @@ var MapLibreAdapter = class extends BaseMapAdapter {
 		};
 	}
 	destroyLayer(handle) {
+		for (const [layerId, layerHandle] of this.layers) {
+			if (layerHandle !== handle) continue;
+			this.pendingLayerUpdates.get(layerId)?.cancel();
+			this.pendingLayerUpdates.delete(layerId);
+			this.deferredLayerRemovals.delete(layerId);
+			break;
+		}
 		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 deferred = this.deferredLayerRemovals.get(layerId);
+		const isPureRemoval = ops.adds.length === 0 && ops.updates.length === 0 && (ops.removes?.length ?? 0) > 0;
+		if (deferred && isPureRemoval) {
+			deferred.after.then(() => this.flushDeferredLayerRemoval(layerId, deferred), () => this.flushDeferredLayerRemoval(layerId, deferred));
+			return;
+		}
+		if (deferred) this.deferredLayerRemovals.delete(layerId);
+		this.updateSourceData(layerId, ops.full);
+	}
+	updateSourceData(layerId, features) {
 		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,
+		const promotedFeatures = features.map((f) => this.promoteFeature(f));
+		let resolveSourceData;
+		const sourceDataCompletion = new Promise((resolve) => {
+			resolveSourceData = resolve;
+		});
+		const onSourceData = (event) => {
+			if (event.sourceDataType !== "content") return;
+			source.off("data", onSourceData);
+			resolveSourceData();
+		};
+		source.on("data", onSourceData);
+		const result = source.setData({
+			type: "FeatureCollection",
+			features: promotedFeatures
+		}, true);
+		const supportsCompletionPromise = isPromiseLike(result);
+		if (supportsCompletionPromise) source.off("data", onSourceData);
+		const completion = supportsCompletionPromise ? Promise.resolve(result) : sourceDataCompletion;
+		const pending = {
+			completion,
+			cancel() {
+				source.off("data", onSourceData);
+			}
+		};
+		this.pendingLayerUpdates.set(layerId, pending);
+		completion.catch(() => {});
+	}
+	flushDeferredLayerRemoval(layerId, deferred) {
+		if (this.deferredLayerRemovals.get(layerId) !== deferred) return;
+		this.deferredLayerRemovals.delete(layerId);
+		this.updateSourceData(layerId, this.getLayerFeatures(layerId));
+	}
+	deferLayerRemovalUntilLayerUpdate(layerId, updatedLayerId) {
+		const pending = this.pendingLayerUpdates.get(updatedLayerId);
+		if (!pending || !this.layers.has(layerId)) return;
+		this.deferredLayerRemovals.set(layerId, { after: pending.completion });
+	}
+	/**
+	* Promote a source feature for MapLibre: stamp `_fid` (so data-driven paint
+	* and picks can key on the caller's feature id) and, for a hatch-patterned
+	* Polygon, `_fillPatternImageId` (registering the tile image on demand). At
+	* most one object spread — a feature needing neither passes through
+	* untouched.
+	*/
+	promoteFeature(feature) {
+		const extra = {};
+		if (feature.id !== void 0) extra._fid = feature.id;
+		const imageId = this.resolveFillPatternImage(feature);
+		if (imageId !== void 0) extra[FILL_PATTERN_IMAGE_ID_PROPERTY] = imageId;
+		if (Object.keys(extra).length === 0) return feature;
+		return {
+			...feature,
 			properties: {
-				...f.properties ?? {},
-				_fid: f.id
+				...feature.properties ?? {},
+				...extra
 			}
-		} : f);
-		source.setData({
-			type: "FeatureCollection",
-			features
-		});
+		};
+	}
+	/**
+	* Resolve a hatch-patterned Polygon's `style.fillPattern`/`fillColor` to its
+	* hatch-tile image id, registering the image on demand. Returns `undefined`
+	* for features without a hatch pattern, so `fillPatternImageId` stays the
+	* single source of truth for the id baked into `_fillPatternImageId`.
+	*/
+	resolveFillPatternImage(feature) {
+		const props = feature.properties;
+		const pattern = props?.style?.fillPattern;
+		if (!isHatchPattern(pattern)) return void 0;
+		const color = props?.fillColor ?? props?.style?.fillColor ?? "rgba(0,0,0,0)";
+		const imageId = fillPatternImageId(color, pattern);
+		this.ensureFillPatternImage(imageId, color, pattern);
+		return imageId;
+	}
+	/** Register a hatch-tile image once per (color, pattern) pair, keyed by `fillPatternImageId`. */
+	ensureFillPatternImage(imageId, color, pattern) {
+		if (this.map.hasImage(imageId)) return;
+		const image = makeFillPatternImage(color, pattern, 2);
+		this.map.addImage(imageId, image, { pixelRatio: 2 });
 	}
 	applyIconResources(resources) {
 		if (typeof Image === "undefined") return;
@@ -611,8 +764,10 @@ var MapLibreAdapter = class extends BaseMapAdapter {
 			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 (type === "fill") {
+				if (mlId.endsWith("-fill-pattern")) continue;
+				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"]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbat-mapper/tactical-draw-adapter-maplibre",
-  "version": "0.2.0-alpha.11",
+  "version": "0.2.0-alpha.13",
   "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.16",
-    "@orbat-mapper/tactical-draw": "^0.2.0-alpha.26"
+    "@orbat-mapper/control-measures": "^0.2.0-alpha.20",
+    "@orbat-mapper/tactical-draw": "^0.2.0-alpha.28"
   },
   "peerDependencies": {
     "maplibre-gl": ">=4.0.0 <6.0.0"