@loaders.gl/polyfills 4.0.0-alpha.4 → 4.0.0-alpha.6

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

@@ -0,0 +1,22 @@
+import { Headers } from './headers.node';
+export declare class Response {
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly headers: Headers;
+    readonly url: string;
+    bodyUsed: boolean;
+    private readonly _body;
+    constructor(body: any, options: {
+        headers?: any;
+        status?: number;
+        statusText?: string;
+        url: string;
+    });
+    get body(): any;
+    arrayBuffer(): Promise<any>;
+    text(): Promise<string>;
+    json(): Promise<any>;
+    blob(): Promise<Blob>;
+}
+//# sourceMappingURL=response.node.d.ts.map

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

@@ -0,0 +1 @@
+{"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,88 +1,76 @@
-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";
+// 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 = 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.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);
+        }
+        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.Response = 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: string): {
+    arrayBuffer: ArrayBuffer;
+    mimeType: string;
+};
+/**
+ * @param data
+ * @todo Duplicate of core
+ */
+export declare function toArrayBuffer(data: unknown): ArrayBuffer;
+//# 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":"AAKA;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG;IAAC,WAAW,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAoBvF;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,WAAW,CA+BxD"}

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

@@ -1,57 +1,65 @@
-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".concat(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 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(".concat(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)) {
+        // @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.node.js.map
+exports.toArrayBuffer = toArrayBuffer;

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

@@ -0,0 +1,17 @@
+/**
+ *
+ */
+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
+ * @return A concatenated ArrayBuffer
+ * @note duplicates loader-utils since polyfills should be independent
+ */
+export declare function concatenateArrayBuffers(sources: (ArrayBuffer | Uint8Array)[]): ArrayBuffer;
+//# 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":"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,89 +1,73 @@
-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];
-    return await new Promise((resolve, reject) => {
-      const stream = fs.createReadStream(noqueryUrl, {
-        encoding: null
-      });
-      stream.once('readable', () => resolve(stream));
-      stream.on('error', error => reject(error));
-    });
-  }
-
-  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;
-  }
+"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 = void 0;
+const zlib_1 = __importDefault(require("zlib"));
+const decode_data_uri_node_1 = require("./decode-data-uri.node");
+/**
+ *
+ */
+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;
+/**
+ *
+ * @param readStream
+ * @returns
+ */
+async function concatenateReadStream(readStream) {
+    const arrayBufferChunks = [];
+    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'));
+            }
+            arrayBufferChunks.push((0, decode_data_uri_node_1.toArrayBuffer)(chunk));
+        });
+        readStream.on('end', () => {
+            const arrayBuffer = concatenateArrayBuffers(arrayBufferChunks);
+            resolve(arrayBuffer);
+        });
     });
-    readStream.on('end', () => resolve(arrayBuffer));
-  });
-}
-
-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
-  };
 }
-
-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;
+exports.concatenateReadStream = concatenateReadStream;
+/**
+ * Concatenate a sequence of ArrayBuffers
+ * @return A concatenated ArrayBuffer
+ * @note duplicates loader-utils since polyfills should be independent
+ */
+function concatenateArrayBuffers(sources) {
+    // Make sure all inputs are wrapped in typed arrays
+    const sourceArrays = sources.map((source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2);
+    // Get length of all inputs
+    const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);
+    // Allocate array with space for all inputs
+    const result = new Uint8Array(byteLength);
+    // Copy the subarrays
+    let offset = 0;
+    for (const sourceArray of sourceArrays) {
+        result.set(sourceArray, offset);
+        offset += sourceArray.byteLength;
+    }
+    // We work with ArrayBuffers, discard the typed array wrapper
+    return result.buffer;
 }
-//# sourceMappingURL=stream-utils.node.js.map
+exports.concatenateArrayBuffers = concatenateArrayBuffers;

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"}