make Encoder to handle bigint with ExtensionCodec

gfx · gfx · commit ac2529ec7d3e · 2019-05-08T10:55:14.000+09:00
diff --git a/README.md b/README.md
@@ -106,6 +106,37 @@ const decoded = decode(encoded, { extensionCodec });
 
 Not that extension types for custom objects must be `[0, 127]`, while `[-1, -128]` is reserved for MessagePack itself.
 
+#### Handling BigInt with ExtensionCodec
+
+This library does not handle BigInt by default, but you can handle it with `ExtensionCodec` like this:
+
+```typescript
+import { deepStrictEqual } from "assert";
+import { encode, decode, ExtensionCodec } from "../src";
+
+const BIGINT_EXT_TYPE = 0; // Any in 0-127
+
+const extensionCodec = new ExtensionCodec();
+extensionCodec.register({
+  type: BIGINT_EXT_TYPE,
+  encode: (input: unknown) => {
+    // eslint-disable-next-line valid-typeof
+    if (typeof input === "bigint") {
+      return encode(input.toString());
+    } else {
+      return null;
+    }
+  },
+  decode: (data: Uint8Array) => {
+    return BigInt(decode(data));
+  },
+});
+
+const value = BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1);
+const encoded: = encode(value, { extensionCodec });
+deepStrictEqual(decode(encoded, { extensionCodec }), value);
+```
+
 ### MessagePack Mapping Table
 
 The following table shows how JavaScript values are mapped to [MessagePack formats](https://github.com/msgpack/msgpack/blob/master/spec.md) and vice versa.
diff --git a/src/Encoder.ts b/src/Encoder.ts
@@ -22,17 +22,10 @@ export class Encoder {
       this.encodeBoolean(object);
     } else if (typeof object === "number") {
       this.encodeNumber(object);
-
-      // eslint-disable-next-line valid-typeof
-    } else if (typeof object === "bigint") {
-      this.encodeBigInt(object);
     } else if (typeof object === "string") {
       this.encodeString(object);
-    } else if (typeof object === "object") {
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      this.encodeObject(object!, depth);
     } else {
-      throw new Error(`Unrecognized object: ${Object.prototype.toString.apply(object)}`);
+      this.encodeObject(object, depth);
     }
   }
 
@@ -118,11 +111,6 @@ export class Encoder {
     }
   }
 
-  encodeBigInt(_object: bigint) {
-    // BigInt literals is not available here!
-    throw new Error("BigInt is not yet implemented!");
-  }
-
   encodeString(object: string) {
     const byteLength = utf8Count(object);
     if (byteLength < 32) {
@@ -149,7 +137,7 @@ export class Encoder {
     this.pos += byteLength;
   }
 
-  encodeObject(object: object, depth: number) {
+  encodeObject(object: unknown, depth: number) {
     // try to encode objects with custom codec first of non-primitives
     const ext = this.extensionCodec.tryToEncode(object);
     if (ext != null) {
@@ -158,8 +146,11 @@ export class Encoder {
       this.encodeBinary(object);
     } else if (Array.isArray(object)) {
       this.encodeArray(object, depth);
-    } else {
+    } else if (typeof object === "object") {
       this.encodeMap(object as Record<string, unknown>, depth);
+    } else {
+      // symbol, function and other special object come here unless extensionCodec handles them.
+      throw new Error(`Unrecognized object: ${Object.prototype.toString.apply(object)}`);
     }
   }
 
diff --git a/test/codec-bigint.test.ts b/test/codec-bigint.test.ts
@@ -0,0 +1,44 @@
+import assert from "assert";
+import { encode, decode, ExtensionCodec } from "../src";
+
+const extensionCodec = new ExtensionCodec();
+extensionCodec.register({
+  type: 0,
+  encode: (input: unknown) => {
+    // eslint-disable-next-line valid-typeof
+    if (typeof input === "bigint") {
+      return encode(input.toString());
+    } else {
+      return null;
+    }
+  },
+  decode: (data: Uint8Array) => {
+    return BigInt(decode(data));
+  },
+});
+
+describe("codec BigInt", () => {
+  before(function() {
+    if (typeof BigInt === "undefined") {
+      this.skip();
+    }
+  });
+
+  it("encodes and decodes 0n", () => {
+    const value = BigInt(0);
+    const encoded = encode(value, { extensionCodec });
+    assert.deepStrictEqual(decode(encoded, { extensionCodec }), value);
+  });
+
+  it("encodes and decodes MAX_SAFE_INTEGER+1", () => {
+    const value = BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1);
+    const encoded = encode(value, { extensionCodec });
+    assert.deepStrictEqual(decode(encoded, { extensionCodec }), value);
+  });
+
+  it("encodes and decodes MIN_SAFE_INTEGER-1", () => {
+    const value = BigInt(Number.MIN_SAFE_INTEGER) - BigInt(1);
+    const encoded = encode(value, { extensionCodec });
+    assert.deepStrictEqual(decode(encoded, { extensionCodec }), value);
+  });
+});
