wip

Author: kuhe

packages/core/src/submodules/cbor/ByteVector.ts

@@ -1,29 +1,85 @@
+import { CborMajorType } from "./cbor";
+
 export class ByteVector {
-  public data: Uint8Array = new Uint8Array(100_000);
-  public cursor: number = 0;
+  private data: Uint8Array = new Uint8Array();
+  private dataView: DataView = new DataView(this.data.buffer, 0, 0);
+  private cursor: number = 0;
+
+  public constructor(private initialSize: number = 1_000_000) {
+    this.resize(initialSize);
+  }
 
-  public write(byte: number) {
-    if (this.data.length - this.cursor < 1) {
-      this.resize(this.data.length + 1_000_000);
+  public write(...bytes: number[]) {
+    for (const byte of bytes) {
+      if (this.cursor === this.data.length) {
+        this.resize(this.cursor + this.initialSize);
+      }
+      this.data[this.cursor++] = byte;
     }
-    this.data[this.cursor++] = byte;
   }
 
   public writeSeries(bytes: Uint8Array) {
-    while ((this.data.length - this.cursor) * 1.1 < bytes.length) {
-      this.resize(this.data.length + 1_000_000);
+    if (this.cursor + bytes.length >= this.data.length) {
+      this.resize(this.cursor + bytes.length + this.initialSize);
     }
     this.data.set(bytes, this.cursor);
-    this.cursor += bytes.length;
+    this.cursor += bytes.byteLength;
+  }
+
+  public writeUnsignedInt(major: CborMajorType, bitSize: 16 | 32 | 64, value: number | bigint) {
+    if (this.cursor + bitSize / 8 >= this.data.length) {
+      this.resize(this.cursor + bitSize / 8 + this.initialSize);
+    }
+    const dv = byteVector.getDataView();
+    switch (bitSize) {
+      case 16:
+        this.write((major << 5) | 25);
+        dv.setUint16(byteVector.getCursor(), Number(value) as number);
+        this.cursor += 2;
+        break;
+      case 32:
+        this.write((major << 5) | 26);
+        dv.setUint32(byteVector.getCursor(), Number(value) as number);
+        this.cursor += 4;
+        break;
+      case 64:
+        this.write((major << 5) | 27);
+        dv.setBigUint64(byteVector.getCursor(), BigInt(value) as bigint);
+        this.cursor += 8;
+        break;
+    }
   }
 
-  public resize(size: number) {
-    const old = this.data.subarray(0, this.cursor);
-    this.data = new Uint8Array(size);
-    this.data.set(old, 0);
+  public toUint8Array(): Uint8Array {
+    const out = new Uint8Array(this.cursor);
+    out.set(this.data.slice(0, this.cursor), 0);
+    this.data = new Uint8Array(this.initialSize);
+    this.cursor = 0;
+    this.dataView = new DataView(this.data.buffer, 0, this.initialSize);
+    return out;
+  }
+
+  public getDataView() {
+    return this.dataView;
+  }
+
+  public getCursor() {
+    return this.cursor;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  private resize(size: number) {
+    const data = this.data;
+    this.data = typeof Buffer !== "undefined" ? new Uint8Array(size) : new Uint8Array(size);
+    if (data) {
+      this.data.set(data, 0);
+    }
+    this.dataView = new DataView(this.data.buffer, 0, size);
   }
 }
 
+export const byteVector = new ByteVector();
+
 export function join(byteArrays: Uint8Array[]): Uint8Array {
   let length = 0;
   for (const arr of byteArrays) {

packages/core/src/submodules/cbor/cbor.spec.ts

@@ -2,7 +2,7 @@ import * as fs from "fs";
 import JSONbig from "json-bigint";
 import * as path from "path";
 
-import { cbor, setUnsignedInt } from "./cbor";
+import { cbor } from "./cbor";
 
 // syntax is ESM but the test target is CJS.
 const here = __dirname;
@@ -14,34 +14,6 @@ const successTests = JSONbig({ useNativeBigInt: true, alwaysParseAsBig: false })
   fs.readFileSync(path.join(here, "test-data", "success-tests.json"))
 );
 
-describe("setUnsignedInt", () => {
-  for (const [value, bitSize] of [
-    [1, 16],
-    [258, 16],
-    [256256, 16],
-    [5, 32],
-    [258, 32],
-    [125432, 32],
-    [5, 64],
-    [258, 64],
-    [BigInt(42462464262), 64],
-  ] as [number | bigint, number][]) {
-    it(`should functionally match DataView int${bitSize} value of ${value}`, () => {
-      expect(setUnsignedInt(bitSize as 16 | 32 | 64, value, new Uint8Array(8))).toEqual(
-        (() => {
-          const u = new Uint8Array(8);
-          if (bitSize < 64) {
-            new DataView(u.buffer, u.buffer.byteLength - u.length)["setUint" + bitSize](0, value);
-          } else {
-            new DataView(u.buffer, u.buffer.byteLength - u.length).setBigUint64(0, BigInt(value));
-          }
-          return u;
-        })()
-      );
-    });
-  }
-});
-
 describe("cbor", () => {
   const examples = [
     {

packages/core/src/submodules/cbor/cbor.ts

@@ -1,6 +1,6 @@
 import { fromUtf8, toUtf8 } from "@smithy/util-utf8";
 
-import { ByteVector, join } from "./ByteVector";
+import { byteVector, join } from "./ByteVector";
 
 /**
  * This cbor serde implementation is derived from AWS SDK for Go's implementation.
@@ -44,7 +44,7 @@ type Int64 = bigint;
 type Float16Binary = number;
 type Float32Binary = number;
 
-type CborMajorType =
+export type CborMajorType =
   | typeof majorUint64
   | typeof majorNegativeInt64
   | typeof majorUnstructuredByteString
@@ -94,25 +94,6 @@ function demote(bigInteger: bigint): number {
   return num;
 }
 
-/**
- * @internal
- * Write unsigned int into uint8 array.
- */
-export function setUnsignedInt(bitSize: 16 | 32 | 64, value: number | bigint, byteArray: Uint8Array): Uint8Array {
-  switch (bitSize) {
-    case 16:
-      offsetDataView(byteArray).setUint16(0, Number(value) as number);
-      break;
-    case 32:
-      offsetDataView(byteArray).setUint32(0, Number(value) as number);
-      break;
-    case 64:
-      offsetDataView(byteArray).setBigUint64(0, BigInt(value) as bigint);
-      break;
-  }
-  return byteArray;
-}
-
 // decode
 
 function float16ToUint32(float: Float16Binary): Uint32 {
@@ -480,7 +461,7 @@ function decode(payload: Uint8Array, bigIntBehavior: BigIntBehavior): [CborValue
 
 // encode
 
-function encodeHeader(major: CborMajorType, value: Uint64 | number, byteVector: ByteVector): void {
+function encodeHeader(major: CborMajorType, value: Uint64 | number): void {
   if (value < 24) {
     byteVector.write((major << 5) | (value as number));
     return;
@@ -489,22 +470,13 @@ function encodeHeader(major: CborMajorType, value: Uint64 | number, byteVector:
     byteVector.write(value as number);
     return;
   } else if (value < TWO.SIXTEEN) {
-    const float16Container = new Uint8Array(3);
-    float16Container[0] = (major << 5) | specialFloat16;
-    setUnsignedInt(16, value, float16Container.subarray(1));
-    byteVector.writeSeries(float16Container);
+    byteVector.writeUnsignedInt(major, 16, value);
     return;
   } else if (value < TWO.THIRTY_TWO) {
-    const float32Container = new Uint8Array(5);
-    float32Container[0] = (major << 5) | specialFloat32;
-    setUnsignedInt(32, value, float32Container.subarray(1));
-    byteVector.writeSeries(float32Container);
+    byteVector.writeUnsignedInt(major, 32, value);
     return;
   }
-  const float64Container = new Uint8Array(9);
-  float64Container[0] = (major << 5) | specialFloat64;
-  setUnsignedInt(64, value, float64Container.subarray(1));
-  byteVector.writeSeries(float64Container);
+  byteVector.writeUnsignedInt(major, 64, value);
   return;
 }
 
@@ -516,7 +488,7 @@ function compose(major: CborMajorType, minor: Uint8): Uint8 {
  * @param input - JS data object.
  * @param byteVector - mutated, not returned.
  */
-function encode(input: any, byteVector: ByteVector): void {
+function encode(input: any): void {
   if (input === null) {
     byteVector.write(compose(majorSpecial, specialNull));
     return;
@@ -534,9 +506,7 @@ function encode(input: any, byteVector: ByteVector): void {
       return;
     case "number":
       if (Number.isInteger(input)) {
-        input >= 0
-          ? encodeHeader(majorUint64, input, byteVector)
-          : encodeHeader(majorNegativeInt64, Math.abs(input) - 1, byteVector);
+        input >= 0 ? encodeHeader(majorUint64, input) : encodeHeader(majorNegativeInt64, Math.abs(input) - 1);
         return;
       }
       const float64Container = new Uint8Array(9);
@@ -545,33 +515,31 @@ function encode(input: any, byteVector: ByteVector): void {
       byteVector.writeSeries(float64Container);
       return;
     case "bigint":
-      input >= 0
-        ? encodeHeader(majorUint64, input, byteVector)
-        : encodeHeader(majorNegativeInt64, -input - BigInt(1), byteVector);
+      input >= 0 ? encodeHeader(majorUint64, input) : encodeHeader(majorNegativeInt64, -input - BigInt(1));
       return;
     case "string":
-      encodeHeader(majorUtf8String, input.length, byteVector);
+      encodeHeader(majorUtf8String, input.length);
       byteVector.writeSeries(fromUtf8(input));
       return;
   }
 
   if (Array.isArray(input)) {
     const _input = input.filter(notUndef);
-    encodeHeader(majorList, _input.length, byteVector);
+    encodeHeader(majorList, _input.length);
     for (const vv of _input) {
-      encode(vv, byteVector);
+      encode(vv);
     }
     return;
   } else if (typeof input.byteLength === "number") {
-    encodeHeader(majorUnstructuredByteString, input.length, byteVector);
+    encodeHeader(majorUnstructuredByteString, input.length);
     byteVector.writeSeries(input);
     return;
   } else if (typeof input === "object") {
     const entries = Object.entries(input).filter(valueNotUndef);
-    encodeHeader(majorMap, entries.length, byteVector);
+    encodeHeader(majorMap, entries.length);
     for (const [key, value] of entries) {
-      encode(key, byteVector);
-      encode(value, byteVector);
+      encode(key);
+      encode(value);
     }
     return;
   }
@@ -595,8 +563,7 @@ export const cbor = {
     return decode(payload, bigIntBehavior)[0];
   },
   serialize(input: any) {
-    const byteVector = new ByteVector();
-    encode(input, byteVector);
-    return byteVector.data.subarray(0, byteVector.cursor);
+    encode(input);
+    return byteVector.toUint8Array();
   },
 };