@loaders.gl/polyfills 3.1.0-alpha.3 → 3.1.0-beta.2

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

@@ -1,88 +1,77 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { assert } from '../../utils/assert';
-import { decompressReadStream, concatenateReadStream } from './utils/stream-utils.node';
-import Headers from './headers.node';
-
-const isBoolean = x => typeof x === 'boolean';
-
-const isFunction = x => typeof x === 'function';
-
-const isObject = x => x !== null && typeof x === 'object';
-
-const isReadableNodeStream = x => isObject(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);
-
-import { Readable } from 'stream';
-export default class Response {
-  constructor(body, options) {
-    _defineProperty(this, "ok", void 0);
-
-    _defineProperty(this, "status", void 0);
-
-    _defineProperty(this, "statusText", void 0);
-
-    _defineProperty(this, "headers", void 0);
-
-    _defineProperty(this, "url", void 0);
-
-    _defineProperty(this, "bodyUsed", false);
-
-    _defineProperty(this, "_body", void 0);
-
-    const {
-      headers,
-      status = 200,
-      statusText = 'OK',
-      url
-    } = options || {};
-    this.url = url;
-    this.ok = status === 200;
-    this.status = status;
-    this.statusText = statusText;
-    this.headers = new Headers((options === null || options === void 0 ? void 0 : options.headers) || {});
-
-    if (isReadableNodeStream(body)) {
-      this._body = decompressReadStream(body, headers);
-    } else if (typeof body === 'string') {
-      this._body = Readable.from([new TextEncoder().encode(body)]);
-    } else {
-      this._body = Readable.from([body || new ArrayBuffer(0)]);
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 isBoolean = (x) => typeof x === 'boolean';
+const isFunction = (x) => typeof x === 'function';
+const isObject = (x) => x !== null && typeof x === 'object';
+const isReadableNodeStream = (x) => isObject(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);
+/**
+ * Polyfill for Browser Response
+ *
+ * Under Node.js we return a mock "fetch response object"
+ * so that apps can use the same API as in the browser.
+ *
+ * Note: This is intended to be a "lightweight" implementation and will have limitations.
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/API/Response
+ */
+const stream_1 = require("stream");
+class Response {
+    // TODO - handle ArrayBuffer, ArrayBufferView, Buffer
+    constructor(body, options) {
+        this.bodyUsed = false;
+        const { headers, status = 200, statusText = 'OK', url } = options || {};
+        this.url = url;
+        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 || {});
+        // Check for content-encoding and create a decompression stream
+        if (isReadableNodeStream(body)) {
+            this._body = (0, stream_utils_node_1.decompressReadStream)(body, headers);
+        }
+        else if (typeof body === 'string') {
+            this._body = stream_1.Readable.from([new TextEncoder().encode(body)]);
+        }
+        else {
+            this._body = stream_1.Readable.from([body || new ArrayBuffer(0)]);
+        }
     }
-  }
-
-  get body() {
-    assert(!this.bodyUsed);
-    assert(isReadableNodeStream(this._body));
-    this.bodyUsed = true;
-    return this._body;
-  }
-
-  async arrayBuffer() {
-    if (!isReadableNodeStream(this._body)) {
-      return this._body || new ArrayBuffer(0);
+    // Subset of Properties
+    // Returns a readable stream to the "body" of the response (or file)
+    get body() {
+        (0, assert_1.assert)(!this.bodyUsed);
+        (0, assert_1.assert)(isReadableNodeStream(this._body)); // Not implemented: conversion of ArrayBuffer etc to stream
+        this.bodyUsed = true;
+        return this._body;
     }
-
-    const data = await concatenateReadStream(this._body);
-    return data;
-  }
-
-  async text() {
-    const arrayBuffer = await this.arrayBuffer();
-    const textDecoder = new TextDecoder();
-    return textDecoder.decode(arrayBuffer);
-  }
-
-  async json() {
-    const text = await this.text();
-    return JSON.parse(text);
-  }
-
-  async blob() {
-    if (typeof Blob === 'undefined') {
-      throw new Error('Blob polyfill not installed');
+    // Subset of Methods
+    async arrayBuffer() {
+        if (!isReadableNodeStream(this._body)) {
+            return this._body || new ArrayBuffer(0);
+        }
+        const data = await (0, stream_utils_node_1.concatenateReadStream)(this._body);
+        return data;
+    }
+    async text() {
+        const arrayBuffer = await this.arrayBuffer();
+        const textDecoder = new TextDecoder();
+        return textDecoder.decode(arrayBuffer);
+    }
+    async json() {
+        const text = await this.text();
+        return JSON.parse(text);
+    }
+    async blob() {
+        if (typeof Blob === 'undefined') {
+            throw new Error('Blob polyfill not installed');
+        }
+        return new Blob([await this.arrayBuffer()]);
     }
-
-    return new Blob([await this.arrayBuffer()]);
-  }
-
 }
-//# sourceMappingURL=response.node.js.map
+exports.default = Response;

package/dist/node/fetch/utils/decode-data-uri.node.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 declare function decodeDataUri(uri: any): {
+    arrayBuffer: any;
+    mimeType: any;
+};
+/**
+ * @param data
+ * @todo Duplicate of core
+ */
+export declare function toArrayBuffer(data: any): any;
+//# sourceMappingURL=decode-data-uri.node.d.ts.map

package/dist/node/fetch/utils/decode-data-uri.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode-data-uri.node.d.ts","sourceRoot":"","sources":["../../../../src/node/fetch/utils/decode-data-uri.node.ts"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,KAAA;;;EAoBhC;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,KAAA,OA4BjC"}

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

@@ -1,57 +1,63 @@
-import { assert } from '../../../utils/assert';
-
-const isArrayBuffer = x => x && x instanceof ArrayBuffer;
-
-const isBuffer = x => x && x instanceof Buffer;
-
-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
-  };
+"use strict";
+// Based on binary-gltf-utils under MIT license: Copyright (c) 2016-17 Karl Cheng
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toArrayBuffer = exports.decodeDataUri = void 0;
+const assert_1 = require("../../../utils/assert");
+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 }
+ */
+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 };
 }
