@tak-ps/node-cot 2.7.0 → 2.8.1

package/.github/workflows/release.yml

@@ -26,4 +26,4 @@ jobs:
             - name: npm publish
               run: npm publish
               env:
-                  NPM_TOKEN: ${{ secrets.NPM_SECRET }}
+                  NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

package/CHANGELOG.md

@@ -10,14 +10,16 @@
 
 ## Version History
 
-### v2.7.0
+### v2.8.1
 
-- :rocket: Improved date parsing in CoT messages created using from_geojson
+- :bug: Fix typo in error message
 
-### v2.6.0
+### v2.8.0
 
-- :tada: Add support for passing style properties via GeoJSON Properties
-- :rocket: Add support for encoding/decoding 32bit signed ARGB values
+- :bug: Significant improvements to start/time/stale parsing
+- :white_check_mark: Add tests for date parsing
+- :rocket: Support parsing `Date` types
+- :arrow_up: General Dep Update
 
 ### v2.5.0
 

package/lib/util.js

@@ -10,10 +10,13 @@ export default class Util {
      *
      * @param {String} type CoT Type
      * @param {String} how CoT how
+     * @param {Date|string|null} time              Time of CoT Message - if omitted, current time is used
+     * @param {Date|string|null} start             Start Time of CoT - if omitted, current time is used
+     * @param {Date|string|null|numeric} stale     Expiration of CoT - if null now+20s is used. Alternative an integer representing the ms offset
      *
      * @returns {Object}
      */
-    static cot_event_attr(type, how) {
+    static cot_event_attr(type, how, time, start, stale) {
         if (!type) throw new Error('type param required');
         if (!how) throw new Error('how param required');
 
@@ -22,7 +25,7 @@ export default class Util {
             ...Util.cot_uuid(),
             type,
             how,
-            ...Util.cot_date()
+            ...Util.cot_date(time, start, stale)
         };
     }
 
@@ -85,24 +88,22 @@ export default class Util {
      *
      * cot_date() - Time: now, Start: now, Stale: now + 20s
      *
-     * @param {Date|null} time              Time of CoT Message - if omitted, current time is used
-     * @param {Date|null} start             Start Time of CoT - if omitted, current time is used
-     * @param {Date|null|numeric} stale     Expiration of CoT - if null now+20s is used. Alternative an integer representing the start + ms
+     * @param {Date|string|null} time              Time of CoT Message - if omitted, current time is used
+     * @param {Date|string|null} start             Start Time of CoT - if omitted, current time is used
+     * @param {Date|string|null|numeric} stale     Expiration of CoT - if null now+20s is used. Alternative an integer representing the ms offset
      *
      * @returns {Object}
      */
     static cot_date(time, start, stale) {
         const now = Date.now();
 
-        if (!time) time = new Date(now).toISOString();
-        if (!start) start = new Date(now).toISOString();
+        time = new Date(time || now).toISOString();
+        start = new Date(start || now).toISOString();
 
         if (!stale) {
-            stale = new Date(new Date(start).getTime() + 20 * 1000).toISOString();
+            stale = new Date(+new Date(start) + 20 * 1000).toISOString();
         } else if (!isNaN(parseInt(stale))) {
-            stale = new Date(new Date(start).getTime() + stale * 1000).toISOString();
-        } else if (typeof stale === 'string') {
-            stale = new Date(stale).toISOString();
+            stale = new Date(+new Date(start) + stale).toISOString();
         }
 
         return { time, start, stale };

package/lib/xml.js

@@ -52,7 +52,13 @@ export default class XMLCot {
 
         const cot = {
             event: {
-                _attributes: Util.cot_event_attr(feature.properties.type || 'a-f-G', feature.properties.how || 'm-g'),
+                _attributes: Util.cot_event_attr(
+                    feature.properties.type || 'a-f-G',
+                    feature.properties.how || 'm-g',
+                    feature.properties.time,
+                    feature.properties.start,
+                    feature.properties.stale
+                ),
                 point: Util.cot_point(),
                 detail: Util.cot_event_detail(feature.properties.callsign)
             }
@@ -61,15 +67,8 @@ 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 ['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');
+        if (!['Point', 'Polygon', 'LineString'].includes(feature.geometry.type)) throw new Error('Unsupported Geometry Type');
 
         if (feature.geometry.type === 'Point') {
             cot.event.point._attributes.lon = feature.geometry.coordinates[0];

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@tak-ps/node-cot",
     "type": "module",
-    "version": "2.7.0",
+    "version": "2.8.1",
     "description": "Lightweight JavaScript library for parsing and manipulating TAK messages",
     "main": "index.js",
     "scripts": {

package/test/from_geojson.test.js

@@ -123,3 +123,60 @@ test('XML.from_geojson - LineString', (t) => {
 
     t.end();
 });
+
+test('XML.from_geojson - Start', (t) => {
+    const geo = XML.from_geojson({
+        type: 'Feature',
+        properties: {
+            // 1hr in the future
+            start: new Date(+new Date() + 60 * 60 * 1000)
+        },
+        geometry: {
+            type: 'Point',
+            coordinates: [1.1, 2.2]
+        }
+    });
+
+    // Approx +/- 100ms + 1hr ahead of Now
+    t.ok(+new Date(geo.raw.event._attributes.start) > +new Date() + 60 * 60 * 1000 - 100);
+    t.ok(+new Date(geo.raw.event._attributes.start) < +new Date() + 60 * 60 * 1000 + 100);
+
+    // Approx +/- 100ms ahead of Now
+    t.ok(+new Date(geo.raw.event._attributes.time) > +new Date() - 100);
+    t.ok(+new Date(geo.raw.event._attributes.time) < +new Date() + 100);
+
+    // Approx +/- 100ms +1hr20s ahead of now
+    t.ok(+new Date(geo.raw.event._attributes.stale) > +new Date(geo.raw.event._attributes.start) - 100 + 20 * 1000);
+    t.ok(+new Date(geo.raw.event._attributes.stale) < +new Date(geo.raw.event._attributes.start) + 100 + 20 * 1000);
+
+    t.end();
+});
+
+test('XML.from_geojson - Start/Stale', (t) => {
+    const geo = XML.from_geojson({
+        type: 'Feature',
+        properties: {
+            // 1hr in the future
+            start: new Date(+new Date() + 60 * 60 * 1000),
+            stale: 60 * 1000
+        },
+        geometry: {
+            type: 'Point',
+            coordinates: [1.1, 2.2]
+        }
+    });
+
+    // Approx +/- 100ms + 1hr ahead of Now
+    t.ok(+new Date(geo.raw.event._attributes.start) > +new Date() + 60 * 60 * 1000 - 100);
+    t.ok(+new Date(geo.raw.event._attributes.start) < +new Date() + 60 * 60 * 1000 + 100);
+
+    // Approx +/- 100ms ahead of Now
+    t.ok(+new Date(geo.raw.event._attributes.time) > +new Date() - 100);
+    t.ok(+new Date(geo.raw.event._attributes.time) < +new Date() + 100);
+
+    // Approx +/- 100ms +1hr60s ahead of now
+    t.ok(+new Date(geo.raw.event._attributes.stale) > +new Date(geo.raw.event._attributes.start) - 100 + 60 * 1000);
+    t.ok(+new Date(geo.raw.event._attributes.stale) < +new Date(geo.raw.event._attributes.start) + 100 + 60 * 1000);
+
+    t.end();
+});

package/test/util.test.js

@@ -0,0 +1,34 @@
+import test from 'tape';
+import Util from '../lib/util.js';
+
+test('Util.cot_date - default', (t) => {
+    const res = Util.cot_date();
+
+    // Within 100ms of current time
+    t.ok(+new Date(res.time) > +new Date() - 100, 'res.time within 100ms of current time');
+
+    // res.start is the same as res.time
+    t.equals(+new Date(res.start), +new Date(res.time), 'by default res.start === res.time');
+
+    // Approx 20s ahead of start
+    t.ok(+new Date(res.stale) > +new Date(res.start) + 20 * 1000 - 100);
+    t.ok(+new Date(res.stale) < +new Date(res.start) + 20 * 1000 + 100);
+
+    t.end();
+});
+
+test('Util.cot_date - stale', (t) => {
+    const res = Util.cot_date(null, null, 1000);
+
+    // Within 100ms of current time
+    t.ok(+new Date(res.time) > +new Date() - 100, 'res.time within 100ms of current time');
+
+    // res.start is the same as res.time
+    t.equals(+new Date(res.start), +new Date(res.time), 'by default res.start === res.time');
+
+    // Approx 1s ahead of start
+    t.ok(+new Date(res.stale) > +new Date(res.start) + 1 * 1000 - 100);
+    t.ok(+new Date(res.stale) < +new Date(res.start) + 1 * 1000 + 100);
+
+    t.end();
+});