@tak-ps/node-cot 2.4.0 → 2.6.0

package/.github/workflows/release.yml

@@ -0,0 +1,29 @@
+name: NPM Release
+
+on:
+    push:
+        tags:
+        - '*'
+
+jobs:
+    build:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v3
+
+            - name: Get tag
+              id: tag
+              uses: dawidd6/action-get-tag@v1
+
+            - uses: actions/setup-node@v3
+              with:
+                  node-version: 18
+                  registry-url: https://registry.npmjs.org/
+
+            - name: npm install
+              run: npm install
+
+            - name: npm publish
+              run: npm publish
+              env:
+                  NPM_TOKEN: ${{ secrets.NPM_SECRET }}

package/.github/workflows/test.yml

@@ -1,6 +1,9 @@
 name: Test
 
 on:
+    push:
+        branches:
+            - main
     pull_request:
         types:
             - opened
@@ -25,8 +28,8 @@ jobs:
             - name: Install
               run: npm install
 
-            - name: Test
-              run: npm test
-
             - name: Lint
               run: npm run lint
+
+            - name: Test
+              run: npm test

package/CHANGELOG.md

@@ -10,6 +10,15 @@
 
 ## Version History
 
+### v2.6.0
+
+- :tada: Add support for passing style properties via GeoJSON Properties
+- :rocket: Add support for encoding/decoding 32bit signed ARGB values
+
+### v2.5.0
+
+- :tada: Automatically perform basic schema validation on CoT Creation
+
 ### v2.4.0
 
 - :tada: `from_geojson(Feature.LineString)` Support

package/index.js

@@ -1,3 +1,3 @@
-import XML from './src/xml.js';
+import XML from './lib/xml.js';
 
 export { XML };

package/lib/color.js

@@ -0,0 +1,46 @@
+import _color from 'color';
+
+/**
+ * Helper functions for working with CoT Colours
+ *
+ * @param {Number|Number[]} color 32bit packged ARGB or [A, R, G, B]
+ * @class
+ */
+export default class Color {
+    constructor(color) {
+        if (!isNaN(Number(color))) {
+            this.r = (color >> 16) & 255;
+            this.g = (color >>  8) & 255;
+            this.b = (color >> 0) & 255;
+            this.a = ((color >> 24) & 255) / 255;
+        } else if (Array.isArray(color)) {
+            this.a = color[0];
+            this.r = color[1];
+            this.g = color[2];
+            this.b = color[3];
+        } else {
+            const c = _color(color);
+
+            this.a = c.valpha;
+            this.r = c.color[0];
+            this.g = c.color[1];
+            this.b = c.color[2];
+        }
+    }
+
+    as_32bit() {
+        return (this.a << 24) | (this.r << 16) | (this.g << 8) | this.b;
+    }
+
+    as_opacity() {
+        return this.a;
+    }
+
+    as_argb() {
+        return [this.a, this.r, this.b, this.g];
+    }
+
+    as_rgb() {
+        return [this.r, this.b, this.g];
+    }
+}

package/lib/schema.json

