Convert CBOR functions to typescript

Author: ahoenerBE

src/util/cborTypedArrayTags.js

@@ -0,0 +1,128 @@
+type TypedArrayConstructor =
+    | Uint8ArrayConstructor
+    | Uint16ArrayConstructor
+    | Uint32ArrayConstructor
+    | Int8ArrayConstructor
+    | Int16ArrayConstructor
+    | Int32ArrayConstructor
+    | Float32ArrayConstructor
+    | Float64ArrayConstructor;
+
+// Type for functions that convert arrays
+type ArrayConverter = (bytes: Uint8Array) => number[];
+
+const UPPER32 = Math.pow(2, 32);
+
+let warnedPrecision = false;
+function warnPrecision() {
+  if (!warnedPrecision) {
+    warnedPrecision = true;
+    console.warn(
+      'CBOR 64-bit integer array values may lose precision. No further warnings.'
+    );
+  }
+}
+
+/**
+ * Unpack 64-bit unsigned integer from byte array.
+ * @param {Uint8Array} bytes
+ */
+function decodeUint64LE(bytes: Uint8Array) {
+  warnPrecision();
+
+  const byteLen = bytes.byteLength;
+  const offset = bytes.byteOffset;
+  const arrLen = byteLen / 8;
+
+  const buffer = bytes.buffer.slice(offset, offset + byteLen);
+  const uint32View = new Uint32Array(buffer);
+
+  const arr = new Array<number>(arrLen);
+  for (let i = 0; i < arrLen; i++) {
+    const si = i * 2;
+    const lo = uint32View[si];
+    const hi = uint32View[si + 1];
+    arr[i] = lo + UPPER32 * hi;
+  }
+
+  return arr;
+}
+
+/**
+ * Unpack 64-bit signed integer from byte array.
+ * @param {Uint8Array} bytes
+ */
+function decodeInt64LE(bytes: Uint8Array) {
+  warnPrecision();
+
+  const byteLen = bytes.byteLength;
+  const offset = bytes.byteOffset;
+  const arrLen = byteLen / 8;
+
+  const buffer = bytes.buffer.slice(offset, offset + byteLen);
+  const uint32View = new Uint32Array(buffer);
+  const int32View = new Int32Array(buffer);
+
+  const arr = new Array<number>(arrLen);
+  for (let i = 0; i < arrLen; i++) {
+    const si = i * 2;
+    const lo = uint32View[si];
+    const hi = int32View[si + 1];
+    arr[i] = lo + UPPER32 * hi;
+  }
+
+  return arr;
+}
+
+/**
+ * Unpack typed array from byte array.
+ * @param {Uint8Array} bytes
+ * @param {ArrayConstructor} ArrayType - Desired output array type
+ */
+function decodeNativeArray<T extends TypedArrayConstructor>(bytes: Uint8Array, ArrayType: T): T['prototype'] {
+  const byteLen = bytes.byteLength;
+  const offset = bytes.byteOffset;
+  const buffer = bytes.buffer.slice(offset, offset + byteLen);
+  return new ArrayType(buffer);
+}
+
+/**
+ * Supports a subset of draft CBOR typed array tags:
+ *     <https://tools.ietf.org/html/draft-ietf-cbor-array-tags-00>
+ *
+ * Only supports little-endian tags for now.
+ */
+const nativeArrayTypes = {
+  64: Uint8Array,
+  69: Uint16Array,
+  70: Uint32Array,
+  72: Int8Array,
+  77: Int16Array,
+  78: Int32Array,
+  85: Float32Array,
+  86: Float64Array
+} as const;
+
+/**
+ * We can also decode 64-bit integer arrays, since ROS has these types.
+ */
+const conversionArrayTypes: Record<number, ArrayConverter> = {
+  71: decodeUint64LE,
+  79: decodeInt64LE
+} as const;
+
+/**
+ * Handle CBOR typed array tags during decoding.
+ * @param {Uint8Array} data
+ * @param tag
+ */
+export default function cborTypedArrayTagger(data: Uint8Array, tag: keyof typeof nativeArrayTypes) {
+  if (tag in nativeArrayTypes) {
+    const arrayType = nativeArrayTypes[tag];
+    return decodeNativeArray(data, arrayType);
+  }
+  if (tag in conversionArrayTypes) {
+    return conversionArrayTypes[tag](data);
+  }
+  return data;
+}

src/util/cborTypedArrayTags.ts

@@ -3,9 +3,9 @@ import CBOR from 'cbor-js';
 import cborTypedArrayTagger from '../src/util/cborTypedArrayTags.js';
 
 /** Convert hex string to ArrayBuffer. */
