node-mavlink 1.2.0 → 1.3.1

package/lib/serialization.test.ts

@@ -1,256 +0,0 @@
-import { SERIALIZERS, DESERIALIZERS } from './serialization'
-
-describe('serialization', () => {
-  describe('char', () => {
-    it('will serialize char', () => {
-      const b = Buffer.from([0])
-      SERIALIZERS['char'](42, b, 0)
-      expect(b).toStrictEqual(Buffer.from([42]))
-    })
-    it('will deserialize char', () => {
-      const b = Buffer.from([42])
-      const result = DESERIALIZERS['char'](b, 0)
-      expect(result).toBe('*')
-    })
-    it('will serialize char[]', () => {
-      const b = Buffer.from(new Array(3))
-      SERIALIZERS['char[]']('LOL', b, 0, 5)
-      expect(b).toStrictEqual(Buffer.from([76, 79, 76]))
-    })
-    it('will deserialize char[]', () => {
-      const b = Buffer.from([76, 79, 76, 0, 0, 0, 0, 0])
-      const result = DESERIALIZERS['char[]'](b, 0, 5)
-      expect(result).toBe('LOL')
-    })
-  })
-
-  describe('uint8_t', () => {
-    it('will serialize 8-bit unsigned int', () => {
-      const b = Buffer.from([0])
-      SERIALIZERS['uint8_t'](2, b, 0)
-      expect(b).toStrictEqual(Buffer.from([2]))
-    })
-    it('will deserialize 8-bit unsigned int', () => {
-      const b = Buffer.from([2])
-      const result = DESERIALIZERS['uint8_t'](b, 0)
-      expect(result).toBe(2)
-    })
-    it('will serialize array of 8-bit unsigned int', () => {
-      const b = Buffer.from(new Array(3))
-      SERIALIZERS['uint8_t[]']([ 1, 2, 4 ], b, 0, 3)
-      expect(b).toStrictEqual(Buffer.from([1, 2, 4]))
-    })
-    it('will deserialize array of 8-bit unsigned int', () => {
-      const b = Buffer.from([1, 2, 4])
-      const result = DESERIALIZERS['uint8_t[]'](b, 0, 3)
-      expect(result).toStrictEqual([1, 2, 4])
-    })
-  })
-
-  describe('int8_t', () => {
-    it('will serialize 8-bit signed int', () => {
-      const b = Buffer.from([0])
-      SERIALIZERS['int8_t'](-2, b, 0)
-      expect(b).toStrictEqual(Buffer.from([-2]))
-    })
-    it('will deserialize 8-bit signed int', () => {
-      const b = Buffer.from([-2])
-      const result = DESERIALIZERS['int8_t'](b, 0)
-      expect(result).toBe(-2)
-    })
-    it('will serialize array of 8-bit signed int', () => {
-      const b = Buffer.from(new Array(3))
-      SERIALIZERS['int8_t[]']([ 1, -2, -5 ], b, 0, 3)
-      expect(b).toStrictEqual(Buffer.from([1, -2, -5]))
-    })
-    it('will deserialize array of 8-bit signed int', () => {
-      const b = Buffer.from([255, 254, 252])
-      const result = DESERIALIZERS['int8_t[]'](b, 0, 3)
-      expect(result).toStrictEqual([-1, -2, -4])
-    })
-  })
-
-  describe('uint16_t', () => {
-    it('will serialize 16-bit unsigned int', () => {
-      const b = Buffer.from([0, 0])
-      SERIALIZERS['uint16_t'](2, b, 0)
-      expect(b).toStrictEqual(Buffer.from([2, 0]))
-    })
-    it('will deserialize 16-bit unsigned int', () => {
-      const b = Buffer.from([2, 0])
-      const result = DESERIALIZERS['uint16_t'](b, 0)
-      expect(result).toBe(2)
-    })
-    it('will serialize array of 16-bit unsigned int', () => {
-      const b = Buffer.from(new Array(6))
-      SERIALIZERS['uint16_t[]']([ 1, 2, 4 ], b, 0, 3)
-      expect(b).toStrictEqual(Buffer.from([1, 0, 2, 0, 4, 0]))
-    })
-    it('will deserialize array of 16-bit unsigned int', () => {
-      const b = Buffer.from([1, 0, 2, 0, 4, 0])
-      const result = DESERIALIZERS['uint16_t[]'](b, 0, 3)
-      expect(result).toStrictEqual([1, 2, 4])
-    })
-  })
-
-  describe('int16_t', () => {
-    it('will serialize 16-bit signed int', () => {
-      const b = Buffer.from([0, 0])
-      SERIALIZERS['int16_t'](-2, b, 0)
-      expect(b).toStrictEqual(Buffer.from([254, 255]))
-    })
-    it('will deserialize 16-bit signed int', () => {
-      const b = Buffer.from([254, 255])
-      const result = DESERIALIZERS['int16_t'](b, 0)
-      expect(result).toBe(-2)
-    })
-    it('will serialize array of 16-bit signed int', () => {
-      const b = Buffer.from(new Array(6))
-      SERIALIZERS['int16_t[]']([1, -2, -5], b, 0, 3)
-      expect(b).toStrictEqual(Buffer.from([1, 0, 254, 255, 251, 255]))
-    })
-    it('will deserialize array of 16-bit signed int', () => {
-      const b = Buffer.from([1, 0, 254, 255, 251, 255])
-      const result = DESERIALIZERS['int16_t[]'](b, 0, 3)
-      expect(result).toStrictEqual([1, -2, -5])
-    })
-  })
-
-  describe('uint32_t', () => {
-    it('will serialize 32-bit unsigned int', () => {
-      const b = Buffer.from([0, -1, -2, -3])
-      SERIALIZERS['uint32_t'](2, b, 0)
-      expect(b).toStrictEqual(Buffer.from([2, 0, 0, 0]))
-    })
-    it('will deserialize 32-bit unsigned int', () => {
-      const b = Buffer.from([2, 0, 0, 0])
-      const result = DESERIALIZERS['uint32_t'](b, 0)
-      expect(result).toBe(2)
-    })
-    it('will serialize array of 32-bit unsigned int', () => {
-      const b = Buffer.from(new Array(12))
-      SERIALIZERS['uint32_t[]']([ 1, 2, 4 ], b, 0, 3)
-      expect(b).toStrictEqual(Buffer.from([1, 0, 0, 0, 2, 0, 0, 0, 4, 0, 0, 0]))
-    })
-    it('will deserialize array of 32-bit unsigned int', () => {
-      const b = Buffer.from([1, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0])
-      const result = DESERIALIZERS['uint32_t[]'](b, 0, 3)
-      expect(result).toStrictEqual([1, 2, 5])
-    })
-  })
-
-  describe('int32_t', () => {
-    it('will serialize 32-bit signed int', () => {
-      const b = Buffer.from([0, 0, 0, 0])
-      SERIALIZERS['int32_t'](-2, b, 0)
-      expect(b).toStrictEqual(Buffer.from([254, 255, 255, 255]))
-    })
-    it('will deserialize 32-bit signed int', () => {
-      const b = Buffer.from([254, 255, 255, 255])
-      const result = DESERIALIZERS['int32_t'](b, 0)
-      expect(result).toBe(-2)
-    })
-    it('will serialize array of 32-bit signed int', () => {
-      const b = Buffer.from(new Array(12))
-      SERIALIZERS['int32_t[]']([ 1, -2, -5 ], b, 0, 3)
-      expect(b).toStrictEqual(Buffer.from([1, 0, 0, 0, 254, 255, 255, 255, 251, 255, 255, 255]))
-    })
-    it('will deserialize array of 32-bit signed int', () => {
-      const b = Buffer.from([1, 0, 0, 0, 254, 255, 255, 255, 250, 255, 255, 255])
-      const result = DESERIALIZERS['int32_t[]'](b, 0, 3)
-      expect(result).toStrictEqual([1, -2, -6])
-    })
-  })
-
-  describe('uint64_t', () => {
-    it('will serialize 64-bit unsigned int', () => {
-      const b = Buffer.from([0, -1, -2, -3, -4, -5, -6, -7])
-      SERIALIZERS['uint64_t'](2n, b, 0)
-      expect(b).toStrictEqual(Buffer.from([2, 0, 0, 0, 0, 0, 0, 0]))
-    })
-    it('will deserialize 64-bit unsigned int', () => {
-      const b = Buffer.from([2, 0, 0, 0, 0, 0, 0, 0])
-      const result = DESERIALIZERS['uint64_t'](b, 0)
-      expect(result).toBe(2n)
-    })
-    it('will serialize array of 64-bit unsigned int', () => {
-      const b = Buffer.from(new Array(24))
-      SERIALIZERS['uint64_t[]']([ 1n, 2n, 4n ], b, 0, 3)
-      expect(b).toStrictEqual(Buffer.from([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0]))
-    })
-    it('will deserialize array of 64-bit unsigned int', () => {
-      const b = Buffer.from([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0])
-      const result = DESERIALIZERS['uint64_t[]'](b, 0, 3)
-      expect(result).toEqual([1n, 2n, 5n])
-    })
-  })
-
-  describe('int64_t', () => {
-    it('will serialize 64-bit signed int', () => {
-      const b = Buffer.from([0, 0, 0, 0, 0, 0, 0, 0])
-      SERIALIZERS['int64_t'](-2n, b, 0)
-      expect(b).toStrictEqual(Buffer.from([254, 255, 255, 255, 255, 255, 255, 255]))
-    })
-    it('will deserialize 64-bit signed int', () => {
-      const b = Buffer.from([254, 255, 255, 255, 255, 255, 255, 255])
-      const result = DESERIALIZERS['int64_t'](b, 0)
-      expect(result).toBe(-2n)
-    })
-    it('will serialize array of 64-bit signed int', () => {
-      const b = Buffer.from(new Array(24))
-      SERIALIZERS['int64_t[]']([ 1n, -2n, -5n ], b, 0, 3)
-      expect(b).toStrictEqual(Buffer.from([1, 0, 0, 0, 0, 0, 0, 0, 254, 255, 255, 255, 255, 255, 255, 255, 251, 255, 255, 255, 255, 255, 255, 255]))
-    })
-    it('will deserialize array of 64-bit signed int', () => {
-      const b = Buffer.from([1, 0, 0, 0, 0, 0, 0, 0, 254, 255, 255, 255, 255, 255, 255, 255, 250, 255, 255, 255, 255, 255, 255, 255])
-      const result = DESERIALIZERS['int64_t[]'](b, 0, 3)
-      expect(result).toEqual([1n, -2n, -6n])
-    })
-  })
-
-  describe('float', () => {
-    it('will serialize float', () => {
-      const b = Buffer.from([0, -1, -2, -3])
-      SERIALIZERS['float'](2.5, b, 0)
-      expect(b).toStrictEqual(Buffer.from([0, 0, 32, 64]))
-    })
-    it('will deserialize float', () => {
-      const b = Buffer.from([0, 0, 32, 192])
-      const result = DESERIALIZERS['float'](b, 0)
-      expect(result).toBe(-2.5)
-    })
-    it('will serialize array of floats', () => {
-      const b = Buffer.from(new Array(12))
-      SERIALIZERS['float[]']([ 1, 2, 4 ], b, 0, 3)
-      expect(b).toStrictEqual(Buffer.from([0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 128, 64]))
-    })
-    it('will deserialize array of floats', () => {
-      const b = Buffer.from([0, 0, 192, 63, 0, 0, 32, 192, 0, 0, 128, 64])
-      const result = DESERIALIZERS['float[]'](b, 0, 3)
-      expect(result).toStrictEqual([1.5, -2.5, 4])
-    })
-  })
-
-  describe('double', () => {
-    it('will serialize double', () => {
-      const b = Buffer.from([0, -1, -2, -3, -4, -5, -6, -7])
-      SERIALIZERS['double'](2.34, b, 0)
-      expect(b).toStrictEqual(Buffer.from([184, 30, 133, 235, 81, 184, 2, 64]))
-    })
-    it('will deserialize double', () => {
-      const b = Buffer.from([184, 30, 133, 235, 81, 184, 2, 64])
-      const result = DESERIALIZERS['double'](b, 0)
-      expect(result).toBe(2.34)
-    })
-    it('will serialize array of doubles', () => {
-      const b = Buffer.from(new Array(24))
-      SERIALIZERS['double[]']([ 1.5, -2.5, 4 ], b, 0, 3)
-      expect(b).toStrictEqual(Buffer.from([0, 0, 0, 0, 0, 0, 248, 63, 0, 0, 0, 0, 0, 0, 4, 192, 0, 0, 0, 0, 0, 0, 16, 64]))
-    })
-    it('will deserialize array of doubles', () => {
-      const b = Buffer.from([0, 0, 0, 0, 0, 0, 248, 63, 0, 0, 0, 0, 0, 0, 4, 192, 0, 0, 0, 0, 0, 0, 16, 64])
-      const result = DESERIALIZERS['double[]'](b, 0, 3)
-      expect(result).toStrictEqual([1.5, -2.5, 4])
-    })
-  })
-})

