node-mavlink 1.2.0 → 1.3.1

package/dist/lib/serialization.d.ts

@@ -1,58 +1,18 @@
 /// <reference types="node" />
-import { int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t, float, double } from 'mavlink-mappings';
+declare type Serializer = ((value: any, buffer: Buffer, offset: number) => void) | ((value: any, buffer: Buffer, offset: number, maxLen: number) => void);
 /**
  * A dictionary containing functions that serialize a certain value based on the field type
  */
 export declare const SERIALIZERS: {
-    uint8_t_mavlink_version: (value: uint8_t, buffer: Buffer, offset: number) => number;
-    char: (value: int8_t, buffer: Buffer, offset: number) => number;
-    int8_t: (value: int8_t, buffer: Buffer, offset: number) => number;
-    uint8_t: (value: uint8_t, buffer: Buffer, offset: number) => number;
-    int16_t: (value: int16_t, buffer: Buffer, offset: number) => number;
-    uint16_t: (value: uint16_t, buffer: Buffer, offset: number) => number;
-    int32_t: (value: int32_t, buffer: Buffer, offset: number) => number;
-    uint32_t: (value: uint32_t, buffer: Buffer, offset: number) => number;
-    int64_t: (value: int64_t, buffer: Buffer, offset: number) => number;
-    uint64_t: (value: uint64_t, buffer: Buffer, offset: number) => number;
-    float: (value: float, buffer: Buffer, offset: number) => number;
-    double: (value: double, buffer: Buffer, offset: number) => number;
-    'char[]': (value: string, buffer: Buffer, offset: number, maxLen: number) => void;
-    'int8_t[]': (value: uint8_t[], buffer: Buffer, offset: number, maxLen: number) => void;
-    'uint8_t[]': (value: uint8_t[], buffer: Buffer, offset: number, maxLen: number) => void;
-    'int16_t[]': (value: uint16_t[], buffer: Buffer, offset: number, maxLen: number) => void;
-    'uint16_t[]': (value: uint16_t[], buffer: Buffer, offset: number, maxLen: number) => void;
-    'int32_t[]': (value: uint32_t[], buffer: Buffer, offset: number, maxLen: number) => void;
-    'uint32_t[]': (value: uint32_t[], buffer: Buffer, offset: number, maxLen: number) => void;
-    'int64_t[]': (value: uint64_t[], buffer: Buffer, offset: number, maxLen: number) => void;
-    'uint64_t[]': (value: uint64_t[], buffer: Buffer, offset: number, maxLen: number) => void;
-    'float[]': (value: float[], buffer: Buffer, offset: number, maxLen: number) => void;
-    'double[]': (value: double[], buffer: Buffer, offset: number, maxLen: number) => void;
+    [x: string]: Serializer;
+};
+declare type Deserializer = ((buffer: Buffer, offset: number) => any) | ((buffer: Buffer, offset: number, length: number) => any);
+declare type Deserializers = {
+    [key: string]: Deserializer;
 };
 /**
  * A dictionary containing functions that deserialize a certain value based on the field type
  */
