@orbat-mapper/tactical-draw 0.2.0-alpha.27 → 0.2.0-alpha.28

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { AmplifierPlacement, AmplifierPlacements, ControlMeasure, ControlMeasureKind, ControlMeasureRender, ControlMeasureStyle, TextAmplifiers } from "@orbat-mapper/control-measures";
+import { AmplifierPlacement, AmplifierPlacements, ControlMeasure, ControlMeasureKind, ControlMeasureRender, ControlMeasureStyle, FillPattern, TextAmplifiers } from "@orbat-mapper/control-measures";
 import { Feature, Position } from "geojson";
 
 //#region src/gestures/types.d.ts
@@ -40,6 +40,51 @@ interface EditPointerDriver {
   dispose(): void;
 }
 //#endregion
+//#region src/fill-pattern.d.ts
+/**
+ * Shared hatch fill-pattern tiles for area control-measure fills (ADR-0035
+ * `FillPattern`, excluding `"solid"` which every adapter already renders as a
+ * flat color). Both the MapLibre adapter (raster `addImage` pattern) and the
+ * OpenLayers adapter (canvas `Pattern` fill) need the *same* diagonal-hachure
+ * texture, so it is rasterized once here in pure math — no `HTMLCanvasElement`
+ * — so it works in adapter code and in jsdom/node tests alike.
+ */
+type HatchPattern = Exclude<FillPattern, "solid">;
+/**
+ * Every non-solid `FillPattern` as a runtime list — the value-level companion
+ * to {@link HatchPattern}, so adapters can test membership and build filter
+ * expressions without re-spelling the pattern vocabulary.
+ */
+declare const HATCH_PATTERNS: readonly HatchPattern[];
+/**
+ * Stable id for a rasterized tile, keyed by pattern and color. Adapters use
+ * this as the image-registry key (MapLibre `addImage` id, OpenLayers pattern
+ * cache key) so the same color+pattern never gets rasterized twice. Color is
+ * lowercased so `"#FF0000"` and `"#ff0000"` share one texture.
+ */
+declare function fillPatternImageId(color: string, pattern: HatchPattern): string;
+/**
+ * Tile edge length in device pixels for a given `pixelRatio`. Must be a power
+ * of two — MapLibre requires POT dimensions for seamless WebGL texture wrap —
+ * and scales linearly with `pixelRatio` for the ratios that matter in
+ * practice (1x/2x displays: 32 -> 64, both already POT). Non-POT products
+ * (e.g. a 3x ratio, 32*3=96) round up to the next POT rather than losing the
+ * power-of-two guarantee.
+ */
+declare function fillPatternImageDimension(pixelRatio: number): number;
+/**
+ * Rasterize one seamless hatch tile as a straight RGBA pixel buffer — no
+ * canvas involved, so this runs identically in a browser adapter and in
+ * jsdom/node tests. Diagonal lines are snapped to slope ±1 (45°) so the
+ * mod-based coverage math in {@link lineCoverage} tiles exactly; `"cross"`
+ * unions both diagonals via `Math.max` coverage.
+ */
+declare function makeFillPatternImage(color: string, pattern: HatchPattern, pixelRatio?: number): {
+  width: number;
+  height: number;
+  data: Uint8ClampedArray;
+};
+//#endregion
 //#region src/map-adapter.d.ts
 type PixelCoordinate = [number, number];
 type MapCursor = "" | "default" | "crosshair" | "grab" | "grabbing" | "pointer";
@@ -102,6 +147,14 @@ interface HandleStyle {
   strokeWidth?: number;
   strokeDash?: readonly number[];
   fillColor?: string;
+  /**
+   * How `fillColor` paints a filled part's interior. Absent or `"solid"` is
+   * today's flat fill; `"hachure"`/`"cross"` request the shared hatch texture
+   * ({@link makeFillPatternImage}). Alpha rides in `fillColor` — there is no
+   * separate opacity field. Adapters that cannot rasterize a pattern degrade
+   * to solid. Per-feature only: layer-level `StyleOptions` has no equivalent.
+   */
+  fillPattern?: "solid" | HatchPattern;
   pointRadius?: number;
 }
 type LayerId = string;
@@ -1910,4 +1963,4 @@ declare function nearestWorldCopyLng(lng: number, refLng: number): number;
 /** `nearestWorldCopyLng` applied to a lon/lat position. */
 declare function nearestWorldCopyPosition(position: Position, refLng: number): Position;
 //#endregion
