@orbat-mapper/point-symbols 0.1.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Orbat Mapper
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,48 @@
+# @orbat-mapper/point-symbols
+
+Optional milsymbol-backed point-symbol rendering for
+`@orbat-mapper/tactical-draw`. Installing this package is opt-in; applications
+that only use control measures do not install or bundle milsymbol.
+
+## Installation
+
+```bash
+pnpm add @orbat-mapper/point-symbols milsymbol
+```
+
+`milsymbol` is a peer dependency so the host and this capability share one
+instance and its global registries.
+
+## Usage
+
+```ts
+import { TacticalDraw } from "@orbat-mapper/tactical-draw";
+import { milsymbolPointSymbols } from "@orbat-mapper/point-symbols";
+
+const pointSymbols = milsymbolPointSymbols();
+const tacticalDraw = new TacticalDraw(adapter, { pointSymbols });
+
+tacticalDraw.render([
+  {
+    id: "unit-1",
+    kind: "point-symbol",
+    sidc: "130315003611010300000000000000",
+    position: [10.75, 59.91],
+    rotation: 0,
+    size: { value: 32, unit: "pixels" },
+  },
+]);
+```
+
+Use `renderPointSymbol(symbol)` for standalone synchronous SVG rendering.
+Capability instances may be shared by several TacticalDraw facades and retain
+an LRU render cache. Call `capability.invalidate()` after changing milsymbol's
+global configuration.
+
+The bundled capability emits SVG produced by milsymbol. A custom
+`PointSymbolCapability` must return trusted or sanitized SVG: the Leaflet
+adapter inserts that SVG into the live DOM when it constructs a `divIcon`.
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,21 @@
+import { PointSymbol, PointSymbol as PointSymbol$1, PointSymbolAnchor, PointSymbolCapability, PointSymbolColors, PointSymbolGraphicModifiers, PointSymbolRender, PointSymbolRender as PointSymbolRender$1, PointSymbolSize, PointSymbolSize as PointSymbolSize$1, PointSymbolStyle } from "@orbat-mapper/tactical-draw";
+
+//#region src/render-point-symbol.d.ts
+declare function renderPointSymbol(symbol: PointSymbol$1): PointSymbolRender$1;
+//#endregion
+//#region src/capability.d.ts
+interface MilsymbolPointSymbolsOptions {
+  defaultSize?: PointSymbolSize$1;
+  defaultRotation?: number;
+  maxCacheEntries?: number;
+  /** Capability-wide milsymbol options, below per-symbol and canonical fields. */
+  milsymbolOptions?: Record<string, unknown>;
+  /** Compute uncommon per-symbol milsymbol options before persisted raw overrides. */
+  resolveOptions?: (symbol: PointSymbol$1) => Record<string, unknown> | undefined;
+}
+interface MilsymbolPointSymbolCapability extends PointSymbolCapability {
+  clearCache(): void;
+}
+declare function milsymbolPointSymbols(options?: MilsymbolPointSymbolsOptions): MilsymbolPointSymbolCapability;
+//#endregion
+export { type MilsymbolPointSymbolCapability, type MilsymbolPointSymbolsOptions, type PointSymbol, type PointSymbolAnchor, type PointSymbolColors, type PointSymbolGraphicModifiers, type PointSymbolRender, type PointSymbolSize, type PointSymbolStyle, milsymbolPointSymbols, renderPointSymbol };

package/dist/index.mjs