@@ -0,0 +1,83 @@
+{
+    "type": "object",
+    "required": [
+        "event"
+    ],
+    "properties": {
+        "event": {
+            "type": "object",
+            "required": [
+                "_attributes",
+                "point"
+            ],
+            "properties": {
+                "_attributes": {
+                    "type": "object",
+                    "required": [
+                        "version",
+                        "uid",
+                        "type",
+                        "time",
+                        "start",
+                        "stale"
+                    ],
+                    "properties": {
+                        "version": {
+                            "type": "string"
+                        },
+                        "uid": {
+                            "type": "string"
+                        },
+                        "type": {
+                            "type": "string"
+                        },
+                        "time": {
+                            "type": "string"
+                        },
+                        "start": {
+                            "type": "string"
+                        },
+                        "stale": {
+                            "type": "string"
+                        }
+                    }
+                },
+                "point": {
+                    "type": "object",
+                    "required": [
+                        "_attributes"
+                    ],
+                    "properties": {
+                        "_attributes": {
+                            "type": "object",
+                            "required": [
+                                "lat",
+                                "lon",
+                                "hae",
+                                "ce",
+                                "le"
+                            ],
+                            "properties": {
+                                "lat": {
+                                    "type": "number"
+                                },
+                                "lon": {
+                                    "type": "number"
+                                },
+                                "hae": {
+                                    "type": "number"
+                                },
+                                "ce": {
+                                    "type": "number"
+                                },
+                                "le": {
+                                    "type": "number"
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

package/{src → lib}/xml.js

@@ -1,6 +1,12 @@
 import xmljs from 'xml-js';
 import Util from './util.js';
+import Color from './color.js';
 import PointOnFeature from '@turf/point-on-feature';
+import AJV from 'ajv';
+import fs from 'fs';
+
+const ajv = (new AJV({ allErrors: true })).compile(JSON.parse(fs.readFileSync(new URL('./schema.json', import.meta.url))));
+
 
 /**
  * Convert to and from an XML CoT message
@@ -26,6 +32,11 @@ export default class XMLCot {
                 this.raw.event.point._attributes[key] = parseFloat(this.raw.event.point._attributes[key]);
             }
         }
+
+        if (!this.raw.event._attributes.uid) this.raw.event._attributes.uuid = Util.cot_uuid().uid;
+
+        ajv(this.raw);
+        if (ajv.errors) throw new Error(ajv.errors[0].message);
     }
 
     /**
@@ -61,36 +72,48 @@ export default class XMLCot {
             cot.event.point._attributes.lon = feature.geometry.coordinates[0];
             cot.event.point._attributes.lat = feature.geometry.coordinates[1];
         } else if (['Polygon', 'LineString'].includes(feature.geometry.type)) {
-            cot.event._attributes.type = 'u-d-f';
+            const stroke = new Color(feature.properties.stroke || -1761607936);
+            if (feature.properties['stroke-opacity']) stroke.a = feature.properties['stroke-opacity'];
+            cot.event.detail.strokeColor = { _attributes: { value: stroke.as_32bit() } };
 
-            if (feature.geometry.type === 'Polygon') {
-                cot.event._attributes.type = 'u-d-r';
+            if (!feature.properties['stroke-width']) feature.properties['stroke-width'] = 3;
+            cot.event.detail.strokeWeight = { _attributes: {
+                value: feature.properties['stroke-width']
+            } };
+
+            if (!feature.properties['stroke-style']) feature.properties['stroke-style'] = 'solid';
+            cot.event.detail.strokeStyle = { _attributes: {
+                value: feature.properties['stroke-style']
+            } };
+
+            if (feature.geometry.type === 'LineString') {
+                cot.event._attributes.type = 'u-d-f';
 
-                // Inner rings are not yet supported
                 cot.event.detail.link = [];
-                feature.geometry.coordinates[0].pop(); // Dont' Close Loop in COT
-                for (const coord of feature.geometry.coordinates[0]) {
+                for (const coord of feature.geometry.coordinates) {
                     cot.event.detail.link.push({
                         _attributes: { point: `${coord[1]},${coord[0]}` }
                     });
                 }
-            } else if (feature.geometry.type === 'LineString') {
-                cot.event._attributes.type = 'u-d-f';
+            } else if (feature.geometry.type === 'Polygon') {
+                cot.event._attributes.type = 'u-d-r';
 
+                // Inner rings are not yet supported
                 cot.event.detail.link = [];
-                for (const coord of feature.geometry.coordinates) {
+                feature.geometry.coordinates[0].pop(); // Dont' Close Loop in COT
+                for (const coord of feature.geometry.coordinates[0]) {
                     cot.event.detail.link.push({
                         _attributes: { point: `${coord[1]},${coord[0]}` }
                     });
                 }
+
+                const fill = new Color(feature.properties.fill || -1761607936);
+                if (feature.properties['fill-opacity']) fill.a = feature.properties['fill-opacity'];
+                cot.event.detail.fillColor = { _attributes: { value: fill.as_32bit() } };
             }
 
             cot.event.detail.labels_on = { _attributes: { value: 'false' } };
             cot.event.detail.tog = { _attributes: { enabled: '0' } };
-            cot.event.detail.strokeColor = { _attributes: { value: '-256' } };
-            cot.event.detail.strokeWeight = { _attributes: { value: '3.0' } };
-            cot.event.detail.strokeStyle = { _attributes: { value: 'solid' } };
-            cot.event.detail.fillColor = { _attributes: { value: '-1761607936' } };
 
             const centre = PointOnFeature(feature);
             cot.event.point._attributes.lon = centre.geometry.coordinates[0];

package/package.json

@@ -1,15 +1,17 @@
 {
     "name": "@tak-ps/node-cot",
     "type": "module",
-    "version": "2.4.0",
+    "version": "2.6.0",
     "description": "Lightweight JavaScript library for parsing and manipulating TAK messages",
     "main": "index.js",
     "scripts": {
         "test": "tape test/**.test.js",
-        "lint": "eslint *.js src/*.js test/*.js"
+        "lint": "eslint *.js lib/*.js test/*.js"
     },
     "dependencies": {
         "@turf/point-on-feature": "^6.5.0",
+        "ajv": "^8.11.2",
+        "color": "^4.2.3",
         "protobufjs": "^7.1.2",
         "uuid": "^9.0.0",
         "xml-js": "^1.6.11"

package/test/from_geojson.test.js

@@ -68,10 +68,10 @@ test('XML.from_geojson - Polygon', (t) => {
         ],
         labels_on: { _attributes: { value: 'false' } },
         tog: { _attributes: { enabled: '0' } },
-        strokeColor: { _attributes: { value: '-256' } },
-        strokeWeight: { _attributes: { value: '3.0' } },
+        strokeColor: { _attributes: { value: 16776960 } },
+        strokeWeight: { _attributes: { value: 3 } },
         strokeStyle: { _attributes: { value: 'solid' } },
-        fillColor: { _attributes: { value: '-1761607936' } }
+        fillColor: { _attributes: { value: 16776960 } }
     });
 
     t.end();
@@ -116,10 +116,9 @@ test('XML.from_geojson - LineString', (t) => {
         ],
         labels_on: { _attributes: { value: 'false' } },
         tog: { _attributes: { enabled: '0' } },
-        strokeColor: { _attributes: { value: '-256' } },
-        strokeWeight: { _attributes: { value: '3.0' } },
+        strokeColor: { _attributes: { value: 16776960 } },
+        strokeWeight: { _attributes: { value: 3 } },
         strokeStyle: { _attributes: { value: 'solid' } },
-        fillColor: { _attributes: { value: '-1761607936' } }
     });
 
     t.end();

package/test/styles.test.js

@@ -0,0 +1,33 @@
+import test from 'tape';
+import { XML } from '../index.js';
+
+test('XML.from_geojson - Polygon Style', (t) => {
+    const geo = XML.from_geojson({
+        type: 'Feature',
+        properties: {
+
+        },
+        geometry: {
+            type: 'Point',
+            coordinates: [1.1, 2.2]
+        }
+    });
+
+    t.equals(geo.raw.event._attributes.version, '2.0');
+    t.equals(geo.raw.event._attributes.type, 'a-f-G');
+    t.equals(geo.raw.event._attributes.how, 'm-g');
+    t.equals(geo.raw.event._attributes.uid.length, 36);
+    t.equals(geo.raw.event._attributes.time.length, 24);
+    t.equals(geo.raw.event._attributes.start.length, 24);
+    t.equals(geo.raw.event._attributes.stale.length, 24);
+
+    t.deepEquals(geo.raw.event.point, {
+        _attributes: { lat: 2.2, lon: 1.1, hae: 0, ce: 9999999, le: 9999999 }
+    });
+
+    t.deepEquals(geo.raw.event.detail, {
+        contact: { _attributes: { callsign: 'UNKNOWN' } }
+    });
+
+    t.end();
+});

package/scripts/convert.js

@@ -1,29 +0,0 @@
-const path = require('path')
-const {cot, proto} = require(path.join(__dirname, '../index.js'))
-
-const run = (message) => {
-    if (!message) {
-        console.error('Enter a TAK message')
-        return
-    }
-
-    const bufferMessage = typeof message !== Buffer ? Buffer.from(message, 'hex') : message
-
-    if (bufferMessage[0] === 191) { // TAK message format 0xbf
-        console.log('TAK message received')
-        const trimmedBuffer = bufferMessage.slice(3, bufferMessage.length) // remove tak message header from content
-        if (bufferMessage[1] === 0) { // is COT XML
-            console.error('Enter a TAK proto message')
-        } else if (bufferMessage[1] === 1) { // is Protobuf
-            console.log('TAK protobuf format')
-            const protoMessage = proto.proto2js(trimmedBuffer)
-            const cotMessage = proto.protojs2cotjs(protoMessage)
-            console.log(cotMessage)
-            console.log(cot.js2xml(cotMessage))
-        }
-    } else { // not TAK message format
-        console.error('Enter a TAK proto message')
-    }
-}
-
-run(process.argv[2])

package/scripts/parse.js

@@ -1,34 +0,0 @@
-const path = require('path')
-const {cot, proto} = require(path.join(__dirname, '../index.js'))
-
-// https://github.com/deptofdefense/AndroidTacticalAssaultKit-CIV/blob/master/commoncommo/core/impl/protobuf/protocol.txt
-
-const run = (message) => {
-    if (!message) {
-        console.error('Enter a TAK message')
-        return
-    }
-
-    const bufferMessage = typeof message !== Buffer ? Buffer.from(message, 'hex') : message
-
-    if (bufferMessage[0] === 191) { // TAK message format 0xbf
-        console.log('TAK message received')
-        const trimmedBuffer = bufferMessage.slice(3, bufferMessage.length) // remove tak message header from content
-        if (bufferMessage[1] === 0) { // is COT XML
-            console.log('COT XML format')
-            console.log(cot.xml2js(trimmedBuffer)) // try parsing raw XML
-        } else if (bufferMessage[1] === 1) { // is Protobuf
-            console.log('TAK protobuf format')
-            console.log(proto.proto2js(trimmedBuffer))
-        }
-    } else { // not TAK message format
-        try {
-            console.log('COT XML received')
-            console.log(cot.xml2js(message)) // try parsing raw XML
-        } catch (e) {
-            console.error('Failed to parse message', e)
-        }
-    }
-}
-
-run(process.argv[2])