prettier

Author: gfx

package.json

@@ -9,6 +9,7 @@
     "prepublishOnly": "TEST_DIST=true npm run test",
     "test": "TS_NODE_FILES=true mocha 'test/**/*.test.ts'",
     "test:cover": "TS_NODE_FILES=true npx nyc mocha 'test/**/*.test.ts'",
+    "format": "prettier --write 'src/**/*.ts' 'test/**/*.ts'",
     "profile:encode": "rm -f isolate-*.log ; node --prof --require ts-node/register  -e 'require(\"./benchmark/profile-encode\")' && node --prof-process --preprocess -j isolate-*.log | npx flamebearer",
     "profile:decode": "rm -f isolate-*.log ; node --prof --require ts-node/register  -e 'require(\"./benchmark/profile-decode\")' && node --prof-process --preprocess -j isolate-*.log | npx flamebearer",
     "benchmark": "npx ts-node benchmark/benchmark-from-msgpack-lite.ts"
@@ -35,6 +36,7 @@
     "mocha": "^6.1.4",
     "msgpack-lite": "^0.1.26",
     "msgpack-test-js": "^1.0.0",
+    "prettier": "^1.17.0",
     "ts-loader": "^5.4.5",
     "ts-node": "^8.1.0",
     "typescript": "^3.4.5"

src/BufferType.ts

@@ -1,2 +1 @@
-
 export type BufferType = ArrayLike<number> | Uint8Array;

src/utils/is.ts

@@ -1,4 +1,3 @@
-
 export function isNodeJsBuffer(object: unknown): object is Buffer {
   return typeof Buffer !== "undefined" && Buffer.isBuffer(object);
 }

src/utils/prettyByte.ts

@@ -1,4 +1,3 @@
-
 export function prettyByte(byte: number): string {
   return `0x${byte.toString(16).padStart(2, "0")}`;
 }

src/utils/uf8Encode.ts

@@ -2,7 +2,7 @@ import { prettyByte } from "./prettyByte";
 
 // Using TextEncoder is opt-in because NodeJS v12's impl is much slower than pure-JavaScript version (i.e. _utf8Encode).
 // Set `PREFER_TEXT_ENOCDER=true` to use TextEncoder if available.
-const USE_TEXT_ENCODER = (process.env.PREFER_TEXT_ENOCDER === 'true' && typeof TextEncoder !== "undefined");
+const USE_TEXT_ENCODER = process.env.PREFER_TEXT_ENOCDER === "true" && typeof TextEncoder !== "undefined";
 
 function _utf8Encode(str: string): ReadonlyArray<number> {
   const len = str.length;
@@ -22,22 +22,26 @@ function _utf8Encode(str: string): ReadonlyArray<number> {
         }
       }
       if (value >= 0xd800 && value <= 0xdbff) {
-        continue;  // drop lone surrogate
+        continue; // drop lone surrogate
       }
     }
 