package/lib/serialization.ts

@@ -1,176 +0,0 @@
-import {
-  int8_t,
-  uint8_t,
-  int16_t,
-  uint16_t,
-  int32_t,
-  uint32_t,
-  int64_t,
-  uint64_t,
-  float,
-  double,
-} from 'mavlink-mappings'
-
-/**
- * A dictionary containing functions that serialize a certain value based on the field type
- */
-export const SERIALIZERS = {
-  // special types
-  'uint8_t_mavlink_version': (value: uint8_t, buffer: Buffer, offset: number) => buffer.writeUInt8(value, offset),
-
-  // singular types
-  'char'    : (value: int8_t, buffer: Buffer, offset: number) => buffer.writeUInt8(value, offset),
-  'int8_t'  : (value: int8_t, buffer: Buffer, offset: number) => buffer.writeInt8(value, offset),
-  'uint8_t' : (value: uint8_t, buffer: Buffer, offset: number) => buffer.writeUInt8(value, offset),
-  'int16_t' : (value: int16_t, buffer: Buffer, offset: number) => buffer.writeInt16LE(value, offset),
-  'uint16_t': (value: uint16_t, buffer: Buffer, offset: number) => buffer.writeUInt16LE(value, offset),
-  'int32_t' : (value: int32_t, buffer: Buffer, offset: number) => buffer.writeInt32LE(value, offset),
-  'uint32_t': (value: uint32_t, buffer: Buffer, offset: number) => buffer.writeUInt32LE(value, offset),
-  'int64_t' : (value: int64_t, buffer: Buffer, offset: number) => buffer.writeBigInt64LE(value, offset),
-  'uint64_t': (value: uint64_t, buffer: Buffer, offset: number) => buffer.writeBigUInt64LE(value, offset),
-  'float'   : (value: float, buffer: Buffer, offset: number) => buffer.writeFloatLE(value, offset),
-  'double'  : (value: double, buffer: Buffer, offset: number) => buffer.writeDoubleLE(value, offset),
-
-  // array types
-  'char[]': (value: string, buffer: Buffer, offset: number, maxLen: number) => {
-    for (let i = 0; i < value.length && i < maxLen; i++) {
-      const code = value.charCodeAt(i)
-      buffer.writeUInt8(code, offset + i)
-    }
-  },
-  'int8_t[]': (value: uint8_t[], buffer: Buffer, offset: number, maxLen: number) => {
-    for (let i = 0; i < value.length && i < maxLen; i++) {
-      buffer.writeInt8(value[i], offset + i)
-    }
-  },
-  'uint8_t[]': (value: uint8_t[], buffer: Buffer, offset: number, maxLen: number) => {
-    for (let i = 0; i < value.length && i < maxLen; i++) {
-      buffer.writeUInt8(value[i], offset + i)
-    }
-  },
-  'int16_t[]': (value: uint16_t[], buffer: Buffer, offset: number, maxLen: number) => {
-    for (let i = 0; i < value.length && i < maxLen; i++) {
-      buffer.writeInt16LE(value[i], offset + i * 2)
-    }
-  },
-  'uint16_t[]': (value: uint16_t[], buffer: Buffer, offset: number, maxLen: number) => {
-    for (let i = 0; i < value.length && i < maxLen; i++) {
-      buffer.writeUInt16LE(value[i], offset + i * 2)
-    }
-  },
-  'int32_t[]': (value: uint32_t[], buffer: Buffer, offset: number, maxLen: number) => {
-    for (let i = 0; i < value.length && i < maxLen; i++) {
-      buffer.writeInt32LE(value[i], offset + i * 4)
-    }
-  },
-  'uint32_t[]': (value: uint32_t[], buffer: Buffer, offset: number, maxLen: number) => {
-    for (let i = 0; i < value.length && i < maxLen; i++) {
-      buffer.writeUInt32LE(value[i], offset + i * 4)
-    }
-  },
-  'int64_t[]': (value: uint64_t[], buffer: Buffer, offset: number, maxLen: number) => {
-    for (let i = 0; i < value.length && i < maxLen; i++) {
-      buffer.writeBigInt64LE(value[i], offset + i * 8)
-    }
-  },
-  'uint64_t[]': (value: uint64_t[], buffer: Buffer, offset: number, maxLen: number) => {
-    for (let i = 0; i < value.length && i < maxLen; i++) {
-      buffer.writeBigUInt64LE(value[i], offset + i * 8)
-    }
-  },
-  'float[]': (value: float[], buffer: Buffer, offset: number, maxLen: number) => {
-    for (let i = 0; i < value.length && i < maxLen; i++) {
-      buffer.writeFloatLE(value[i], offset + i * 4)
-    }
-  },
-  'double[]': (value: double[], buffer: Buffer, offset: number, maxLen: number) => {
-    for (let i = 0; i < value.length && i < maxLen; i++) {
-      buffer.writeDoubleLE(value[i], offset + i * 8)
-    }
-  },
-}
-
-/**
- * A dictionary containing functions that deserialize a certain value based on the field type
- */
-export const DESERIALIZERS = {
-  // special types
-  'uint8_t_mavlink_version': (buffer: Buffer, offset: number) => buffer.readUInt8(offset),
-
-  // singular types
-  'char'    : (buffer: Buffer, offset: number) => String.fromCharCode(buffer.readUInt8(offset)),
-  'int8_t'  : (buffer: Buffer, offset: number) => buffer.readInt8(offset),
-  'uint8_t' : (buffer: Buffer, offset: number) => buffer.readUInt8(offset),
-  'int16_t' : (buffer: Buffer, offset: number) => buffer.readInt16LE(offset),
-  'uint16_t': (buffer: Buffer, offset: number) => buffer.readUInt16LE(offset),
-  'int32_t' : (buffer: Buffer, offset: number) => buffer.readInt32LE(offset),
-  'uint32_t': (buffer: Buffer, offset: number) => buffer.readUInt32LE(offset),
-  'int64_t' : (buffer: Buffer, offset: number) => buffer.readBigInt64LE(offset),
-  'uint64_t': (buffer: Buffer, offset: number) => buffer.readBigUInt64LE(offset),
-  'float'   : (buffer: Buffer, offset: number) => buffer.readFloatLE(offset),
-  'double'  : (buffer: Buffer, offset: number) => buffer.readDoubleLE(offset),
-
-  // array types
-  'char[]': (buffer: Buffer, offset: number, length: number) => {
-    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: Buffer, offset: number, length: number) => {
-    const result = new Array<number>(length)
-    for (let i = 0; i < length; i++) result[i] = buffer.readInt8(offset + i)
-    return result
-  },
-  'uint8_t[]': (buffer: Buffer, offset: number, length: number) => {
-    const result = new Array<number>(length)
-    for (let i = 0; i < length; i++) result[i] = buffer.readUInt8(offset + i)
-    return result
-  },
-  'int16_t[]': (buffer: Buffer, offset: number, length: number) => {
-    const result = new Array<number>(length)
-    for (let i = 0; i < length; i++) result[i] = buffer.readInt16LE(offset + i * 2)
-    return result
-  },
-  'uint16_t[]': (buffer: Buffer, offset: number, length: number) => {
-    const result = new Array<number>(length)
-    for (let i = 0; i < length; i++) result[i] = buffer.readUInt16LE(offset + i * 2)
-    return result
-  },
-  'int32_t[]': (buffer: Buffer, offset: number, length: number) => {
-    const result = new Array<number>(length)
-    for (let i = 0; i < length; i++) result[i] = buffer.readInt32LE(offset + i * 4)
-    return result
-  },
-  'uint32_t[]': (buffer: Buffer, offset: number, length: number) => {
-    const result = new Array<number>(length)
-    for (let i = 0; i < length; i++) result[i] = buffer.readUInt32LE(offset + i * 4)
-    return result
-  },
-  'int64_t[]': (buffer: Buffer, offset: number, length: number) => {
-    const result = new Array<BigInt>(length)
-    for (let i = 0; i < length; i++) result[i] = buffer.readBigInt64LE(offset + i * 8)
-    return result
-  },
-  'uint64_t[]': (buffer: Buffer, offset: number, length: number) => {
-    const result = new Array<BigInt>(length)
-    for (let i = 0; i < length; i++) result[i] = buffer.readBigUInt64LE(offset + i * 8)
-    return result
-  },
-  'float[]': (buffer: Buffer, offset: number, length: number) => {
-    const result = new Array<number>(length)
-    for (let i = 0; i < length; i++) result[i] = buffer.readFloatLE(offset + i * 4)
-    return result
-  },
-  'double[]': (buffer: Buffer, offset: number, length: number) => {
-    const result = new Array<number>(length)
-    for (let i = 0; i < length; i++) result[i] = buffer.readDoubleLE(offset + i * 8)
-    return result
-  },
-}

