@orbat-mapper/tactical-draw 0.2.0-alpha.12 → 0.2.0-alpha.14

package/dist/index.d.mts

@@ -57,9 +57,12 @@ interface StyleOptions {
 /**
  * Text (label) style for a layer. When `labelProperty` is set, adapters also
  * read per-feature label properties: `rotation` (radians, rendered as
- * `π − rotation`), `textSizePixels`/`textSizeZoom`/`textSizeResolution`
- * (ADR-0020), and `textAnchor` (`"start"` = text begins at the label point,
- * `"end"` = text ends there; absent = centered).
+ * `π − rotation`), the size anchor's `textSizeMeters` (ground) or
+ * `textSizePixels` (screen) (ADR-0028), and `textAnchor` (`"start"` = text
+ * begins at the label point, `"end"` = text ends there; absent = centered).
+ * A ground-anchored label renders at
+ * `clamp(textSizeMeters / resolution, textSizeMinPixels, textSizeMaxPixels)`;
+ * a screen-anchored one at a constant `textSizePixels`, unclamped.
  */
 interface TextStyleOptions {
   text?: string;
@@ -69,6 +72,18 @@ interface TextStyleOptions {
   strokeColor?: string;
   strokeWidth?: number;
   rotation?: number;
+  /**
+   * Lower edge of the ground-anchored label clamp band (ADR-0028): text never
+   * renders below this pixel size, however far the view zooms out.
+   * @default 8
+   */
+  textSizeMinPixels?: number;
+  /**
+   * Upper edge of the ground-anchored label clamp band (ADR-0028): text never
+   * renders above this pixel size, however far the view zooms in.
+   * @default 24
+   */
+  textSizeMaxPixels?: number;
 }
 /**
  * Per-feature style for edit handles (vertex / midpoint / translate / rotate).
@@ -333,6 +348,20 @@ declare function bindAbortable(signal: AbortSignal | undefined, attach: () => ()
  * when missing or shaped wrong so callers fall through to the layer style.
  */
 declare function coerceHandleStyle(raw: unknown): HandleStyle | undefined;
+/** Default lower edge of the ground-anchored label clamp band (ADR-0028). */
+declare const DEFAULT_TEXT_SIZE_MIN_PIXELS = 8;
+/** Default upper edge of the ground-anchored label clamp band (ADR-0028). */
+declare const DEFAULT_TEXT_SIZE_MAX_PIXELS = 24;
+/**
+ * Rendered pixel size of a ground-anchored label (ADR-0028):
+ * `textSizeMeters / resolution`, clamped to the layer's text-style band.
+ * Within the band the text scales with its graphic; past either edge it pins
+ * to the bound, so zooming out never yields unreadable smudges and zooming in
+ * never yields screen-covering text. Shared by the adapters that resolve text
+ * size in code (OpenLayers, Leaflet); the MapLibre adapter evaluates the same
+ * clamp inside its per-zoom-stop style expression.
+ */
+declare function resolveGroundTextSizePixels(textSizeMeters: number, resolution: number, text?: Pick<TextStyleOptions, "textSizeMinPixels" | "textSizeMaxPixels">): number;
 //#endregion
 //#region src/gestures/hit-test.d.ts
 type ToPixel = (lonLat: Position) => PixelCoordinate | null;
@@ -1167,11 +1196,12 @@ declare class TacticalDraw {
   private renderMeasuresToGraphics;
   /**
    * Re-render the graphics layer on a view (zoom) change so pixel-denominated
-   * measures rescale live. Skipped entirely when nothing rendered carries a
-   * resolution-dependent size — meter geometry is zoom-independent, so a rebuild
-   * would be wasted layer writes. During an active edit the edited measure lives
-   * on the preview layer (lifted from graphics), so it is excluded here exactly
-   * as in `render()`; the preview's own view-change subscription rescales it.
+   * and not-yet-committed label-sized measures rescale live. Skipped entirely
+   * when nothing rendered still reads live view state — meter geometry with a
+   * captured label size is zoom-independent, so a rebuild would be wasted
+   * layer writes. During an active edit the edited measure lives on the
+   * preview layer (lifted from graphics), so it is excluded here exactly as
+   * in `render()`; the preview's own view-change subscription rescales it.
    */
   private readonly handleViewChange;
   /**
@@ -1486,4 +1516,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, type DrawMeasureDraft, type DrawOptions, type DrawSession, type EditChangeEvent, type EditManyOptions, type EditMode, type EditOptions, type EditPointerDriver, type EditSession, type FeatureOps, type GuideStyle, type HandleStyle, type InteractionStyle, type LayerId, type MapAdapter, type MapCursor, type MapEvent, type MapEventHandler, type NativeEventEntry, type PickEvent, type PickHandler, type PickOptions, type PixelCoordinate, type PointerCallback, PointerCallbackHub, type PointerEventInfo, type SettleReason, type SizeAnchor, 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, coerceHandleStyle, combineWithHostSignal, getSizeAnchor, hitTestFeature, ignoreAbort, isTacticalDrawAbortError, nearestWorldCopyLng, nearestWorldCopyPosition, pickHitTolerance, tryControlMeasureIdFromFeature };
+export { BaseMapAdapter, type CombinedAbort, DEFAULT_TEXT_SIZE_MAX_PIXELS, DEFAULT_TEXT_SIZE_MIN_PIXELS, type DrawMeasureDraft, type DrawOptions, type DrawSession, type EditChangeEvent, type EditManyOptions, type EditMode, type EditOptions, type EditPointerDriver, type EditSession, type FeatureOps, type GuideStyle, type HandleStyle, type InteractionStyle, type LayerId, type MapAdapter, type MapCursor, type MapEvent, type MapEventHandler, type NativeEventEntry, type PickEvent, type PickHandler, type PickOptions, type PixelCoordinate, type PointerCallback, PointerCallbackHub, type PointerEventInfo, type SettleReason, type SizeAnchor, 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, coerceHandleStyle, combineWithHostSignal, getSizeAnchor, hitTestFeature, ignoreAbort, isTacticalDrawAbortError, nearestWorldCopyLng, nearestWorldCopyPosition, pickHitTolerance, resolveGroundTextSizePixels, tryControlMeasureIdFromFeature };

package/dist/index.mjs

@@ -232,6 +232,24 @@ function coerceHandleStyle(raw) {
 	if (!raw || typeof raw !== "object") return void 0;
 	return raw;
 }
+/** Default lower edge of the ground-anchored label clamp band (ADR-0028). */
+const DEFAULT_TEXT_SIZE_MIN_PIXELS = 8;
+/** Default upper edge of the ground-anchored label clamp band (ADR-0028). */
+const DEFAULT_TEXT_SIZE_MAX_PIXELS = 24;
+/**
+* Rendered pixel size of a ground-anchored label (ADR-0028):
+* `textSizeMeters / resolution`, clamped to the layer's text-style band.
+* Within the band the text scales with its graphic; past either edge it pins
+* to the bound, so zooming out never yields unreadable smudges and zooming in
+* never yields screen-covering text. Shared by the adapters that resolve text
+* size in code (OpenLayers, Leaflet); the MapLibre adapter evaluates the same
+* clamp inside its per-zoom-stop style expression.
+*/
+function resolveGroundTextSizePixels(textSizeMeters, resolution, text) {
+	const min = text?.textSizeMinPixels ?? 8;
+	const max = text?.textSizeMaxPixels ?? 24;
+	return Math.min(max, Math.max(min, textSizeMeters / resolution));
+}
 //#endregion
 //#region src/gestures/hit-test.ts
 /** Squared distance from `pixel` to the segment p1→p2 in pixel space, or null if either endpoint fails to project or the segment has zero length. */
@@ -504,11 +522,14 @@ function combineWithHostSignal(hostSignal) {
 	};
 }
 /**
-* Per-kind pixel-denominated size option and the meter option it bakes into —
-* the single source of which option makes a measure screen-anchored. Both the
-* resolution gate ([[measureUsesAdapterResolution]]) and the bake
-* ([[bakePixelSizeToGround]]) derive from this table, so a new pixel-sized kind
-* is one entry here (ADR-0020).
+* Per-kind pixel-denominated *geometry* size option and the meter option it
+* bakes into — the single source of which geometry option makes a measure
+* screen-anchored. Label sizing is not listed here: every `capturesLabelSize`
+* kind carries the shared `labelSizePixels` → `labelSize` pair implicitly
+* (ADR-0028) — see [[sizeOptionSpecs]]. Both the resolution gate
+* ([[measureUsesAdapterResolution]]) and the bake ([[bakePixelSizeToGround]])
+* derive from this table, so a new pixel-sized kind is one entry here
+* (ADR-0020).
 */
 const PIXEL_SIZE_OPTIONS = {
 	boundary: {
@@ -523,6 +544,14 @@ const PIXEL_SIZE_OPTIONS = {
 		pixels: "echelonSizePixels",
 		meters: "echelonSize"
 	},
+	"base-camp": {
+		pixels: "echelonSizePixels",
+		meters: "echelonSize"
+	},
+	"guerrilla-base": {
+		pixels: "echelonSizePixels",
+		meters: "echelonSize"
+	},
 	flot: {
 		pixels: "radiusPixels",
 		meters: "radius"
@@ -548,19 +577,52 @@ const PIXEL_SIZE_OPTIONS = {
 		meters: "toothHeight"
 	}
 };
+/** The shared label-size pair every `capturesLabelSize` kind carries (ADR-0028). */
+const LABEL_SIZE_SPEC = {
+	pixels: "labelSizePixels",
+	meters: "labelSize"
+};
+/**
+* Every pixel/meter size-option pair `kind` can carry: its geometry entry from
+* [[PIXEL_SIZE_OPTIONS]] (if any) plus the shared label pair when the kind
+* captures a label size — a kind like Boundary can carry both anchor-bearing
+* dimensions at once (echelon glyph + labels).
+*/
+function sizeOptionSpecs(kind) {
+	const specs = [];
+	const geometry = PIXEL_SIZE_OPTIONS[kind];
+	if (geometry) specs.push(geometry);
+	if (getControlMeasureMetadata(kind).capturesLabelSize) specs.push(LABEL_SIZE_SPEC);
+	return specs;
+}
 /**
 * Whether `measure` carries a pixel-denominated size option whose resolution
 * to meters depends on the live map (`metersPerPixel`) — i.e. it is
 * *screen-anchored*. Used both to inject the override
 * ([[withAdapterMeasureOptions]]) and to let zoom-driven re-renders skip
-* measures whose geometry is resolution-independent. Accepts the minimal
+* measures whose render is resolution-independent. Accepts the minimal
 * `{ kind, options }` shape so in-flight draw/edit handlers can gate against
 * working options without materialising a full measure.
 */
 function measureUsesAdapterResolution(measure) {
-	const spec = PIXEL_SIZE_OPTIONS[measure.kind];
-	if (!spec) return false;
-	return measure.options?.[spec.pixels] !== void 0;
+	const options = measure.options;
+	return sizeOptionSpecs(measure.kind).some((spec) => options?.[spec.pixels] !== void 0);
+}
+/**
+* Whether rendering `measure` through [[renderMeasureForAdapter]] reads live
+* adapter view state — either a pixel-denominated size
+* ([[measureUsesAdapterResolution]]) or draw-time label sizing that
+* [[withCommittedAdapterMeasureOptions]] would still stamp (a
+* `capturesLabelSize` kind not yet carrying any label size). The view-change
+* rerender gates key off this so such measures rescale live; committed
+* ground-anchored measures carry `labelSize` meters, stay zoom-independent,
+* and keep skipping the rebuild.
+*/
+function measureRendersFromViewState(measure) {
+	if (measureUsesAdapterResolution(measure)) return true;
+	if (!getControlMeasureMetadata(measure.kind).capturesLabelSize) return false;
+	const options = measure.options;
+	return typeof options?.labelSizePixels !== "number" && typeof options?.labelSize !== "number";
 }
 /**
 * The [[SizeAnchor]] a measure currently encodes (ADR-0020): `screen` when it
@@ -582,16 +644,15 @@ function getSizeAnchor(measure) {
 * carries no pixel size or the adapter has no usable resolution.
 */
 function bakePixelSizeToGround(measure, adapter) {
-	const spec = PIXEL_SIZE_OPTIONS[measure.kind];
-	if (!spec) return measure;
 	const options = measure.options ?? {};
-	const pixels = options[spec.pixels];
-	if (typeof pixels !== "number") return measure;
+	const specs = sizeOptionSpecs(measure.kind).filter((spec) => typeof options[spec.pixels] === "number");
+	if (specs.length === 0) return measure;
 	const mpp = adapter.getResolution();
 	if (mpp === void 0 || mpp <= 0) return measure;
+	const pixelKeys = new Set(specs.map((spec) => spec.pixels));
 	const rest = {};
-	for (const [key, value] of Object.entries(options)) if (key !== spec.pixels && key !== "metersPerPixel") rest[key] = value;
-	rest[spec.meters] = pixels * mpp;
+	for (const [key, value] of Object.entries(options)) if (!pixelKeys.has(key) && key !== "metersPerPixel") rest[key] = value;
+	for (const spec of specs) rest[spec.meters] = options[spec.pixels] * mpp;
 	return {
 		...measure,
 		options: rest
@@ -617,22 +678,24 @@ function withAdapterMeasureOptions(measure, adapter) {
 	};
 }
 /**
-* Capture draw-time label sizing options on commit. These are stable feature
-* style inputs; adapters scale from them without TacticalDraw re-rendering on
-* every zoom.
+* Stamp the draw-time default label size, in its screen-anchored
+* (`labelSizePixels`) form, onto a `capturesLabelSize` measure that carries no
+* label size of its own (ADR-0028). The pixel form keeps the in-flight
+* preview screen-anchored through the gesture; the commit's default `ground`
+* anchor then bakes it to `labelSize` meters via [[bakePixelSizeToGround]],
+* while a `screen` commit persists the pixels. No-op once either label-size
+* option is present (e.g. already committed), so it's safe to call on every
+* render as well as on commit itself — see [[renderMeasureForAdapter]].
 */
-function withCommittedAdapterMeasureOptions(measure, adapter) {
+function withCommittedAdapterMeasureOptions(measure) {
 	if (!getControlMeasureMetadata(measure.kind).capturesLabelSize) return measure;
-	if (typeof measure.options?.labelSizePixels === "number") return measure;
-	const zoom = adapter.getZoom();
-	const resolution = adapter.getResolution();
+	const options = measure.options;
+	if (typeof options?.labelSizePixels === "number" || typeof options?.labelSize === "number") return measure;
 	return {
 		...measure,
 		options: {
 			...measure.options,
-			labelSizePixels: 14,
-			...zoom !== void 0 ? { labelSizeZoom: zoom } : {},
-			...resolution !== void 0 && resolution > 0 ? { labelSizeResolution: resolution } : {}
+			labelSizePixels: 14
 		}
 	};
 }
@@ -641,10 +704,17 @@ function withCommittedAdapterMeasureOptions(measure, adapter) {
 * "turn a measure into features against the live map" — every TacticalDraw
 * layer write (graphics reconcile, draw preview, edit preview, commit snapshot)
 * routes through here so pixel sizing is resolved identically everywhere and no
-* call site can forget the injection. See [[withAdapterMeasureOptions]].
+* call site can forget the injection. Composes [[withAdapterMeasureOptions]]
+* (pixel size → `metersPerPixel`) with [[withCommittedAdapterMeasureOptions]]
+* (label size defaults for `capturesLabelSize` kinds), so draw/edit previews
+* get the same label clearance a commit would bake in — the input `measure`
+* is never mutated, and callers that need the persisted/working measure to
+* stay free of these render-only options must keep using that separately
+* (draw/edit commit paths call [[withCommittedAdapterMeasureOptions]]
+* directly to produce the value they persist).
 */
 function renderMeasureForAdapter(adapter, measure, opts) {
-	return renderControlMeasure(withAdapterMeasureOptions(measure, adapter), opts);
+	return renderControlMeasure(withAdapterMeasureOptions(withCommittedAdapterMeasureOptions(measure), adapter), opts);
 }
 //#endregion
 //#region src/tactical-draw/run-interaction.ts
@@ -923,7 +993,7 @@ function runFixedLengthDraw(options) {
 		ctx.writeLayer(guideLayer, guideFeatures);
 	}
 	function rescaleOnViewChange() {
-		if (!measureUsesAdapterResolution({
+		if (!measureRendersFromViewState({
 			kind,
 			options: measureOptions
 		})) return;
@@ -939,7 +1009,7 @@ function runFixedLengthDraw(options) {
 			...measureStyle !== void 0 ? { style: measureStyle } : {},
 			...measureProperties !== void 0 ? { properties: measureProperties } : {},
 			...measureTextAmplifiers !== void 0 ? { textAmplifiers: measureTextAmplifiers } : {}
-		}, adapter);
+		});
 		const measure = sizeAnchor === "screen" ? captured : bakePixelSizeToGround(captured, adapter);
 		return {
 			measure: cloneControlMeasure(measure),
@@ -1296,7 +1366,7 @@ function runVariableLengthDraw(options) {
 		ctx.writeLayer(guideLayer, guideFeatures);
 	}
 	function rescaleOnViewChange() {
-		if (!measureUsesAdapterResolution({
+		if (!measureRendersFromViewState({
 			kind,
 			options: measureOptions
 		})) return;
@@ -1311,7 +1381,7 @@ function runVariableLengthDraw(options) {
 			...measureStyle !== void 0 ? { style: measureStyle } : {},
 			...measureProperties !== void 0 ? { properties: measureProperties } : {},
 			...measureTextAmplifiers !== void 0 ? { textAmplifiers: measureTextAmplifiers } : {}
-		}, adapter);
+		});
 		const measure = sizeAnchor === "screen" ? built : bakePixelSizeToGround(built, adapter);
 		return {
 			measure: cloneControlMeasure(measure),
@@ -2107,7 +2177,7 @@ function runEdit(opts) {
 	}
 	function rescaleOnViewChange() {
 		if (ctx.settled) return;
-		if (measureUsesAdapterResolution({
+		if (measureRendersFromViewState({
 			kind: measure.kind,
 			options: workingOptions
 		})) renderPreview();
@@ -3022,7 +3092,7 @@ function runGroupTransform(opts) {
 	}
 	function rescaleOnViewChange() {
 		if (ctx.settled) return;
-		if (members.some((m) => measureUsesAdapterResolution({
+		if (members.some((m) => measureRendersFromViewState({
 			kind: m.measure.kind,
 			options: m.measure.options
 		}))) renderAllPreviews();
@@ -3594,17 +3664,18 @@ var TacticalDraw = class {
 	}
 	/**
 	* Re-render the graphics layer on a view (zoom) change so pixel-denominated
-	* measures rescale live. Skipped entirely when nothing rendered carries a
-	* resolution-dependent size — meter geometry is zoom-independent, so a rebuild
-	* would be wasted layer writes. During an active edit the edited measure lives
-	* on the preview layer (lifted from graphics), so it is excluded here exactly
-	* as in `render()`; the preview's own view-change subscription rescales it.
+	* and not-yet-committed label-sized measures rescale live. Skipped entirely
+	* when nothing rendered still reads live view state — meter geometry with a
+	* captured label size is zoom-independent, so a rebuild would be wasted
+	* layer writes. During an active edit the edited measure lives on the
+	* preview layer (lifted from graphics), so it is excluded here exactly as
+	* in `render()`; the preview's own view-change subscription rescales it.
 	*/
 	handleViewChange = () => {
 		if (this.destroyed || !this.hasRendered) return;
 		const excluded = this.excludedInteractionIds();
 		const visible = excluded.size > 0 ? this.lastRenderedMeasures.filter((m) => !excluded.has(m.id)) : this.lastRenderedMeasures;
-		if (!visible.some(measureUsesAdapterResolution)) return;
+		if (!visible.some(measureRendersFromViewState)) return;
 		this.renderMeasuresToGraphics(visible);
 	};
 	/**
@@ -4311,4 +4382,4 @@ function nearestWorldCopyPosition(position, refLng) {
 	return [nearestWorldCopyLng(position[0], refLng), ...position.slice(1)];
 }
 //#endregion
-export { BaseMapAdapter, PointerCallbackHub, TOUCH_HIT_TOLERANCE_PX, TacticalDraw, TacticalDrawAbortError, TacticalDrawDestroyedError, bindAbortable, coerceHandleStyle, combineWithHostSignal, getSizeAnchor, hitTestFeature, ignoreAbort, isTacticalDrawAbortError, nearestWorldCopyLng, nearestWorldCopyPosition, pickHitTolerance, tryControlMeasureIdFromFeature };
+export { BaseMapAdapter, DEFAULT_TEXT_SIZE_MAX_PIXELS, DEFAULT_TEXT_SIZE_MIN_PIXELS, PointerCallbackHub, TOUCH_HIT_TOLERANCE_PX, TacticalDraw, TacticalDrawAbortError, TacticalDrawDestroyedError, bindAbortable, coerceHandleStyle, combineWithHostSignal, getSizeAnchor, hitTestFeature, ignoreAbort, isTacticalDrawAbortError, nearestWorldCopyLng, nearestWorldCopyPosition, pickHitTolerance, resolveGroundTextSizePixels, tryControlMeasureIdFromFeature };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbat-mapper/tactical-draw",
-  "version": "0.2.0-alpha.12",
+  "version": "0.2.0-alpha.14",
   "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.9"
+    "@orbat-mapper/control-measures": "^0.2.0-alpha.11"
   },
   "devDependencies": {
     "@arethetypeswrong/core": "^0.18.3",