-    if ((value & 0xffffff80) === 0) {  // 1-byte
+    if ((value & 0xffffff80) === 0) {
+      // 1-byte
       bytes.push(value);
       continue;
-    } else if ((value & 0xfffff800) === 0) {  // 2-bytes
-      bytes.push(((value >>  6) & 0x1f) | 0xc0)
-    } else if ((value & 0xffff0000) === 0) {  // 3-byte
+    } else if ((value & 0xfffff800) === 0) {
+      // 2-bytes
+      bytes.push(((value >> 6) & 0x1f) | 0xc0);
+    } else if ((value & 0xffff0000) === 0) {
+      // 3-byte
       bytes.push(((value >> 12) & 0x0f) | 0xe0);
-      bytes.push(((value >>  6) & 0x3f) | 0x80);
-    } else if ((value & 0xffe00000) === 0) {  // 4-byte
+      bytes.push(((value >> 6) & 0x3f) | 0x80);
+    } else if ((value & 0xffe00000) === 0) {
+      // 4-byte
       bytes.push(((value >> 18) & 0x07) | 0xf0);
       bytes.push(((value >> 12) & 0x3f) | 0x80);
-      bytes.push(((value >>  6) & 0x3f) | 0x80);
+      bytes.push(((value >> 6) & 0x3f) | 0x80);
     } else {
       throw new Error(`Invalid UTF-8 byte in encode: ${prettyByte(value)} at ${pos}`);
     }

test/ExtensionCodec.test.ts

@@ -3,25 +3,36 @@ import util from "util";
 import { ExtensionCodec, EXT_TIMESTAMP } from "../src/ExtensionCodec";
 
 describe("ExtensionCodec", () => {
-
   const defaultCodec = ExtensionCodec.defaultCodec;
   context("timestamp", () => {
     it("encodes and decodes a date without milliseconds (timestamp 32)", () => {
       const date = new Date(1556633024000);
       const encoded = defaultCodec.tryToEncode(date);
-      assert.deepStrictEqual(defaultCodec.decode(EXT_TIMESTAMP, encoded!.data), date, `date: ${date.toISOString()}, encoded: ${util.inspect(encoded)}`);
+      assert.deepStrictEqual(
+        defaultCodec.decode(EXT_TIMESTAMP, encoded!.data),
+        date,
+        `date: ${date.toISOString()}, encoded: ${util.inspect(encoded)}`,
+      );
     });
 
     it("encodes and decodes a date with milliseconds (timestamp 64)", () => {
       const date = new Date(1556633024123);
       const encoded = defaultCodec.tryToEncode(date);
-      assert.deepStrictEqual(defaultCodec.decode(EXT_TIMESTAMP, encoded!.data), date, `date: ${date.toISOString()}, encoded: ${util.inspect(encoded)}`);
+      assert.deepStrictEqual(
+        defaultCodec.decode(EXT_TIMESTAMP, encoded!.data),
+        date,
+        `date: ${date.toISOString()}, encoded: ${util.inspect(encoded)}`,
+      );
     });
 
     it("encodes and decodes a future date (timestamp 96)", () => {
       const date = new Date(0x400000000 * 1000);
       const encoded = defaultCodec.tryToEncode(date);
-      assert.deepStrictEqual(defaultCodec.decode(EXT_TIMESTAMP, encoded!.data), date, `date: ${date.toISOString()}, encoded: ${util.inspect(encoded)}`);
+      assert.deepStrictEqual(
+        defaultCodec.decode(EXT_TIMESTAMP, encoded!.data),
+        date,
+        `date: ${date.toISOString()}, encoded: ${util.inspect(encoded)}`,
+      );
     });
   });
 });

test/codec-timestamp.test.ts

@@ -16,12 +16,12 @@ const SPECS = {
 } as Record<string, Date>;
 
 describe("codec: timestamp 32/64/96", () => {
-    for (const name of Object.keys(SPECS)) {
-      const value = SPECS[name];
+  for (const name of Object.keys(SPECS)) {
+    const value = SPECS[name];
 
-      it(`encodes and decodes ${name} (${value.toISOString()})`, () => {
-        const encoded = encode(value);
-        assert.deepStrictEqual(decode(encoded), value, `encoded: ${util.inspect(encoded)}`);
-      });
-    }
+    it(`encodes and decodes ${name} (${value.toISOString()})`, () => {
+      const encoded = encode(value);
+      assert.deepStrictEqual(decode(encoded), value, `encoded: ${util.inspect(encoded)}`);
+    });
+  }
 });

test/encode-edge-cases.test.ts

@@ -1,5 +1,5 @@
 import assert from "assert";
-import { encode, decode } from '../src';
+import { encode, decode } from "../src";
 
 describe("edge cases", () => {
   context("try to encode trycyclic refs", () => {
@@ -9,15 +9,15 @@ describe("edge cases", () => {
       assert.throws(() => {
         encode(cyclicRefs);
       }, /too deep/i);
-    })
+    });
   });
 
   context("try to encode non-encodable objects", () => {
     it("throws errors", () => {
       assert.throws(() => {
-        encode(Symbol('this is a symbol!'));
+        encode(Symbol("this is a symbol!"));
       }, /unrecognized object/i);
-    })
+    });
   });
 
   context("try to decode invlid MessagePack binary", () => {

test/types/ieee754.d.ts

@@ -1,4 +1,11 @@
 declare module "ieee754" {
   function read(buf: ArrayLike<number>, offset: number, isLE: boolean, mLen: number, nBytes: number): number;
-  function write(buf: ArrayLike<number>, value: number, index: number, isLE: boolean, mLen: number, nBytes: number): void;
+  function write(
+    buf: ArrayLike<number>,
+    value: number,
+    index: number,
+    isLE: boolean,
+    mLen: number,
+    nBytes: number,
+  ): void;
 }