-export declare const DESERIALIZERS: {
-    uint8_t_mavlink_version: (buffer: Buffer, offset: number) => number;
-    char: (buffer: Buffer, offset: number) => string;
-    int8_t: (buffer: Buffer, offset: number) => number;
-    uint8_t: (buffer: Buffer, offset: number) => number;
-    int16_t: (buffer: Buffer, offset: number) => number;
-    uint16_t: (buffer: Buffer, offset: number) => number;
-    int32_t: (buffer: Buffer, offset: number) => number;
-    uint32_t: (buffer: Buffer, offset: number) => number;
-    int64_t: (buffer: Buffer, offset: number) => bigint;
-    uint64_t: (buffer: Buffer, offset: number) => bigint;
-    float: (buffer: Buffer, offset: number) => number;
-    double: (buffer: Buffer, offset: number) => number;
-    'char[]': (buffer: Buffer, offset: number, length: number) => string;
-    'int8_t[]': (buffer: Buffer, offset: number, length: number) => number[];
-    'uint8_t[]': (buffer: Buffer, offset: number, length: number) => number[];
-    'int16_t[]': (buffer: Buffer, offset: number, length: number) => number[];
-    'uint16_t[]': (buffer: Buffer, offset: number, length: number) => number[];
-    'int32_t[]': (buffer: Buffer, offset: number, length: number) => number[];
-    'uint32_t[]': (buffer: Buffer, offset: number, length: number) => number[];
-    'int64_t[]': (buffer: Buffer, offset: number, length: number) => BigInt[];
-    'uint64_t[]': (buffer: Buffer, offset: number, length: number) => BigInt[];
-    'float[]': (buffer: Buffer, offset: number, length: number) => number[];
-    'double[]': (buffer: Buffer, offset: number, length: number) => number[];
-};
+export declare const DESERIALIZERS: Deserializers;
+export {};
+//# sourceMappingURL=serialization.d.ts.map

package/dist/lib/serialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialization.d.ts","sourceRoot":"","sources":["../../lib/serialization.ts"],"names":[],"mappings":";AAaA,aAAK,UAAU,GACd,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC,GACtD,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC,CAAA;AAiFvE;;GAEG;AACH,eAAO,MAAM,WAAW;;CAIvB,CAAA;AAED,aAAK,YAAY,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,GAAG,CAAC,CAAA;AACzH,aAAK,aAAa,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAA;CAAE,CAAA;AAqFpD;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,aAI3B,CAAA"}

package/dist/lib/serialization.js

