@tak-ps/node-cot 2.5.0 → 2.7.0

package/CHANGELOG.md

@@ -10,6 +10,15 @@
 
 ## Version History
 
+### v2.7.0
+
+- :rocket: Improved date parsing in CoT messages created using from_geojson
+
+### 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

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/util.js

@@ -98,9 +98,11 @@ export default class Util {
         if (!start) start = new Date(now).toISOString();
 
         if (!stale) {
-            stale = new Date(now + 20 * 1000).toISOString();
+            stale = new Date(new Date(start).getTime() + 20 * 1000).toISOString();
         } else if (!isNaN(parseInt(stale))) {
-            stale = new Date(now + 20 * 1000).toISOString();
+            stale = new Date(new Date(start).getTime() + stale * 1000).toISOString();
+        } else if (typeof stale === 'string') {
+            stale = new Date(stale).toISOString();
         }
 
         return { time, start, stale };

package/lib/xml.js

@@ -1,5 +1,6 @@
 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';
@@ -60,10 +61,13 @@ export default class XMLCot {
         if (feature.id) cot.event._attributes.uid = feature.id;
         if (feature.properties.callsign && !feature.id) cot.event._attributes.uid = feature.properties.callsign;
 
-        for (const key of ['time', 'start', 'stale', 'type', 'how']) {
+        for (const key of ['type', 'how']) {
             if (feature.properties[key]) cot.event._attributes[key] = feature.properties[key];
         }
 
+        const dts = Util.cot_date(feature.properties.time, feature.properties.start, feature.properties.stale);
+        Object.assign(cot.event._attributes, dts);
+
         if (!feature.geometry) throw new Error('Must have Geometry');
         if (!['Point', 'Polygon', 'LineString'].includes(feature.geometry.type)) throw new Error('Unsupported Geoemtry Type');
 
@@ -71,36 +75,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];