@krokodilushka/mavlink-parser-browserify 0.1.0

package/dist/lib/serialization.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+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: {
+    [x: string]: Serializer;
+};
+type Deserializer = ((buffer: Buffer, offset: number) => any) | ((buffer: Buffer, offset: number, length: number) => any);
+type Deserializers = {
+    [key: string]: Deserializer;
+};
+/**
+ * A dictionary containing functions that deserialize a certain value based on the field type
+ */
+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,KAAK,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,KAAK,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,KAAK,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

@@ -0,0 +1,184 @@
+"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

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+/**
+ * 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
+ */
+export declare function hex(n: number, len?: number, prefix?: string): string;
+/**
+ * Dump a buffer in a readable form
+ *
+ * @param buffer buffer to dump
+ * @param lineWidth width of the line, in bytes of buffer
+ */
+export declare function dump(buffer: Buffer, lineWidth?: number): void;
+/**
+ * Sleep for a given number of miliseconds
+ *
+ * @param {number} ms of miliseconds to sleep
+ */
+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.
+ * 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
+ */
+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

@@ -0,0 +1,77 @@
+"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/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@krokodilushka/mavlink-parser-browserify",
+  "version": "0.1.0",
+  "author": "Guillaume de Boyer <gdeboyer@gmail.com>",
+  "license": "LGPL",
+  "description": "MavLink definitions and parsing library for the browser",
+  "keywords": [
+    "mavlink"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/geopan/mavlink-parser-broserify"
+  },
+  "bugs": {
+    "email": "gdeboyer@gmail.com",
+    "url": "https://github.com/geopan/mavlink-parser-broserify/issues"
+  },
+  "funding": {
+    "type": "patreon",
+    "url": "https://www.patreon.com/padcom"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "mavlink-mappings": "^1.0.13-20230115-3"
+  },
+  "scripts": {
+    "clean": "rm -rf dist lib/*.js",
+    "build": "tsc",
+    "test": "jest",
+    "dev": "jest --watch",
+    "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",
+    "@types/node": "^15.14.9",
+    "@types/xml2js": "^0.4.8",
+    "@types/yargs": "^17.0.8",
+    "jest": "^27.5.1",
+    "minimize-js": "^1.3.0",
+    "serialport": "^10.0.0",
+    "ts-jest": "^27.1.4",
+    "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,24 @@
+#!/usr/bin/env node
+
+const { join } = require('node:path')
+const { createReadStream } = require('node:fs')
+const { createMavLinkStream } = require('.')
+const { minimal, common, ardupilotmega } = require('.')
+
+const REGISTRY = {
+  ...minimal.REGISTRY,
+  ...common.REGISTRY,
+  ...ardupilotmega.REGISTRY,
+}
+
+const port = createReadStream(join(__dirname, 'examples/GH-5.bin'))
+const parser = createMavLinkStream(port)
+parser.on('data', packet => {
+  const clazz = REGISTRY[packet.header.msgid]
+  if (clazz) {
+    const data = packet.protocol.data(packet.payload, clazz)
+    console.log('Received packet:', data)
+  } else {
+    console.log(packet.debug())
+  }
+})

package/sanity-check.mjs

@@ -0,0 +1,24 @@
+#!/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'
+import { minimal, common, ardupilotmega } from './dist/index.js'
+
+const REGISTRY = {
+  ...minimal.REGISTRY,
+  ...common.REGISTRY,
+  ...ardupilotmega.REGISTRY,
+}
+
+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 => {
+  const clazz = REGISTRY[packet.header.msgid]
+  if (clazz) {
+    const data = packet.protocol.data(packet.payload, clazz)
+    console.log('Received packet:', data)
+  }
+})