@@ -1 +1,184 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.DESERIALIZERS=exports.SERIALIZERS=void 0,exports.SERIALIZERS={uint8_t_mavlink_version:(r,e,n)=>e.writeUInt8(r,n),char:(r,e,n)=>e.writeUInt8(r,n),int8_t:(r,e,n)=>e.writeInt8(r,n),uint8_t:(r,e,n)=>e.writeUInt8(r,n),int16_t:(r,e,n)=>e.writeInt16LE(r,n),uint16_t:(r,e,n)=>e.writeUInt16LE(r,n),int32_t:(r,e,n)=>e.writeInt32LE(r,n),uint32_t:(r,e,n)=>e.writeUInt32LE(r,n),int64_t:(r,e,n)=>e.writeBigInt64LE(r,n),uint64_t:(r,e,n)=>e.writeBigUInt64LE(r,n),float:(r,e,n)=>e.writeFloatLE(r,n),double:(r,e,n)=>e.writeDoubleLE(r,n),"char[]":(r,e,n,i)=>{for(let t=0;t<r.length&&t<i;t++){const o=r.charCodeAt(t);e.writeUInt8(o,n+t)}},"int8_t[]":(r,e,n,i)=>{for(let t=0;t<r.length&&t<i;t++)e.writeInt8(r[t],n+t)},"uint8_t[]":(r,e,n,i)=>{for(let t=0;t<r.length&&t<i;t++)e.writeUInt8(r[t],n+t)},"int16_t[]":(r,e,n,i)=>{for(let t=0;t<r.length&&t<i;t++)e.writeInt16LE(r[t],n+t*2)},"uint16_t[]":(r,e,n,i)=>{for(let t=0;t<r.length&&t<i;t++)e.writeUInt16LE(r[t],n+t*2)},"int32_t[]":(r,e,n,i)=>{for(let t=0;t<r.length&&t<i;t++)e.writeInt32LE(r[t],n+t*4)},"uint32_t[]":(r,e,n,i)=>{for(let t=0;t<r.length&&t<i;t++)e.writeUInt32LE(r[t],n+t*4)},"int64_t[]":(r,e,n,i)=>{for(let t=0;t<r.length&&t<i;t++)e.writeBigInt64LE(r[t],n+t*8)},"uint64_t[]":(r,e,n,i)=>{for(let t=0;t<r.length&&t<i;t++)e.writeBigUInt64LE(r[t],n+t*8)},"float[]":(r,e,n,i)=>{for(let t=0;t<r.length&&t<i;t++)e.writeFloatLE(r[t],n+t*4)},"double[]":(r,e,n,i)=>{for(let t=0;t<r.length&&t<i;t++)e.writeDoubleLE(r[t],n+t*8)}},exports.DESERIALIZERS={uint8_t_mavlink_version:(r,e)=>r.readUInt8(e),char:(r,e)=>String.fromCharCode(r.readUInt8(e)),int8_t:(r,e)=>r.readInt8(e),uint8_t:(r,e)=>r.readUInt8(e),int16_t:(r,e)=>r.readInt16LE(e),uint16_t:(r,e)=>r.readUInt16LE(e),int32_t:(r,e)=>r.readInt32LE(e),uint32_t:(r,e)=>r.readUInt32LE(e),int64_t:(r,e)=>r.readBigInt64LE(e),uint64_t:(r,e)=>r.readBigUInt64LE(e),float:(r,e)=>r.readFloatLE(e),double:(r,e)=>r.readDoubleLE(e),"char[]":(r,e,n)=>{let i="";for(let t=0;t<n;t++){const o=r.readUInt8(e+t);if(o!==0)i+=String.fromCharCode(o);else break}return i},"int8_t[]":(r,e,n)=>{const i=new Array(n);for(let t=0;t<n;t++)i[t]=r.readInt8(e+t);return i},"uint8_t[]":(r,e,n)=>{const i=new Array(n);for(let t=0;t<n;t++)i[t]=r.readUInt8(e+t);return i},"int16_t[]":(r,e,n)=>{const i=new Array(n);for(let t=0;t<n;t++)i[t]=r.readInt16LE(e+t*2);return i},"uint16_t[]":(r,e,n)=>{const i=new Array(n);for(let t=0;t<n;t++)i[t]=r.readUInt16LE(e+t*2);return i},"int32_t[]":(r,e,n)=>{const i=new Array(n);for(let t=0;t<n;t++)i[t]=r.readInt32LE(e+t*4);return i},"uint32_t[]":(r,e,n)=>{const i=new Array(n);for(let t=0;t<n;t++)i[t]=r.readUInt32LE(e+t*4);return i},"int64_t[]":(r,e,n)=>{const i=new Array(n);for(let t=0;t<n;t++)i[t]=r.readBigInt64LE(e+t*8);return i},"uint64_t[]":(r,e,n)=>{const i=new Array(n);for(let t=0;t<n;t++)i[t]=r.readBigUInt64LE(e+t*8);return i},"float[]":(r,e,n)=>{const i=new Array(n);for(let t=0;t<n;t++)i[t]=r.readFloatLE(e+t*4);return i},"double[]":(r,e,n)=>{const i=new Array(n);for(let t=0;t<n;t++)i[t]=r.readDoubleLE(e+t*8);return i}};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DESERIALIZERS = exports.SERIALIZERS = void 0;
+const SPECIAL_TYPES_SERIALIZERS = {
+    'uint8_t_mavlink_version': (value, buffer, offset) => buffer.writeUInt8(value, offset),
+};
+const SINGULAR_TYPES_SERIALIZERS = {
+    'char': (value, buffer, offset) => buffer.writeUInt8(value, offset),
+    'int8_t': (value, buffer, offset) => buffer.writeInt8(value, offset),
+    'uint8_t': (value, buffer, offset) => buffer.writeUInt8(value, offset),
+    'int16_t': (value, buffer, offset) => buffer.writeInt16LE(value, offset),
+    'uint16_t': (value, buffer, offset) => buffer.writeUInt16LE(value, offset),
+    'int32_t': (value, buffer, offset) => buffer.writeInt32LE(value, offset),
+    'uint32_t': (value, buffer, offset) => buffer.writeUInt32LE(value, offset),
+    'int64_t': (value, buffer, offset) => buffer.writeBigInt64LE(value, offset),
+    'uint64_t': (value, buffer, offset) => buffer.writeBigUInt64LE(value, offset),
+    'float': (value, buffer, offset) => buffer.writeFloatLE(value, offset),
+    'double': (value, buffer, offset) => buffer.writeDoubleLE(value, offset),
+};
+const ARRAY_TYPES_SERIALIZERS = {
+    'char[]': (value, buffer, offset, maxLen) => {
+        for (let i = 0; i < value.length && i < maxLen; i++) {
+            const code = value.charCodeAt(i);
+            buffer.writeUInt8(code, offset + i);
+        }
+    },
+    'int8_t[]': (value, buffer, offset, maxLen) => {
+        for (let i = 0; i < value.length && i < maxLen; i++) {
+            buffer.writeInt8(value[i], offset + i);
+        }
+    },
+    'uint8_t[]': (value, buffer, offset, maxLen) => {
+        for (let i = 0; i < value.length && i < maxLen; i++) {
+            buffer.writeUInt8(value[i], offset + i);
+        }
+    },
+    'int16_t[]': (value, buffer, offset, maxLen) => {
+        for (let i = 0; i < value.length && i < maxLen; i++) {
+            buffer.writeInt16LE(value[i], offset + i * 2);
+        }
+    },
+    'uint16_t[]': (value, buffer, offset, maxLen) => {
+        for (let i = 0; i < value.length && i < maxLen; i++) {
+            buffer.writeUInt16LE(value[i], offset + i * 2);
+        }
+    },
+    'int32_t[]': (value, buffer, offset, maxLen) => {
+        for (let i = 0; i < value.length && i < maxLen; i++) {
+            buffer.writeInt32LE(value[i], offset + i * 4);
+        }
+    },
+    'uint32_t[]': (value, buffer, offset, maxLen) => {
+        for (let i = 0; i < value.length && i < maxLen; i++) {
+            buffer.writeUInt32LE(value[i], offset + i * 4);
+        }
+    },
+    'int64_t[]': (value, buffer, offset, maxLen) => {
+        for (let i = 0; i < value.length && i < maxLen; i++) {
+            buffer.writeBigInt64LE(value[i], offset + i * 8);
+        }
+    },
+    'uint64_t[]': (value, buffer, offset, maxLen) => {
+        for (let i = 0; i < value.length && i < maxLen; i++) {
+            buffer.writeBigUInt64LE(value[i], offset + i * 8);
+        }
+    },
+    'float[]': (value, buffer, offset, maxLen) => {
+        for (let i = 0; i < value.length && i < maxLen; i++) {
+            buffer.writeFloatLE(value[i], offset + i * 4);
+        }
+    },
+    'double[]': (value, buffer, offset, maxLen) => {
+        for (let i = 0; i < value.length && i < maxLen; i++) {
+            buffer.writeDoubleLE(value[i], offset + i * 8);
+        }
+    },
+};
+/**
+ * A dictionary containing functions that serialize a certain value based on the field type
+ */
+exports.SERIALIZERS = {
+    ...SPECIAL_TYPES_SERIALIZERS,
+    ...SINGULAR_TYPES_SERIALIZERS,
+    ...ARRAY_TYPES_SERIALIZERS,
+};
+const SPECIAL_DESERIALIZERS = {
+    'uint8_t_mavlink_version': (buffer, offset) => buffer.readUInt8(offset),
+};
+const SINGULAR_TYPES_DESERIALIZERS = {
+    'char': (buffer, offset) => String.fromCharCode(buffer.readUInt8(offset)),
+    'int8_t': (buffer, offset) => buffer.readInt8(offset),
+    'uint8_t': (buffer, offset) => buffer.readUInt8(offset),
+    'int16_t': (buffer, offset) => buffer.readInt16LE(offset),
+    'uint16_t': (buffer, offset) => buffer.readUInt16LE(offset),
+    'int32_t': (buffer, offset) => buffer.readInt32LE(offset),
+    'uint32_t': (buffer, offset) => buffer.readUInt32LE(offset),
+    'int64_t': (buffer, offset) => buffer.readBigInt64LE(offset),
+    'uint64_t': (buffer, offset) => buffer.readBigUInt64LE(offset),
+    'float': (buffer, offset) => buffer.readFloatLE(offset),
+    'double': (buffer, offset) => buffer.readDoubleLE(offset),
+};
+const ARRAY_TYPES_DESERIALIZERS = {
+    'char[]': (buffer, offset, length) => {
+        let result = '';
+        for (let i = 0; i < length; i++) {
+            const charCode = buffer.readUInt8(offset + i);
+            if (charCode !== 0) {
+                result += String.fromCharCode(charCode);
+            }
+            else {
+                break;
+            }
+        }
+        return result;
+    },
+    'int8_t[]': (buffer, offset, length) => {
+        const result = new Array(length);
+        for (let i = 0; i < length; i++)
+            result[i] = buffer.readInt8(offset + i);
+        return result;
+    },
+    'uint8_t[]': (buffer, offset, length) => {
+        const result = new Array(length);
+        for (let i = 0; i < length; i++)
+            result[i] = buffer.readUInt8(offset + i);
+        return result;
+    },
+    'int16_t[]': (buffer, offset, length) => {
+        const result = new Array(length);
+        for (let i = 0; i < length; i++)
+            result[i] = buffer.readInt16LE(offset + i * 2);
+        return result;
+    },
+    'uint16_t[]': (buffer, offset, length) => {
+        const result = new Array(length);
+        for (let i = 0; i < length; i++)
+            result[i] = buffer.readUInt16LE(offset + i * 2);
+        return result;
+    },
+    'int32_t[]': (buffer, offset, length) => {
+        const result = new Array(length);
+        for (let i = 0; i < length; i++)
+            result[i] = buffer.readInt32LE(offset + i * 4);
+        return result;
+    },
+    'uint32_t[]': (buffer, offset, length) => {
+        const result = new Array(length);
+        for (let i = 0; i < length; i++)
+            result[i] = buffer.readUInt32LE(offset + i * 4);
+        return result;
+    },
+    'int64_t[]': (buffer, offset, length) => {
+        const result = new Array(length);
+        for (let i = 0; i < length; i++)
+            result[i] = buffer.readBigInt64LE(offset + i * 8);
+        return result;
+    },
+    'uint64_t[]': (buffer, offset, length) => {
+        const result = new Array(length);
+        for (let i = 0; i < length; i++)
+            result[i] = buffer.readBigUInt64LE(offset + i * 8);
+        return result;
+    },
+    'float[]': (buffer, offset, length) => {
+        const result = new Array(length);
+        for (let i = 0; i < length; i++)
+            result[i] = buffer.readFloatLE(offset + i * 4);
+        return result;
+    },
+    'double[]': (buffer, offset, length) => {
+        const result = new Array(length);
+        for (let i = 0; i < length; i++)
+            result[i] = buffer.readDoubleLE(offset + i * 8);
+        return result;
+    },
+};
+/**
+ * A dictionary containing functions that deserialize a certain value based on the field type
+ */
+exports.DESERIALIZERS = {
+    ...SPECIAL_DESERIALIZERS,
+    ...SINGULAR_TYPES_DESERIALIZERS,
+    ...ARRAY_TYPES_DESERIALIZERS,
+};

