organize models and new modules

src/decoder.ts

@@ -1,8 +1,5 @@
-import { DataPacketChunk } from './decoders/data/data-packet-chunk';
+import { Decoders } from '.';
-import { InfoPacketChunk } from './decoders/info/info-packet-chunk';
+import { DataPacketChunk, InfoPacketChunk, InfoTrackerChunk, PacketHeaderChunk } from './models';
-import { InfoTrackerChunk } from './decoders/info/info-tracker-chunk';
-import packetDecoder from './decoders/packet';
-import { PacketHeaderChunk } from './decoders/packet-header-chunk';
 
 export class Decoder {
   // TODO(jwetzell): check if these last packet headers are necessary to hold on to
@@ -51,7 +48,7 @@ export class Decoder {
 
   // TODO(jwetzell): add invalid frame id decoding. Scenario where a frame id is reused before one is complete
   decode(packetBuf: Buffer): DataPacketChunk | InfoPacketChunk | undefined {
-    const packet = packetDecoder(packetBuf);
+    const packet = Decoders.Packet(packetBuf);
     if (packet === undefined) {
       return packet;
     }

src/decoders/chunk.ts

@@ -1,9 +1,4 @@
-export interface Chunk {
+import { Chunk } from '../models/chunk';
-  id?: number;
-  has_subchunks?: boolean;
-  data_len?: number;
-  chunk_data?: Buffer;
-}
 
 export default (buffer: Buffer, dataDecoder: Function): Chunk => {
   let offset = 0;

src/decoders/data/data-packet-chunk.ts

@@ -1,12 +1,6 @@
+import { Decoders } from '..';
 import { Constants } from '../../constants';
-import chunk, { Chunk } from '../chunk';
+import { DataPacketChunk } from '../../models/data/data-packet-chunk';
-import packetHeaderChunk, { PacketHeaderChunk } from '../packet-header-chunk';
-import dataTrackerListChunk, { DataTrackerListChunk } from './data-tracker-list-chunk';
-
-export interface DataPacketChunk extends Chunk {
-  packet_header: PacketHeaderChunk;
-  tracker_list: DataTrackerListChunk;
-}
 
 function decodeDataPacketChunk(dataPacketChunk: DataPacketChunk) {
   if (dataPacketChunk.has_subchunks && dataPacketChunk.chunk_data && dataPacketChunk.data_len) {
@@ -15,14 +9,14 @@ function decodeDataPacketChunk(dataPacketChunk: DataPacketChunk) {
       const chunkId = dataPacketChunk.chunk_data.readUInt16LE(offset);
       switch (chunkId) {
         case 0x0000:
-          dataPacketChunk.packet_header = packetHeaderChunk(dataPacketChunk.chunk_data.subarray(offset));
+          dataPacketChunk.packet_header = Decoders.PacketHeaderChunk(dataPacketChunk.chunk_data.subarray(offset));
           offset += Constants.CHUNK_HEADER_SIZE;
           if (dataPacketChunk.packet_header?.data_len) {
             offset += dataPacketChunk.packet_header.data_len;
           }
           break;
         case 0x0001:
-          dataPacketChunk.tracker_list = dataTrackerListChunk(dataPacketChunk.chunk_data.subarray(offset));
+          dataPacketChunk.tracker_list = Decoders.DataTrackerListChunk(dataPacketChunk.chunk_data.subarray(offset));
           offset += Constants.CHUNK_HEADER_SIZE;
           if (dataPacketChunk.tracker_list.data_len) {
             offset += dataPacketChunk.tracker_list.data_len;
@@ -35,4 +29,4 @@ function decodeDataPacketChunk(dataPacketChunk: DataPacketChunk) {
   }
 }
 
-export default (buffer: Buffer): DataPacketChunk => chunk(buffer, decodeDataPacketChunk) as DataPacketChunk;
+export default (buffer: Buffer): DataPacketChunk => Decoders.Chunk(buffer, decodeDataPacketChunk) as DataPacketChunk;

src/decoders/data/data-tracker-chunk.ts

@@ -1,22 +1,12 @@
+import { Decoders } from '..';
 import { Constants } from '../../constants';
-import chunk, { Chunk } from '../chunk';
+import { DataTrackerChunk } from '../../models/data/data-tracker-chunk';
-import dataTrackerFieldChunk, { DataTrackerFieldChunk } from './data-tracker-field-chunk';
-
-export interface DataTrackerChunk extends Chunk {
-  pos: DataTrackerFieldChunk;
-  speed: DataTrackerFieldChunk;
-  ori: DataTrackerFieldChunk;
-  status: DataTrackerFieldChunk;
-  accel: DataTrackerFieldChunk;
-  trgtpos: DataTrackerFieldChunk;
-  timestamp: DataTrackerFieldChunk;
-}
 
 function decodeTrackerChunk(trackerChunk: DataTrackerChunk) {
   if (trackerChunk.chunk_data && trackerChunk.data_len) {
     let offset = 0;
     while (offset < trackerChunk.data_len) {
-      const trackerFieldChunk = dataTrackerFieldChunk(trackerChunk.chunk_data.subarray(offset));
+      const trackerFieldChunk = Decoders.DataTrackerFieldChunk(trackerChunk.chunk_data.subarray(offset));
       offset += Constants.CHUNK_HEADER_SIZE;
       if (trackerFieldChunk.data_len) {
         offset += trackerFieldChunk.data_len;
@@ -50,4 +40,4 @@ function decodeTrackerChunk(trackerChunk: DataTrackerChunk) {
   }
 }
 
-export default (buffer: Buffer): DataTrackerChunk => chunk(buffer, decodeTrackerChunk) as DataTrackerChunk;
+export default (buffer: Buffer): DataTrackerChunk => Decoders.Chunk(buffer, decodeTrackerChunk) as DataTrackerChunk;

src/decoders/data/data-tracker-field-chunk.ts

@@ -1,9 +1,7 @@
 /* eslint-disable no-case-declarations */
-import chunk, { Chunk } from '../chunk';
 
-export interface DataTrackerFieldChunk extends Chunk {
+import { Decoders } from '..';
-  [key: string]: number | bigint | number[] | Buffer | undefined | boolean;
+import { DataTrackerFieldChunk } from '../../models/data/data-tracker-field-chunk';
-}
 
 function readXYZ(trackerFieldChunk: DataTrackerFieldChunk, prefix: string = '') {
   if (trackerFieldChunk.chunk_data) {
@@ -47,4 +45,4 @@ function decodeTrackerFieldChunk(trackerFieldChunk: DataTrackerFieldChunk) {
 }
 
 export default (buffer: Buffer): DataTrackerFieldChunk =>
-  chunk(buffer, decodeTrackerFieldChunk) as DataTrackerFieldChunk;
+  Decoders.Chunk(buffer, decodeTrackerFieldChunk) as DataTrackerFieldChunk;

src/decoders/data/data-tracker-list-chunk.ts

@@ -1,12 +1,6 @@
+import { Decoders } from '..';
 import { Constants } from '../../constants';
-import chunk, { Chunk } from '../chunk';
+import { DataTrackerListChunk } from '../../models/data/data-tracker-list-chunk';
-import dataTrackerChunk, { DataTrackerChunk } from './data-tracker-chunk';
-
-export interface DataTrackerListChunk extends Chunk {
-  trackers: {
-    [key: number]: DataTrackerChunk;
-  };
-}
 
 function decodeDataTrackerListChunk(dataTrackerListChunk: DataTrackerListChunk) {
   dataTrackerListChunk.trackers = {};
@@ -15,7 +9,7 @@ function decodeDataTrackerListChunk(dataTrackerListChunk: DataTrackerListChunk)
   let offset = 0;
   if (dataTrackerListChunk.chunk_data) {
     while (offset < dataTrackerListChunk.chunk_data.length) {
-      const trackerChunk = dataTrackerChunk(dataTrackerListChunk.chunk_data.subarray(offset));
+      const trackerChunk = Decoders.DataTrackerChunk(dataTrackerListChunk.chunk_data.subarray(offset));
       offset += Constants.CHUNK_HEADER_SIZE;
       if (trackerChunk.data_len) {
         offset += trackerChunk.data_len;
@@ -27,4 +21,4 @@ function decodeDataTrackerListChunk(dataTrackerListChunk: DataTrackerListChunk)
   }
 }
 export default (buffer: Buffer): DataTrackerListChunk =>
-  chunk(buffer, decodeDataTrackerListChunk) as DataTrackerListChunk;
+  Decoders.Chunk(buffer, decodeDataTrackerListChunk) as DataTrackerListChunk;

src/decoders/index.ts

@@ -0,0 +1,29 @@
+import Chunk from './chunk';
+import Packet from './packet';
+import PacketHeaderChunk from './packet-header-chunk';
+
+import DataPacketChunk from './data/data-packet-chunk';
+import DataTrackerChunk from './data/data-tracker-chunk';
+import DataTrackerFieldChunk from './data/data-tracker-field-chunk';
+import DataTrackerListChunk from './data/data-tracker-list-chunk';
+
+import InfoPacketChunk from './info/info-packet-chunk';
+import InfoSystemNameChunk from './info/info-system-name-chunk';
+import InfoTrackerChunk from './info/info-tracker-chunk';
+import InfoTrackerListChunk from './info/info-tracker-list-chunk';
+import InfoTrackerNameChunk from './info/info-tracker-name-chunk';
+
+export const Decoders = {
+  Chunk,
+  PacketHeaderChunk,
+  Packet,
+  DataPacketChunk,
+  DataTrackerChunk,
+  DataTrackerFieldChunk,
+  DataTrackerListChunk,
+  InfoPacketChunk,
+  InfoSystemNameChunk,
+  InfoTrackerChunk,
+  InfoTrackerListChunk,
+  InfoTrackerNameChunk,
+};

src/decoders/info/info-packet-chunk.ts

@@ -1,14 +1,6 @@
+import { Decoders } from '..';
 import { Constants } from '../../constants';
-import chunk, { Chunk } from '../chunk';
+import { InfoPacketChunk } from '../../models/info/info-packet-chunk';
-import packetHeaderChunk, { PacketHeaderChunk } from '../packet-header-chunk';
-import infoSystemNameChunk, { InfoSystemNameChunk } from './info-system-name-chunk';
-import infoTrackerListChunk, { InfoTrackerListChunk } from './info-tracker-list-chunk';
-
-export interface InfoPacketChunk extends Chunk {
-  packet_header: PacketHeaderChunk;
-  system_name: InfoSystemNameChunk;
-  tracker_list: InfoTrackerListChunk;
-}
 
 function decodeInfoPacketChunk(infoPacketChunk: InfoPacketChunk) {
   if (infoPacketChunk.has_subchunks && infoPacketChunk.chunk_data && infoPacketChunk.data_len) {
@@ -17,21 +9,21 @@ function decodeInfoPacketChunk(infoPacketChunk: InfoPacketChunk) {
       const chunkId = infoPacketChunk.chunk_data.readUInt16LE(offset);
       switch (chunkId) {
         case 0x0000:
-          infoPacketChunk.packet_header = packetHeaderChunk(infoPacketChunk.chunk_data.subarray(offset));
+          infoPacketChunk.packet_header = Decoders.PacketHeaderChunk(infoPacketChunk.chunk_data.subarray(offset));
           offset += Constants.CHUNK_HEADER_SIZE;
           if (infoPacketChunk.packet_header?.data_len) {
             offset += infoPacketChunk.packet_header.data_len;
           }
           break;
         case 0x0001:
-          infoPacketChunk.system_name = infoSystemNameChunk(infoPacketChunk.chunk_data.subarray(offset));
+          infoPacketChunk.system_name = Decoders.InfoSystemNameChunk(infoPacketChunk.chunk_data.subarray(offset));
           offset += Constants.CHUNK_HEADER_SIZE;
           if (infoPacketChunk.system_name?.data_len) {
             offset += infoPacketChunk.system_name.data_len;
           }
           break;
         case 0x0002:
-          infoPacketChunk.tracker_list = infoTrackerListChunk(infoPacketChunk.chunk_data.subarray(offset));
+          infoPacketChunk.tracker_list = Decoders.InfoTrackerListChunk(infoPacketChunk.chunk_data.subarray(offset));
           offset += Constants.CHUNK_HEADER_SIZE;
           if (infoPacketChunk.tracker_list?.data_len) {
             offset += infoPacketChunk.tracker_list.data_len;
@@ -44,4 +36,4 @@ function decodeInfoPacketChunk(infoPacketChunk: InfoPacketChunk) {
   }
 }
 
-export default (buffer: Buffer): InfoPacketChunk => chunk(buffer, decodeInfoPacketChunk) as InfoPacketChunk;
+export default (buffer: Buffer): InfoPacketChunk => Decoders.Chunk(buffer, decodeInfoPacketChunk) as InfoPacketChunk;

src/decoders/info/info-system-name-chunk.ts

@@ -1,8 +1,5 @@
-import chunk, { Chunk } from '../chunk';
+import { Decoders } from '..';
-
+import { InfoSystemNameChunk } from '../../models/info/info-system-name-chunk';
-export interface InfoSystemNameChunk extends Chunk {
-  system_name: string;
-}
 
 function decodeSystemNameChunk(systemNameChunk: InfoSystemNameChunk) {
   if (systemNameChunk.chunk_data !== undefined && systemNameChunk.data_len !== undefined) {
@@ -10,4 +7,5 @@ function decodeSystemNameChunk(systemNameChunk: InfoSystemNameChunk) {
   }
 }
 
-export default (buffer: Buffer): InfoSystemNameChunk => chunk(buffer, decodeSystemNameChunk) as InfoSystemNameChunk;
+export default (buffer: Buffer): InfoSystemNameChunk =>
+  Decoders.Chunk(buffer, decodeSystemNameChunk) as InfoSystemNameChunk;

src/decoders/info/info-tracker-chunk.ts

@@ -1,10 +1,6 @@
+import { Decoders } from '..';
 import { Constants } from '../../constants';
-import chunk, { Chunk } from '../chunk';
+import { InfoTrackerChunk } from '../../models/info/info-tracker-chunk';
-import infoTrackerNameChunk, { InfoTrackerNameChunk } from './info-tracker-name-chunk';
-
-export interface InfoTrackerChunk extends Chunk {
-  tracker_name?: InfoTrackerNameChunk;
-}
 
 function decodeInfoTrackerChunk(infoTrackerChunk: InfoTrackerChunk) {
   if (infoTrackerChunk.has_subchunks && infoTrackerChunk.chunk_data && infoTrackerChunk.data_len) {
@@ -13,7 +9,7 @@ function decodeInfoTrackerChunk(infoTrackerChunk: InfoTrackerChunk) {
       const chunkId = infoTrackerChunk.chunk_data.readUInt16LE(offset);
       switch (chunkId) {
         case 0x0000:
-          infoTrackerChunk.tracker_name = infoTrackerNameChunk(infoTrackerChunk.chunk_data.subarray(offset));
+          infoTrackerChunk.tracker_name = Decoders.InfoTrackerNameChunk(infoTrackerChunk.chunk_data.subarray(offset));
           offset += Constants.CHUNK_HEADER_SIZE;
           if (infoTrackerChunk.tracker_name?.data_len) {
             offset += infoTrackerChunk?.tracker_name?.data_len;
@@ -27,4 +23,4 @@ function decodeInfoTrackerChunk(infoTrackerChunk: InfoTrackerChunk) {
   }
 }
 
-export default (buffer: Buffer): InfoTrackerChunk => chunk(buffer, decodeInfoTrackerChunk);
+export default (buffer: Buffer): InfoTrackerChunk => Decoders.Chunk(buffer, decodeInfoTrackerChunk);

src/decoders/info/info-tracker-list-chunk.ts

@@ -1,19 +1,14 @@
+import { Decoders } from '..';
 import { Constants } from '../../constants';
-import chunk, { Chunk } from '../chunk';
+import { InfoTrackerListChunk } from '../../models/info/info-tracker-list-chunk';
-import infoTrackerChunk, { InfoTrackerChunk } from './info-tracker-chunk';
 
-export interface InfoTrackerListChunk extends Chunk {
-  trackers: {
-    [key: number]: InfoTrackerChunk;
-  };
-}
 function decodeInfoTrackerListChunk(infoTrackerListChunk: InfoTrackerListChunk) {
   infoTrackerListChunk.trackers = {};
   if (infoTrackerListChunk.has_subchunks && infoTrackerListChunk.chunk_data) {
     let offset = 0;
     if (infoTrackerListChunk.data_len) {
       while (offset < infoTrackerListChunk.data_len) {
-        const trackerChunk = infoTrackerChunk(infoTrackerListChunk.chunk_data.subarray(offset));
+        const trackerChunk = Decoders.InfoTrackerChunk(infoTrackerListChunk.chunk_data.subarray(offset));
         offset += Constants.CHUNK_HEADER_SIZE;
         if (trackerChunk.data_len) {
           offset += trackerChunk.data_len;
@@ -26,4 +21,4 @@ function decodeInfoTrackerListChunk(infoTrackerListChunk: InfoTrackerListChunk)
   }
 }
 export default (buffer: Buffer): InfoTrackerListChunk =>
-  chunk(buffer, decodeInfoTrackerListChunk) as InfoTrackerListChunk;
+  Decoders.Chunk(buffer, decodeInfoTrackerListChunk) as InfoTrackerListChunk;

src/decoders/info/info-tracker-name-chunk.ts

@@ -1,11 +1,10 @@
-import chunk, { Chunk } from '../chunk';
+import { Decoders } from '..';
-export interface InfoTrackerNameChunk extends Chunk {
+import { InfoTrackerNameChunk } from '../../models/info/info-tracker-name-chunk';
-  tracker_name: string;
-}
 
 function decodeTrackerNameChunk(trackerNameChunk: InfoTrackerNameChunk) {
   if (trackerNameChunk.chunk_data !== undefined && trackerNameChunk.data_len !== undefined) {
     trackerNameChunk.tracker_name = trackerNameChunk.chunk_data.subarray(0, trackerNameChunk.data_len).toString();
   }
 }
-export default (buffer: Buffer): InfoTrackerNameChunk => chunk(buffer, decodeTrackerNameChunk) as InfoTrackerNameChunk;
+export default (buffer: Buffer): InfoTrackerNameChunk =>
+  Decoders.Chunk(buffer, decodeTrackerNameChunk) as InfoTrackerNameChunk;

src/decoders/packet-header-chunk.ts

@@ -1,14 +1,7 @@
-import chunk, { Chunk } from './chunk';
+import { Decoders } from '.';
-export interface PacketHeaderChunk extends Chunk {
+import { PacketHeaderChunk } from '../models/packet-header-chunk';
-  packet_timestamp?: bigint;
-  version_high?: number;
-  version_low?: number;
-  frame_id?: number;
-  frame_packet_count?: number;
-}
 
 function decodePacketHeaderChunk(packetHeaderChunk: PacketHeaderChunk) {
-  // TODO(jwetzell): remove the string conversion
   if (packetHeaderChunk.chunk_data) {
     packetHeaderChunk.packet_timestamp = packetHeaderChunk.chunk_data.readBigUInt64LE(0);
     packetHeaderChunk.version_high = packetHeaderChunk.chunk_data.readUInt8(8);
@@ -18,4 +11,4 @@ function decodePacketHeaderChunk(packetHeaderChunk: PacketHeaderChunk) {
   }
 }
 
-export default (buffer: Buffer): PacketHeaderChunk => chunk(buffer, decodePacketHeaderChunk);
+export default (buffer: Buffer): PacketHeaderChunk => Decoders.Chunk(buffer, decodePacketHeaderChunk);

src/decoders/packet.ts

@@ -1,14 +1,14 @@
-import infoPacketChunk, { InfoPacketChunk } from './info/info-packet-chunk';
+import { Decoders } from '.';
-
+import { DataPacketChunk } from '../models/data/data-packet-chunk';
-import dataPacketChunk, { DataPacketChunk } from './data/data-packet-chunk';
+import { InfoPacketChunk } from '../models/info/info-packet-chunk';
 
 export default (buffer: Buffer): InfoPacketChunk | DataPacketChunk | undefined => {
   const chunkId = buffer.readUInt16LE();
   switch (chunkId) {
     case 0x6756:
-      return infoPacketChunk(buffer);
+      return Decoders.InfoPacketChunk(buffer);
     case 0x6755:
-      return dataPacketChunk(buffer);
+      return Decoders.DataPacketChunk(buffer);
     default:
       return undefined;
   }

src/encoder.ts

@@ -1,12 +1,7 @@
 import { Tracker } from './models/tracker';
 
+import { Encoders } from '.';
 import { Constants } from './constants';
-import dataPacketChunk from './encoders/data/data-packet-chunk';
-import dataTrackerListChunk from './encoders/data/data-tracker-list-chunk';
-import infoPacketChunk from './encoders/info/info-packet-chunk';
-import infoSystemNameChunk from './encoders/info/info-system-name-chunk';
-import infoTrackerListChunk from './encoders/info/info-tracker-list-chunk';
-import packetHeaderChunk from './encoders/packet-header-chunk';
 
 export class Encoder {
   private systemName: string;
@@ -20,6 +15,25 @@ export class Encoder {
     this.versionLow = versionLow;
   }
 
+  setSystemName(systemName: string) {
+    this.systemName = systemName;
+  }
+  setVersionHigh(versionHigh: number) {
+    this.versionHigh = versionHigh;
+  }
+
+  setVersionLow(versionLow: number) {
+    this.versionLow = versionLow;
+  }
+
+  resetDataFrameId() {
+    this.dataFrameId = 1;
+  }
+
+  resetInfoFrameId() {
+    this.infoFrameId = 1;
+  }
+
   getInfoPackets(timestamp: bigint, trackers: Tracker[], frameId?: number) {
     if (frameId !== undefined) {
       if (!Number.isInteger(frameId)) {
@@ -31,7 +45,7 @@ export class Encoder {
       }
     }
 
-    const systemNameChunk = infoSystemNameChunk(this.systemName);
+    const systemNameChunk = Encoders.InfoSystemNameChunk(this.systemName);
 
     const trackerChunks = trackers.map((tracker: Tracker) => tracker.getInfoChunk());
 
@@ -52,7 +66,7 @@ export class Encoder {
       currentInfoPacketSize += trackerChunk.length;
     });
     trackerChunksLists.push(currentTrackerList);
-    const header = packetHeaderChunk(
+    const header = Encoders.PacketHeaderChunk(
       timestamp,
       this.versionHigh,
       this.versionLow,
@@ -60,7 +74,9 @@ export class Encoder {
       trackerChunksLists.length
     );
     trackerChunksLists.forEach((trackerChunkList) => {
-      infoPackets.push(infoPacketChunk(header, systemNameChunk, infoTrackerListChunk(trackerChunkList)));
+      infoPackets.push(
+        Encoders.InfoPacketChunk(header, systemNameChunk, Encoders.InfoTrackerListChunk(trackerChunkList))
+      );
     });
     this.infoFrameId += 1;
     if (this.infoFrameId > 255) {
@@ -99,7 +115,7 @@ export class Encoder {
     });
     trackerChunksLists.push(currentTrackerList);
 
-    const header = packetHeaderChunk(
+    const header = Encoders.PacketHeaderChunk(
       timestamp,
       this.versionHigh,
       this.versionLow,
@@ -107,7 +123,7 @@ export class Encoder {
       trackerChunksLists.length
     );
     trackerChunksLists.forEach((trackerChunks) => {
-      dataPackets.push(dataPacketChunk(header, dataTrackerListChunk(trackerChunks)));
+      dataPackets.push(Encoders.DataPacketChunk(header, Encoders.DataTrackerListChunk(trackerChunks)));
     });
     this.dataFrameId += 1;
     if (this.dataFrameId > 255) {

src/encoders/index.ts

@@ -0,0 +1,38 @@
+import Chunk from './chunk';
+import DataPacketChunk from './data/data-packet-chunk';
+import DataTrackerAccelChunk from './data/data-tracker-accel-chunk';
+import DataTrackerChunk from './data/data-tracker-chunk';
+import DataTrackerListChunk from './data/data-tracker-list-chunk';
+import DataTrackerOriChunk from './data/data-tracker-ori-chunk';
+import DataTrackerPosChunk from './data/data-tracker-pos-chunk';
+import DataTrackerSpeedChunk from './data/data-tracker-speed-chunk';
+import DataTrackerStatusChunk from './data/data-tracker-status-chunk';
+import DataTrackerTimestampChunk from './data/data-tracker-timestamp-chunk';
+import DataTrackerTrgtposChunk from './data/data-tracker-trgtpos-chunk';
+import PacketHeaderChunk from './packet-header-chunk';
+
+import InfoPacketChunk from './info/info-packet-chunk';
+import InfoSystemNameChunk from './info/info-system-name-chunk';
+import InfoTrackerChunk from './info/info-tracker-chunk';
+import InfoTrackerListChunk from './info/info-tracker-list-chunk';
+import InfoTrackerNameChunk from './info/info-tracker-name-chunk';
+
+export const Encoders = {
+  DataPacketChunk,
+  DataTrackerAccelChunk,
+  DataTrackerChunk,
+  DataTrackerListChunk,
+  DataTrackerOriChunk,
+  DataTrackerPosChunk,
+  DataTrackerSpeedChunk,
+  DataTrackerStatusChunk,
+  DataTrackerTimestampChunk,
+  DataTrackerTrgtposChunk,
+  InfoPacketChunk,
+  InfoSystemNameChunk,
+  InfoTrackerChunk,
+  InfoTrackerListChunk,
+  InfoTrackerNameChunk,
+  PacketHeaderChunk,
+  Chunk,
+};

src/index.ts

@@ -1,3 +1,6 @@
 export { Decoder } from './decoder';
+export * from './decoders';
 export { Encoder } from './encoder';
+export * from './encoders';
+export * from './models';
 export { Tracker } from './models/tracker';

src/models/chunk.ts

@@ -0,0 +1,6 @@
+export interface Chunk {
+  id?: number;
+  has_subchunks?: boolean;
+  data_len?: number;
+  chunk_data?: Buffer;
+}

src/models/data/data-packet-chunk.ts

@@ -0,0 +1,8 @@
+import { Chunk } from '../chunk';
+import { PacketHeaderChunk } from '../packet-header-chunk';
+import { DataTrackerListChunk } from './data-tracker-list-chunk';
+
+export interface DataPacketChunk extends Chunk {
+  packet_header: PacketHeaderChunk;
+  tracker_list: DataTrackerListChunk;
+}

src/models/data/data-tracker-chunk.ts

@@ -0,0 +1,12 @@
+import { Chunk } from '../chunk';
+import { DataTrackerFieldChunk } from './data-tracker-field-chunk';
+
+export interface DataTrackerChunk extends Chunk {
+  pos?: DataTrackerFieldChunk;
+  speed?: DataTrackerFieldChunk;
+  ori?: DataTrackerFieldChunk;
+  status?: DataTrackerFieldChunk;
+  accel?: DataTrackerFieldChunk;
+  trgtpos?: DataTrackerFieldChunk;
+  timestamp?: DataTrackerFieldChunk;
+}

src/models/data/data-tracker-field-chunk.ts

@@ -0,0 +1,5 @@
+import { Chunk } from '../chunk';
+
+export interface DataTrackerFieldChunk extends Chunk {
+  [key: string]: number | bigint | number[] | Buffer | undefined | boolean;
+}

src/models/data/data-tracker-list-chunk.ts

@@ -0,0 +1,8 @@
+import { Chunk } from '../chunk';
+import { DataTrackerChunk } from './data-tracker-chunk';
+
+export interface DataTrackerListChunk extends Chunk {
+  trackers: {
+    [key: number]: DataTrackerChunk;
+  };
+}

src/models/index.ts

@@ -0,0 +1,11 @@
+export * from './chunk';
+export * from './data/data-packet-chunk';
+export * from './data/data-tracker-chunk';
+export * from './data/data-tracker-field-chunk';
+export * from './data/data-tracker-list-chunk';
+export * from './info/info-packet-chunk';
+export * from './info/info-system-name-chunk';
+export * from './info/info-tracker-chunk';
+export * from './info/info-tracker-list-chunk';
+export * from './info/info-tracker-name-chunk';
+export * from './packet-header-chunk';

src/models/info/info-packet-chunk.ts

@@ -0,0 +1,10 @@
+import { Chunk } from '../chunk';
+import { PacketHeaderChunk } from '../packet-header-chunk';
+import { InfoSystemNameChunk } from './info-system-name-chunk';
+import { InfoTrackerListChunk } from './info-tracker-list-chunk';
+
+export interface InfoPacketChunk extends Chunk {
+  packet_header: PacketHeaderChunk;
+  system_name: InfoSystemNameChunk;
+  tracker_list: InfoTrackerListChunk;
+}

src/models/info/info-system-name-chunk.ts

@@ -0,0 +1,5 @@
+import { Chunk } from '../chunk';
+
+export interface InfoSystemNameChunk extends Chunk {
+  system_name: string;
+}

src/models/info/info-tracker-chunk.ts

@@ -0,0 +1,6 @@
+import { Chunk } from '../chunk';
+import { InfoTrackerNameChunk } from './info-tracker-name-chunk';
+
+export interface InfoTrackerChunk extends Chunk {
+  tracker_name?: InfoTrackerNameChunk;
+}

src/models/info/info-tracker-list-chunk.ts

@@ -0,0 +1,8 @@
+import { Chunk } from '../chunk';
+import { InfoTrackerChunk } from './info-tracker-chunk';
+
+export interface InfoTrackerListChunk extends Chunk {
+  trackers: {
+    [key: number]: InfoTrackerChunk;
+  };
+}

src/models/info/info-tracker-name-chunk.ts

@@ -0,0 +1,5 @@
+import { Chunk } from '../chunk';
+
+export interface InfoTrackerNameChunk extends Chunk {
+  tracker_name: string;
+}

src/models/packet-header-chunk.ts

@@ -0,0 +1,9 @@
+import { Chunk } from './chunk';
+
+export interface PacketHeaderChunk extends Chunk {
+  packet_timestamp?: bigint;
+  version_high?: number;
+  version_low?: number;
+  frame_id?: number;
+  frame_packet_count?: number;
+}