perf: minor adjustments to how ints and objects are read

Author: blacha

src/__benchmark__/benchmark.array.ts

@@ -2,7 +2,7 @@ import { bp } from '../index.js';
 
 const PointParser = bp.object('Point', {
   x: bp.lu16,
-  y: bp.lu16,
+  y: bp.lu32,
 });
 
 const PointsParser = bp.object('SimpleObject', {
@@ -11,12 +11,12 @@ const PointsParser = bp.object('SimpleObject', {
 });
 
 const n = 1000;
-const buf = Buffer.alloc(4 + n * 4);
+const buf = Buffer.alloc(4 + n * 6);
 
 buf.writeUInt32LE(n, 0);
 for (let i = 0; i < n; i++) {
   buf.writeUInt16LE(123, 4 + i * 4);
-  buf.writeUInt16LE(456, 4 + i * 4 + 2);
+  buf.writeUInt32LE(456, 4 + i * 4 + 2);
 }
 
 for (let i = 0; i < 1_000; i++) {

src/int.ts

@@ -13,23 +13,23 @@ export class UInt8 extends StrutBase<number> {
 export class LUInt16 extends StrutBase<number> {
   size = 2;
   parse(bytes: StrutParserInput, pkt: StrutParserContext): number {
-    const offset = pkt.offset;
-    const byteA = bytes[offset];
-    const byteB = bytes[offset + 1] << 8;
-    pkt.offset += this.size;
+    let offset = pkt.offset;
+    const byteA = bytes[offset++];
+    const byteB = bytes[offset++] << 8;
+    pkt.offset += 2;
     return byteA | byteB;
   }
 }
 
 export class LUInt32 extends StrutBase<number> {
   size = 4;
   parse(bytes: StrutParserInput, pkt: StrutParserContext): number {
-    const offset = pkt.offset;
-    const byteA = bytes[offset];
-    const byteB = bytes[offset + 1] << 8;
-    const byteC = bytes[offset + 2] << 16;
-    const byteD = bytes[offset + 3] * 0x1000000;
-    pkt.offset += this.size;
+    let offset = pkt.offset;
+    const byteA = bytes[offset++];
+    const byteB = bytes[offset++] << 8;
+    const byteC = bytes[offset++] << 16;
+    const byteD = bytes[offset++] * 0x1000000;
+    pkt.offset = offset;
     return (byteA | byteB | byteC) + byteD;
   }
 }

src/object.ts

@@ -80,33 +80,35 @@ export class StrutTypeArrayOffset<T> extends StrutBase<T[]> {
   }
 }
 
-export class StrutTypeObject<T extends Record<string, StrutAny>> extends StrutBase<{
-  [K in keyof T]: StrutInfer<T[K]>;
-}> {
+export type StrutReturnType<T> = { [K in keyof T]: StrutInfer<T[K]> };
+
+export class StrutTypeObject<T extends Record<string, StrutAny>> extends StrutBase<StrutReturnType<T>> {
   type: StrutType<T>;
-  fields: [string, StrutAny][];
+  fields: { key: string; parser: StrutAny }[];
 
   constructor(name: string, obj: T) {
     super(name);
-    this.fields = Object.entries(obj);
+    this.fields = [];
+    for (const [key, parser] of Object.entries(obj)) {
+      this.fields.push({ key, parser });
+    }
   }
 
   private _size = -1;
   get size(): number {
     if (this._size > -1) return this._size;
     let size = 0;
-    for (const ctx of this.fields) size += ctx[1].size;
+    for (const ctx of this.fields) size += ctx.parser.size;
     this._size = size;
     return this._size;
   }
 
-  parse(bytes: StrutParserInput, ctx: StrutParserContext): { [K in keyof T]: StrutInfer<T[K]> } {
-    const value = {} as any;
-    for (const [key, parser] of this.fields) {
-      const res = parser.parse(bytes, ctx);
-      if (res != null) value[key] = res;
-      if (ctx.offset > bytes.length) throw new Error(`${this.name}: Buffer Overflow`);
+  parse(bytes: StrutParserInput, ctx: StrutParserContext): StrutReturnType<T> {
+    const value = {} as Record<string, unknown>;
+    for (const kv of this.fields) {
+      const res = kv.parser.parse(bytes, ctx);
+      if (res != null) value[kv.key] = res;
     }
-    return value;
+    return value as StrutReturnType<T>;
   }
 }