Merge branch 'javascript_codec' into structure_cloneable

Author: gfx

src/ExtensionCodec.ts

@@ -61,25 +61,25 @@ export class ExtensionCodec<ContextType = undefined> implements ExtensionCodecTy
   }
 
   public tryToEncode(object: unknown, context: ContextType): ExtData | null {
-    // built-in extensions
-    for (let i = 0; i < this.builtInEncoders.length; i++) {
-      const encoder = this.builtInEncoders[i];
+    // custom extensions
+    for (let i = 0; i < this.encoders.length; i++) {
+      const encoder = this.encoders[i];
       if (encoder != null) {
         const data = encoder(object, context);
         if (data != null) {
-          const type = -1 - i;
+          const type = i;
           return new ExtData(type, data);
         }
       }
     }
 
-    // custom extensions
-    for (let i = 0; i < this.encoders.length; i++) {
-      const encoder = this.encoders[i];
+    // built-in extensions
+    for (let i = 0; i < this.builtInEncoders.length; i++) {
+      const encoder = this.builtInEncoders[i];
       if (encoder != null) {
         const data = encoder(object, context);
         if (data != null) {
-          const type = i;
+          const type = -1 - i;
           return new ExtData(type, data);
         }
       }

src/JavaScriptCodec.ts

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

src/index.ts

@@ -44,3 +44,6 @@ export {
   encodeTimestampExtension,
   decodeTimestampExtension,
 };
+
+export { JavaScriptCodec, EXT_JAVASCRIPT, encodeJavaScriptData, decodeJavaScriptData } from "./JavaScriptCodec";
+

test/javascript-codec.test.ts

@@ -0,0 +1,28 @@
+import assert from "assert";
+import { encode, decode, JavaScriptCodec } from "@msgpack/msgpack";
+
+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, // not supported
+        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,
+        bigint: typeof(BigInt) !== "undefined" ? BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1) : null,
+      };
+      const encoded = encode(object, { extensionCodec: JavaScriptCodec });
+
+      assert.deepStrictEqual(decode(encoded, { extensionCodec: JavaScriptCodec }), object);
+    });
+  });
+});