@tak-ps/node-cot 12.30.1 → 12.31.0

package/CHANGELOG.md

@@ -12,6 +12,10 @@
 
 ### Pending Fixed
 
+### v12.31.0 - 2025-04-30
+
+- :tada: Add CoT Type <=> SIDC
+
 ### v12.30.1 - 2025-04-28
 
 - :arrow_up: Update Core Deps

package/dist/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@tak-ps/node-cot",
     "type": "module",
-    "version": "12.30.1",
+    "version": "12.31.0",
     "description": "Lightweight JavaScript library for parsing and manipulating TAK messages",
     "author": "Nick Ingalls <nick@ingalls.ca>",
     "main": "dist/index.js",
@@ -30,6 +30,7 @@
         "archiver": "^7.0.1",
         "color": "^5.0.0",
         "json-diff-ts": "^4.0.1",
+        "milsymbol": "^3.0.2",
         "node-stream-zip": "^1.15.0",
         "protobufjs": "^7.3.0",
         "rimraf": "^6.0.0",

package/lib/utils/2525.ts

@@ -0,0 +1,53 @@
+/**
+ * @class
+ *
+ * Convert a COT Atom Type to/from Symbol Identification Code (SIDC)
+ * Migrated to TypeScript from the original Kotlin verison
+ * @ https://github.com/cyberpython/kotcot under the MIT License
+ */
+export default class Type2525 {
+
+    /**
+     * Given a COT Atom Type, return an SIDC
+     * @param cotType - Cursor On Target Type (Note must start with atomic "a")
+     */
+    static to2525B(cotType: string): string {
+        if (!cotType.match(/^a-[puafnshjkox]-[PAGSUFXZ](-\w+)*$/)) {
+            throw new TypeError("CoT to 2525B can only be applied to well-formed Atom type CoT Events.")
+        }
+
+        const m2525bChars = cotType.substring(4).replace(/[^A-Z0-9]+/g, "");
+        const m2525bBattleDim = m2525bChars.substring(0, 1);
+
+        const cotAffiliation = cotType.substring(2, 3);
+        const m2525bAffiliation = (cotAffiliation === "o" || cotAffiliation === "x")
+            ? "U"
+            : cotAffiliation.toUpperCase();
+
+            const m2525bFuncId = m2525bChars.length > 1
+                ? m2525bChars.substring(1).padEnd(6, "-").substring(0, 6)
+                : "------";
+
+        return `S${m2525bAffiliation}${m2525bBattleDim}P${m2525bFuncId}-----`;
+    }
+
+    static from2525B(sidc : string) : string {
+        if (!/^S[PUAFNSHGWMDLJK-][PAGSUFXZ-][AP-][A-Z0-9-]{10}[AECGNS-]$/.test(sidc)) {
+            throw new Error("2525B to CoT can only be applied to well-formed warfighting 2525B SIDCs.");
+        }
+
+        const m2525bAffiliation = sidc.substring(1, 2);
+        const cotAffiliation = ["G", "W", "M", "D", "L"].includes(m2525bAffiliation)
+            ? "f"
+            : m2525bAffiliation === "-"
+                ? "o"
+                : m2525bAffiliation.toLowerCase();
+
+                const cotBattleDim = sidc.substring(2, 3);
+                const cotFuncId = Array.from(sidc.substring(4, 10).replace(/[^A-Z0-9]+/g, ""))
+                .map((x) => `-${x}`)
+                .join("");
+
+        return `a-${cotAffiliation}-${cotBattleDim}${cotFuncId}`;
+    }
+}

package/lib/utils/type.ts

@@ -0,0 +1,53 @@
+import { Static, TSchema, TUnknown } from '@sinclair/typebox'
+import { Value } from '@sinclair/typebox/value'
+
+export type TypeOpts = {
+    verbose?: boolean;
+    default?: boolean;
+    convert?: boolean;
+    clean?: boolean;
+}
+
+export default class TypeValidator {
+    /**
+     * Arbitrary JSON objects occasionally need to get typed as part of an ETL
+     * This function provides the ability to strictly type unknown objects at runtime
+     */
+    static type<T extends TSchema = TUnknown>(
+        type: T,
+        body: unknown,
+        opts?: TypeOpts
+    ): Static<T> {
+        if (!opts) opts = {};
+        if (opts.verbose === undefined) opts.verbose = false;
+        if (opts.default === undefined) opts.default = true;
+        if (opts.convert === undefined) opts.convert = true;
+        if (opts.clean === undefined) opts.clean = true;
+
+        if (opts.default) {
+            Value.Default(type, body)
+        }
+
+        if (opts.clean) {
+            Value.Clean(type, body)
+        }
+
+        if (opts.convert) {
+            Value.Convert(type, body)
+        }
+
+        const result = Value.Check(type, body)
+
+        if (result) return body;
+
+        const errors = Value.Errors(type, body);
+
+        const firstError = errors.First();
+
+        if (opts.verbose) {
+            throw new Error(`Internal Validation Error: ${JSON.stringify(firstError)} -- Body: ${JSON.stringify(body)}`);
+        } else {
+            throw new Error(`Internal Validation Error`);
+        }
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@tak-ps/node-cot",
     "type": "module",
-    "version": "12.30.1",
+    "version": "12.31.0",
     "description": "Lightweight JavaScript library for parsing and manipulating TAK messages",
     "author": "Nick Ingalls <nick@ingalls.ca>",
     "main": "dist/index.js",
@@ -30,6 +30,7 @@
         "archiver": "^7.0.1",
         "color": "^5.0.0",
         "json-diff-ts": "^4.0.1",
+        "milsymbol": "^3.0.2",
         "node-stream-zip": "^1.15.0",
         "protobufjs": "^7.3.0",
         "rimraf": "^6.0.0",