add JavaScriptCodec to serialize JavaScript data structure

Author: gfx

src/Encoder.ts

@@ -24,16 +24,14 @@ export class Encoder {
       throw new Error(`Too deep objects in depth ${depth}`);
     }
 
-    if (object == null) {
-      this.encodeNil();
-    } else if (typeof object === "boolean") {
+    if (typeof object === "boolean") {
       this.encodeBoolean(object);
     } else if (typeof object === "number") {
       this.encodeNumber(object);
     } else if (typeof object === "string") {
       this.encodeString(object);
     } else {
-      this.encodeObject(object, depth);
+      this.encodeObjectOrNil(object, depth);
     }
   }
 
@@ -164,11 +162,14 @@ export class Encoder {
     }
   }
 
-  encodeObject(object: unknown, depth: number) {
+  encodeObjectOrNil(object: unknown, depth: number) {
     // try to encode objects with custom codec first of non-primitives
     const ext = this.extensionCodec.tryToEncode(object);
     if (ext != null) {
       this.encodeExtension(ext);
+    } else if (object == null) {
+      // `encodeNil()` must be here for extentionCodec to handle null / undefined.
+      this.encodeNil();
     } else if (Array.isArray(object)) {
       this.encodeArray(object, depth);
     } else if (ArrayBuffer.isView(object)) {

src/JavaScriptCodec.ts

@@ -0,0 +1,66 @@
+import { ExtensionCodec, ExtensionCodecType } from "./ExtensionCodec";
+import { encode } from "./encode";
+import { decode } from "./decode";
+
+export const JavaScriptCodecType = 0;
+
+export function encodeJavaScriptData(input: unknown): Uint8Array | null {
+  if (input == null) {
+    // to distinguish undefined from null
+    if (input === undefined) {
+      return encode(["undefined"]);
+    } else {
+      return null; // fallback to MessagePack nil
+    }
+  } else if (input instanceof Map) {
+    return encode(["Map", [...input]]);
+  } else if (input instanceof Set) {
+    return encode(["Set", [...input]]);
+  } else if (input instanceof Date) {
+    // Not a MessagePack timestamp because
+    // it may be overrided by users
+    return encode(["Date", input.getTime()]);
+  } else if (input instanceof RegExp) {
+    return encode(["RegExp", [input.source, input.flags]]);
+  } else {
+    return null;
+  }
+}
+
+export function decodeJavaScriptData(data: Uint8Array) {
+  const [constructor, source] = decode(data) as [string, any];
+
+  switch (constructor) {
+    case "undefined": {
+      return undefined;
+    }
+    case "Map": {
+      return new Map<unknown, unknown>(source);
+    }
+    case "Set": {
+      return new Set<unknown>(source);
+    }
+    case "Date": {
+      return new Date(source);
+    }
+    case "RegExp": {
+      const [pattern, flags] = source;
+      return new RegExp(pattern, flags);
+    }
+    default: {
+      throw new Error(`Unknown constructor: ${constructor}`);
+    }
+  }
+}
+
+export const JavaScriptCodec: ExtensionCodecType = (() => {
+  const ext = new ExtensionCodec();
+
+  ext.register({
+    type: JavaScriptCodecType,
+    encode: encodeJavaScriptData,
+    decode: decodeJavaScriptData,
+  });
+
+  return ext;
+})();

test/javascript-codec.test.ts

@@ -0,0 +1,28 @@
+import assert from "assert";
+import { encode, decode } from "@msgpack/msgpack";
+import { JavaScriptCodec } from "src/JavaScriptCodec";
+
+describe("JavaScriptCodec", () => {
+  context("mixed", () => {
+    // this data comes from https://github.com/yahoo/serialize-javascript
+
+    it("encodes and decodes the object", () => {
+      const object = {
+        str: "string",
+        num: 0,
+        obj: { foo: "foo", bar: "bar" },
+        arr: [1, 2, 3],
+        bool: true,
+        nil: null,
+        undef: undefined,
+        date: new Date("Thu, 28 Apr 2016 22:02:17 GMT"),
+        map: new Map([["foo", 10], ["bar", 20]]),
+        set: new Set([123, 456]),
+        regexp: /foo\n/i,
+      };
+      const encoded = encode(object, { extensionCodec: JavaScriptCodec });
+
+      assert.deepStrictEqual(decode(encoded, { extensionCodec: JavaScriptCodec }), object);
+    });
+  });
+});