-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();
-  }
-
-  return assert(false, `toArrayBuffer(${JSON.stringify(data, null, 2).slice(10)})`);
+exports.decodeDataUri = decodeDataUri;
+/**
+ * @param data
+ * @todo Duplicate of core
+ */
+function toArrayBuffer(data) {
+    if (isArrayBuffer(data)) {
+        return data;
+    }
+    // TODO - per docs we should just be able to call buffer.buffer, but there are issues
+    if (isBuffer(data)) {
+        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
+    if (data && typeof data === 'object' && data._toArrayBuffer) {
+        return data._toArrayBuffer();
+    }
+    return (0, assert_1.assert)(false, `toArrayBuffer(${JSON.stringify(data, null, 2).slice(10)})`);
 }
-//# sourceMappingURL=decode-data-uri.node.js.map
+exports.toArrayBuffer = toArrayBuffer;

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

@@ -0,0 +1,4 @@
+export declare function createReadStream(url: any, options: any): Promise<unknown>;
+export declare function decompressReadStream(readStream: any, headers: any): any;
+export declare function concatenateReadStream(readStream: any): Promise<unknown>;
+//# sourceMappingURL=stream-utils.node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stream-utils.node.d.ts","sourceRoot":"","sources":["../../../../src/node/fetch/utils/stream-utils.node.ts"],"names":[],"mappings":"AAUA,wBAAsB,gBAAgB,CAAC,GAAG,KAAA,EAAE,OAAO,KAAA,oBAsBlD;AAED,wBAAgB,oBAAoB,CAAC,UAAU,KAAA,EAAE,OAAO,KAAA,OAYvD;AAED,wBAAsB,qBAAqB,CAAC,UAAU,KAAA,oBAoBrD"}

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

@@ -1,89 +1,98 @@
-import fs from 'fs';
-import http from 'http';
-import https from 'https';
-import zlib from 'zlib';
-import { toArrayBuffer } from './decode-data-uri.node';
-
-const isRequestURL = url => url.startsWith('http:') || url.startsWith('https:');
-
-export async function createReadStream(url, options) {
-  if (!isRequestURL(url)) {
-    const noqueryUrl = url.split('?')[0];
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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"));
+const zlib_1 = __importDefault(require("zlib"));
+const decode_data_uri_node_1 = require("./decode-data-uri.node");
+const isRequestURL = (url) => 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 stream = fs.createReadStream(noqueryUrl, {
-        encoding: null
-      });
-      stream.once('readable', () => resolve(stream));
-      stream.on('error', error => reject(error));
+        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();
     });
-  }
-
-  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':
-      return readStream.pipe(zlib.createBrotliDecompress());
-
-    case 'gzip':
-      return readStream.pipe(zlib.createGunzip());
-
-    case 'deflate':
-      return readStream.pipe(zlib.createDeflate());
-
-    default:
-      return readStream;
-  }
+exports.createReadStream = createReadStream;
+function decompressReadStream(readStream, headers) {
+    switch (headers.get('content-encoding')) {
+        case 'br':
+            return readStream.pipe(zlib_1.default.createBrotliDecompress());
+        case 'gzip':
+            return readStream.pipe(zlib_1.default.createGunzip());
+        case 'deflate':
+            return readStream.pipe(zlib_1.default.createDeflate());
+        default:
+            // No compression or an unknown one, just return it as is
+            return readStream;
+    }
 }
