Merge pull request #40 from msgpack/std-temporal

add decodeTimestampToTimeSpec() to register custom timestamp ext handlers

Author: gfx

README.md

@@ -152,6 +152,50 @@ const encoded: = encode(value, { extensionCodec });
 deepStrictEqual(decode(encoded, { extensionCodec }), value);
 ```
 
+#### The temporal module as timestamp extensions
+
+This library maps `Date` to the MessagePack timestamp extension, but you re-map the [temporal module](https://github.com/tc39/proposal-temporal) to the timestamp ext like this:
+
+```typescript
+import { Instant } from "@std-proposal/temporal";
+import { deepStrictEqual } from "assert";
+import {
+  encode,
+  decode,
+  ExtensionCodec,
+  EXT_TIMESTAMP,
+  encodeTimeSpecToTimestamp,
+  decodeTimestampToTimeSpec,
+} from "@msgpack/msgpack";
+
+const extensionCodec = new ExtensionCodec();
+extensionCodec.register({
+  type: EXT_TIMESTAMP, // override the default behavior!
+  encode: (input: any) => {
+    if (input instanceof Instant) {
+      const sec = input.seconds;
+      const nsec = Number(input.nanoseconds - BigInt(sec) * BigInt(1e9));
+      return encodeTimeSpecToTimestamp({ sec, nsec });
+    } else {
+      return null;
+    }
+  },
+  decode: (data: Uint8Array) => {
+    const timeSpec = decodeTimestampToTimeSpec(data);
+    const sec = BigInt(timeSpec.sec);
+    const nsec = BigInt(timeSpec.nsec);
+    return Instant.fromEpochNanoseconds(sec * BigInt(1e9) + nsec);
+  },
+});
+
+const instant = Instant.fromEpochMilliseconds(Date.now());
+const encoded = encode(instant, { extensionCodec });
+const decoded = decode(encoded, { extensionCodec });
+deepStrictEqual(decoded, instant);
+```
+
+This will be default after the temporal module is implemented in major browsers, which is not a near-future, though.
+
 ## 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.

package-lock.json

@@ -53,6 +53,7 @@
   "homepage": "https://msgpack.org/",
   "devDependencies": {
     "@bitjourney/check-es-version-webpack-plugin": "^1.0.2",
+    "@std-proposal/temporal": "0.0.1",
     "@types/base64-js": "^1.2.5",
     "@types/mocha": "^5.2.6",
     "@types/node": "^11.13.12",

package.json

@@ -12,6 +12,7 @@ export {
   EXT_TIMESTAMP,
   encodeDateToTimeSpec,
   encodeTimeSpecToTimestamp,
+  decodeTimestampToTimeSpec,
   encodeTimestampExtension,
   decodeTimestampExtension,
 } from "./timestamp";

src/index.ts

@@ -44,8 +44,8 @@ export function encodeTimeSpecToTimestamp({ sec, nsec }: TimeSpec): Uint8Array {
 
 export function encodeDateToTimeSpec(date: Date): TimeSpec {
   const msec = date.getTime();
-  const sec = Math.floor(msec / 1000);
-  const nsec = (msec - sec * 1000) * 1e6;
+  const sec = Math.floor(msec / 1e3);
+  const nsec = (msec - sec * 1e3) * 1e6;
 
   // Normalizes { sec, nsec } to ensure nsec is unsigned.
   const nsecInSec = Math.floor(nsec / 1e9);
@@ -64,39 +64,44 @@ export function encodeTimestampExtension(object: unknown): Uint8Array | null {
   }
 }
 
-export function decodeTimestampExtension(data: Uint8Array): Date {
+export function decodeTimestampToTimeSpec(data: Uint8Array): TimeSpec {
   // data may be 32, 64, or 96 bits
   switch (data.byteLength) {
     case 4: {
       // timestamp 32 = { sec32 }
       const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
       const sec = view.getUint32(0);
-      return new Date(sec * 1000);
+      const nsec = 0;
+      return { sec, nsec };
     }
     case 8: {
       // timestamp 64 = { nsec30, sec34 }
       const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
 
       const nsec30AndSecHigh2 = view.getUint32(0);
       const secLow32 = view.getUint32(4);
-      const nsec = nsec30AndSecHigh2 >>> 2;
       const sec = (nsec30AndSecHigh2 & 0x3) * 0x100000000 + secLow32;
-      return new Date(sec * 1000 + nsec / 1e6);
+      const nsec = nsec30AndSecHigh2 >>> 2;
+      return { sec, nsec };
     }
     case 12: {
       // timestamp 96 = { nsec32 (unsigned), sec64 (signed) }
       const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
 
-      const nsec = view.getUint32(0);
       const sec = getInt64(view, 4);
-
-      return new Date(sec * 1000 + nsec / 1e6);
+      const nsec = view.getUint32(0);
+      return { sec, nsec };
     }
     default:
       throw new Error(`Unrecognized data size for timestamp: ${data.length}`);
   }
 }
 
+export function decodeTimestampExtension(data: Uint8Array): Date {
+  const timeSpec = decodeTimestampToTimeSpec(data);
+  return new Date(timeSpec.sec * 1e3 + timeSpec.nsec / 1e6);
+}
+
 export const timestampExtension = {
   type: EXT_TIMESTAMP,
   encode: encodeTimestampExtension,

src/timestamp.ts

@@ -1,5 +1,12 @@
 import { deepStrictEqual } from "assert";
-import { encode, decode } from "../src";
+import {
+  encode,
+  decode,
+  ExtensionCodec,
+  EXT_TIMESTAMP,
+  encodeTimeSpecToTimestamp,
+  decodeTimestampToTimeSpec,
+} from "../src";
 
 describe("README", () => {
   context("#synopsis", () => {
@@ -21,4 +28,41 @@ describe("README", () => {
       deepStrictEqual(decode(encoded), object);
     });
   });
+
+  context("timestamp/temporal", () => {
+    before(function() {
+      if (typeof BigInt === "undefined") {
+        this.skip();
+      }
+    });
+
+    it("overrides timestamp-ext with std-temporal", () => {
+      const Instant = require("@std-proposal/temporal").Instant;
+
+      const extensionCodec = new ExtensionCodec();
+      extensionCodec.register({
+        type: EXT_TIMESTAMP,
+        encode: (input: any) => {
+          if (input instanceof Instant) {
+            const sec = input.seconds;
+            const nsec = Number(input.nanoseconds - BigInt(sec) * BigInt(1e9));
+            return encodeTimeSpecToTimestamp({ sec, nsec });
+          } else {
+            return null;
+          }
+        },
+        decode: (data: Uint8Array) => {
+          const timeSpec = decodeTimestampToTimeSpec(data);
+          const sec = BigInt(timeSpec.sec);
+          const nsec = BigInt(timeSpec.nsec);
+          return Instant.fromEpochNanoseconds(sec * BigInt(1e9) + nsec);
+        },
+      });
+
+      const instant = Instant.fromEpochMilliseconds(Date.now());
+      const encoded = encode(instant, { extensionCodec });
+      const decoded = decode(encoded, { extensionCodec });
+      deepStrictEqual(decoded, instant);
+    });
+  });
 });