WIP for structured clone algo

gfx · gfx · commit 9737a9b83c1c · 2021-01-03T15:00:58.000+09:00
diff --git a/src/JavaScriptCodec.ts b/src/JavaScriptCodec.ts
@@ -1,57 +1,151 @@
+// Implementation of "Structured Clone" algorithm in MessagPack
+// https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm
+
 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,
+const enum JS {
+  // defined in "structured clone algorithm"
+  // commente-outed ones are TODOs
+
+  // Boolean = "Boolean",
+  // String = "String",
+  Date = "Date",
+  RegExp = "RegExp",
+  // Blob = "Blob",
+  // File = "File",
+  // FileList = "FileList",
+  ArrayBuffer = "ArrayBuffer",
+  Int8Array = "Int8Array",
+  Uint8Array = "Uint8Array",
+  Uint8ClampedArray = "Uint8ClampedArray",
+  Int16Array = "Int16Array",
+  Uint16Array = "Uint16Array",
+  Int32Array = "Int32Array",
+  Uint32Array = "Uint32Array",
+  Float32Array = "Float32Array",
+  Float64Array = "Float64Array",
+  BigInt64Array = "BigInt64Array",
+  BigUint64Array = "BigUint64Array",
+  DataView = "DataView",
+  // ImageBitMap = "ImageBitMap",
+  // ImageData = "ImageData",
+  Map = "Map",
+  Set = "Set",
+
+  // and more
+  BigInt = "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()]);
+export function encodeJavaScriptStructure(input: unknown): Uint8Array | null {
+  if (!(input instanceof Object)) {
+    if (typeof input === "bigint") {
+      return encode([JS.BigInt, input.toString()]);
+    } else {
+      return null;
+    }
+  }
+  const type = input.constructor.name;
+
+  if (ArrayBuffer.isView(input)) {
+    if (type === JS.Uint8Array) {
+      return null; // fall through to the default encoder
+    } else if (type === JS.DataView || type === JS.Int8Array || type === JS.Uint8ClampedArray) {
+      // handles them as a byte buffer
+      const v = new Uint8Array(input.buffer, input.byteOffset, input.byteLength)
+      return encode([type, v]);
+    } else {
+      // handles them as a number array for portability
+      return encode([type, ...(input as unknown as Iterable<number>)]);
+    }
+  } else if (type === JS.ArrayBuffer) {
+    const bufferView = new Uint8Array(input as ArrayBuffer);
+    return encode([type, bufferView]);
+  } else if (type === JS.Map) {
+    return encode([JS.Map, ...input as Map<unknown, unknown>]);
+  } else if (type === JS.Set) {
+    return encode([JS.Set, ...input as Set<unknown>]);
+  } else if (type === JS.Date) {
+    return encode([JS.Date, (input as Date).getTime()]);
+  } else if (type === JS.RegExp) {
+    return encode([JS.RegExp, (input as RegExp).source, (input as RegExp).flags]);
   } 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);
+export function decodeJavaScriptStructure(data: Uint8Array) {
+  const [type, ...source] = decode(data) as [JS, ...any];
+  switch (type) {
+    case JS.BigInt: {
+      const [str] = source;
+      return BigInt(str);
     }
-    case JSData.Date: {
-      return new Date(source);
+    case JS.Date: {
+      const [millis] = source;
+      return new Date(millis);
     }
-    case JSData.RegExp: {
+    case JS.RegExp: {
       const [pattern, flags] = source;
       return new RegExp(pattern, flags);
     }
-    case JSData.BigInt: {
-      return BigInt(source);
+    case JS.ArrayBuffer: {
+      const [buffer] = source as [Uint8Array];
+      return buffer.slice(0).buffer;
+    }
+    case JS.Int8Array: {
+      const [v] = source as [Uint8Array];
+      return new Int8Array(v.buffer, v.byteOffset, v.byteLength);
+    }
+    case JS.Uint8Array: {
+      // unlikely because it is handled by the default decoder,
+      // but technically possible with no conflict.
+      const [v] = source as [Uint8Array];
+      return new Uint8Array(v.buffer, v.byteOffset, v.byteLength);
+    }
+    case JS.Uint8ClampedArray: {
+      const [v] = source as [Uint8Array];
+      return new Uint8ClampedArray(v.buffer, v.byteOffset, v.byteLength);
+    }
+    case JS.Int16Array: {
+      return Int16Array.from(source as ReadonlyArray<number>);
+    }
+    case JS.Uint16Array: {
+      return Uint16Array.from(source as ReadonlyArray<number>);
+    }
+    case JS.Int32Array: {
+      return Int32Array.from(source as ReadonlyArray<number>);
+    }
+    case JS.Uint32Array: {
+      return Uint32Array.from(source as ReadonlyArray<number>);
+    }
+    case JS.Float32Array: {
+      return Float32Array.from(source as ReadonlyArray<number>);
+    }
+    case JS.Float64Array: {
+      return Float64Array.from(source as ReadonlyArray<number>);
+    }
+    case JS.BigInt64Array: {
+      return BigInt64Array.from(source as ReadonlyArray<bigint>);
+    }
+    case JS.BigUint64Array: {
+      return BigUint64Array.from(source as ReadonlyArray<bigint>);
+    }
+    case JS.DataView: {
+      const [v] = source as [Uint8Array];
+      return new DataView(v.buffer, v.byteOffset, v.byteLength);
+    }
+    case JS.Map: {
+      return new Map(source);
+    }
+    case JS.Set: {
+      return new Set(source);
     }
     default: {
-      throw new Error(`Unknown data type: ${jsDataType}`);
+      throw new Error(`Unknown data type: ${type}`);
     }
   }
 }
@@ -61,8 +155,8 @@ export const JavaScriptCodec: ExtensionCodecType<undefined> = (() => {
 
   ext.register({
     type: EXT_JAVASCRIPT,
-    encode: encodeJavaScriptData,
-    decode: decodeJavaScriptData,
+    encode: encodeJavaScriptStructure,
+    decode: decodeJavaScriptStructure,
   });
 
   return ext;
diff --git a/src/index.ts b/src/index.ts
@@ -45,5 +45,15 @@ export {
   decodeTimestampExtension,
 };
 
-export { JavaScriptCodec, EXT_JAVASCRIPT, encodeJavaScriptData, decodeJavaScriptData } from "./JavaScriptCodec";
-
+import {
+  JavaScriptCodec,
+  EXT_JAVASCRIPT,
+  encodeJavaScriptStructure,
+  decodeJavaScriptStructure,
+} from "./JavaScriptCodec";
+export {
+  JavaScriptCodec,
+  EXT_JAVASCRIPT,
+  encodeJavaScriptStructure,
+  decodeJavaScriptStructure,
+};
diff --git a/test/javascript-codec.test.ts b/test/javascript-codec.test.ts
@@ -3,25 +3,51 @@ 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", () => {
+    it("encodes and decodes structured data", () => {
       const object = {
+        // basic
         str: "string",
         num: 0,
         obj: { foo: "foo", bar: "bar" },
         arr: [1, 2, 3],
         bool: true,
         nil: null,
-        // undef: undefined, // not supported
+
+        // JavaScript structures
         date: new Date("Thu, 28 Apr 2016 22:02:17 GMT"),
+        regexp: /foo\n/i,
+        arrayBuffer: Uint8Array.from([0, 1, 2, 0xff]).buffer,
+        int8Array: Int8Array.from([0, 1, 2, 0xff]),
+        uint8ClampedArray: Uint8ClampedArray.from([0, 1, 2, 0xff]),
+        int16Array: Int16Array.from([0, 1, 2, 0xffff]),
+        uint16Array: Uint16Array.from([0, 1, 2, -1]),
+        int32Array: Int32Array.from([0, 1, 2, 0xffff]),
+        uint32Array: Uint32Array.from([0, 1, 2, -1]),
+        float32Array: Float32Array.from([0, 1, 2, Math.PI, Math.E]),
+        float64Array: Float64Array.from([0, 1, 2, Math.PI, Math.E]),
         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);
+    });
+  });
+
+  context("bigint and its family", () => {
+    it("encodes and decodes structured data", function () {
+      if (typeof BigInt === "undefined" || typeof BigInt64Array === "undefined" || typeof BigUint64Array === "undefined") {
+        this.skip();
+      }
+
+      const object = {
+        bigint: BigInt(42),
+        bigintArray: [BigInt(42)],
 
+        // TODO:
+        //bigInt64array: BigInt64Array.from([BigInt(0), BigInt(Number.MIN_SAFE_INTEGER) - BigInt(1)]),
+        //bigUint64array: BigUint64Array.from([BigInt(0), BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1)]),
+      };
+      const encoded = encode(object, { extensionCodec: JavaScriptCodec });
       assert.deepStrictEqual(decode(encoded, { extensionCodec: JavaScriptCodec }), object);
     });
   });
