Switch from cbor-js to cbor2

Author: EzraBrooks

package-lock.json

@@ -44,7 +44,7 @@
     "@xmldom/xmldom": "^0.9.8",
     "bson": "^7.0.0",
     "buffer": "^6.0.3",
-    "cbor-js": "^0.1.0",
+    "cbor2": "^2.0.1",
     "eventemitter3": "^5.0.1",
     "fast-png": "^7.0.1",
     "uuid": "^13.0.0",

package.json

@@ -11,8 +11,7 @@ import {
   isRosbridgePngMessage,
 } from "../../types/protocol.ts";
 import { deserialize } from "bson";
-import CBOR from "cbor-js";
-import typedArrayTagger from "../../util/cborTypedArrayTags.ts";
+import { decode } from "cbor2";
 import decompressPng from "../../util/decompressPng.ts";
 
 /**
@@ -221,7 +220,7 @@ export abstract class AbstractTransport
    * It is one technique for compressing JSON data.
    */
   private handleCborMessage(cbor: ArrayBuffer) {
-    const data: unknown = CBOR.decode(cbor, typedArrayTagger);
+    const data: unknown = decode(new Uint8Array(cbor));
     if (isRosbridgeMessage(data)) {
       this.handleRosbridgeMessage(data);
     } else {

src/core/transport/Transport.ts

@@ -1,6 +1,5 @@
 import { describe, it, expect } from "vitest";
-import CBOR from "cbor-js";
-import cborTypedArrayTagger from "../src/util/cborTypedArrayTags.ts";
+import { decode } from "cbor2";
 
 /** Convert hex string to ArrayBuffer. */
 function hexToBuffer(hex: string) {
@@ -11,15 +10,16 @@ function hexToBuffer(hex: string) {
   const arr = tokens.map(function (t) {
     return parseInt(t, 16);
   });
-  return new Uint8Array(arr).buffer;
+  return new Uint8Array(arr);
 }
 
 describe("CBOR Typed Array Tagger", function () {
   it("should convert tagged Uint16Array", function () {
     const data = hexToBuffer("d84546010002000300");
-    const msg = CBOR.decode(data, cborTypedArrayTagger);
+    const msg = decode(data);
 
     if (!(msg instanceof Uint16Array)) {
+      console.error(msg);
       throw new Error("Expected Uint16Array");
     }
     expect(msg).to.have.lengthOf(3);
@@ -30,7 +30,7 @@ describe("CBOR Typed Array Tagger", function () {
 
   it("should convert tagged Uint32Array", function () {
     const data = hexToBuffer("d8464c010000000200000003000000");
-    const msg = CBOR.decode(data, cborTypedArrayTagger);
+    const msg = decode(data);
 
     if (!(msg instanceof Uint32Array)) {
       throw new Error("Expected Uint32Array");
@@ -41,24 +41,24 @@ describe("CBOR Typed Array Tagger", function () {
     expect(msg[2]).to.equal(3);
   });
 
-  it("should convert tagged Uint64Array", function () {
+  it("should convert tagged BigUint64Array", function () {
     const data = hexToBuffer(
       "d8475818010000000000000002000000000000000300000000000000",
     );
-    const msg = CBOR.decode(data, cborTypedArrayTagger);
+    const msg = decode(data);
 
-    if (!Array.isArray(msg)) {
-      throw new Error("Expected Array");
+    if (!(msg instanceof BigUint64Array)) {
+      throw new Error("Expected BigUint64Array");
     }
     expect(msg).to.have.lengthOf(3);
-    expect(msg[0]).to.equal(1);
-    expect(msg[1]).to.equal(2);
-    expect(msg[2]).to.equal(3);
+    expect(msg[0]).to.equal(BigInt(1));
+    expect(msg[1]).to.equal(BigInt(2));
+    expect(msg[2]).to.equal(BigInt(3));
   });
 
   it("should convert tagged Int8Array", function () {
     const data = hexToBuffer("d8484301fe03");
-    const msg = CBOR.decode(data, cborTypedArrayTagger);
+    const msg = decode(data);
 
     if (!(msg instanceof Int8Array)) {
       throw new Error("Expected Int8Array");
@@ -71,7 +71,7 @@ describe("CBOR Typed Array Tagger", function () {
 
   it("should convert tagged Int16Array", function () {
     const data = hexToBuffer("d84d460100feff0300");
-    const msg = CBOR.decode(data, cborTypedArrayTagger);
+    const msg = decode(data);
 
     if (!(msg instanceof Int16Array)) {
       throw new Error("Expected Int16Array");
@@ -84,7 +84,7 @@ describe("CBOR Typed Array Tagger", function () {
 
   it("should convert tagged Int32Array", function () {
     const data = hexToBuffer("d84e4c01000000feffffff03000000");
-    const msg = CBOR.decode(data, cborTypedArrayTagger);
+    const msg = decode(data);
 
     if (!(msg instanceof Int32Array)) {
       throw new Error("Expected Int32Array");
@@ -95,24 +95,24 @@ describe("CBOR Typed Array Tagger", function () {
     expect(msg[2]).to.equal(3);
   });
 
-  it("should convert tagged Int64Array", function () {
+  it("should convert tagged BigInt64Array", function () {
     const data = hexToBuffer(
       "d84f58180100000000000000feffffffffffffff0300000000000000",
     );
-    const msg = CBOR.decode(data, cborTypedArrayTagger);
+    const msg = decode(data);
 
-    if (!Array.isArray(msg)) {
-      throw new Error("Expected Array");
+    if (!(msg instanceof BigInt64Array)) {
+      throw new Error("Expected BigInt64Array");
     }
     expect(msg).to.have.lengthOf(3);
-    expect(msg[0]).to.equal(1);
-    expect(msg[1]).to.equal(-2);
-    expect(msg[2]).to.equal(3);
+    expect(msg[0]).to.equal(BigInt(1));
+    expect(msg[1]).to.equal(BigInt(-2));
+    expect(msg[2]).to.equal(BigInt(3));
   });
 
   it("should convert tagged Float32Array", function () {
     const data = hexToBuffer("d8554ccdcc8c3fcdcc0cc033335340");
-    const msg = CBOR.decode(data, cborTypedArrayTagger);
+    const msg = decode(data);
 
     if (!(msg instanceof Float32Array)) {
       throw new Error("Expected Float32Array");
@@ -127,7 +127,7 @@ describe("CBOR Typed Array Tagger", function () {
     const data = hexToBuffer(
       "d85658189a9999999999f13f9a999999999901c06666666666660a40",
     );
-    const msg = CBOR.decode(data, cborTypedArrayTagger);
+    const msg = decode(data);
 
     if (!(msg instanceof Float64Array)) {
       throw new Error("Expected Float64Array");
@@ -140,7 +140,7 @@ describe("CBOR Typed Array Tagger", function () {
 
   it("should be able to unpack two typed arrays", function () {
     const data = hexToBuffer("82d8484308fe05d84d460100feff0300");
-    const msg = CBOR.decode(data, cborTypedArrayTagger);
+    const msg = decode(data);
 
     if (!Array.isArray(msg)) {
       throw new Error("Expected Array");

src/types/cbor-js.d.ts

@@ -8,7 +8,7 @@ import type {
   RosbridgeMessage,
   RosbridgePngMessage,
 } from "../src/types/protocol.ts";
-import CBOR from "cbor-js";
+import { encode } from "cbor2";
 import * as fastpng from "fast-png";
 import * as bson from "bson";
 import * as ws from "ws";
@@ -287,8 +287,9 @@ describe("Transport", () => {
     });
 
     it("should handle CBOR message", async () => {
-      const successMessage = CBOR.encode({ op: "test" });
-      const failureMessage = CBOR.encode({ foo: "bar" });
+      // CBOR data comes as ArrayBuffer from WebSocket, not Uint8Array
+      const successMessage = encode({ op: "test" }).buffer;
+      const failureMessage = encode({ foo: "bar" }).buffer;
 
       // -- SUCCESS -- //