@loaders.gl/polyfills 4.2.0-alpha.4 → 4.2.0-alpha.5

package/dist/buffer/btoa.node.js

@@ -1,7 +1,9 @@
+// btoa, atob polyfills for Node.js
+// Note: The atob and btoa functions (not just the polyfills!) are not unicode safe
+// But still useful for unit testing
 export function atob(string) {
-  return Buffer.from(string).toString('base64');
+    return Buffer.from(string).toString('base64');
 }
 export function btoa(base64) {
-  return Buffer.from(base64, 'base64').toString('ascii');
+    return Buffer.from(base64, 'base64').toString('ascii');
 }
-//# sourceMappingURL=btoa.node.js.map

package/dist/buffer/to-array-buffer.node.js

@@ -1,8 +1,8 @@
 export function bufferToArrayBuffer(buffer) {
-  if (Buffer.isBuffer(buffer)) {
-    const typedArray = new Uint8Array(buffer);
-    return typedArray.buffer;
-  }
-  return buffer;
+    // TODO - per docs we should just be able to call buffer.buffer, but there are issues
+    if (Buffer.isBuffer(buffer)) {
+        const typedArray = new Uint8Array(buffer);
+        return typedArray.buffer;
+    }
+    return buffer;
 }
-//# sourceMappingURL=to-array-buffer.node.js.map

package/dist/crypto/node-hash.js

@@ -1,56 +1,52 @@
+// This dependency is too big, application must provide it
 import { Hash } from '@loaders.gl/crypto';
