Initial TS Support

Not sure why I try to upgrade so many big libraries to TS and ESM, it gets complicated quickly hehe.

My goal is that I want to have something like JSZip, but build using only vanilla library features, and to be fully ESM compatible, as well as have first-party type definitions. Also, using a Promise-based API is key as well.

https://stackoverflow.com/questions/14527820/does-html-5s-blobbuilder-still-work-in-google-chrome
https://gist.github.com/eligrey/1079572/aeac96e31f03bb8aeecedd5e5a6a89ac92c106cc
https://www.google.com/search?q=require%28%27setimmediate%27%29
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat
https://stackoverflow.com/questions/29676635/convert-uint8array-to-array-in-javascript

Author: Offroaders123

lib/support.js

@@ -20,6 +20,7 @@ else {
     }
     catch (e) {
         try {
+            // @ts-expect-error - Legacy `Blob` constructor fallback
             var Builder = self.BlobBuilder || self.WebKitBlobBuilder || self.MozBlobBuilder || self.MSBlobBuilder;
             var builder = new Builder();
             builder.append(buffer);

lib/utils.js

@@ -4,6 +4,7 @@ var support = require("./support");
 var base64 = require("./base64");
 var nodejsUtils = require("./nodejsUtils");
 var external = require("./external");
+// @ts-expect-error - Legacy fallback, it seems
 require("setimmediate");
 
 
@@ -12,7 +13,7 @@ require("setimmediate");
  * array but may have > 255 char codes. Be sure to take only the first byte
  * and returns the byte array.
  * @param {String} str the string to transform.
- * @return {Array|Uint8Array} the string in a binary format.
+ * @return {Array<number>|Uint8Array} the string in a binary format.
  */
 function string2binary(str) {
     var result = null;
@@ -76,8 +77,8 @@ function identity(input) {
 /**
  * Fill in an array with a string.
  * @param {String} str the string to use.
- * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to fill in (will be mutated).
- * @return {Array|ArrayBuffer|Uint8Array|Buffer} the updated array.
+ * @param {Array<number>|Uint8Array|Buffer} array the array to fill in (will be mutated).
+ * @return {Array<number>|Uint8Array|Buffer} the updated array.
  */
 function stringToArrayLike(str, array) {
     for (var i = 0; i < str.length; ++i) {
@@ -95,24 +96,24 @@ var arrayToStringHelper = {
     /**
      * Transform an array of int into a string, chunk by chunk.
      * See the performances notes on arrayLikeToString.
-     * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to transform.
-     * @param {String} type the type of the array.
-     * @param {Integer} chunk the chunk size.
+     * @param {Array<number>|Uint8Array|Buffer} array the array to transform.
+     * @param {"array" | "nodebuffer" | "uint8array"} type the type of the array.
+     * @param {number} chunk the chunk size.
      * @return {String} the resulting string.
      * @throws Error if the chunk is too big for the stack.
      */
     stringifyByChunk: function(array, type, chunk) {
         var result = [], k = 0, len = array.length;
         // shortcut
         if (len <= chunk) {
-            return String.fromCharCode.apply(null, array);
+            return String.fromCharCode.apply(null, [].slice.call(array));
         }
         while (k < len) {
             if (type === "array" || type === "nodebuffer") {
-                result.push(String.fromCharCode.apply(null, array.slice(k, Math.min(k + chunk, len))));
+                result.push(String.fromCharCode.apply(null, [].slice.call(/** @type {number[] | Buffer} */ (array).slice(k, Math.min(k + chunk, len)))));
             }
             else {
-                result.push(String.fromCharCode.apply(null, array.subarray(k, Math.min(k + chunk, len))));
+                result.push(String.fromCharCode.apply(null, [].slice.call(/** @type {Uint8Array} */(array).subarray(k, Math.min(k + chunk, len)))));
             }
             k += chunk;
         }
@@ -122,7 +123,7 @@ var arrayToStringHelper = {
      * Call String.fromCharCode on every item in the array.
      * This is the naive implementation, which generate A LOT of intermediate string.
      * This should be used when everything else fail.
-     * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to transform.
+     * @param {Array<number>|Uint8Array|Buffer} array the array to transform.
      * @return {String} the result.
      */
     stringifyByChar: function(array){
@@ -138,7 +139,7 @@ var arrayToStringHelper = {
          */
         uint8array : (function () {
             try {
-                return support.uint8array && String.fromCharCode.apply(null, new Uint8Array(1)).length === 1;
+                return support.uint8array && String.fromCharCode.apply(null, [].slice.call(new Uint8Array(1))).length === 1;
             } catch (e) {
                 return false;
             }
@@ -148,7 +149,7 @@ var arrayToStringHelper = {
          */
         nodebuffer : (function () {
             try {
-                return support.nodebuffer && String.fromCharCode.apply(null, nodejsUtils.allocBuffer(1)).length === 1;
+                return support.nodebuffer && String.fromCharCode.apply(null, [].slice.call(nodejsUtils.allocBuffer(1))).length === 1;
             } catch (e) {
                 return false;
             }
@@ -158,7 +159,7 @@ var arrayToStringHelper = {
 
 /**
  * Transform an array-like object to a string.
- * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to transform.
+ * @param {Array<number>|Uint8Array|Buffer} array the array to transform.
  * @return {String} the result.
  */
 function arrayLikeToString(array) {
@@ -345,8 +346,8 @@ exports.resolve = function(path) {
 /**
  * Return the type of the input.
  * The type will be in a format valid for JSZip.utils.transformTo : string, array, uint8array, arraybuffer.
- * @param {Object} input the input to identify.
- * @return {String} the (lowercase) type of the input.
+ * @param {string|object} input the input to identify.
+ * @return {"string"|"array"|"nodebuffer"|"arraybuffer"|"uint8array"} the (lowercase) type of the input.
  */
 exports.getTypeOf = function(input) {
     if (typeof input === "string") {
@@ -368,11 +369,12 @@ exports.getTypeOf = function(input) {
 
 /**
  * Throw an exception if the type is not supported.
- * @param {String} type the type to check.
+ * @param {string} type the type to check.
  * @throws {Error} an Error if the browser doesn't support the requested type.
+ * @returns {asserts type is keyof support}
  */
 exports.checkSupport = function(type) {
-    var supported = support[type.toLowerCase()];
+    var supported = support[/** @type {keyof support} */ (type.toLowerCase())];
     if (!supported) {
         throw new Error(type + " is not supported by this platform");
     }
@@ -398,8 +400,11 @@ exports.pretty = function(str) {
 
 /**
  * Defer the call of a function.
- * @param {Function} callback the function to call asynchronously.
- * @param {Array} args the arguments to give to the callback.
+ * @template {(this: This, ...args: any[]) => void} T
+ * @template This
+ * @param {T} callback the function to call asynchronously.
+ * @param {Parameters<T>} args the arguments to give to the callback.
+ * @param {This | null} self
  */
 exports.delay = function(callback, args, self) {
     setImmediate(function () {

package-lock.json

@@ -42,6 +42,7 @@
     "inflate"
   ],
   "devDependencies": {
+    "@types/readable-stream": "^4.0.10",
     "benchmark": "^2.1.4",
     "browserify": "~13.0.0",
     "eslint": "^8.18.0",

package.json

@@ -37,8 +37,8 @@
     // "noResolve": true,                                /* Disallow `import`s, `require`s or `<reference>`s from expanding the number of files TypeScript should add to a project. */
 
     /* JavaScript Support */
-    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the `checkJS` option to get errors from these files. */
-    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the `checkJS` option to get errors from these files. */
+    "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
     // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from `node_modules`. Only applicable with `allowJs`. */
 
     /* Emit */