-export { BaseMapAdapter, type CombinedAbort, DEFAULT_LABEL_SIZE_PIXELS, DEFAULT_TEXT_SIZE_MAX_PIXELS, DEFAULT_TEXT_SIZE_MIN_PIXELS, type DrawMeasureDraft, type DrawOptions, type DrawPointSymbolDraft, type DrawSession, type EditChangeEvent, type EditManyOptions, type EditMode, type EditOptions, type EditPointerDriver, type EditSession, type FeatureOps, type Graphic, type GraphicEditChangeEvent, type GraphicEditSession, type GraphicGeometrySnappingOptions, type GraphicRender, type GraphicSnapshot, type GuideStyle, type HandleStyle, type IconResource, type InteractionHit, type InteractionStyle, type LayerId, type MapAdapter, type MapCursor, type MapEvent, type MapEventHandler, type NativeEventEntry, type PickEvent, type PickHandler, type PickOptions, type PixelCoordinate, type PointSymbol, type PointSymbolAnchor, type PointSymbolCapability, PointSymbolCapabilityRequiredError, type PointSymbolColors, type PointSymbolFootprint, type PointSymbolGraphicModifiers, type PointSymbolRender, type PointSymbolSize, type PointSymbolStyle, type PointerCallback, PointerCallbackHub, type PointerEventInfo, type SessionChangeSource, type SessionHistory, type SessionHistoryState, type SettleReason, type SizeAnchor, type SnapCandidate, type SnapCandidateProvider, type SnapCandidateRequest, type SnapInteraction, type SnapResult, type SnappingOptions, type StyleOptions, TOUCH_HIT_TOLERANCE_PX, TacticalDraw, TacticalDrawAbortError, type TacticalDrawAbortReason, TacticalDrawDestroyedError, type TacticalDrawLayerOptions, type TacticalDrawOptions, type TextStyleOptions, type ToPixel, type TransformBox, type TransformChangeEvent, type TransformSession, bindAbortable, clonePointSymbol, coerceHandleStyle, combineWithHostSignal, effectivePointSymbolPixelSize, getSizeAnchor, hitTestFeature, hitTestIconFeature, ignoreAbort, isPointSymbol, isTacticalDrawAbortError, nearestWorldCopyLng, nearestWorldCopyPosition, pickHitTolerance, pointSymbolFootprint, resizePointSymbolSize, resolveGroundTextSizePixels, tryControlMeasureIdFromFeature };
+export { BaseMapAdapter, type CombinedAbort, DEFAULT_LABEL_SIZE_PIXELS, DEFAULT_TEXT_SIZE_MAX_PIXELS, DEFAULT_TEXT_SIZE_MIN_PIXELS, type DrawMeasureDraft, type DrawOptions, type DrawPointSymbolDraft, type DrawSession, type EditChangeEvent, type EditManyOptions, type EditMode, type EditOptions, type EditPointerDriver, type EditSession, type FeatureOps, type Graphic, type GraphicEditChangeEvent, type GraphicEditSession, type GraphicGeometrySnappingOptions, type GraphicRender, type GraphicSnapshot, type GuideStyle, HATCH_PATTERNS, type HandleStyle, type HatchPattern, type IconResource, type InteractionHit, type InteractionStyle, type LayerId, type MapAdapter, type MapCursor, type MapEvent, type MapEventHandler, type NativeEventEntry, type PickEvent, type PickHandler, type PickOptions, type PixelCoordinate, type PointSymbol, type PointSymbolAnchor, type PointSymbolCapability, PointSymbolCapabilityRequiredError, type PointSymbolColors, type PointSymbolFootprint, type PointSymbolGraphicModifiers, type PointSymbolRender, type PointSymbolSize, type PointSymbolStyle, type PointerCallback, PointerCallbackHub, type PointerEventInfo, type SessionChangeSource, type SessionHistory, type SessionHistoryState, type SettleReason, type SizeAnchor, type SnapCandidate, type SnapCandidateProvider, type SnapCandidateRequest, type SnapInteraction, type SnapResult, type SnappingOptions, type StyleOptions, TOUCH_HIT_TOLERANCE_PX, TacticalDraw, TacticalDrawAbortError, type TacticalDrawAbortReason, TacticalDrawDestroyedError, type TacticalDrawLayerOptions, type TacticalDrawOptions, type TextStyleOptions, type ToPixel, type TransformBox, type TransformChangeEvent, type TransformSession, bindAbortable, clonePointSymbol, coerceHandleStyle, combineWithHostSignal, effectivePointSymbolPixelSize, fillPatternImageDimension, fillPatternImageId, getSizeAnchor, hitTestFeature, hitTestIconFeature, ignoreAbort, isPointSymbol, isTacticalDrawAbortError, makeFillPatternImage, nearestWorldCopyLng, nearestWorldCopyPosition, pickHitTolerance, pointSymbolFootprint, resizePointSymbolSize, resolveGroundTextSizePixels, tryControlMeasureIdFromFeature };

package/dist/index.mjs