package/dist/lib/utils.d.ts

@@ -18,9 +18,9 @@ export declare function dump(buffer: Buffer, lineWidth?: number): void;
 /**
  * Sleep for a given number of miliseconds
  *
- * @param ms number of miliseconds to sleep
+ * @param {number} ms of miliseconds to sleep
  */
-export declare function sleep(ms: any): Promise<unknown>;
+export declare function sleep(ms: number): Promise<unknown>;
 /**
  * Execute a callback every <code>interval</code>ms and if it will not return
  * a truthy value in the <code>timeout<code>ms then throw a Timeout exception.
@@ -28,8 +28,9 @@ export declare function sleep(ms: any): Promise<unknown>;
  * a particular expression should be evaluated and how long will it take to end
  * the execution without success. Great for time-sensitive operations.
  *
- * @param cb callback to call every <code>interval</code>ms
+ * @param cb callback to call every <code>interval</code>ms. Waiting stops if the callback returns a truthy value.
  * @param timeout number of miliseconds that need to pass before the Timeout exception is thrown
  * @param interval number of miliseconds before re-running the callback
  */
-export declare function waitFor(cb: any, timeout?: number, interval?: number): Promise<unknown>;
+export declare function waitFor<T>(cb: () => T, timeout?: number, interval?: number): Promise<T>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/lib/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../lib/utils.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,GAAE,MAAU,EAAE,MAAM,SAAO,UAE5D;AAED;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,SAAK,QAclD;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,oBAE/B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,OAAO,SAAQ,EAAE,QAAQ,SAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAoBzF"}

