Migrate Loader Utils to TypeScript

.eslintrc.json

@@ -1,10 +1,15 @@
 {
   "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 +23,12 @@
     "no-var": "error",
     "prefer-const": "error",
     "prefer-arrow-callback": "error",
-    "object-shorthand": "error"
+    "object-shorthand": "error",
+    "node/no-unsupported-features/es-syntax": 0,
+    "node/no-missing-require": 0,
+    "node/no-missing-import": 0,
+    "node/no-unpublished-import": 0,
+    "@typescript-eslint/no-var-requires": 0,
+    "@typescript-eslint/no-explicit-any": 0
   }
 }

.gitignore

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

.prettierignore

@@ -2,4 +2,4 @@
 /dist
 /node_modules
 /test/fixtures
-CHANGELOG.md
+CHANGELOG.md

lib/getHashDigest.js → lib/getHashDigest.ts

@@ -1,4 +1,4 @@
-"use strict";
+import { Hash } from "crypto";
 
 const baseEncodeTables = {
   26: "abcdefghijklmnopqrstuvwxyz",
@@ -11,12 +11,23 @@ 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 +37,12 @@ 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,44 +69,49 @@ function encodeBufferToBase(buffer, base, length) {
   return output;
 }
 
-let crypto = undefined;
-let createXXHash64 = undefined;
-let createMd4 = undefined;
-let BatchedHash = undefined;
-let BulkUpdateDecorator = undefined;
-
-function getHashDigest(buffer, algorithm, digestType, maxLength) {
+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;
+
+export default function getHashDigest(
+  buffer: Buffer,
+  algorithm: string | "xxhash64" | "md4" | "native-md4",
+  digestType: DigestTypes | string,
+  maxLength: number
+) {
   algorithm = algorithm || "xxhash64";
   maxLength = maxLength || 9999;
 
   let hash;
 
   if (algorithm === "xxhash64") {
     if (createXXHash64 === undefined) {
-      createXXHash64 = require("./hash/xxhash64");
+      createXXHash64 = require("./hash/xxhash64").default;
 
       if (BatchedHash === undefined) {
-        BatchedHash = require("./hash/BatchedHash");
+        BatchedHash = require("./hash/BatchedHash").default;
       }
     }
 
-    hash = new BatchedHash(createXXHash64());
+    hash = new BatchedHash(createXXHash64() as unknown as Hash);
   } else if (algorithm === "md4") {
     if (createMd4 === undefined) {
-      createMd4 = require("./hash/md4");
+      createMd4 = require("./hash/md4").default;
 
       if (BatchedHash === undefined) {
-        BatchedHash = require("./hash/BatchedHash");
+        BatchedHash = require("./hash/BatchedHash").default;
       }
     }
 
-    hash = new BatchedHash(createMd4());
+    hash = new BatchedHash(createMd4() as unknown as Hash);
   } else if (algorithm === "native-md4") {
     if (typeof crypto === "undefined") {
       crypto = require("crypto");
 
       if (BulkUpdateDecorator === undefined) {
-        BulkUpdateDecorator = require("./hash/BulkUpdateDecorator");
+        BulkUpdateDecorator = require("./hash/BulkUpdateDecorator").default;
       }
     }
 
@@ -101,7 +121,7 @@ function getHashDigest(buffer, algorithm, digestType, maxLength) {
       crypto = require("crypto");
 
       if (BulkUpdateDecorator === undefined) {
-        BulkUpdateDecorator = require("./hash/BulkUpdateDecorator");
+        BulkUpdateDecorator = require("./hash/BulkUpdateDecorator").default;
       }
     }
 
@@ -122,10 +142,18 @@ 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 {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
     return hash.digest(digestType || "hex").substr(0, maxLength);
   }
 }
-
-module.exports = getHashDigest;

lib/hash/BatchedHash.js → 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,18 @@ 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);
+      }
+    }
+    if (encoding !== undefined) {
+      return this.hash.digest(encoding);
+    } else {
+      return this.hash.digest();
     }
-
-    return this.hash.digest(encoding);
   }
 }
-
-module.exports = BatchedHash;

lib/hash/BulkUpdateDecorator.js → lib/hash/BulkUpdateDecorator.ts

@@ -1,15 +1,23 @@
+import type { Hash, Encoding, BinaryToTextEncoding } from "crypto";
+type HashOrFactory = Hash | (() => Hash);
+
 const BULK_SIZE = 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 +37,34 @@ 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();
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        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();
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          this.hash = this.hashFactory!();
         }
 
         this.hash.update(this.buffer);
@@ -66,8 +80,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 +102,19 @@ class BulkUpdateDecorator {
         return cacheEntry;
       }
 
-      this.hash = this.hashFactory();
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      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 +123,3 @@ class BulkUpdateDecorator {
     return digestResult;
   }
 }
-
-module.exports = BulkUpdateDecorator;

lib/hash/md4.js → 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);