package/lib/utils.ts

@@ -1,75 +0,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
- */
-export function hex(n: number, len: number = 2, prefix = '0x') {
-  return `${prefix}${n.toString(16).padStart(len, '0')}`
-}
-
-/**
- * Dump a buffer in a readable form
- *
- * @param buffer buffer to dump
- * @param lineWidth width of the line, in bytes of buffer
- */
-export function dump(buffer: 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(' '))
-  }
-}
-
-/**
- * Sleep for a given number of miliseconds
- *
- * @param ms number of miliseconds to sleep
- */
-export function sleep(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms))
-}
-
-/**
- * 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
- * @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 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)
-    }
-  })
-}

package/tests/main.ts

@@ -1,59 +0,0 @@
-#!/usr/bin/env ts-node
-
-import yargs from 'yargs'
-import { existsSync, createReadStream } from 'fs'
-import { minimal, common, ardupilotmega } from 'mavlink-mappings'
-import { createMavLinkStream, MavLinkPacket, Logger, LogLevel, MavLinkPacketRegistry } from '..'
-import { dump } from '..'
-
-Logger.on('log', ({ context, level, message }) => {
-  if (level <= LogLevel.error) {
-    console.log(`${new Date().toISOString()} ${context} [${LogLevel[level]}]`, ...message)
-  }
-})
-
-async function configure() {
-  return yargs(process.argv.slice(2))
-    .command('e2e', 'Execute end to end serialization/deserialization verification',
-      yargs => yargs.positional('input', {
-        description: 'Input file (- for stdin)',
-        default: '-'
-      }),
-      argv => {
-        if (argv.input !== '-' && !existsSync(argv.input)) {
-          console.error(`error: ${argv.input} not found`)
-          process.exit(1)
-        }
-      }
-    )
-    .help()
-    .alias('help', 'h')
-    .parse()
-}
-
-async function main() {
-  const config = await configure()
-
-  const command = config._[0]
-  if (command === 'e2e') {
-    const REGISTRY: MavLinkPacketRegistry = {
-      ...minimal.REGISTRY,
-      ...common.REGISTRY,
-      ...ardupilotmega.REGISTRY,
-    }
-
-    const input = config.input === '-' ? process.stdin : createReadStream(config.input)
-    const reader = createMavLinkStream(input, dump)
-
-    reader.on('data', (packet: MavLinkPacket) => {
-      const clazz = REGISTRY[packet.header.msgid]
-      if (clazz) {
-        packet.protocol.data(packet.payload, clazz)
-      } else {
-        console.log('< (unknown)', packet.debug())
-      }
-    })
-  }
-}
-
-main()

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "commonjs",
-    "lib": ["ES2020", "DOM"],
-    "target": "es2020",
-    "declaration": true,
-    "outDir": "./dist",
-    "esModuleInterop": true
-  },
-  "include": [
-    "index.ts",
-  ],
-  "exclude": [
-    "node_modules"
-  ]
-}