@orbat-mapper/tactical-draw 0.2.0-alpha.32 → 0.2.0-alpha.33

package/dist/index.d.mts

@@ -877,6 +877,15 @@ interface InteractionStyle {
   scaleHandle?: HandleStyle;
   rotateHandle?: HandleStyle;
   boxOutline?: GuideStyle;
+  /**
+   * Line style for the passive, non-interactive selection highlight rendered
+   * by {@link TacticalDraw.setHighlightedGraphics}. A dashed, muted variant of
+   * `boxOutline` so a locked/highlighted selection reads as visually distinct
+   * from an active edit's oriented transform box. Delivered per-feature via
+   * `properties.style` on the highlight outline `LineString`, resolved through
+   * the same built-in → façade → per-call slot system as every other field.
+   */
+  highlightOutline?: GuideStyle;
   /**
    * Pixel padding added on every side of the fitted transform box
    * (`fitTransformBox`, ADR-0017) so the box doesn't tightly hug the rendered
@@ -1547,6 +1556,12 @@ type DrawPointSymbolDraft = Pick<PointSymbol, "kind" | "sidc"> & Partial<Omit<Po
  */
 interface TacticalDrawLayerOptions {
   graphics?: LayerId;
+  /**
+   * Passive selection-highlight outlines ({@link TacticalDraw.setHighlightedGraphics}).
+   * Resolved immediately above `graphics` so highlight boxes stack over base
+   * graphics but below the preview / guide / handles interaction chrome.
+   */
+  highlight?: LayerId;
   preview?: LayerId;
   guide?: LayerId;
   handles?: LayerId;
@@ -1733,6 +1748,7 @@ interface DrawOptions {
 declare class TacticalDraw {
   private readonly adapter;
   private readonly graphicsLayer;
+  private readonly highlightLayer;
   private readonly previewLayer;
   private readonly guideLayer;
   private readonly handlesLayer;
@@ -1794,6 +1810,20 @@ declare class TacticalDraw {
    */
   private lastRenderedMeasures;
   private snapGeometryFeatures;
+  /**
+   * Ids of graphics currently carrying a passive selection-highlight outline
+   * ({@link setHighlightedGraphics}). Declarative set-replace, no session —
+   * re-projected on every view change and re-evaluated at the end of every
+   * `render()` so outlines track geometry, style, and dropped graphics.
+   */
+  private highlightedIds;
+  /**
+   * Whether the highlight layer currently holds any outline. Lets
+   * `renderHighlights` skip a redundant empty write on every view change /
+   * render while no highlights are set, but still emit the one clearing write
+   * that removes outlines when the set transitions to empty.
+   */
+  private hasHighlightOutlines;
   constructor(adapter: MapAdapter, options?: TacticalDrawOptions);
   /** Replace snapping configuration without recreating the map adapter or façade. */
   setSnappingOptions(options?: SnappingOptions): void;
@@ -1858,6 +1888,34 @@ declare class TacticalDraw {
    * pure style replay).
    */
   render(measures: readonly Graphic[]): void;
+  /**
+   * Replace the passive selection-highlight set with `ids`. Declarative and
+   * idempotent (mirrors {@link render}): a non-interactive outline box is drawn
+   * around each still-rendered graphic on the dedicated highlight layer — no
+   * draw / edit / transform session, no promise, no pick subscription. Passing
+   * `[]` clears every highlight. Unknown ids and ids currently lifted into an
+   * active edit / transform session are skipped (the live session's own visuals
+   * supersede the passive outline). Hosts use it for Excalidraw-style
+   * "locked selection" chrome.
+   */
+  setHighlightedGraphics(ids: readonly string[]): void;
+  /**
+   * Project the current {@link highlightedIds} into one outline `LineString`
+   * per graphic and reconcile them onto the highlight layer. Idempotent and
+   * id-keyed via `adapter.updateLayerFeatures`, so a set-replace removes stale
+   * outlines and an unchanged set is a cheap no-op write. Skips ids that are
+   * unknown (not in the last render) or lifted into an active session, and
+   * bails gracefully when the adapter cannot invert pixels to coordinates
+   * (`getCoordinateFromPixel` is optional in the MapAdapter ABI).
+   */
+  private renderHighlights;
+  /**
+   * Fit the passive-highlight transform box for one graphic: the point-symbol
+   * footprint for symbols, the snug text footprint for Text graphics, and the
+   * projected-geometry bounding box (at the current bearing) for every other
+   * control measure. Returns `null` when nothing projects this frame.
+   */
+  private highlightBoxForGraphic;
   /**
    * Nested-call guard + preempt, shared by `draw` and `edit`. Returns a
    * pre-rejected promise when called re-entrantly from inside another
@@ -2093,6 +2151,7 @@ declare class TacticalDraw {
   /** @internal — exposed for tests and future controllers. */
   get layerIds(): {
     graphics: LayerId;
+    highlight: LayerId;
     preview: LayerId;
     guide: LayerId;
     handles: LayerId;
@@ -2104,6 +2163,7 @@ declare class TacticalDraw {
    */
   private applyGuideStyle;
   private baseGuideStyle;
+  private baseHighlightStyle;
   /**
    * Resolve handle slots (plus `boxOutline`) across built-in → façade →
    * per-call with per-slot, per-property shallow merge. Explicit `undefined`

package/dist/index.mjs

@@ -5843,6 +5843,7 @@ function runPointSymbolEdit(opts) {
 var TacticalDraw = class {
 	adapter;
 	graphicsLayer;
+	highlightLayer;
 	previewLayer;
 	guideLayer;
 	handlesLayer;
@@ -5904,6 +5905,20 @@ var TacticalDraw = class {
 	*/
 	lastRenderedMeasures = [];
 	snapGeometryFeatures = [];
+	/**
+	* Ids of graphics currently carrying a passive selection-highlight outline
+	* ({@link setHighlightedGraphics}). Declarative set-replace, no session —
+	* re-projected on every view change and re-evaluated at the end of every
+	* `render()` so outlines track geometry, style, and dropped graphics.
+	*/
+	highlightedIds = [];
+	/**
+	* Whether the highlight layer currently holds any outline. Lets
+	* `renderHighlights` skip a redundant empty write on every view change /
+	* render while no highlights are set, but still emit the one clearing write
+	* that removes outlines when the set transitions to empty.
+	*/
+	hasHighlightOutlines = false;
 	constructor(adapter, options) {
 		this.adapter = adapter;
 		this.graphicsStyle = resolveStyleHints(BUILT_IN_GRAPHICS_STYLE, options?.graphicsStyle, void 0);
@@ -5915,6 +5930,7 @@ var TacticalDraw = class {
 		const owned = /* @__PURE__ */ new Set();
 		const provided = options?.layers ?? {};
 		this.graphicsLayer = resolveSlot(adapter, provided.graphics, owned);
+		this.highlightLayer = resolveSlot(adapter, provided.highlight, owned);
 		this.previewLayer = resolveSlot(adapter, provided.preview, owned);
 		this.guideLayer = resolveSlot(adapter, provided.guide, owned);
 		this.handlesLayer = resolveSlot(adapter, provided.handles, owned);
@@ -5923,6 +5939,7 @@ var TacticalDraw = class {
 		this.adapter.setLayerStyle(this.graphicsLayer, graphicsLayerStyle);
 		this.adapter.setLayerStyle(this.previewLayer, graphicsLayerStyle);
 		this.adapter.setLayerStyle(this.guideLayer, guideToStyleOptions(this.baseGuideStyle()));
+		this.adapter.setLayerStyle(this.highlightLayer, guideToStyleOptions(this.baseHighlightStyle()));
 		this.adapter.onViewChange(this.handleViewChange);
 	}
 	/** Replace snapping configuration without recreating the map adapter or façade. */
@@ -5970,6 +5987,7 @@ var TacticalDraw = class {
 	*/
 	handleViewChange = () => {
 		if (this.destroyed || !this.hasRendered) return;
+		this.renderHighlights();
 		const excluded = this.excludedInteractionIds();
 		const visible = excluded.size > 0 ? this.lastRenderedMeasures.filter((m) => !excluded.has(m.id)) : this.lastRenderedMeasures;
 		const nativeGroundIconScaling = this.adapter.scalesGroundPointSymbolsNatively === true;
@@ -6067,6 +6085,88 @@ var TacticalDraw = class {
 				if (handle.graphicIds.some((id) => !rendered.has(id))) handle.abort("removed");
 			});
 		}
+		this.renderHighlights();
+	}
+	/**
+	* Replace the passive selection-highlight set with `ids`. Declarative and
+	* idempotent (mirrors {@link render}): a non-interactive outline box is drawn
+	* around each still-rendered graphic on the dedicated highlight layer — no
+	* draw / edit / transform session, no promise, no pick subscription. Passing
+	* `[]` clears every highlight. Unknown ids and ids currently lifted into an
+	* active edit / transform session are skipped (the live session's own visuals
+	* supersede the passive outline). Hosts use it for Excalidraw-style
+	* "locked selection" chrome.
+	*/
+	setHighlightedGraphics(ids) {
+		this.assertAlive();
+		this.highlightedIds = ids.slice();
+		this.renderHighlights();
+	}
+	/**
+	* Project the current {@link highlightedIds} into one outline `LineString`
+	* per graphic and reconcile them onto the highlight layer. Idempotent and
+	* id-keyed via `adapter.updateLayerFeatures`, so a set-replace removes stale
+	* outlines and an unchanged set is a cheap no-op write. Skips ids that are
+	* unknown (not in the last render) or lifted into an active session, and
+	* bails gracefully when the adapter cannot invert pixels to coordinates
+	* (`getCoordinateFromPixel` is optional in the MapAdapter ABI).
+	*/
+	renderHighlights() {
+		if (this.destroyed) return;
+		if (this.highlightedIds.length === 0 && !this.hasHighlightOutlines) return;
+		const fromPixel = this.adapter.getCoordinateFromPixel?.bind(this.adapter);
+		if (!fromPixel) return;
+		const resolved = this.resolveInteractionStyle(void 0);
+		const style = resolved.highlightOutline;
+		const padding = resolved.boxPadding ?? 0;
+		const excluded = this.excludedInteractionIds();
+		const bearing = this.adapter.getBearing();
+		const features = [];
+		for (const id of this.highlightedIds) {
+			if (excluded.has(id)) continue;
+			const graphic = this.lastRenderedMeasures.find((g) => g.id === id);
+			if (!graphic) continue;
+			const box = this.highlightBoxForGraphic(graphic, bearing, padding);
+			if (!box) continue;
+			let invertFailed = false;
+			const invert = (pixel) => {
+				const coord = fromPixel(pixel);
+				if (!coord) {
+					invertFailed = true;
+					return [pixel[0], pixel[1]];
+				}
+				return coord;
+			};
+			const feature = boxOutlineFeature(box, invert, `__td_highlight__:${id}`, style);
+			if (!invertFailed) features.push(feature);
+		}
+		this.adapter.updateLayerFeatures(this.highlightLayer, features);
+		this.hasHighlightOutlines = features.length > 0;
+	}
+	/**
+	* Fit the passive-highlight transform box for one graphic: the point-symbol
+	* footprint for symbols, the snug text footprint for Text graphics, and the
+	* projected-geometry bounding box (at the current bearing) for every other
+	* control measure. Returns `null` when nothing projects this frame.
+	*/
+	highlightBoxForGraphic(graphic, bearing, padding) {
+		if (isPointSymbol(graphic)) {
+			if (!this.pointSymbols) return null;
+			return pointSymbolFootprint(graphic, this.pointSymbols.render(graphic), this.adapter)?.box ?? null;
+		}
+		const render = renderMeasureForAdapter(this.adapter, graphic, { graphicsStyle: this.graphicsStyle });
+		if (graphic.kind === "text") return fitTextFootprintFromFeatures(render.features, (lonLat) => this.adapter.getPixelFromCoordinate(lonLat), {
+			resolution: this.adapter.getResolution(),
+			bearing
+		});
+		const positions = [];
+		for (const feature of render.features) if (feature.geometry) collectFeaturePositions(feature.geometry, positions);
+		const pixels = [];
+		for (const position of positions) {
+			const pixel = this.adapter.getPixelFromCoordinate(position);
+			if (pixel) pixels.push(pixel);
+		}
+		return fitTransformBox(pixels, bearing, padding);
 	}
 	/**
 	* Nested-call guard + preempt, shared by `draw` and `edit`. Returns a
@@ -6121,6 +6221,7 @@ var TacticalDraw = class {
 			clearSlot();
 			this.clearSnapResult();
 			if (extraSettle) extraSettle();
+			this.renderHighlights();
 		};
 		this.activeInteraction.begin();
 		try {
@@ -6132,7 +6233,10 @@ var TacticalDraw = class {
 		}
 		if (!settledDuringCreate) {
 			this.activeInteraction.set(handle);
-			if (activate && !handle.settled) deactivate = activate(handle) ?? null;
+			if (activate && !handle.settled) {
+				deactivate = activate(handle) ?? null;
+				this.renderHighlights();
+			}
 		}
 		handle.promise.then(clearSlot, clearSlot);
 		return handle.promise;
@@ -6648,6 +6752,7 @@ var TacticalDraw = class {
 	get layerIds() {
 		return {
 			graphics: this.graphicsLayer,
+			highlight: this.highlightLayer,
 			preview: this.previewLayer,
 			guide: this.guideLayer,
 			handles: this.handlesLayer
@@ -6670,6 +6775,9 @@ var TacticalDraw = class {
 	baseGuideStyle() {
 		return mergeSlot(BUILT_IN_INTERACTION_STYLE.guide, this.defaultInteractionStyle?.guide);
 	}
+	baseHighlightStyle() {
+		return mergeSlot(BUILT_IN_INTERACTION_STYLE.highlightOutline, this.defaultInteractionStyle?.highlightOutline);
+	}
 	/**
 	* Resolve handle slots (plus `boxOutline`) across built-in → façade →
 	* per-call with per-slot, per-property shallow merge. Explicit `undefined`
@@ -6697,6 +6805,8 @@ var TacticalDraw = class {
 		}
 		const boxOutline = mergeSlot(mergeSlot(BUILT_IN_INTERACTION_STYLE.boxOutline, this.defaultInteractionStyle?.boxOutline), perCall?.boxOutline);
 		if (boxOutline) out.boxOutline = boxOutline;
+		const highlightOutline = mergeSlot(mergeSlot(BUILT_IN_INTERACTION_STYLE.highlightOutline, this.defaultInteractionStyle?.highlightOutline), perCall?.highlightOutline);
+		if (highlightOutline) out.highlightOutline = highlightOutline;
 		const boxPadding = perCall && "boxPadding" in perCall ? perCall.boxPadding : this.defaultInteractionStyle && "boxPadding" in this.defaultInteractionStyle ? this.defaultInteractionStyle.boxPadding : void 0;
 		if (typeof boxPadding === "number") out.boxPadding = boxPadding;
 		return out;
@@ -6737,6 +6847,11 @@ const BUILT_IN_INTERACTION_STYLE = {
 		strokeColor: "#4f7cff",
 		strokeWidth: 1
 	},
+	highlightOutline: {
+		strokeColor: "#8ea3c9",
+		strokeWidth: 1.5,
+		strokeDash: [4, 4]
+	},
 	vertexHandle: {
 		pointRadius: 6,
 		fillColor: "#ffffff",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbat-mapper/tactical-draw",
-  "version": "0.2.0-alpha.32",
+  "version": "0.2.0-alpha.33",
   "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",