package/dist/lib/utils.js

@@ -1 +1,77 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.waitFor=exports.sleep=exports.dump=exports.hex=void 0;function hex(t,o=2,e="0x"){return`${e}${t.toString(16).padStart(o,"0")}`}exports.hex=hex;function dump(t,o=16){const e=[];let r=0;for(let n=0;n<t.length;n++)e.push(hex(t[n],2,"0x")),e.length===o&&(console.log(hex(r,4),"|",e.join(" ")),r+=o,e.length=0);e.length>0&&console.log(hex(r,4),"|",e.join(" "))}exports.dump=dump;function sleep(t){return new Promise(o=>setTimeout(o,t))}exports.sleep=sleep;async function waitFor(t,o=1e4,e=100){return new Promise((r,n)=>{const l=setTimeout(()=>{s(),n("Timeout")},o),u=setInterval(()=>{const i=t();i&&(s(),r(i))}),s=()=>{clearTimeout(l),clearTimeout(u)}})}exports.waitFor=waitFor;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitFor = exports.sleep = exports.dump = exports.hex = void 0;
+/**
+ * Convert a number to hexadecimal representation with a minumum
+ * number of characters and optional prefix (0x by default)
+ *
+ * @param n value to convert
+ * @param len length of the converted string (without prefix)
+ * @param prefix prefix to prepend the generated string with
+ */
+function hex(n, len = 2, prefix = '0x') {
+    return `${prefix}${n.toString(16).padStart(len, '0')}`;
+}
+exports.hex = hex;
+/**
+ * Dump a buffer in a readable form
+ *
+ * @param buffer buffer to dump
+ * @param lineWidth width of the line, in bytes of buffer
+ */
+function dump(buffer, lineWidth = 16) {
+    const line = [];
+    let address = 0;
+    for (let i = 0; i < buffer.length; i++) {
+        line.push(hex(buffer[i], 2, '0x'));
+        if (line.length === lineWidth) {
+            console.log(hex(address, 4), '|', line.join(' '));
+            address += lineWidth;
+            line.length = 0;
+        }
+    }
+    if (line.length > 0) {
+        console.log(hex(address, 4), '|', line.join(' '));
+    }
+}
+exports.dump = dump;
+/**
+ * Sleep for a given number of miliseconds
+ *
+ * @param {number} ms of miliseconds to sleep
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+exports.sleep = sleep;
+/**
+ * Execute a callback every <code>interval</code>ms and if it will not return
+ * a truthy value in the <code>timeout<code>ms then throw a Timeout exception.
+ * This is a very useful utility that will allow you to specify how often
+ * a particular expression should be evaluated and how long will it take to end
+ * the execution without success. Great for time-sensitive operations.
+ *
+ * @param cb callback to call every <code>interval</code>ms. Waiting stops if the callback returns a truthy value.
+ * @param timeout number of miliseconds that need to pass before the Timeout exception is thrown
+ * @param interval number of miliseconds before re-running the callback
+ */
+async function waitFor(cb, timeout = 10000, interval = 100) {
+    return new Promise((resolve, reject) => {
+        const timeoutTimer = setTimeout(() => {
+            cleanup();
+            reject('Timeout');
+        }, timeout);
+        const intervalTimer = setInterval(() => {
+            const result = cb();
+            if (result) {
+                cleanup();
+                resolve(result);
+            }
+        });
+        const cleanup = () => {
+            clearTimeout(timeoutTimer);
+            clearTimeout(intervalTimer);
+        };
+    });
+}
+exports.waitFor = waitFor;

