@loaders.gl/polyfills 3.3.0-alpha.9 → 3.3.1

package/dist/node/fetch/response.node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"response.node.d.ts","sourceRoot":"","sources":["../../../src/node/fetch/response.node.ts"],"names":[],"mappings":"AAEA,OAAO,OAAO,MAAM,gBAAgB,CAAC;AAoBrC,MAAM,CAAC,OAAO,OAAO,QAAQ;IAC3B,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,OAAO,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC;gBAIrB,IAAI,KAAA,EACJ,OAAO,EAAE;QACP,OAAO,CAAC,MAAC;QACT,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,GAAG,EAAE,MAAM,CAAC;KACb;IAuBH,IAAI,IAAI,QAKP;IAIK,WAAW;IAQX,IAAI;IAMJ,IAAI;IAKJ,IAAI;CAMX"}
+{"version":3,"file":"response.node.d.ts","sourceRoot":"","sources":["../../../src/node/fetch/response.node.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,OAAO,EAAC,MAAM,gBAAgB,CAAC;AAoBvC,qBAAa,QAAQ;IACnB,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,OAAO,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC;gBAIrB,IAAI,KAAA,EACJ,OAAO,EAAE;QACP,OAAO,CAAC,MAAC;QACT,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,GAAG,EAAE,MAAM,CAAC;KACb;IAuBH,IAAI,IAAI,QAKP;IAIK,WAAW;IAQX,IAAI;IAMJ,IAAI;IAKJ,IAAI;CAMX"}

package/dist/node/fetch/response.node.js

@@ -1,11 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+// loaders.gl, MIT license
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Response = void 0;
 const assert_1 = require("../../utils/assert");
 const stream_utils_node_1 = require("./utils/stream-utils.node");
-const headers_node_1 = __importDefault(require("./headers.node"));
+const headers_node_1 = require("./headers.node");
 const isBoolean = (x) => typeof x === 'boolean';
 const isFunction = (x) => typeof x === 'function';
 const isObject = (x) => x !== null && typeof x === 'object';
@@ -30,7 +29,7 @@ class Response {
         this.ok = status === 200;
         this.status = status; // TODO - handle errors and set status
         this.statusText = statusText;
-        this.headers = new headers_node_1.default(options?.headers || {});
+        this.headers = new headers_node_1.Headers(options?.headers || {});
         // Check for content-encoding and create a decompression stream
         if (isReadableNodeStream(body)) {
             this._body = (0, stream_utils_node_1.decompressReadStream)(body, headers);
@@ -74,4 +73,4 @@ class Response {
         return new Blob([await this.arrayBuffer()]);
     }
 }
-exports.default = Response;
+exports.Response = Response;

package/dist/node/fetch/utils/stream-utils.node.d.ts

@@ -1,5 +1,12 @@
-export declare function createReadStream(url: any, options: any): Promise<any>;
+/**
+ *
+ */
 export declare function decompressReadStream(readStream: any, headers: any): any;
+/**
+ *
+ * @param readStream
+ * @returns
+ */
 export declare function concatenateReadStream(readStream: any): Promise<ArrayBuffer>;
 /**
  * Concatenate a sequence of ArrayBuffers

package/dist/node/fetch/utils/stream-utils.node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream-utils.node.d.ts","sourceRoot":"","sources":["../../../../src/node/fetch/utils/stream-utils.node.ts"],"names":[],"mappings":"AAYA,wBAAsB,gBAAgB,CAAC,GAAG,KAAA,EAAE,OAAO,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC,CAsBjE;AAED,wBAAgB,oBAAoB,CAAC,UAAU,KAAA,EAAE,OAAO,KAAA,OAYvD;AAED,wBAAsB,qBAAqB,CAAC,UAAU,KAAA,GAAG,OAAO,CAAC,WAAW,CAAC,CAsB5E;AA6BD;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,CAAC,WAAW,GAAG,UAAU,CAAC,EAAE,GAAG,WAAW,CAqB1F"}
+{"version":3,"file":"stream-utils.node.d.ts","sourceRoot":"","sources":["../../../../src/node/fetch/utils/stream-utils.node.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,KAAA,EAAE,OAAO,KAAA,OAYvD;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CAAC,UAAU,KAAA,GAAG,OAAO,CAAC,WAAW,CAAC,CAsB5E;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,CAAC,WAAW,GAAG,UAAU,CAAC,EAAE,GAAG,WAAW,CAqB1F"}

package/dist/node/fetch/utils/stream-utils.node.js

@@ -1,41 +1,15 @@
 "use strict";
+// loaders.gl, MIT license
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.concatenateArrayBuffers = exports.concatenateReadStream = exports.decompressReadStream = exports.createReadStream = void 0;
-const fs_1 = __importDefault(require("fs")); // `fs` will be empty object in browsers (see package.json "browser" field).
-const http_1 = __importDefault(require("http"));
-const https_1 = __importDefault(require("https"));
+exports.concatenateArrayBuffers = exports.concatenateReadStream = exports.decompressReadStream = void 0;
 const zlib_1 = __importDefault(require("zlib"));
 const decode_data_uri_node_1 = require("./decode-data-uri.node");
-function isRequestURL(url) {
-    return url.startsWith('http:') || url.startsWith('https:');
-}
-// Returns a promise that resolves to a readable stream
-async function createReadStream(url, options) {
-    // Handle file streams in node
-    if (!isRequestURL(url)) {
-        const noqueryUrl = url.split('?')[0];
-        // Now open the stream
-        return await new Promise((resolve, reject) => {
-            // @ts-ignore
-            const stream = fs_1.default.createReadStream(noqueryUrl, { encoding: null });
-            stream.once('readable', () => resolve(stream));
-            stream.on('error', (error) => reject(error));
-        });
-    }
-    // HANDLE HTTP/HTTPS REQUESTS IN NODE
-    // TODO: THIS IS BAD SINCE WE RETURN A PROMISE INSTEAD OF A STREAM
-    return await new Promise((resolve, reject) => {
-        const requestFunction = url.startsWith('https:') ? https_1.default.request : http_1.default.request;
-        const requestOptions = getRequestOptions(url, options);
-        const req = requestFunction(requestOptions, (res) => resolve(res));
-        req.on('error', (error) => reject(error));
-        req.end();
-    });
-}
-exports.createReadStream = createReadStream;
+/**
+ *
+ */
 function decompressReadStream(readStream, headers) {
     switch (headers.get('content-encoding')) {
         case 'br':
@@ -50,6 +24,11 @@ function decompressReadStream(readStream, headers) {
     }
 }
 exports.decompressReadStream = decompressReadStream;
+/**
+ *
+ * @param readStream
+ * @returns
+ */
 async function concatenateReadStream(readStream) {
     const arrayBufferChunks = [];
     return await new Promise((resolve, reject) => {
@@ -70,29 +49,6 @@ async function concatenateReadStream(readStream) {
     });
 }
 exports.concatenateReadStream = concatenateReadStream;
-// HELPERS
-function getRequestOptions(url, options) {
-    // Ensure header keys are lower case so that we can merge without duplicates
-    const originalHeaders = options?.headers || {};
-    const headers = {};
-    for (const key of Object.keys(originalHeaders)) {
-        headers[key.toLowerCase()] = originalHeaders[key];
-    }
-    // Add default accept-encoding to headers
-    headers['accept-encoding'] = headers['accept-encoding'] || 'gzip,br,deflate';
-    const urlObject = new URL(url);
-    return {
-        hostname: urlObject.hostname,
-        path: urlObject.pathname,
-        method: 'GET',
-        // Add options and user provided 'options.fetch' overrides if available
-        ...options,
-        ...options?.fetch,
-        // Override with updated headers with accepted encodings:
-        headers,
-        port: urlObject.port
-    };
-}
 /**
  * Concatenate a sequence of ArrayBuffers
  * @return A concatenated ArrayBuffer

package/dist/node/images/parse-image.node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-image.node.d.ts","sourceRoot":"","sources":["../../../src/node/images/parse-image.node.ts"],"names":[],"mappings":"AAKA,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,wBAAsB,cAAc,CAAC,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAwBjG"}
+{"version":3,"file":"parse-image.node.d.ts","sourceRoot":"","sources":["../../../src/node/images/parse-image.node.ts"],"names":[],"mappings":"AAGA,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,wBAAsB,cAAc,CAAC,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAUjG"}

package/dist/node/images/parse-image.node.js

@@ -5,26 +5,34 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseImageNode = void 0;
 const get_pixels_1 = __importDefault(require("get-pixels"));
-const assert_1 = require("../../utils/assert");
-const util_1 = __importDefault(require("util"));
 async function parseImageNode(arrayBuffer, mimeType) {
-    (0, assert_1.assert)(mimeType, 'MIMEType is required to parse image under Node.js');
-    // TODO - check if getPixels callback is asynchronous if provided with buffer input
-    // if not, parseImage can be a sync function
-    const getPixelsAsync = util_1.default.promisify(get_pixels_1.default);
+    if (!mimeType) {
+        throw new Error('MIMEType is required to parse image under Node.js');
+    }
     const buffer = arrayBuffer instanceof Buffer ? arrayBuffer : Buffer.from(arrayBuffer);
     const ndarray = await getPixelsAsync(buffer, mimeType);
-    const shape = [...ndarray.shape];
-    const layers = ndarray.shape.length === 4 ? ndarray.shape.shift() : 1;
-    const data = ndarray.data instanceof Buffer ? new Uint8Array(ndarray.data) : ndarray.data;
-    // extract width/height etc
-    return {
-        shape,
-        data,
-        width: ndarray.shape[0],
-        height: ndarray.shape[1],
-        components: ndarray.shape[2],
-        layers
-    };
+    return ndarray;
 }
 exports.parseImageNode = parseImageNode;
+// TODO - check if getPixels callback is asynchronous if provided with buffer input
+// if not, parseImage can be a sync function
+function getPixelsAsync(buffer, mimeType) {
+    return new Promise((resolve) => (0, get_pixels_1.default)(buffer, mimeType, (err, ndarray) => {
+        if (err) {
+            throw err;
+        }
+        const shape = [...ndarray.shape];
+        const layers = ndarray.shape.length === 4 ? ndarray.shape.shift() : 1;
+        const data = ndarray.data instanceof Buffer ? new Uint8Array(ndarray.data) : ndarray.data;
+        // extract width/height etc
+        resolve({
+            shape,
+            data,
+            width: ndarray.shape[0],
+            height: ndarray.shape[1],
+            components: ndarray.shape[2],
+            // TODO - error
+            layers: layers ? [layers] : []
+        });
+    }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/polyfills",
-  "version": "3.3.0-alpha.9",
+  "version": "3.3.1",
   "description": "Polyfills for TextEncoder/TextDecoder",
   "license": "MIT",
   "publishConfig": {
@@ -98,6 +98,7 @@
   "dependencies": {
     "@babel/runtime": "^7.3.1",
     "@xmldom/xmldom": "^0.7.5",
+    "buffer": "^6.0.3",
     "get-pixels": "^3.3.2",
     "ndarray": "^1.0.18",
     "save-pixels": "^2.3.2",
@@ -105,5 +106,5 @@
     "through": "^2.3.8",
     "web-streams-polyfill": "^3.0.0"
   },
-  "gitHead": "c95a4ff72512668a93d9041ce8636bac09333fd5"
+  "gitHead": "51632b5948e496a4b75e970030ad7579650c129d"
 }

package/src/index.ts

@@ -8,9 +8,9 @@ import {allSettled} from './promise/all-settled';
 // Node specific
 import * as base64 from './node/buffer/btoa.node';
 
-import HeadersNode from './node/fetch/headers.node';
-import ResponseNode from './node/fetch/response.node';
-import fetchNode from './node/fetch/fetch.node';
+import {Headers as HeadersNode} from './node/fetch/headers.node';
+import {Response as ResponseNode} from './node/fetch/response.node';
+import {fetchNode as fetchNode} from './node/fetch/fetch.node';
 
 import {encodeImageNode} from './node/images/encode-image.node';
 import {parseImageNode} from './node/images/parse-image.node';
@@ -20,7 +20,8 @@ export {BlobPolyfill} from './node/file/blob';
 export {FileReaderPolyfill} from './node/file/file-reader';
 export {FilePolyfill} from './node/file/file';
 export {installFilePolyfills} from './node/file/install-file-polyfills';
-export {default as _fetchNode} from './node/fetch/fetch.node';
+export {fetchNode as _fetchNode} from './node/fetch/fetch.node';
+export {fetchFileNode as _fetchFileNode} from './node/fetch/fetch-file.node';
 
 // POLYFILLS: TextEncoder, TextDecoder
 // - Recent Node versions have these classes but virtually no encodings unless special build.

package/src/node/fetch/fetch-file.node.ts

@@ -0,0 +1,51 @@
+// loaders.gl, MIT license
+
+import fs from 'fs'; // `fs` will be empty object in browsers (see package.json "browser" field).
+import {Response} from './response.node';
+import {Headers} from './headers.node';
+
+export function isRequestURL(url: string): boolean {
+  return url.startsWith('http:') || url.startsWith('https:');
+}
+
+export async function fetchFileNode(url: string, options): Promise<Response> {
+  const noqueryUrl = url.split('?')[0];
+
+  try {
+    // Now open the stream
+    const body = await new Promise((resolve, reject) => {
+      // @ts-ignore
+      const stream = fs.createReadStream(noqueryUrl, {encoding: null});
+      stream.once('readable', () => resolve(stream));
+      stream.on('error', (error) => reject(error));
+    });
+
+    const status = 200;
+    const statusText = 'OK';
+    const headers = getHeadersForFile(noqueryUrl);
+    return new Response(body, {headers, status, statusText, url});
+  } catch (error) {
+    const status = 400;
+    const statusText = (error as Error).message;
+    const headers = {};
+    return new Response((error as Error).message, {headers, status, statusText, url});
+  }
+}
+
+function getHeadersForFile(noqueryUrl: string): Headers {
+  const headers = {};
+
+  // Fix up content length if we can for best progress experience
+  if (!headers['content-length']) {
+    const stats = fs.statSync(noqueryUrl);
+    headers['content-length'] = stats.size;
+  }
+
+  // Automatically decompress gzipped files with .gz extension
+  if (noqueryUrl.endsWith('.gz')) {
+    noqueryUrl = noqueryUrl.slice(0, -3);
+    headers['content-encoding'] = 'gzip';
+  }
+
+  return new Headers(headers);
+}

package/src/node/fetch/fetch.node.ts

@@ -1,20 +1,29 @@
-import fs from 'fs'; // `fs` will be empty object in browsers (see package.json "browser" field).
-import Response from './response.node';
-import Headers from './headers.node';
+// loaders.gl, MIT license
 
+import http from 'http';
+import https from 'https';
+import {Response} from './response.node';
+import {Headers} from './headers.node';
 import {decodeDataUri} from './utils/decode-data-uri.node';
-import {createReadStream} from './utils/stream-utils.node';
 
-const isDataURL = (url) => url.startsWith('data:');
-const isRequestURL = (url) => url.startsWith('http:') || url.startsWith('https:');
+import {fetchFileNode} from './fetch-file.node';
+
+const isDataURL = (url: string): boolean => url.startsWith('data:');
+const isRequestURL = (url: string): boolean => url.startsWith('http:') || url.startsWith('https:');
 
 /**
  * Emulation of Browser fetch for Node.js
  * @param url
  * @param options
  */
-export default async function fetchNode(url, options) {
+// eslint-disable-next-line complexity
+export async function fetchNode(url: string, options): Promise<Response> {
   try {
+    // Handle file streams in node
+    if (!isRequestURL(url) && !isDataURL(url)) {
+      return await fetchFileNode(url, options);
+    }
+
     // Handle data urls in node, to match `fetch``
     // Note - this loses the MIME type, data URIs are handled directly in fetch
     if (isDataURL(url)) {
@@ -35,7 +44,7 @@ export default async function fetchNode(url, options) {
     }
 
     // Need to create the stream in advance since Response constructor needs to be sync
-    const body = await createReadStream(originalUrl, options);
+    const body = await createHTTPRequestReadStream(originalUrl, options);
     const headers = getHeaders(url, body, syntheticResponseHeaders);
     const {status, statusText} = getStatus(body);
 
@@ -55,6 +64,23 @@ export default async function fetchNode(url, options) {
   }
 }
 
+/** Returns a promise that resolves to a readable stream */
+export async function createHTTPRequestReadStream(
+  url: string,
+  options
+): Promise<http.IncomingMessage> {
+  // HANDLE HTTP/HTTPS REQUESTS IN NODE
+  // TODO: THIS IS BAD SINCE WE RETURN A PROMISE INSTEAD OF A STREAM
+  return await new Promise((resolve, reject) => {
+    const requestOptions = getRequestOptions(url, options);
+    const req = url.startsWith('https:')
+      ? https.request(requestOptions, (res) => resolve(res))
+      : http.request(requestOptions, (res) => resolve(res));
+    req.on('error', (error) => reject(error));
+    req.end();
+  });
+}
+
 /**
  * Generate redirect url from location without origin and protocol.
  * @param originalUrl
@@ -72,9 +98,33 @@ function generateRedirectUrl(originalUrl: string, location: string): string {
 }
 
 // HELPER FUNCTIONS
-// PRIVATE
 
-function getStatus(httpResponse) {
+function getRequestOptions(url: string, options?: {fetch?: typeof fetch; headers?}) {
+  // Ensure header keys are lower case so that we can merge without duplicates
+  const originalHeaders = options?.headers || {};
+  const headers = {};
+  for (const key of Object.keys(originalHeaders)) {
+    headers[key.toLowerCase()] = originalHeaders[key];
+  }
+
+  // Add default accept-encoding to headers
+  headers['accept-encoding'] = headers['accept-encoding'] || 'gzip,br,deflate';
+
+  const urlObject = new URL(url);
+  return {
+    hostname: urlObject.hostname,
+    path: urlObject.pathname,
+    method: 'GET',
+    // Add options and user provided 'options.fetch' overrides if available
+    ...options,
+    ...options?.fetch,
+    // Override with updated headers with accepted encodings:
+    headers,
+    port: urlObject.port
+  };
+}
+
+function getStatus(httpResponse: http.IncomingMessage): {status: number; statusText: string} {
   if (httpResponse.statusCode) {
     return {status: httpResponse.statusCode, statusText: httpResponse.statusMessage || 'NA'};
   }
@@ -105,24 +155,8 @@ function getHeaders(url, httpResponse, additionalHeaders = {}) {
   return new Headers(headers);
 }
 
-function getContentLength(url) {
-  if (isRequestURL(url)) {
-    // Needs to be read from actual headers
-    return null;
-  } else if (isDataURL(url)) {
-    // TODO - remove media type etc
-    return url.length - 'data:'.length;
-  }
-  // File URL
-  // TODO - how to handle non-existing file, this presumably just throws
-  try {
-    // strip query params from URL
-    const noqueryUrl = url.split('?')[0];
-    const stats = fs.statSync(noqueryUrl);
-    return stats.size;
-  } catch (error) {
-    // ignore for now
-  }
-
-  return null;
+/** Needs to be read from actual headers */
+function getContentLength(url: string): number | null {
+  // TODO - remove media type etc
+  return isDataURL(url) ? url.length - 'data:'.length : null;
 }

package/src/node/fetch/headers.node.ts

@@ -2,7 +2,7 @@
  * Polyfill for Browser Headers
  * Based on https://github.com/github/fetch under MIT license
  */
-export default class Headers {
+export class Headers {
   map: {};
 
   constructor(headers) {

package/src/node/fetch/response.node.ts

@@ -1,6 +1,8 @@
+// loaders.gl, MIT license
+
 import {assert} from '../../utils/assert';
 import {decompressReadStream, concatenateReadStream} from './utils/stream-utils.node';
-import Headers from './headers.node';
+import {Headers} from './headers.node';
 
 const isBoolean = (x) => typeof x === 'boolean';
 const isFunction = (x) => typeof x === 'function';
@@ -20,7 +22,7 @@ const isReadableNodeStream = (x) =>
  */
 import {Readable} from 'stream';
 
-export default class Response {
+export class Response {
   readonly ok: boolean;
   readonly status: number;
   readonly statusText: string;

package/src/node/fetch/utils/stream-utils.node.ts

@@ -1,39 +1,12 @@
-import fs from 'fs'; // `fs` will be empty object in browsers (see package.json "browser" field).
-import http from 'http';
-import https from 'https';
+// loaders.gl, MIT license
+
 import zlib from 'zlib';
 
 import {toArrayBuffer} from './decode-data-uri.node';
 
-function isRequestURL(url: string): boolean {
-  return url.startsWith('http:') || url.startsWith('https:');
-}
-
-// Returns a promise that resolves to a readable stream
-export async function createReadStream(url, options): Promise<any> {
-  // Handle file streams in node
-  if (!isRequestURL(url)) {
-    const noqueryUrl = url.split('?')[0];
-    // Now open the stream
-    return await new Promise((resolve, reject) => {
-      // @ts-ignore
-      const stream = fs.createReadStream(noqueryUrl, {encoding: null});
-      stream.once('readable', () => resolve(stream));
-      stream.on('error', (error) => reject(error));
-    });
-  }
-
-  // HANDLE HTTP/HTTPS REQUESTS IN NODE
-  // TODO: THIS IS BAD SINCE WE RETURN A PROMISE INSTEAD OF A STREAM
-  return await new Promise((resolve, reject) => {
-    const requestFunction = url.startsWith('https:') ? https.request : http.request;
-    const requestOptions = getRequestOptions(url, options);
-    const req = requestFunction(requestOptions, (res) => resolve(res));
-    req.on('error', (error) => reject(error));
-    req.end();
-  });
-}
-
+/**
+ *
+ */
 export function decompressReadStream(readStream, headers) {
   switch (headers.get('content-encoding')) {
     case 'br':
@@ -48,6 +21,11 @@ export function decompressReadStream(readStream, headers) {
   }
 }
 
+/**
+ *
+ * @param readStream
+ * @returns
+ */
 export async function concatenateReadStream(readStream): Promise<ArrayBuffer> {
   const arrayBufferChunks: ArrayBuffer[] = [];
 
@@ -72,33 +50,6 @@ export async function concatenateReadStream(readStream): Promise<ArrayBuffer> {
   });
 }
 
-// HELPERS
-
-function getRequestOptions(url: string, options?: {fetch?: typeof fetch; headers?}) {
-  // Ensure header keys are lower case so that we can merge without duplicates
-  const originalHeaders = options?.headers || {};
-  const headers = {};
-  for (const key of Object.keys(originalHeaders)) {
-    headers[key.toLowerCase()] = originalHeaders[key];
-  }
-
-  // Add default accept-encoding to headers
-  headers['accept-encoding'] = headers['accept-encoding'] || 'gzip,br,deflate';
-
-  const urlObject = new URL(url);
-  return {
-    hostname: urlObject.hostname,
-    path: urlObject.pathname,
-    method: 'GET',
-    // Add options and user provided 'options.fetch' overrides if available
-    ...options,
-    ...options?.fetch,
-    // Override with updated headers with accepted encodings:
-    headers,
-    port: urlObject.port
-  };
-}
-
 /**
  * Concatenate a sequence of ArrayBuffers
  * @return A concatenated ArrayBuffer

package/src/node/images/parse-image.node.ts

@@ -1,6 +1,4 @@
 import getPixels from 'get-pixels';
-import {assert} from '../../utils/assert';
-import util from 'util';
 
 // Note: These types are also defined in @loaders.gl/images and need to be kept in sync
 type NDArray = {
@@ -13,27 +11,40 @@ type NDArray = {
 };
 
 export async function parseImageNode(arrayBuffer: ArrayBuffer, mimeType: string): Promise<NDArray> {
-  assert(mimeType, 'MIMEType is required to parse image under Node.js');
-
-  // TODO - check if getPixels callback is asynchronous if provided with buffer input
-  // if not, parseImage can be a sync function
-  const getPixelsAsync = util.promisify(getPixels);
+  if (!mimeType) {
+    throw new Error('MIMEType is required to parse image under Node.js');
+  }
 
   const buffer = arrayBuffer instanceof Buffer ? arrayBuffer : Buffer.from(arrayBuffer);
 
   const ndarray = await getPixelsAsync(buffer, mimeType);
 
-  const shape = [...ndarray.shape];
-  const layers = ndarray.shape.length === 4 ? ndarray.shape.shift() : 1;
-  const data = ndarray.data instanceof Buffer ? new Uint8Array(ndarray.data) : ndarray.data;
-
-  // extract width/height etc
-  return {
-    shape,
-    data,
-    width: ndarray.shape[0],
-    height: ndarray.shape[1],
-    components: ndarray.shape[2],
-    layers
-  };
+  return ndarray;
+}
+
+// TODO - check if getPixels callback is asynchronous if provided with buffer input
+// if not, parseImage can be a sync function
+function getPixelsAsync(buffer: Buffer, mimeType: string): Promise<NDArray> {
+  return new Promise<NDArray>((resolve) =>
+    getPixels(buffer, mimeType, (err, ndarray) => {
+      if (err) {
+        throw err;
+      }
+
+      const shape = [...ndarray.shape];
+      const layers = ndarray.shape.length === 4 ? ndarray.shape.shift() : 1;
+      const data = ndarray.data instanceof Buffer ? new Uint8Array(ndarray.data) : ndarray.data;
+
+      // extract width/height etc
+      resolve({
+        shape,
+        data,
+        width: ndarray.shape[0],
+        height: ndarray.shape[1],
+        components: ndarray.shape[2],
+        // TODO - error
+        layers: layers ? [layers] : []
+      });
+    })
+  );
 }