-function hexToBuffer(hex) {
-  var tokens = hex.match(/[0-9a-fA-F]{2}/gi);
-  var arr = tokens.map(function(t) {
+function hexToBuffer(hex: string) {
+  const tokens = hex.match(/[0-9a-fA-F]{2}/gi) ?? [];
+  const arr = tokens.map((t: string) => {
     return parseInt(t, 16);
   });
   return new Uint8Array(arr).buffer;
@@ -15,8 +15,8 @@ function hexToBuffer(hex) {
 describe('CBOR Typed Array Tagger', function() {
 
   it('should convert tagged Uint16Array', function() {
-    var data = hexToBuffer('d84546010002000300');
-    var msg = CBOR.decode(data, cborTypedArrayTagger);
+    const data = hexToBuffer('d84546010002000300');
+    const msg = CBOR.decode(data, cborTypedArrayTagger);
 
     expect(msg).to.be.a('Uint16Array');
     expect(msg).to.have.lengthOf(3);
@@ -26,8 +26,8 @@ describe('CBOR Typed Array Tagger', function() {
   });
 
   it('should convert tagged Uint32Array', function() {
-    var data = hexToBuffer('d8464c010000000200000003000000');
-    var msg = CBOR.decode(data, cborTypedArrayTagger);
+    const data = hexToBuffer('d8464c010000000200000003000000');
+    const msg = CBOR.decode(data, cborTypedArrayTagger);
 
     expect(msg).to.be.a('Uint32Array');
     expect(msg).to.have.lengthOf(3);
@@ -37,8 +37,8 @@ describe('CBOR Typed Array Tagger', function() {
   });
 
   it('should convert tagged Uint64Array', function() {
-    var data = hexToBuffer('d8475818010000000000000002000000000000000300000000000000');
-    var msg = CBOR.decode(data, cborTypedArrayTagger);
+    const data = hexToBuffer('d8475818010000000000000002000000000000000300000000000000');
+    const msg = CBOR.decode(data, cborTypedArrayTagger);
 
     expect(msg).to.be.a('Array');
     expect(msg).to.have.lengthOf(3);
@@ -48,8 +48,8 @@ describe('CBOR Typed Array Tagger', function() {
   });
 
   it('should convert tagged Int8Array', function() {
-    var data = hexToBuffer('d8484301fe03');
-    var msg = CBOR.decode(data, cborTypedArrayTagger);
+    const data = hexToBuffer('d8484301fe03');
+    const msg = CBOR.decode(data, cborTypedArrayTagger);
 
     expect(msg).to.be.a('Int8Array');
     expect(msg).to.have.lengthOf(3);
@@ -59,8 +59,8 @@ describe('CBOR Typed Array Tagger', function() {
   });
 
   it('should convert tagged Int16Array', function() {
-    var data = hexToBuffer('d84d460100feff0300');
-    var msg = CBOR.decode(data, cborTypedArrayTagger);
+    const data = hexToBuffer('d84d460100feff0300');
+    const msg = CBOR.decode(data, cborTypedArrayTagger);
 
     expect(msg).to.be.a('Int16Array');
     expect(msg).to.have.lengthOf(3);
@@ -70,8 +70,8 @@ describe('CBOR Typed Array Tagger', function() {
   });
 
   it('should convert tagged Int32Array', function() {
-    var data = hexToBuffer('d84e4c01000000feffffff03000000');
-    var msg = CBOR.decode(data, cborTypedArrayTagger);
+    const data = hexToBuffer('d84e4c01000000feffffff03000000');
+    const msg = CBOR.decode(data, cborTypedArrayTagger);
 
     expect(msg).to.be.a('Int32Array');
     expect(msg).to.have.lengthOf(3);
@@ -81,8 +81,8 @@ describe('CBOR Typed Array Tagger', function() {
   });
 
   it('should convert tagged Int64Array', function() {
-    var data = hexToBuffer('d84f58180100000000000000feffffffffffffff0300000000000000');
-    var msg = CBOR.decode(data, cborTypedArrayTagger);
+    const data = hexToBuffer('d84f58180100000000000000feffffffffffffff0300000000000000');
+    const msg = CBOR.decode(data, cborTypedArrayTagger);
 
     expect(msg).to.be.a('Array');
     expect(msg).to.have.lengthOf(3);
@@ -92,8 +92,8 @@ describe('CBOR Typed Array Tagger', function() {
   });
 
   it('should convert tagged Float32Array', function() {
-    var data = hexToBuffer('d8554ccdcc8c3fcdcc0cc033335340');
-    var msg = CBOR.decode(data, cborTypedArrayTagger);
+    const data = hexToBuffer('d8554ccdcc8c3fcdcc0cc033335340');
+    const msg = CBOR.decode(data, cborTypedArrayTagger);
 
     expect(msg).to.be.a('Float32Array');
     expect(msg).to.have.lengthOf(3);
@@ -103,8 +103,8 @@ describe('CBOR Typed Array Tagger', function() {
   });
 
   it('should convert tagged Float64Array', function() {
-    var data = hexToBuffer('d85658189a9999999999f13f9a999999999901c06666666666660a40');
-    var msg = CBOR.decode(data, cborTypedArrayTagger);
+    const data = hexToBuffer('d85658189a9999999999f13f9a999999999901c06666666666660a40');
+    const msg = CBOR.decode(data, cborTypedArrayTagger);
 
     expect(msg).to.be.a('Float64Array');
     expect(msg).to.have.lengthOf(3);
@@ -114,8 +114,8 @@ describe('CBOR Typed Array Tagger', function() {
   });
 
   it('should be able to unpack two typed arrays', function() {
-    var data = hexToBuffer('82d8484308fe05d84d460100feff0300');
-    var msg = CBOR.decode(data, cborTypedArrayTagger);
+    const data = hexToBuffer('82d8484308fe05d84d460100feff0300');
+    const msg = CBOR.decode(data, cborTypedArrayTagger);
 
     expect(msg).to.be.a('Array');
     expect(msg).to.have.lengthOf(2);