-export async function concatenateReadStream(readStream) {
-  let arrayBuffer = new ArrayBuffer(0);
-  return await new Promise((resolve, reject) => {
-    readStream.on('error', error => reject(error));
-    readStream.on('readable', () => readStream.read());
-    readStream.on('data', chunk => {
-      if (typeof chunk === 'string') {
-        reject(new Error('Read stream not binary'));
-      }
-
-      const chunkAsArrayBuffer = toArrayBuffer(chunk);
-      arrayBuffer = concatenateArrayBuffers(arrayBuffer, chunkAsArrayBuffer);
+exports.decompressReadStream = decompressReadStream;
+async function concatenateReadStream(readStream) {
+    let arrayBuffer = new ArrayBuffer(0);
+    return await new Promise((resolve, reject) => {
+        readStream.on('error', (error) => reject(error));
+        // Once the readable callback has been added, stream switches to "flowing mode"
+        // In Node 10 (but not 12 and 14) this causes `data` and `end` to never be called unless we read data here
+        readStream.on('readable', () => readStream.read());
+        readStream.on('data', (chunk) => {
+            if (typeof chunk === 'string') {
+                reject(new Error('Read stream not binary'));
+            }
+            const chunkAsArrayBuffer = (0, decode_data_uri_node_1.toArrayBuffer)(chunk);
+            arrayBuffer = concatenateArrayBuffers(arrayBuffer, chunkAsArrayBuffer);
+        });
+        readStream.on('end', () => resolve(arrayBuffer));
     });
-    readStream.on('end', () => resolve(arrayBuffer));
-  });
 }
-
+exports.concatenateReadStream = concatenateReadStream;
+// HELPERS
 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
-  };
+    // 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
+    };
 }
-
 function concatenateArrayBuffers(source1, source2) {
-  const sourceArray1 = source1 instanceof ArrayBuffer ? new Uint8Array(source1) : source1;
-  const sourceArray2 = source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2;
-  const temp = new Uint8Array(sourceArray1.byteLength + sourceArray2.byteLength);
-  temp.set(sourceArray1, 0);
-  temp.set(sourceArray2, sourceArray1.byteLength);
-  return temp.buffer;
+    const sourceArray1 = source1 instanceof ArrayBuffer ? new Uint8Array(source1) : source1;
+    const sourceArray2 = source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2;
+    const temp = new Uint8Array(sourceArray1.byteLength + sourceArray2.byteLength);
+    temp.set(sourceArray1, 0);
+    temp.set(sourceArray2, sourceArray1.byteLength);
+    return temp.buffer;
 }
-//# sourceMappingURL=stream-utils.node.js.map