package/examples/send-receive-file.ts

@@ -9,7 +9,7 @@ import {
 
 const splitter = new MavLinkPacketSplitter()
 const parser = new MavLinkPacketParser()
-const file = createReadStream('./GH-5.bin')
+const file = createReadStream(__dirname + '/GH-5.bin')
 const reader = file.pipe(splitter).pipe(parser)
 
 // create a registry of mappings between a message id and a data class
@@ -28,7 +28,11 @@ reader.on('data', packet => {
   const clazz = REGISTRY[packet.header.msgid]
   if (clazz) {
     const data = packet.protocol.data(packet.payload, clazz)
-    console.log(data)
+    if (packet.header.timestamp) {
+      console.log(new Date(Number(packet.header.timestamp)).toISOString(), data)
+    } else {
+      console.log(data)
+    }
   }
 })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-mavlink",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "author": "Matthias Hryniszak <padcom@gmail.com>",
   "license": "LGPL",
   "description": "MavLink definitions and parsing library",
@@ -22,15 +22,17 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
-    "mavlink-mappings": "^1.0.9-20220424"
+    "mavlink-mappings": "^1.0.12-20220825"
   },
   "scripts": {
-    "build": "tsc && minimize-js dist",
-    "test": "jest && npm run test:batch",
-    "test:batch": "npx ts-node tests/main.ts e2e --input tests/data.mavlink",
+    "clean": "rm -rf dist lib/*.js",
+    "build": "tsc",
+    "test": "jest",
+    "test:batch": "tests/main.js e2e --input tests/data.mavlink",
     "dev": "jest --watch",
-    "test:e2e": "cd tests && ./main.ts e2e --input data.mavlink",
-    "prepublishOnly": "rm -rf dist && npm install && npm run build && npm test"
+    "test:e2e": "./main.js e2e --input data.mavlink",
+    "sanity-check": "./sanity-check.cjs && ./sanity-check.mjs",
+    "prepublishOnly": "npm run clean && npm install && npm test && npm run build && npm run sanity-check"
   },
   "devDependencies": {
     "@types/jest": "^27.4.1",
@@ -41,8 +43,8 @@
     "minimize-js": "^1.3.0",
     "serialport": "^10.0.0",
     "ts-jest": "^27.1.4",
-    "ts-node": "^9.1.1",
-    "typescript": "^4.4.3",
+    "ts-node": "^10.6.0",
+    "typescript": "^4.7.4",
     "wget-improved": "^3.2.1",
     "xml2js": "^0.4.23",
     "yargs": "^17.3.1"

package/sanity-check.cjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+const { join } = require('node:path')
+const { createReadStream } = require('node:fs')
+const { createMavLinkStream } = require('.')
+
+const port = createReadStream(join(__dirname, 'examples/GH-5.bin'))
+const parser = createMavLinkStream(port)
+parser.on('data', packet => console.log(packet.debug()))

package/sanity-check.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { createReadStream } from 'node:fs'
+import { createMavLinkStream } from './dist/index.js'
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url))
+const port = createReadStream(join(__dirname, 'examples/GH-5.bin'))
+const parser = createMavLinkStream(port)
+parser.on('data', packet => console.log(packet.debug()))

