introduce typescript

Author: TheLarkInn

.eslintrc.json

@@ -1,10 +1,11 @@
 {
   "root": true,
-  "plugins": ["node"],
-  "extends": ["eslint:recommended", "plugin:node/recommended"],
+  "plugins": ["node", "@typescript-eslint"],
+  "extends": ["eslint:recommended", "plugin:node/recommended", "plugin:@typescript-eslint/recommended"],
   "env": {
     "node": true
   },
+  "parser": "@typescript-eslint/parser",
   "rules": {
     "no-template-curly-in-string": "error",
     "no-caller": "error",
@@ -18,6 +19,7 @@
     "no-var": "error",
     "prefer-const": "error",
     "prefer-arrow-callback": "error",
-    "object-shorthand": "error"
+    "object-shorthand": "error",
+    "es-syntax": "false"
   }
 }

.gitignore

@@ -1,3 +1,4 @@
 .idea
 node_modules
 coverage
+/dist

lib/getHashDigest.js renamed to lib/getHashDigest.ts

@@ -1,4 +1,4 @@
-"use strict";
+import {Hash} from 'crypto';
 
 const baseEncodeTables = {
   26: "abcdefghijklmnopqrstuvwxyz",
@@ -11,12 +11,15 @@ const baseEncodeTables = {
   64: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_",
 };
 
+type DigestTypes = "base26" | "base32" | "base36" | "base49" | "base52" | "base58" | "base62" | "base64";
+type BaseEncodings = 26 | 32 | 36 | 49 | 52 | 58 | 62 | 64;
+
 /**
  * @param {Uint32Array} uint32Array Treated as a long base-0x100000000 number, little endian
  * @param {number} divisor The divisor
  * @return {number} Modulo (remainder) of the division
  */
-function divmod32(uint32Array, divisor) {
+function divmod32(uint32Array: Uint32Array, divisor: number): number {
   let carry = 0;
   for (let i = uint32Array.length - 1; i >= 0; i--) {
     const value = carry * 0x100000000 + uint32Array[i];
@@ -26,8 +29,8 @@ function divmod32(uint32Array, divisor) {
   return carry;
 }
 
-function encodeBufferToBase(buffer, base, length) {
-  const encodeTable = baseEncodeTables[base];
+function encodeBufferToBase(buffer: Buffer, base: BaseEncodings | number, length: number) {
+  const encodeTable = baseEncodeTables[(base as keyof typeof baseEncodeTables)];
 
   if (!encodeTable) {
     throw new Error("Unknown encoding base" + base);
@@ -54,13 +57,13 @@ function encodeBufferToBase(buffer, base, length) {
   return output;
 }
 
-let crypto = undefined;
-let createXXHash64 = undefined;
-let createMd4 = undefined;
-let BatchedHash = undefined;
-let BulkUpdateDecorator = undefined;
+let crypto: typeof import('crypto')
+let createXXHash64: typeof import('./hash/xxhash64').default;
+let createMd4: typeof import('./hash/md4').default;
+let BatchedHash: typeof import('./hash/BatchedHash').default;
+let BulkUpdateDecorator: typeof import('./hash/BulkUpdateDecorator').default;
 
-function getHashDigest(buffer, algorithm, digestType, maxLength) {
+export default function getHashDigest(buffer: Buffer, algorithm: string | "xxhash64" | "md4" | "native-md4", digestType: DigestTypes | string, maxLength: number) {
   algorithm = algorithm || "xxhash64";
   maxLength = maxLength || 9999;
 
@@ -75,7 +78,7 @@ function getHashDigest(buffer, algorithm, digestType, maxLength) {
       }
     }
 
-    hash = new BatchedHash(createXXHash64());
+    hash = new BatchedHash(createXXHash64() as unknown as Hash);
   } else if (algorithm === "md4") {
     if (createMd4 === undefined) {
       createMd4 = require("./hash/md4");
@@ -85,7 +88,7 @@ function getHashDigest(buffer, algorithm, digestType, maxLength) {
       }
     }
 
-    hash = new BatchedHash(createMd4());
+    hash = new BatchedHash(createMd4() as unknown as Hash);
   } else if (algorithm === "native-md4") {
     if (typeof crypto === "undefined") {
       crypto = require("crypto");
@@ -122,10 +125,11 @@ function getHashDigest(buffer, algorithm, digestType, maxLength) {
     digestType === "base58" ||
     digestType === "base62"
   ) {
-    return encodeBufferToBase(hash.digest(), digestType.substr(4), maxLength);
+    const digestTypeToDigest: number = digestType.substr(4) as unknown as number;
+
+    return encodeBufferToBase(hash.digest() as Buffer, digestTypeToDigest, maxLength);
   } else {
+    // @ts-ignore
     return hash.digest(digestType || "hex").substr(0, maxLength);
   }
 }
-
-module.exports = getHashDigest;

lib/hash/BatchedHash.js renamed to lib/hash/BatchedHash.ts

@@ -1,7 +1,12 @@
-const MAX_SHORT_STRING = require("./wasm-hash").MAX_SHORT_STRING;
+import type { Hash, Encoding, BinaryToTextEncoding } from "crypto";
+import { MAX_SHORT_STRING } from './wasm-hash'
 
-class BatchedHash {
-  constructor(hash) {
+export default class BatchedHash {
+  public string?: string;
+  public encoding?: Encoding;
+  public readonly hash: Hash;
+
+  constructor(hash: Hash) {
     this.string = undefined;
     this.encoding = undefined;
     this.hash = hash;
@@ -13,7 +18,7 @@ class BatchedHash {
    * @param {string=} inputEncoding data encoding
    * @returns {this} updated hash
    */
-  update(data, inputEncoding) {
+  update(data: string | Buffer, inputEncoding?: Encoding): this {
     if (this.string !== undefined) {
       if (
         typeof data === "string" &&
@@ -25,7 +30,12 @@ class BatchedHash {
         return this;
       }
 
-      this.hash.update(this.string, this.encoding);
+      if (this.encoding !== undefined) {
+        this.hash.update(this.string, this.encoding);
+      } else {
+        this.hash.update(this.string)
+      }
+
       this.string = undefined;
     }
 
@@ -38,7 +48,11 @@ class BatchedHash {
         this.string = data;
         this.encoding = inputEncoding;
       } else {
-        this.hash.update(data, inputEncoding);
+        if (inputEncoding !== undefined) {
+          this.hash.update(data, inputEncoding);
+        } else {
+          this.hash.update(data);
+        }
       }
     } else {
       this.hash.update(data);
@@ -52,13 +66,19 @@ class BatchedHash {
    * @param {string=} encoding encoding of the return value
    * @returns {string|Buffer} digest
    */
-  digest(encoding) {
+  digest(encoding?: BinaryToTextEncoding): string | Buffer {
     if (this.string !== undefined) {
-      this.hash.update(this.string, this.encoding);
-    }
+      if (this.encoding !== undefined) {
+        this.hash.update(this.string, this.encoding);
+      } else {
+        this.hash.update(this.string);
+      }
 
-    return this.hash.digest(encoding);
+    }
+    if (encoding !== undefined) {
+      return this.hash.digest(encoding);
+    } else {
+      return this.hash.digest();
+    }
   }
 }
-
-module.exports = BatchedHash;

lib/hash/BulkUpdateDecorator.js renamed to lib/hash/BulkUpdateDecorator.ts

@@ -1,15 +1,24 @@
-const BULK_SIZE = 2000;
+import type { Hash, Encoding, BinaryToTextEncoding } from "crypto";
+type HashOrFactory = Hash | (() => Hash);
+
+const BULK_SIZE: number = 2000;
 
 // We are using an object instead of a Map as this will stay static during the runtime
 // so access to it can be optimized by v8
-const digestCaches = {};
+const digestCaches: {[key: string]: any} = {};
+
 
-class BulkUpdateDecorator {
+export default class BulkUpdateDecorator {
   /**
-   * @param {Hash | function(): Hash} hashOrFactory function to create a hash
+   * @param {HashOrFactory} hashOrFactory function to create a hash
    * @param {string=} hashKey key for caching
    */
-  constructor(hashOrFactory, hashKey) {
+  hash?: Hash;
+  hashFactory?: (() => Hash);
+  hashKey: string;
+  buffer: string;
+
+  constructor(hashOrFactory: HashOrFactory, hashKey: string) {
     this.hashKey = hashKey;
 
     if (typeof hashOrFactory === "function") {
@@ -29,28 +38,32 @@ class BulkUpdateDecorator {
    * @param {string=} inputEncoding data encoding
    * @returns {this} updated hash
    */
-  update(data, inputEncoding) {
+  update(data: string | Buffer, inputEncoding?: Encoding): this {
     if (
       inputEncoding !== undefined ||
       typeof data !== "string" ||
       data.length > BULK_SIZE
     ) {
       if (this.hash === undefined) {
-        this.hash = this.hashFactory();
+        this.hash = this.hashFactory!();
       }
 
       if (this.buffer.length > 0) {
         this.hash.update(this.buffer);
         this.buffer = "";
       }
 
-      this.hash.update(data, inputEncoding);
+      if (inputEncoding === undefined) {
+        this.hash.update(data);
+      } else {
+        this.hash.update(data as string, inputEncoding);
+      }
     } else {
       this.buffer += data;
 
       if (this.buffer.length > BULK_SIZE) {
         if (this.hash === undefined) {
-          this.hash = this.hashFactory();
+          this.hash = this.hashFactory!();
         }
 
         this.hash.update(this.buffer);
@@ -66,8 +79,9 @@ class BulkUpdateDecorator {
    * @param {string=} encoding encoding of the return value
    * @returns {string|Buffer} digest
    */
-  digest(encoding) {
+  digest(encoding?: BinaryToTextEncoding): string | Buffer {
     let digestCache;
+    let digestResult: string | Buffer;
 
     const buffer = this.buffer;
 
@@ -87,14 +101,18 @@ class BulkUpdateDecorator {
         return cacheEntry;
       }
 
-      this.hash = this.hashFactory();
+      this.hash = this.hashFactory!();
     }
 
     if (buffer.length > 0) {
       this.hash.update(buffer);
     }
 
-    const digestResult = this.hash.digest(encoding);
+    if (encoding !== undefined) {
+      digestResult = this.hash.digest(encoding);
+    } else {
+      digestResult = this.hash.digest();
+    }
 
     if (digestCache !== undefined) {
       digestCache.set(buffer, digestResult);
@@ -103,5 +121,3 @@ class BulkUpdateDecorator {
     return digestResult;
   }
 }
-
-module.exports = BulkUpdateDecorator;

lib/hash/md4.js renamed to lib/hash/md4.ts

@@ -3,9 +3,7 @@
 	Author Tobias Koppers @sokra
 */
 
-"use strict";
-
-const create = require("./wasm-hash");
+import { create } from './wasm-hash';
 
 //#region wasm code: md4 (../../../assembly/hash/md4.asm.ts) --initialMemory 1
 const md4 = new WebAssembly.Module(
@@ -17,4 +15,4 @@ const md4 = new WebAssembly.Module(
 );
 //#endregion
 
-module.exports = create.bind(null, md4, [], 64, 32);
+export default create.bind(null, md4, [], 64, 32);