package/dist/node/file/blob-stream-controller.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Forked from @gozala's web-blob under MIT license
+ * @see https://github.com/Gozala/web-blob
+ */
+export declare class BlobStreamController {
+    private chunks;
+    private isWorking;
+    private isCancelled;
+    /**
+     * @param chunks
+     */
+    constructor(chunks: Iterator<Uint8Array>);
+    /**
+     * @param controller
+     */
+    start(controller: ReadableStreamDefaultController): void;
+    /**
+     *
+     * @param controller
+     */
+    work(controller: ReadableStreamDefaultController): Promise<void>;
+    /**
+     *
+     * @param {ReadableStreamDefaultController} controller
+     */
+    pull(controller: any): void;
+    cancel(): void;
+}
+//# sourceMappingURL=blob-stream-controller.d.ts.map

package/dist/node/file/blob-stream-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blob-stream-controller.d.ts","sourceRoot":"","sources":["../../../src/node/file/blob-stream-controller.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,WAAW,CAAkB;IAErC;;OAEG;gBACS,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC;IAIxC;;OAEG;IACH,KAAK,CAAC,UAAU,EAAE,+BAA+B;IAIjD;;;OAGG;IACG,IAAI,CAAC,UAAU,EAAE,+BAA+B;IAyBtD;;;OAGG;IACH,IAAI,CAAC,UAAU,KAAA;IAKf,MAAM;CAGP"}

package/dist/node/file/blob-stream-controller.js

@@ -1,56 +1,63 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-export class BlobStreamController {
-  constructor(chunks) {
-    _defineProperty(this, "chunks", void 0);
-
-    _defineProperty(this, "isWorking", false);
-
-    _defineProperty(this, "isCancelled", false);
-
-    this.chunks = chunks;
-  }
-
-  start(controller) {
-    this.work(controller);
-  }
-
-  async work(controller) {
-    const {
-      chunks
-    } = this;
-    this.isWorking = true;
-
-    while (!this.isCancelled && (controller.desiredSize || 0) > 0) {
-      let next;
-
-      try {
-        next = chunks.next();
-      } catch (error) {
-        controller.error(error);
-        break;
-      }
-
-      if (next) {
-        if (!next.done && !this.isCancelled) {
-          controller.enqueue(next.value);
-        } else {
-          controller.close();
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlobStreamController = void 0;
+/**
+ * Forked from @gozala's web-blob under MIT license
+ * @see https://github.com/Gozala/web-blob
+ */
+class BlobStreamController {
+    /**
+     * @param chunks
+     */
+    constructor(chunks) {
+        this.isWorking = false;
+        this.isCancelled = false;
+        this.chunks = chunks;
+    }
+    /**
+     * @param controller
+     */
+    start(controller) {
+        this.work(controller); // eslint-disable-line @typescript-eslint/no-floating-promises
+    }
+    /**
+     *
+     * @param controller
+     */
+    async work(controller) {
+        const { chunks } = this;
+        this.isWorking = true;
+        while (!this.isCancelled && (controller.desiredSize || 0) > 0) {
+            let next;
+            try {
+                next = chunks.next();
+            }
+            catch (error) {
+                controller.error(error);
+                break;
+            }
+            if (next) {
+                if (!next.done && !this.isCancelled) {
+                    controller.enqueue(next.value);
+                }
+                else {
+                    controller.close();
+                }
+            }
+        }
+        this.isWorking = false;
+    }
+    /**
+     *
+     * @param {ReadableStreamDefaultController} controller
+     */
+    pull(controller) {
+        if (!this.isWorking) {
+            this.work(controller); // eslint-disable-line @typescript-eslint/no-floating-promises
         }
-      }
     }
-
-    this.isWorking = false;
-  }
-
-  pull(controller) {
-    if (!this.isWorking) {
-      this.work(controller);
+    cancel() {
+        this.isCancelled = true;
     }
-  }
-
-  cancel() {
-    this.isCancelled = true;
-  }
-
 }
-//# sourceMappingURL=blob-stream-controller.js.map
+exports.BlobStreamController = BlobStreamController;