-import * as crypto from 'crypto';
+import * as crypto from 'crypto'; // Node.js builtin
+/**
+ * Calculates Cryptographic Hash using Node.js crypto library
+ * @deprecated Warning, experimental class
+ */
 export class NodeHash extends Hash {
-  constructor(options) {
-    var _this$options, _this$options$crypto;
-    super();
-    this.name = 'crypto-node';
-    this.options = void 0;
-    this._algorithm = void 0;
-    this._hash = void 0;
-    this.options = options;
-    if (!((_this$options = this.options) !== null && _this$options !== void 0 && (_this$options$crypto = _this$options.crypto) !== null && _this$options$crypto !== void 0 && _this$options$crypto.algorithm)) {
-      throw new Error(this.name);
+    constructor(options) {
+        super();
+        this.name = 'crypto-node';
+        this.options = options;
+        if (!this.options?.crypto?.algorithm) {
+            throw new Error(this.name);
+        }
     }
-  }
-  async hash(input, encoding) {
-    var _this$options2, _this$options2$crypto, _this$options2$crypto2;
-    const algorithm = (_this$options2 = this.options) === null || _this$options2 === void 0 ? void 0 : (_this$options2$crypto = _this$options2.crypto) === null || _this$options2$crypto === void 0 ? void 0 : (_this$options2$crypto2 = _this$options2$crypto.algorithm) === null || _this$options2$crypto2 === void 0 ? void 0 : _this$options2$crypto2.toLowerCase();
-    try {
-      var _crypto$createHash;
-      if (!crypto.createHash) {
-        throw new Error('crypto.createHash not available');
-      }
-      const hash = (_crypto$createHash = crypto.createHash) === null || _crypto$createHash === void 0 ? void 0 : _crypto$createHash.call(crypto, algorithm);
-      const inputArray = new Uint8Array(input);
-      return hash.update(inputArray).digest('base64');
-    } catch (error) {
-      throw Error(`${algorithm} hash not available. ${error}`);
+    /**
+     * Atomic hash calculation
+     * @returns base64 encoded hash
+     */
+    async hash(input, encoding) {
+        // await this.preload();
+        const algorithm = this.options?.crypto?.algorithm?.toLowerCase();
+        try {
+            if (!crypto.createHash) {
+                throw new Error('crypto.createHash not available');
+            }
+            const hash = crypto.createHash?.(algorithm);
+            const inputArray = new Uint8Array(input);
+            return hash.update(inputArray).digest('base64');
+        }
+        catch (error) {
+            throw Error(`${algorithm} hash not available. ${error}`);
+        }
     }
-  }
-  hashBatches(asyncIterator) {
-    try {
-      var _this = this;
-      let encoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'base64';
-      return async function* () {
-        var _crypto$createHash2, _this$options3, _this$options3$crypto, _this$options3$crypto2, _this$options4, _this$options4$crypto, _this$options4$crypto2;
+    async *hashBatches(asyncIterator, encoding = 'base64') {
+        // await this.preload();
         if (!crypto.createHash) {
-          throw new Error('crypto.createHash not available');
+            throw new Error('crypto.createHash not available');
         }
-        const hash = (_crypto$createHash2 = crypto.createHash) === null || _crypto$createHash2 === void 0 ? void 0 : _crypto$createHash2.call(crypto, (_this$options3 = _this.options) === null || _this$options3 === void 0 ? void 0 : (_this$options3$crypto = _this$options3.crypto) === null || _this$options3$crypto === void 0 ? void 0 : (_this$options3$crypto2 = _this$options3$crypto.algorithm) === null || _this$options3$crypto2 === void 0 ? void 0 : _this$options3$crypto2.toLowerCase());
+        const hash = crypto.createHash?.(this.options?.crypto?.algorithm?.toLowerCase());
         for await (const chunk of asyncIterator) {
-          const inputArray = new Uint8Array(chunk);
-          hash.update(inputArray);
-          yield chunk;
+            // https://stackoverflow.com/questions/25567468/how-to-decrypt-an-arraybuffer
+            const inputArray = new Uint8Array(chunk);
+            hash.update(inputArray);
+            yield chunk;
         }
+        // We can pass our encoding constant directly to Node.js digest as it already supports `hex` and `base64`
         const digest = hash.digest(encoding);
-        (_this$options4 = _this.options) === null || _this$options4 === void 0 ? void 0 : (_this$options4$crypto = _this$options4.crypto) === null || _this$options4$crypto === void 0 ? void 0 : (_this$options4$crypto2 = _this$options4$crypto.onEnd) === null || _this$options4$crypto2 === void 0 ? void 0 : _this$options4$crypto2.call(_this$options4$crypto, {
-          hash: digest
-        });
-      }();
-    } catch (e) {
-      return Promise.reject(e);
+        this.options?.crypto?.onEnd?.({ hash: digest });
     }
-  }
 }
-//# sourceMappingURL=node-hash.js.map

package/dist/fetch/decode-data-uri.js

@@ -1,45 +1,60 @@
-const isArrayBuffer = x => x && x instanceof ArrayBuffer;
-const isBuffer = x => x && x instanceof Buffer;
+// Based on binary-gltf-utils under MIT license: Copyright (c) 2016-17 Karl Cheng
+const isArrayBuffer = (x) => x && x instanceof ArrayBuffer;
+const isBuffer = (x) => x && x instanceof Buffer;
+/**
+ * Parses a data URI into a buffer, as well as retrieving its declared MIME type.
+ *
+ * @param {string} uri - a data URI (assumed to be valid)
+ * @returns {Object} { buffer, mimeType }
+ */
 export function decodeDataUri(uri) {
-  const dataIndex = uri.indexOf(',');
-  let buffer;
-  let mimeType;
-  if (uri.slice(dataIndex - 7, dataIndex) === ';base64') {
-    buffer = Buffer.from(uri.slice(dataIndex + 1), 'base64');
-    mimeType = uri.slice(5, dataIndex - 7).trim();
-  } else {
-    buffer = Buffer.from(decodeURIComponent(uri.slice(dataIndex + 1)));
-    mimeType = uri.slice(5, dataIndex).trim();
-  }
-  if (!mimeType) {
-    mimeType = 'text/plain;charset=US-ASCII';
-  } else if (mimeType.startsWith(';')) {
-    mimeType = `text/plain${mimeType}`;
-  }
-  return {
-    arrayBuffer: toArrayBuffer(buffer),
-    mimeType
-  };
+    const dataIndex = uri.indexOf(',');
+    let buffer;
+    let mimeType;
+    if (uri.slice(dataIndex - 7, dataIndex) === ';base64') {
+        buffer = Buffer.from(uri.slice(dataIndex + 1), 'base64');
+        mimeType = uri.slice(5, dataIndex - 7).trim();
+    }
+    else {
+        buffer = Buffer.from(decodeURIComponent(uri.slice(dataIndex + 1)));
+        mimeType = uri.slice(5, dataIndex).trim();
+    }
+    if (!mimeType) {
+        mimeType = 'text/plain;charset=US-ASCII';
+    }
+    else if (mimeType.startsWith(';')) {
+        mimeType = `text/plain${mimeType}`;
+    }
+    return { arrayBuffer: toArrayBuffer(buffer), mimeType };
 }
+/**
+ * @param data
+ * @todo Duplicate of core
+ */
 export function toArrayBuffer(data) {
-  if (isArrayBuffer(data)) {
-    return data;
-  }
-  if (isBuffer(data)) {
-    const typedArray = new Uint8Array(data);
-    return typedArray.buffer;
-  }
-  if (ArrayBuffer.isView(data)) {
-    return data.buffer;
-  }
-  if (typeof data === 'string') {
-    const text = data;
-    const uint8Array = new TextEncoder().encode(text);
-    return uint8Array.buffer;
-  }
-  if (data && typeof data === 'object' && data._toArrayBuffer) {
-    return data._toArrayBuffer();
-  }
-  throw new Error(`toArrayBuffer(${JSON.stringify(data, null, 2).slice(10)})`);
+    if (isArrayBuffer(data)) {
+        return data;
+    }
+    // TODO - per docs we should just be able to call buffer.buffer, but there are issues
+    if (isBuffer(data)) {
+        // @ts-expect-error
+        const typedArray = new Uint8Array(data);
+        return typedArray.buffer;
+    }
+    // Careful - Node Buffers will look like ArrayBuffers (keep after isBuffer)
+    if (ArrayBuffer.isView(data)) {
+        return data.buffer;
+    }
+    if (typeof data === 'string') {
+        const text = data;
+        const uint8Array = new TextEncoder().encode(text);
+        return uint8Array.buffer;
+    }
+    // HACK to support Blob polyfill
+    // @ts-expect-error
+    if (data && typeof data === 'object' && data._toArrayBuffer) {
+        // @ts-expect-error
+        return data._toArrayBuffer();
+    }
+    throw new Error(`toArrayBuffer(${JSON.stringify(data, null, 2).slice(10)})`);
 }
-//# sourceMappingURL=decode-data-uri.js.map

package/dist/fetch/fetch-polyfill.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import http from 'http';
-import { Response } from './response-polyfill';
+import { Response } from "./response-polyfill.js";
 /**
  * Emulation of Browser fetch for Node.js
  * @param url

package/dist/fetch/fetch-polyfill.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetch-polyfill.d.ts","sourceRoot":"","sources":["../../src/fetch/fetch-polyfill.ts"],"names":[],"mappings":";AAIA,OAAO,IAAI,MAAM,MAAM,CAAC;AAExB,OAAO,EAAC,QAAQ,EAAC,MAAM,qBAAqB,CAAC;AAO7C;;;;GAIG;AAEH,wBAAsB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC,CAgDpF;AAED,2DAA2D;AAC3D,wBAAsB,2BAA2B,CAC/C,GAAG,EAAE,MAAM,EACX,OAAO,KAAA,GACN,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,CAW/B"}
+{"version":3,"file":"fetch-polyfill.d.ts","sourceRoot":"","sources":["../../src/fetch/fetch-polyfill.ts"],"names":[],"mappings":";AAIA,OAAO,IAAI,MAAM,MAAM,CAAC;AAExB,OAAO,EAAC,QAAQ,EAAC,+BAA4B;AAO7C;;;;GAIG;AAEH,wBAAsB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC,CAgDpF;AAED,2DAA2D;AAC3D,wBAAsB,2BAA2B,CAC/C,GAAG,EAAE,MAAM,EACX,OAAO,KAAA,GACN,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,CAW/B"}

package/dist/fetch/fetch-polyfill.js

@@ -1,125 +1,140 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import http from 'http';
 import https from 'https';
 import { Response } from "./response-polyfill.js";
 import { Headers } from "./headers-polyfill.js";
 import { decodeDataUri } from "./decode-data-uri.js";
-const isDataURL = url => url.startsWith('data:');
-const isRequestURL = url => url.startsWith('http:') || url.startsWith('https:');
+const isDataURL = (url) => url.startsWith('data:');
+const isRequestURL = (url) => url.startsWith('http:') || url.startsWith('https:');
+/**
+ * Emulation of Browser fetch for Node.js
+ * @param url
+ * @param options
+ */
+// eslint-disable-next-line complexity
 export async function fetchNode(url, options) {
-  try {
-    if (globalThis.fetch !== fetchNode && (isRequestURL(url) || isDataURL(url))) {
-      return await fetch(url, options);
+    try {
+        // Handle file streams in node
+        // @ts-expect-error
+        if (globalThis.fetch !== fetchNode && (isRequestURL(url) || isDataURL(url))) {
+            // @ts-expect-error
+            return await fetch(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)) {
+            const { arrayBuffer, mimeType } = decodeDataUri(url);
+            const response = new Response(arrayBuffer, {
+                headers: { 'content-type': mimeType },
+                url
+            });
+            return response;
+        }
+        // Automatically decompress gzipped files with .gz extension
+        const syntheticResponseHeaders = {};
+        const originalUrl = url;
+        if (url.endsWith('.gz')) {
+            url = url.slice(0, -3);
+            syntheticResponseHeaders['content-encoding'] = 'gzip';
+        }
+        // Need to create the stream in advance since Response constructor needs to be sync
+        const body = await createHTTPRequestReadStream(originalUrl, options);
+        const headers = getHeaders(url, body, syntheticResponseHeaders);
+        const { status, statusText } = getStatus(body);
+        const followRedirect = 
+        // @ts-expect-error
+        !options || options.followRedirect || options.followRedirect === undefined;
+        if (status >= 300 && status < 400 && headers.has('location') && followRedirect) {
+            const redirectUrl = generateRedirectUrl(url, headers.get('location'));
+            // Redirect
+            return await fetchNode(redirectUrl, options);
+        }
+        return new Response(body, { headers, status, statusText, url });
     }
-    if (isDataURL(url)) {
-      const {
-        arrayBuffer,
-        mimeType
-      } = decodeDataUri(url);
-      const response = new Response(arrayBuffer, {
-        headers: {
-          'content-type': mimeType
-        },
-        url
-      });
-      return response;
+    catch (error) {
+        // TODO - what error code to use here?
+        return new Response(null, { status: 400, statusText: String(error), url });
     }
-    const syntheticResponseHeaders = {};
-    const originalUrl = url;
-    if (url.endsWith('.gz')) {
-      url = url.slice(0, -3);
-      syntheticResponseHeaders['content-encoding'] = 'gzip';
-    }
-    const body = await createHTTPRequestReadStream(originalUrl, options);
-    const headers = getHeaders(url, body, syntheticResponseHeaders);
-    const {
-      status,
-      statusText
-    } = getStatus(body);
-    const followRedirect = !options || options.followRedirect || options.followRedirect === undefined;
-    if (status >= 300 && status < 400 && headers.has('location') && followRedirect) {
-      const redirectUrl = generateRedirectUrl(url, headers.get('location'));
-      return await fetchNode(redirectUrl, options);
-    }
-    return new Response(body, {
-      headers,
-      status,
-      statusText,
-      url
-    });
-  } catch (error) {
-    return new Response(null, {
-      status: 400,
-      statusText: String(error),
-      url
-    });
-  }
 }
+/** Returns a promise that resolves to a readable stream */
 export async function createHTTPRequestReadStream(url, options) {
-  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();
-  });
+    // 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
+ * @param redirectUrl
+ */
 function generateRedirectUrl(originalUrl, location) {
-  if (location.startsWith('http')) {
-    return location;
-  }
-  const url = new URL(originalUrl);
-  url.pathname = location;
-  return url.href;
+    if (location.startsWith('http')) {
+        return location;
+    }
+    // If url doesn't have origin and protocol just extend current url origin with location.
+    const url = new URL(originalUrl);
+    url.pathname = location;
+    return url.href;
 }
+// HELPER FUNCTIONS
 function getRequestOptions(url, options) {
-  const originalHeaders = (options === null || options === void 0 ? void 0 : options.headers) || {};
-  const headers = {};
-  for (const key of Object.keys(originalHeaders)) {
-    headers[key.toLowerCase()] = originalHeaders[key];
-  }
-  headers['accept-encoding'] = headers['accept-encoding'] || 'gzip,br,deflate';
-  const urlObject = new URL(url);
-  return {
-    hostname: urlObject.hostname,
-    path: urlObject.pathname,
-    method: 'GET',
-    ...options,
-    ...(options === null || options === void 0 ? void 0 : options.fetch),
-    headers,
-    port: urlObject.port
-  };
-}
-function getStatus(httpResponse) {
-  if (httpResponse.statusCode) {
+    // 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 {
-      status: httpResponse.statusCode,
-      statusText: httpResponse.statusMessage || 'NA'
+        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
     };
-  }
-  return {
-    status: 200,
-    statusText: 'OK'
-  };
 }
-function getHeaders(url, httpResponse) {
-  let additionalHeaders = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  const headers = {};
-  if (httpResponse && httpResponse.headers) {
-    const httpHeaders = httpResponse.headers;
-    for (const key in httpHeaders) {
-      const header = httpHeaders[key];
-      headers[key.toLowerCase()] = String(header);
+function getStatus(httpResponse) {
+    if (httpResponse.statusCode) {
+        return { status: httpResponse.statusCode, statusText: httpResponse.statusMessage || 'NA' };
+    }
+    return { status: 200, statusText: 'OK' };
+}
+function getHeaders(url, httpResponse, additionalHeaders = {}) {
+    const headers = {};
+    if (httpResponse && httpResponse.headers) {
+        const httpHeaders = httpResponse.headers;
+        for (const key in httpHeaders) {
+            const header = httpHeaders[key];
+            headers[key.toLowerCase()] = String(header);
+        }
     }
-  }
-  if (!headers['content-length']) {
-    const contentLength = getContentLength(url);
-    if (Number.isFinite(contentLength)) {
-      headers['content-length'] = contentLength;
+    // Fix up content length if we can for best progress experience
+    if (!headers['content-length']) {
+        const contentLength = getContentLength(url);
+        if (Number.isFinite(contentLength)) {
+            headers['content-length'] = contentLength;
+        }
     }
-  }
-  Object.assign(headers, additionalHeaders);
-  return new Headers(headers);
+    Object.assign(headers, additionalHeaders);
+    return new Headers(headers);
 }
+/** Needs to be read from actual headers */
 function getContentLength(url) {
-  return isDataURL(url) ? url.length - 'data:'.length : null;
+    // TODO - remove media type etc
+    return isDataURL(url) ? url.length - 'data:'.length : null;
 }
-//# sourceMappingURL=fetch-polyfill.js.map