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

package/dist/node/buffer/btoa.node.d.ts

@@ -0,0 +1,3 @@
+export declare function atob(string: any): string;
+export declare function btoa(base64: any): string;
+//# sourceMappingURL=btoa.node.d.ts.map

package/dist/node/buffer/btoa.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"btoa.node.d.ts","sourceRoot":"","sources":["../../../src/node/buffer/btoa.node.ts"],"names":[],"mappings":"AAIA,wBAAgB,IAAI,CAAC,MAAM,KAAA,UAE1B;AAED,wBAAgB,IAAI,CAAC,MAAM,KAAA,UAE1B"}

package/dist/node/buffer/btoa.node.js

@@ -1,7 +1,14 @@
-export function atob(string) {
-  return Buffer.from(string).toString('base64');
+"use strict";
+// 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
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.btoa = exports.atob = void 0;
+function atob(string) {
+    return Buffer.from(string).toString('base64');
 }
-export function btoa(base64) {
-  return Buffer.from(base64, 'base64').toString('ascii');
+exports.atob = atob;
+function btoa(base64) {
+    return Buffer.from(base64, 'base64').toString('ascii');
 }
-//# sourceMappingURL=btoa.node.js.map
+exports.btoa = btoa;

package/dist/node/buffer/to-array-buffer.node.d.ts

@@ -0,0 +1,2 @@
+export declare function bufferToArrayBuffer(buffer: any): any;
+//# sourceMappingURL=to-array-buffer.node.d.ts.map

package/dist/node/buffer/to-array-buffer.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-array-buffer.node.d.ts","sourceRoot":"","sources":["../../../src/node/buffer/to-array-buffer.node.ts"],"names":[],"mappings":"AAAA,wBAAgB,mBAAmB,CAAC,MAAM,KAAA,OAOzC"}

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

@@ -1,9 +1,12 @@
-export function bufferToArrayBuffer(buffer) {
-  if (Buffer.isBuffer(buffer)) {
-    const typedArray = new Uint8Array(buffer);
-    return typedArray.buffer;
-  }
-
-  return buffer;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bufferToArrayBuffer = void 0;
+function bufferToArrayBuffer(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
+exports.bufferToArrayBuffer = bufferToArrayBuffer;

package/dist/node/fetch/fetch-file.node.d.ts

@@ -0,0 +1,4 @@
+import { Response } from './response.node';
+export declare function isRequestURL(url: string): boolean;
+export declare function fetchFileNode(url: string, options: any): Promise<Response>;
+//# sourceMappingURL=fetch-file.node.d.ts.map

package/dist/node/fetch/fetch-file.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-file.node.d.ts","sourceRoot":"","sources":["../../../src/node/fetch/fetch-file.node.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,QAAQ,EAAC,MAAM,iBAAiB,CAAC;AAGzC,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEjD;AAED,wBAAsB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,KAAA,GAAG,OAAO,CAAC,QAAQ,CAAC,CAsB3E"}

package/dist/node/fetch/fetch-file.node.js

@@ -0,0 +1,51 @@
+"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.fetchFileNode = exports.isRequestURL = void 0;
+const fs_1 = __importDefault(require("fs")); // `fs` will be empty object in browsers (see package.json "browser" field).
+const response_node_1 = require("./response.node");
+const headers_node_1 = require("./headers.node");
+function isRequestURL(url) {
+    return url.startsWith('http:') || url.startsWith('https:');
+}
+exports.isRequestURL = isRequestURL;
+async function fetchFileNode(url, options) {
+    const noqueryUrl = url.split('?')[0];
+    try {
+        // Now open the stream
+        const body = 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));
+        });
+        const status = 200;
+        const statusText = 'OK';
+        const headers = getHeadersForFile(noqueryUrl);
+        return new response_node_1.Response(body, { headers, status, statusText, url });
+    }
+    catch (error) {
+        const status = 400;
+        const statusText = error.message;
+        const headers = {};
+        return new response_node_1.Response(error.message, { headers, status, statusText, url });
+    }
+}
+exports.fetchFileNode = fetchFileNode;
+function getHeadersForFile(noqueryUrl) {
+    const headers = {};
+    // Fix up content length if we can for best progress experience
+    if (!headers['content-length']) {
+        const stats = fs_1.default.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_node_1.Headers(headers);
+}

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

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import http from 'http';
+import { Response } from './response.node';
+/**
+ * Emulation of Browser fetch for Node.js
+ * @param url
+ * @param options
+ */
+export declare function fetchNode(url: string, options: any): Promise<Response>;
+/** Returns a promise that resolves to a readable stream */
+export declare function createHTTPRequestReadStream(url: string, options: any): Promise<http.IncomingMessage>;
+//# sourceMappingURL=fetch.node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.node.d.ts","sourceRoot":"","sources":["../../../src/node/fetch/fetch.node.ts"],"names":[],"mappings":";AAEA,OAAO,IAAI,MAAM,MAAM,CAAC;AAExB,OAAO,EAAC,QAAQ,EAAC,MAAM,iBAAiB,CAAC;AASzC;;;;GAIG;AAEH,wBAAsB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,KAAA,GAAG,OAAO,CAAC,QAAQ,CAAC,CA6CvE;AAED,2DAA2D;AAC3D,wBAAsB,2BAA2B,CAC/C,GAAG,EAAE,MAAM,EACX,OAAO,KAAA,GACN,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,CAW/B"}

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

@@ -1,126 +1,143 @@
-import fs from 'fs';
-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:');
-
-export default async function fetchNode(url, options) {
-  try {
-    if (isDataURL(url)) {
-      const {
-        arrayBuffer,
-        mimeType
-      } = decodeDataUri(url);
-      const response = new Response(arrayBuffer, {
-        headers: {
-          'content-type': mimeType
-        },
-        url
-      });
-      return response;
+"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.createHTTPRequestReadStream = exports.fetchNode = void 0;
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const response_node_1 = require("./response.node");
+const headers_node_1 = require("./headers.node");
+const decode_data_uri_node_1 = require("./utils/decode-data-uri.node");
+const fetch_file_node_1 = require("./fetch-file.node");
+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
+async function fetchNode(url, options) {
+    try {
+        // Handle file streams in node
+        if (!isRequestURL(url) && !isDataURL(url)) {
+            return await (0, fetch_file_node_1.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)) {
+            const { arrayBuffer, mimeType } = (0, decode_data_uri_node_1.decodeDataUri)(url);
+            const response = new response_node_1.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 = !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_node_1.Response(body, { headers, status, statusText, url });
     }
-
-    const syntheticResponseHeaders = {};
-    const originalUrl = url;
-
-    if (url.endsWith('.gz')) {
-      url = url.slice(0, -3);
-      syntheticResponseHeaders['content-encoding'] = 'gzip';
+    catch (error) {
+        // TODO - what error code to use here?
+        return new response_node_1.Response(null, { status: 400, statusText: String(error), url });
     }
-
-    const body = await createReadStream(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
+}
+exports.fetchNode = fetchNode;
+/** Returns a promise that resolves to a readable stream */
+async function createHTTPRequestReadStream(url, options) {
+    // 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_1.default.request(requestOptions, (res) => resolve(res))
+            : http_1.default.request(requestOptions, (res) => resolve(res));
+        req.on('error', (error) => reject(error));
+        req.end();
     });
-  }
 }
-
+exports.createHTTPRequestReadStream = createHTTPRequestReadStream;
+/**
+ * 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;
 }
-
-function getStatus(httpResponse) {
-  if (httpResponse.statusCode) {
+// HELPER FUNCTIONS
+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 {
-      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 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);
+    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_node_1.Headers(headers);
 }
-
+/** Needs to be read from actual headers */
 function getContentLength(url) {
-  if (isRequestURL(url)) {
-    return null;
-  } else if (isDataURL(url)) {
-    return url.length - 'data:'.length;
-  }
-
-  try {
-    const noqueryUrl = url.split('?')[0];
-    const stats = fs.statSync(noqueryUrl);
-    return stats.size;
-  } catch (error) {}
-
-  return null;
+    // TODO - remove media type etc
+    return isDataURL(url) ? url.length - 'data:'.length : null;
 }
-//# sourceMappingURL=fetch.node.js.map

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

@@ -0,0 +1,34 @@
+/**
+ * Polyfill for Browser Headers
+ * Based on https://github.com/github/fetch under MIT license
+ */
+export declare class Headers {
+    map: {};
+    constructor(headers: any);
+    append(name: any, value: any): void;
+    delete(name: any): void;
+    get(name: any): any;
+    has(name: any): boolean;
+    set(name: any, value: any): void;
+    forEach(visitor: any, thisArg?: null): void;
+    keys(): {
+        next(): {
+            done: boolean;
+            value: any;
+        };
+    };
+    values(): {
+        next(): {
+            done: boolean;
+            value: any;
+        };
+    };
+    entries(): {
+        next(): {
+            done: boolean;
+            value: any;
+        };
+    };
+    [Symbol.iterator](): Generator<any, void, unknown>;
+}
+//# sourceMappingURL=headers.node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"headers.node.d.ts","sourceRoot":"","sources":["../../../src/node/fetch/headers.node.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,OAAO;IAClB,GAAG,EAAE,EAAE,CAAC;gBAEI,OAAO,KAAA;IAYnB,MAAM,CAAC,IAAI,KAAA,EAAE,KAAK,KAAA;IAOlB,MAAM,CAAC,IAAI,KAAA;IAIX,GAAG,CAAC,IAAI,KAAA;IAKR,GAAG,CAAC,IAAI,KAAA;IAIR,GAAG,CAAC,IAAI,KAAA,EAAE,KAAK,KAAA;IAIf,OAAO,CAAC,OAAO,KAAA,EAAE,OAAO,OAAO;IAY/B,IAAI;;;;;;IAQJ,MAAM;;;;;;IAQN,OAAO;;;;;;IAQN,CAAC,MAAM,CAAC,QAAQ,CAAC;CAInB"}

package/dist/node/fetch/headers.node.js

@@ -1,125 +1,106 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-
-let _Symbol$iterator;
-
-_Symbol$iterator = Symbol.iterator;
-export default class Headers {
-  constructor(headers) {
-    _defineProperty(this, "map", void 0);
-
-    this.map = {};
-
-    if (headers instanceof Headers) {
-      headers.forEach((value, name) => this.append(name, value));
-    } else if (Array.isArray(headers)) {
-      headers.forEach(header => this.append(header[0], header[1]));
-    } else if (headers) {
-      Object.getOwnPropertyNames(headers).forEach(name => this.append(name, headers[name]));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Headers = void 0;
+/**
+ * Polyfill for Browser Headers
+ * Based on https://github.com/github/fetch under MIT license
+ */
+class Headers {
+    constructor(headers) {
+        this.map = {};
+        if (headers instanceof Headers) {
+            headers.forEach((value, name) => this.append(name, value));
+        }
+        else if (Array.isArray(headers)) {
+            headers.forEach((header) => this.append(header[0], header[1]));
+        }
+        else if (headers) {
+            Object.getOwnPropertyNames(headers).forEach((name) => this.append(name, headers[name]));
+        }
+    }
+    append(name, value) {
+        name = normalizeName(name);
+        value = normalizeValue(value);
+        const oldValue = this.map[name];
+        this.map[name] = oldValue ? `${oldValue}, ${value}` : value;
+    }
+    delete(name) {
+        delete this.map[normalizeName(name)];
     }
-  }
-
-  append(name, value) {
-    name = normalizeName(name);
-    value = normalizeValue(value);
-    const oldValue = this.map[name];
-    this.map[name] = oldValue ? "".concat(oldValue, ", ").concat(value) : value;
-  }
-
-  delete(name) {
-    delete this.map[normalizeName(name)];
-  }
-
-  get(name) {
-    name = normalizeName(name);
-    return this.has(name) ? this.map[name] : null;
-  }
-
-  has(name) {
-    return this.map.hasOwnProperty(normalizeName(name));
-  }
-
-  set(name, value) {
-    this.map[normalizeName(name)] = normalizeValue(value);
-  }
-
-  forEach(visitor, thisArg = null) {
-    for (const name in this.map) {
-      if (this.map.hasOwnProperty(name)) {
-        if (thisArg) {
-          visitor.call(thisArg, this.map[name], name, this);
-        } else {
-          visitor(this.map[name], name, this);
+    get(name) {
+        name = normalizeName(name);
+        return this.has(name) ? this.map[name] : null;
+    }
+    has(name) {
+        return this.map.hasOwnProperty(normalizeName(name));
+    }
+    set(name, value) {
+        this.map[normalizeName(name)] = normalizeValue(value);
+    }
+    forEach(visitor, thisArg = null) {
+        for (const name in this.map) {
+            if (this.map.hasOwnProperty(name)) {
+                if (thisArg) {
+                    visitor.call(thisArg, this.map[name], name, this);
+                }
+                else {
+                    visitor(this.map[name], name, this);
+                }
+            }
         }
-      }
     }
-  }
-
-  keys() {
-    const items = [];
-    this.forEach(function (value, name) {
-      items.push(name);
-    });
-    return iteratorFor(items);
-  }
-
-  values() {
-    const items = [];
-    this.forEach(function (value) {
-      items.push(value);
-    });
-    return iteratorFor(items);
-  }
-
-  entries() {
-    const items = [];
-    this.forEach(function (value, name) {
-      items.push([name, value]);
-    });
-    return iteratorFor(items);
-  }
-
-  *[_Symbol$iterator]() {
-    yield* this.entries();
-  }
-
+    keys() {
+        const items = [];
+        this.forEach(function (value, name) {
+            items.push(name);
+        });
+        return iteratorFor(items);
+    }
+    values() {
+        const items = [];
+        this.forEach(function (value) {
+            items.push(value);
+        });
+        return iteratorFor(items);
+    }
+    entries() {
+        const items = [];
+        this.forEach(function (value, name) {
+            items.push([name, value]);
+        });
+        return iteratorFor(items);
+    }
+    *[Symbol.iterator]() {
+        // @ts-ignore must have a '[Symbol.iterator]()' method that returns an iterator.
+        yield* this.entries();
+    }
 }
-
+exports.Headers = Headers;
 function normalizeName(name) {
-  if (typeof name !== 'string') {
-    name = String(name);
-  }
-
-  if (/[^a-z0-9\-#$%&'*+.^_`|~]/i.test(name) || name === '') {
-    throw new TypeError('Invalid character in header field name');
-  }
-
-  return name.toLowerCase();
+    if (typeof name !== 'string') {
+        name = String(name);
+    }
+    if (/[^a-z0-9\-#$%&'*+.^_`|~]/i.test(name) || name === '') {
+        throw new TypeError('Invalid character in header field name');
+    }
+    return name.toLowerCase();
 }
-
 function normalizeValue(value) {
-  if (typeof value !== 'string') {
-    value = String(value);
-  }
-
-  return value;
+    if (typeof value !== 'string') {
+        value = String(value);
+    }
+    return value;
 }
-
+// Build a destructive iterator for the value list
 function iteratorFor(items) {
-  const iterator = {
-    next() {
-      const value = items.shift();
-      return {
-        done: value === undefined,
-        value
-      };
-    }
-
-  };
-
-  iterator[Symbol.iterator] = function () {
+    const iterator = {
+        next() {
+            const value = items.shift();
+            return { done: value === undefined, value };
+        }
+    };
+    iterator[Symbol.iterator] = function () {
+        return iterator;
+    };
     return iterator;
-  };
-
-  return iterator;
 }
-//# sourceMappingURL=headers.node.js.map