More Util Typings

I'm considering whether I should do this with a fork of the library instead, and work on modernizing that instead of the original, which seems to be a few development iteration types back (ESM, TypeScript, browser-first).

https://github.com/telerik/jszip-esm

It seems like a lot of work for modernizing older projects like these are that they are for Node to start with, and there are a lot of polyfills set up to make it work for modern code, rather than the other way around. To be fair, that's the same issue I'm having with my own projects from a few years ago too, so it's just going to happen, and it's still just something we have to deal with. I guess it's good that the same language has been around long enough for it to grow so much to where that is a concern. People see that as a downside to the JS ecosystem, but it also really shows how much things have grown over the years.

I wish not as many new TS projects were OOP, it's still the same language under the hood, so I find it interesting how the typings for things in that manner seems to have brought non-FP concepts over to JS's fairly functional neighborhood (at least for packages, it seems like most user-facing APIs use functions where possible, and maybe the underlying implementation may use a few classes).

Author: Offroaders123

lib/external.js

@@ -13,6 +13,4 @@ if (typeof Promise !== "undefined") {
 /**
  * Let the user use/change some implementations.
  */
-module.exports = {
-    Promise: ES6Promise
-};
+module.exports.Promise = ES6Promise;

lib/nodejsUtils.js

@@ -1,19 +1,18 @@
 "use strict";
 
-module.exports = {
     /**
      * True if this is running in Nodejs, will be undefined in a browser.
      * In a browser, browserify won't include this file and the whole module
      * will be resolved an empty object.
      */
-    isNode : typeof Buffer !== "undefined",
+    exports.isNode = typeof Buffer !== "undefined";
     /**
      * Create a new nodejs Buffer from an existing content.
-     * @param {Object} data the data to pass to the constructor.
-     * @param {String} encoding the encoding to use.
+     * @param {string} data the data to pass to the constructor.
+     * @param {BufferEncoding} encoding the encoding to use.
      * @return {Buffer} a new Buffer.
      */
-    newBufferFrom: function(data, encoding) {
+    exports.newBufferFrom = function(data, encoding) {
         if (Buffer.from && Buffer.from !== Uint8Array.from) {
             return Buffer.from(data, encoding);
         } else {
@@ -24,34 +23,37 @@ module.exports = {
             }
             return new Buffer(data, encoding);
         }
-    },
+    };
     /**
      * Create a new nodejs Buffer with the specified size.
-     * @param {Integer} size the size of the buffer.
+     * @param {number} size the size of the buffer.
      * @return {Buffer} a new Buffer.
      */
-    allocBuffer: function (size) {
+    exports.allocBuffer = function (size) {
         if (Buffer.alloc) {
             return Buffer.alloc(size);
         } else {
             var buf = new Buffer(size);
             buf.fill(0);
             return buf;
         }
-    },
+    };
     /**
      * Find out if an object is a Buffer.
-     * @param {Object} b the object to test.
-     * @return {Boolean} true if the object is a Buffer, false otherwise.
+     * @param {any} b the object to test.
+     * @return {b is Buffer} true if the object is a Buffer, false otherwise.
      */
-    isBuffer : function(b){
+    exports.isBuffer = function(b){
         return Buffer.isBuffer(b);
-    },
+    };
 
-    isStream : function (obj) {
+    /**
+     * @param {any} obj
+     * @returns {obj is import("readable-stream").Readable}
+     */
+    exports.isStream = function (obj) {
         return obj &&
             typeof obj.on === "function" &&
             typeof obj.pause === "function" &&
             typeof obj.resume === "function";
-    }
-};
+    };

lib/utils.js

@@ -12,8 +12,8 @@ require("setimmediate");
  * Convert a string that pass as a "binary string": it should represent a byte
  * 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<number>|Uint8Array} the string in a binary format.
+ * @param {string} str the string to transform.
+ * @return {number[] | Uint8Array} the string in a binary format.
  */
 function string2binary(str) {
     var result = null;
@@ -27,15 +27,15 @@ function string2binary(str) {
 
 /**
  * Create a new blob with the given content and the given type.
- * @param {String|ArrayBuffer} part the content to put in the blob. DO NOT use
+ * @param {string | ArrayBuffer} part the content to put in the blob. DO NOT use
  * an Uint8Array because the stock browser of android 4 won't accept it (it
  * will be silently converted to a string, "[object Uint8Array]").
  *
  * Use only ONE part to build the blob to avoid a memory leak in IE11 / Edge:
  * when a large amount of Array is used to create the Blob, the amount of
  * memory consumed is nearly 100 times the original data amount.
  *
- * @param {String} type the mime type of the blob.
+ * @param {string} type the mime type of the blob.
  * @return {Blob} the created blob.
  */
 exports.newBlob = function(part, type) {
@@ -50,7 +50,7 @@ exports.newBlob = function(part, type) {
     catch (e) {
 
         try {
-            // deprecated, browser only, old way
+            // @ts-expect-error // deprecated, browser only, old way
             var Builder = self.BlobBuilder || self.WebKitBlobBuilder || self.MozBlobBuilder || self.MSBlobBuilder;
             var builder = new Builder();
             builder.append(part);
@@ -67,8 +67,10 @@ exports.newBlob = function(part, type) {
 };
 /**
  * The identity function.
- * @param {Object} input the input.
- * @return {Object} the same input.
+ * 
+ * @template {object} T
+ * @param {T} input the input.
+ * @return {T} the same input.
  */
 function identity(input) {
     return input;
@@ -373,12 +375,13 @@ exports.getTypeOf = function(input) {
  * @throws {Error} an Error if the browser doesn't support the requested type.
  * @returns {asserts type is keyof support}
  */
-exports.checkSupport = function(type) {
+function checkSupport(type) {
     var supported = support[/** @type {keyof support} */ (type.toLowerCase())];
     if (!supported) {
         throw new Error(type + " is not supported by this platform");
     }
-};
+}
+exports.checkSupport = checkSupport;
 
 exports.MAX_VALUE_16BITS = 65535;
 exports.MAX_VALUE_32BITS = -1; // well, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF" is parsed as -1