@@ -6093,6 +6093,141 @@ function resolveSlot(adapter, supplied, owned) {
 	return id;
 }
 //#endregion
+//#region src/fill-pattern.ts
+/**
+* Every non-solid `FillPattern` as a runtime list — the value-level companion
+* to {@link HatchPattern}, so adapters can test membership and build filter
+* expressions without re-spelling the pattern vocabulary.
+*/
+const HATCH_PATTERNS = ["hachure", "cross"];
+/** Tile edge length, CSS px, before `pixelRatio` scaling. Kept a power of two. */
+const BASE_TILE_SIZE = 32;
+/** Line spacing as a fraction of the tile edge — 4 repeats per tile. */
+const SPACING_DIVISOR = 4;
+/**
+* Stable id for a rasterized tile, keyed by pattern and color. Adapters use
+* this as the image-registry key (MapLibre `addImage` id, OpenLayers pattern
+* cache key) so the same color+pattern never gets rasterized twice. Color is
+* lowercased so `"#FF0000"` and `"#ff0000"` share one texture.
+*/
+function fillPatternImageId(color, pattern) {
+	return `td-hatch-${pattern}-${color.trim().toLowerCase()}`;
+}
+/**
+* Tile edge length in device pixels for a given `pixelRatio`. Must be a power
+* of two — MapLibre requires POT dimensions for seamless WebGL texture wrap —
+* and scales linearly with `pixelRatio` for the ratios that matter in
+* practice (1x/2x displays: 32 -> 64, both already POT). Non-POT products
+* (e.g. a 3x ratio, 32*3=96) round up to the next POT rather than losing the
+* power-of-two guarantee.
+*/
+function fillPatternImageDimension(pixelRatio) {
+	const target = BASE_TILE_SIZE * Math.max(1, Math.round(pixelRatio));
+	return 2 ** Math.ceil(Math.log2(target));
+}
+/**
+* Parse a hex (`#rgb`, `#rrggbb`, `#rrggbbaa`) or `rgb()`/`rgba()` color
+* string into normalized channels, alpha in `[0, 1]`. Unparseable input falls
+* back to opaque black rather than throwing, since a mis-themed fill should
+* still render *something*.
+*/
+function parseColor(color) {
+	const s = color.trim();
+	if (s.startsWith("#")) {
+		const hex = s.slice(1);
+		if (hex.length === 3) return {
+			r: parseInt(hex[0] + hex[0], 16),
+			g: parseInt(hex[1] + hex[1], 16),
+			b: parseInt(hex[2] + hex[2], 16),
+			a: 1
+		};
+		if (hex.length === 6) return {
+			r: parseInt(hex.slice(0, 2), 16),
+			g: parseInt(hex.slice(2, 4), 16),
+			b: parseInt(hex.slice(4, 6), 16),
+			a: 1
+		};
+		if (hex.length === 8) return {
+			r: parseInt(hex.slice(0, 2), 16),
+			g: parseInt(hex.slice(2, 4), 16),
+			b: parseInt(hex.slice(4, 6), 16),
+			a: parseInt(hex.slice(6, 8), 16) / 255
+		};
+	}
+	const fn = s.match(/^rgba?\(([^)]+)\)$/i);
+	if (fn) {
+		const parts = fn[1].split(",").map((p) => p.trim());
+		const r = Number.parseFloat(parts[0] ?? "0");
+		const g = Number.parseFloat(parts[1] ?? "0");
+		const b = Number.parseFloat(parts[2] ?? "0");
+		const a = parts.length > 3 ? Number.parseFloat(parts[3]) : 1;
+		return {
+			r,
+			g,
+			b,
+			a: Number.isFinite(a) ? a : 1
+		};
+	}
+	return {
+		r: 0,
+		g: 0,
+		b: 0,
+		a: 1
+	};
+}
+/** `v mod m`, folded into `[-m/2, m/2)`. Used to find distance to the nearest line in a periodic family. */
+function centeredMod(v, m) {
+	const wrapped = (v % m + m) % m;
+	return wrapped >= m / 2 ? wrapped - m : wrapped;
+}
+const SQRT2 = Math.SQRT2;
+/**
+* Coverage in `[0, 1]` of one diagonal line family (slope +1 or -1, both
+* period `spacing`) at pixel center `(x, y)`, antialiased over a ~1 device-px
+* band. `axis` selects `y - x` (the "/" hachure) or `y + x` (its mirror, added
+* for "cross"). Because `spacing` divides the tile dimension evenly, shifting
+* `x` or `y` by a whole tile is a whole number of `spacing` periods, so the
+* mod-distance — and therefore the coverage — is identical at the tile edges
+* as at their wrapped continuation. That periodicity is what makes the tile
+* seamless.
+*/
+function lineCoverage(x, y, spacing, lineWidth, axis) {
+	const t = axis === "/" ? y - x : y + x;
+	const perpDist = Math.abs(centeredMod(t, spacing)) / SQRT2;
+	const halfWidth = lineWidth / 2;
+	return Math.min(1, Math.max(0, halfWidth + .5 - perpDist));
+}
+/**
+* Rasterize one seamless hatch tile as a straight RGBA pixel buffer — no
+* canvas involved, so this runs identically in a browser adapter and in
+* jsdom/node tests. Diagonal lines are snapped to slope ±1 (45°) so the
+* mod-based coverage math in {@link lineCoverage} tiles exactly; `"cross"`
+* unions both diagonals via `Math.max` coverage.
+*/
+function makeFillPatternImage(color, pattern, pixelRatio = 1) {
+	const size = fillPatternImageDimension(pixelRatio);
+	const spacing = size / SPACING_DIVISOR;
+	const lineWidth = Math.max(1, Math.round(pixelRatio));
+	const { r, g, b, a } = parseColor(color);
+	const data = new Uint8ClampedArray(size * size * 4);
+	for (let y = 0; y < size; y++) for (let x = 0; x < size; x++) {
+		const cx = x + .5;
+		const cy = y + .5;
+		let coverage = lineCoverage(cx, cy, spacing, lineWidth, "/");
+		if (pattern === "cross") coverage = Math.max(coverage, lineCoverage(cx, cy, spacing, lineWidth, "\\"));
+		const i = (y * size + x) * 4;
+		data[i] = r;
+		data[i + 1] = g;
+		data[i + 2] = b;
+		data[i + 3] = Math.round(255 * a * coverage);
+	}
+	return {
+		width: size,
+		height: size,
+		data
+	};
+}
+//#endregion
 //#region src/world-wrap.ts
 /**
 * Shift `lng` by whole world widths (360°) onto the copy nearest `refLng`.
@@ -6111,4 +6246,4 @@ function nearestWorldCopyPosition(position, refLng) {
 	return [nearestWorldCopyLng(position[0], refLng), ...position.slice(1)];
 }
 //#endregion
-export { BaseMapAdapter, DEFAULT_LABEL_SIZE_PIXELS, DEFAULT_TEXT_SIZE_MAX_PIXELS, DEFAULT_TEXT_SIZE_MIN_PIXELS, PointSymbolCapabilityRequiredError, PointerCallbackHub, TOUCH_HIT_TOLERANCE_PX, TacticalDraw, TacticalDrawAbortError, TacticalDrawDestroyedError, bindAbortable, clonePointSymbol, coerceHandleStyle, combineWithHostSignal, effectivePointSymbolPixelSize, getSizeAnchor, hitTestFeature, hitTestIconFeature, ignoreAbort, isPointSymbol, isTacticalDrawAbortError, nearestWorldCopyLng, nearestWorldCopyPosition, pickHitTolerance, pointSymbolFootprint, resizePointSymbolSize, resolveGroundTextSizePixels, tryControlMeasureIdFromFeature };
+export { BaseMapAdapter, DEFAULT_LABEL_SIZE_PIXELS, DEFAULT_TEXT_SIZE_MAX_PIXELS, DEFAULT_TEXT_SIZE_MIN_PIXELS, HATCH_PATTERNS, PointSymbolCapabilityRequiredError, PointerCallbackHub, TOUCH_HIT_TOLERANCE_PX, TacticalDraw, TacticalDrawAbortError, TacticalDrawDestroyedError, bindAbortable, clonePointSymbol, coerceHandleStyle, combineWithHostSignal, effectivePointSymbolPixelSize, fillPatternImageDimension, fillPatternImageId, getSizeAnchor, hitTestFeature, hitTestIconFeature, ignoreAbort, isPointSymbol, isTacticalDrawAbortError, makeFillPatternImage, nearestWorldCopyLng, nearestWorldCopyPosition, pickHitTolerance, pointSymbolFootprint, resizePointSymbolSize, resolveGroundTextSizePixels, tryControlMeasureIdFromFeature };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbat-mapper/tactical-draw",
-  "version": "0.2.0-alpha.27",
+  "version": "0.2.0-alpha.28",
   "description": "Engine-agnostic draw/edit core for tactical control measures (MIL-STD-2525 / APP-6). The MapAdapter ABI and bring-your-own-engine entry point for the tactical-draw package family.",
   "license": "MIT",
   "author": "Orbat Mapper",
@@ -38,7 +38,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@orbat-mapper/control-measures": "^0.2.0-alpha.16"
+    "@orbat-mapper/control-measures": "^0.2.0-alpha.20"
   },
   "devDependencies": {
     "@arethetypeswrong/core": "^0.18.3",