@loaders.gl/polyfills 4.0.0-alpha.23 → 4.0.0-alpha.25

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

@@ -1,14 +0,0 @@
-"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');
-}
-exports.atob = atob;
-function btoa(base64) {
-    return Buffer.from(base64, 'base64').toString('ascii');
-}
-exports.btoa = btoa;

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

@@ -1,12 +0,0 @@
-"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;
-}
-exports.bufferToArrayBuffer = bufferToArrayBuffer;

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

@@ -1,146 +0,0 @@
-"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 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
-        // @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 } = (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 = 
-        // @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_node_1.Response(body, { headers, status, statusText, url });
-    }
-    catch (error) {
-        // TODO - what error code to use here?
-        return new response_node_1.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;
-    }
-    // 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) {
-    // 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) {
-    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);
-        }
-    }
-    // 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_node_1.Headers(headers);
-}
-/** Needs to be read from actual headers */
-function getContentLength(url) {
-    // TODO - remove media type etc
-    return isDataURL(url) ? url.length - 'data:'.length : null;
-}

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

@@ -1,106 +0,0 @@
-"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)];
-    }
-    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]() {
-        // @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();
-}
-function normalizeValue(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 () {
-        return iterator;
-    };
-    return iterator;
-}

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

@@ -1,76 +0,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)]);
-        }
-    }
-    // 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;
-    }
-    // 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()]);
-    }
-}
-exports.Response = Response;

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

@@ -1,65 +0,0 @@
-"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 };
-}
-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)})`);
-}
-exports.toArrayBuffer = toArrayBuffer;

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

@@ -1,73 +0,0 @@
-"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;
-    }
-}
-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);
-        });
-    });
-}
-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;
-}
-exports.concatenateArrayBuffers = concatenateArrayBuffers;

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

@@ -1,63 +0,0 @@
-"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
-        }
-    }
-    cancel() {
-        this.isCancelled = true;
-    }
-}
-exports.BlobStreamController = BlobStreamController;

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

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BlobStream = void 0;
-/**
- * Forked from @gozala's web-blob under MIT license
- * @see https://github.com/Gozala/web-blob
- */
-const readable_stream_1 = require("./readable-stream");
-const blob_stream_controller_1 = require("./blob-stream-controller");
-/**
- * Blob stream is a `ReadableStream` extension optimized to have minimal
- * overhead when consumed as `AsyncIterable<Uint8Array>`.
- * extends {ReadableStream<Uint8Array>}
- * implements {AsyncIterable<Uint8Array>}
- */
-// @ts-ignore
-class BlobStream extends readable_stream_1.ReadableStreamPolyfill {
-    /**
-     * @param chunks
-     */
-    constructor(chunks) {
-        // @ts-ignore
-        super(new blob_stream_controller_1.BlobStreamController(chunks.values()), { type: 'bytes' });
-        /** @private */
-        this._chunks = chunks;
-    }
-    /**
-     * @property [_options.preventCancel]
-     */
-    // @ts-ignore
-    async *[Symbol.asyncIterator](_options) {
-        const reader = this.getReader();
-        yield* this._chunks;
-        reader.releaseLock();
-    }
-}
-exports.BlobStream = BlobStream;