@@ -0,0 +1,136 @@
+import ms from "milsymbol";
+import { normalizeTextAmplifiers } from "@orbat-mapper/control-measures";
+//#region src/render-point-symbol.ts
+const CANONICAL_OCTAGON_SIZE = 100;
+function stableValue(value) {
+	if (Array.isArray(value)) return value.map(stableValue);
+	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, nested]) => [key, stableValue(nested)]));
+	return value;
+}
+function pointSymbolDrawingKey(symbol, capabilityOptions, resolvedOptions) {
+	const drawingStyle = { ...symbol.style ?? {} };
+	delete drawingStyle.opacity;
+	return JSON.stringify(stableValue({
+		sidc: symbol.sidc.trim(),
+		textAmplifiers: normalizeTextAmplifiers(symbol.textAmplifiers),
+		graphicModifiers: symbol.graphicModifiers,
+		style: drawingStyle,
+		capabilityOptions,
+		resolvedOptions,
+		rendererOptions: symbol.rendererOptions?.milsymbol
+	}));
+}
+function hashKey(value) {
+	let hash = 14695981039346656037n;
+	for (let i = 0; i < value.length; i += 1) {
+		hash ^= BigInt(value.charCodeAt(i));
+		hash = BigInt.asUintN(64, hash * 1099511628211n);
+	}
+	return hash.toString(36);
+}
+const TEXT_OPTION_BY_FIELD = {
+	C: "quantity",
+	H: "additionalInformation",
+	N: "hostile",
+	T: "uniqueDesignation",
+	V: "type",
+	W: "dtg",
+	X: "altitudeDepth",
+	Y: "location",
+	AM: "distance",
+	AN: "azimuth",
+	AP: "targetNumber",
+	AS: "country"
+};
+function resolveMilsymbolOptions(symbol, capabilityOptions, resolvedOptions) {
+	const raw = {
+		...capabilityOptions ?? {},
+		...resolvedOptions ?? {},
+		...symbol.rendererOptions?.milsymbol ?? {}
+	};
+	delete raw.sidc;
+	delete raw.SIDC;
+	delete raw.size;
+	const options = raw;
+	const text = normalizeTextAmplifiers(symbol.textAmplifiers);
+	for (const [field, option] of Object.entries(TEXT_OPTION_BY_FIELD)) {
+		const value = text[field];
+		if (value !== void 0) options[option] = value;
+	}
+	const direction = symbol.graphicModifiers?.direction;
+	if (direction !== void 0) options.direction = direction * 180 / Math.PI;
+	const style = symbol.style;
+	if (style?.colors?.fill !== void 0) options.fillColor = style.colors.fill;
+	if (style?.colors?.frame !== void 0) options.frameColor = style.colors.frame;
+	if (style?.colors?.icon !== void 0) options.iconColor = style.colors.icon;
+	if (style?.colors?.info !== void 0) options.infoColor = style.colors.info;
+	if (style?.colors?.outline !== void 0) options.outlineColor = style.colors.outline;
+	if (style?.outlineWidth !== void 0) options.outlineWidth = style.outlineWidth;
+	if (style?.fill !== void 0) options.fill = style.fill;
+	if (style?.frame !== void 0) options.frame = style.frame;
+	if (style?.icon !== void 0) options.icon = style.icon;
+	if (style?.monoColor !== void 0) options.monoColor = style.monoColor;
+	options.size = CANONICAL_OCTAGON_SIZE;
+	return options;
+}
+function renderPointSymbolWithRevision(symbol, revision, capabilityOptions, resolvedOptions) {
+	const rendered = new ms.Symbol(symbol.sidc.trim(), resolveMilsymbolOptions(symbol, capabilityOptions, resolvedOptions));
+	const { width, height } = rendered.getSize();
+	const valid = rendered.isValid() === true;
+	const validation = rendered.isValid(true);
+	return {
+		resourceId: `milsymbol-${revision}-${hashKey(pointSymbolDrawingKey(symbol, capabilityOptions, resolvedOptions))}`,
+		svg: rendered.asSVG(),
+		octagonSize: CANONICAL_OCTAGON_SIZE,
+		width,
+		height,
+		anchor: rendered.getAnchor(),
+		octagonAnchor: rendered.getOctagonAnchor(),
+		valid,
+		...valid ? {} : { validation }
+	};
+}
+function renderPointSymbol(symbol) {
+	return renderPointSymbolWithRevision(symbol, 0);
+}
+//#endregion
+//#region src/capability.ts
+function milsymbolPointSymbols(options = {}) {
+	const maxEntries = Math.max(0, Math.floor(options.maxCacheEntries ?? 1024));
+	const cache = /* @__PURE__ */ new Map();
+	let revision = 0;
+	const clearCache = () => cache.clear();
+	return {
+		defaultSize: structuredClone(options.defaultSize ?? {
+			value: 25,
+			unit: "pixels"
+		}),
+		defaultRotation: options.defaultRotation ?? 0,
+		render(symbol) {
+			const resolved = options.resolveOptions?.(structuredClone(symbol));
+			const key = pointSymbolDrawingKey(symbol, options.milsymbolOptions, resolved);
+			const cached = cache.get(key);
+			if (cached) {
+				cache.delete(key);
+				cache.set(key, cached);
+				return cached;
+			}
+			const render = renderPointSymbolWithRevision(symbol, revision, options.milsymbolOptions, resolved);
+			if (maxEntries > 0) {
+				cache.set(key, render);
+				if (cache.size > maxEntries) {
+					const oldest = cache.keys().next().value;
+					if (oldest !== void 0) cache.delete(oldest);
+				}
+			}
+			return render;
+		},
+		invalidate() {
+			revision += 1;
+			clearCache();
+		},
+		clearCache
+	};
+}
+//#endregion
+export { milsymbolPointSymbols, renderPointSymbol };

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@orbat-mapper/point-symbols",
+  "version": "0.1.0-alpha.1",
+  "description": "Milsymbol-backed MIL-STD-2525 and APP-6 point symbols for tactical-draw.",
+  "license": "MIT",
+  "author": "Orbat Mapper",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/orbat-mapper/tactical-graphics.git",
+    "directory": "packages/point-symbols"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@orbat-mapper/control-measures": "^0.2.0-alpha.15",
+    "@orbat-mapper/tactical-draw": "^0.2.0-alpha.20"
+  },
+  "peerDependencies": {
+    "milsymbol": ">=3.0.4 <4.0.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/core": "^0.18.3",
+    "@types/geojson": "^7946.0.16",
+    "milsymbol": "^3.0.4",
+    "publint": "^0.3.21",
+    "tsdown": "^0.22.2",
+    "typescript": "~5.9.3",
+    "vite": "^8.0.16",
+    "vitest": "^4.1.8"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "lint": "eslint . --fix"
+  }
+}