package/.vscode/launch.json

@@ -1,19 +0,0 @@
-{
-  "version": "0.2.0",
-  "configurations": [
-    {
-      "type": "node",
-      "request": "launch",
-      "name": "Launch Program",
-      "runtimeArgs": [
-        "-r",
-        "ts-node/register"
-      ],
-      "args": [
-        "${workspaceFolder}/tests/main.ts",
-        "e2e",
-        "--input=tests/data.mavlink"
-      ]
-    }
-  ],
-}

package/.vscode/settings.json

@@ -1,3 +0,0 @@
-{
-  "jest.jestCommandLine": "npx jest"
-}

package/index.ts

@@ -1,5 +0,0 @@
-export * from 'mavlink-mappings'
-export * from './lib/utils'
-export * from './lib/logger'
-export * from './lib/mavlink'
-export * from './lib/mavesp'

package/jest.config.js

@@ -1,5 +0,0 @@
-/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
-module.exports = {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-}

package/lib/logger.ts

@@ -1,128 +0,0 @@
-import EventEmitter = require('events')
-
-/**
- * Level of the log entry
- */
-export enum LogLevel {
-  trace     = 5,
-  debug     = 4,
-  info      = 3,
-  warn      = 2,
-  error     = 1,
-  fatal     = 0,
-}
-
-type LoggerRegistry = { [x: string]: Logger }
-type LoggerEvents = 'log'
-type LoggerEventHandler = (context: string, level: LogLevel, message: any[]) => void
-
-/**
- * Simplified interface for logging facilities
- */
-export class Logger {
-  private static readonly events: EventEmitter = new EventEmitter()
-  private static registry: LoggerRegistry = {}
-
-  /**
-   * Gets a logger by name
-   *
-   * @param context logger context
-   */
-  static getLogger(context) {
-    let name = ''
-    if (typeof context === 'function') name = context.name
-    else if (typeof context === 'object') name = (<any>context).constructor.name
-    else if (typeof context === 'string') name = context
-    else throw new Error(`Do not know how to get logger for ${context} (${typeof context})`)
-
-    if (!Logger.registry[name]) Logger.registry[name] = new Logger(name)
-
-    return Logger.registry[name]
-  }
-
-  /**
-   * Binds an event handler
-   *
-   * @param event event to react to
-   * @param handler event handler
-   */
-  static on(event: LoggerEvents, handler: (context, level, message) => void) {
-    this.events.on(event, handler)
-  }
-
-  /**
-   * Removes an event handler
-   *
-   * @param event event to react to
-   * @param handler event handler
-   */
-  static off(event: LoggerEvents, handler: LoggerEventHandler) {
-    this.events.off(event, handler)
-  }
-
-  private context: string
-
-  /**
-   * Constructs a new logger instance
-   *
-   * @param context logger context
-   */
-  constructor(context: string) {
-    this.context = context
-    Logger.events.emit('logger-created', Logger.registry[context])
-  }
-
-  /**
-   * Sends a log message if the trace level is enabled for this logger
-   *
-   * @param args parameters for the log entry
-   */
-  trace(...args: any) {
-    Logger.events.emit('log', { context: this.context, level: LogLevel.trace, message: args })
-  }
-
-  /**
-   * Sends a log message if the debug level is enabled for this logger
-   *
-   * @param args parameters for the log entry
-   */
-  debug(...args: any) {
-    Logger.events.emit('log', { context: this.context, level: LogLevel.debug, message: args })
-  }
-
-  /**
-   * Sends a log message if the info level is enabled for this logger
-   *
-   * @param args parameters for the log entry
-   */
-  info(...args: any) {
-    Logger.events.emit('log', { context: this.context, level: LogLevel.info, message: args })
-  }
-
-  /**
-   * Sends a log message if the warn level is enabled for this logger
-   *
-   * @param args parameters for the log entry
-   */
-  warn(...args: any) {
-    Logger.events.emit('log', { context: this.context, level: LogLevel.warn, message: args })
-  }
-
-  /**
-   * Sends a log message if the error level is enabled for this logger
-   *
-   * @param args parameters for the log entry
-   */
-  error(...args: any) {
-    Logger.events.emit('log', { context: this.context, level: LogLevel.error, message: args })
-  }
-
-  /**
-   * Sends a log message if the fatal level is enabled for this logger
-   *
-   * @param args parameters for the log entry
-   */
-  fatal(...args: any) {
-    Logger.events.emit('log', { context: this.context, level: LogLevel.fatal, message: args })
-  }
-}