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

package/dist/file/blob.js

@@ -1,119 +1,156 @@
-let _Symbol$toStringTag;
+// Forked from @gozala's web-blob under MIT license https://github.com/Gozala/web-blob
 import { BlobStream } from "./blob-stream.js";
-_Symbol$toStringTag = Symbol.toStringTag;
+/**
+ * Forked from @gozala's web-blob under MIT license
+ * @see https://github.com/Gozala/web-blob
+ */
 export class BlobPolyfill {
-  constructor() {
-    let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    this.type = void 0;
-    this.size = void 0;
-    this.parts = void 0;
-    this.parts = [];
-    this.size = 0;
-    for (const part of init) {
-      if (typeof part === 'string') {
-        const bytes = new TextEncoder().encode(part);
-        this.parts.push(bytes);
-        this.size += bytes.byteLength;
-      } else if (part instanceof BlobPolyfill) {
-        this.size += part.size;
-        this.parts.push(...part.parts);
-      } else if (part instanceof ArrayBuffer) {
-        this.parts.push(new Uint8Array(part));
-        this.size += part.byteLength;
-      } else if (part instanceof Uint8Array) {
-        this.parts.push(part);
-        this.size += part.byteLength;
-      } else if (ArrayBuffer.isView(part)) {
-        const {
-          buffer,
-          byteOffset,
-          byteLength
-        } = part;
-        this.parts.push(new Uint8Array(buffer, byteOffset, byteLength));
-        this.size += byteLength;
-      } else {
-        const bytes = new TextEncoder().encode(String(part));
-        this.parts.push(bytes);
-        this.size += bytes.byteLength;
-      }
+    /**
+     * @param [init]
+     * @param [options]
+     */
+    constructor(init = [], options = {}) {
+        this.parts = [];
+        this.size = 0;
+        for (const part of init) {
+            if (typeof part === 'string') {
+                const bytes = new TextEncoder().encode(part);
+                this.parts.push(bytes);
+                this.size += bytes.byteLength;
+            }
+            else if (part instanceof BlobPolyfill) {
+                this.size += part.size;
+                // @ts-ignore - `parts` is marked private so TS will complain about
+                // accessing it.
+                this.parts.push(...part.parts);
+            }
+            else if (part instanceof ArrayBuffer) {
+                this.parts.push(new Uint8Array(part));
+                this.size += part.byteLength;
+            }
+            else if (part instanceof Uint8Array) {
+                this.parts.push(part);
+                this.size += part.byteLength;
+            }
+            else if (ArrayBuffer.isView(part)) {
+                const { buffer, byteOffset, byteLength } = part;
+                this.parts.push(new Uint8Array(buffer, byteOffset, byteLength));
+                this.size += byteLength;
+            }
+            else {
+                const bytes = new TextEncoder().encode(String(part));
+                this.parts.push(bytes);
+                this.size += bytes.byteLength;
+            }
+        }
+        /** @private */
+        this.type = readType(options.type);
+    }
+    /**
+     * Returns a new Blob object containing the data in the specified range of
+     * bytes of the blob on which it's called.
+     * @param start=0 - An index into the Blob indicating the first
+     * byte to include in the new Blob. If you specify a negative value, it's
+     * treated as an offset from the end of the Blob toward the beginning. For
+     * example, `-10` would be the 10th from last byte in the Blob. The default
+     * value is `0`. If you specify a value for start that is larger than the
+     * size of the source Blob, the returned Blob has size 0 and contains no
+     * data.
+     * @param end - An index into the `Blob` indicating the first byte
+     *  that will *not* be included in the new `Blob` (i.e. the byte exactly at
+     * this index is not included). If you specify a negative value, it's treated
+     * as an offset from the end of the Blob toward the beginning. For example,
+     * `-10` would be the 10th from last byte in the `Blob`. The default value is
+     * size.
+     * @param type - The content type to assign to the new Blob;
+     * this will be the value of its type property. The default value is an empty
+     * string.
+     */
+    slice(start = 0, end = this.size, type = '') {
+        const { size, parts: parts } = this;
+        let offset = start < 0 ? Math.max(size + start, 0) : Math.min(start, size);
+        let limit = end < 0 ? Math.max(size + end, 0) : Math.min(end, size);
+        const span = Math.max(limit - offset, 0);
+        const blob = new BlobPolyfill([], { type });
+        if (span === 0) {
+            // @ts-ignore
+            return blob;
+        }
+        let blobSize = 0;
+        const blobParts = [];
+        for (const part of parts) {
+            const { byteLength } = part;
+            if (offset > 0 && byteLength <= offset) {
+                offset -= byteLength;
+                limit -= byteLength;
+            }
+            else {
+                const chunk = part.subarray(offset, Math.min(byteLength, limit));
+                blobParts.push(chunk);
+                blobSize += chunk.byteLength;
+                // no longer need to take that into account
+                offset = 0;
+                // don't add the overflow to new blobParts
+                if (blobSize >= span) {
+                    break;
+                }
+            }
+        }
+        blob.parts = blobParts;
+        blob.size = blobSize;
+        // @ts-ignore
+        return blob;
     }
-    this.type = readType(options.type);
-  }
-  slice() {
-    let start = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-    let end = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.size;
-    let type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
-    const {
-      size,
-      parts: parts
-    } = this;
-    let offset = start < 0 ? Math.max(size + start, 0) : Math.min(start, size);
-    let limit = end < 0 ? Math.max(size + end, 0) : Math.min(end, size);
-    const span = Math.max(limit - offset, 0);
-    const blob = new BlobPolyfill([], {
-      type
-    });
-    if (span === 0) {
-      return blob;
+    /**
+     * Returns a promise that resolves with an ArrayBuffer containing the entire
+     * contents of the Blob as binary data.
+     */
+    // eslint-disable-next-line require-await
+    async arrayBuffer() {
+        return this._toArrayBuffer();
     }
-    let blobSize = 0;
-    const blobParts = [];
-    for (const part of parts) {
-      const {
-        byteLength
-      } = part;
-      if (offset > 0 && byteLength <= offset) {
-        offset -= byteLength;
-        limit -= byteLength;
-      } else {
-        const chunk = part.subarray(offset, Math.min(byteLength, limit));
-        blobParts.push(chunk);
-        blobSize += chunk.byteLength;
-        offset = 0;
-        if (blobSize >= span) {
-          break;
+    /**
+     * Returns a promise that resolves with a USVString containing the entire
+     * contents of the Blob interpreted as UTF-8 text.
+     */
+    // eslint-disable-next-line require-await
+    async text() {
+        const decoder = new TextDecoder();
+        let text = '';
+        for (const part of this.parts) {
+            text += decoder.decode(part);
         }
-      }
+        return text;
     }
-    blob.parts = blobParts;
-    blob.size = blobSize;
-    return blob;
-  }
-  async arrayBuffer() {
-    return this._toArrayBuffer();
-  }
-  async text() {
-    const decoder = new TextDecoder();
-    let text = '';
-    for (const part of this.parts) {
-      text += decoder.decode(part);
+    /**
+     */
+    // @ts-ignore
+    stream() {
+        return new BlobStream(this.parts);
     }
-    return text;
-  }
-  stream() {
-    return new BlobStream(this.parts);
-  }
-  toString() {
-    return '[object Blob]';
-  }
-  get [_Symbol$toStringTag]() {
-    return 'Blob';
-  }
-  _toArrayBuffer() {
-    const buffer = new ArrayBuffer(this.size);
-    const bytes = new Uint8Array(buffer);
-    let offset = 0;
-    for (const part of this.parts) {
-      bytes.set(part, offset);
-      offset += part.byteLength;
+    /**
+     * @returns {string}
+     */
+    toString() {
+        return '[object Blob]';
+    }
+    get [Symbol.toStringTag]() {
+        return 'Blob';
+    }
+    _toArrayBuffer() {
+        const buffer = new ArrayBuffer(this.size);
+        const bytes = new Uint8Array(buffer);
+        let offset = 0;
+        for (const part of this.parts) {
+            bytes.set(part, offset);
+            offset += part.byteLength;
+        }
+        return buffer;
     }
-    return buffer;
-  }
 }
-function readType() {
-  let input = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
-  const type = String(input).toLowerCase();
-  return /[^\u0020-\u007E]/.test(type) ? '' : type;
+/**
+ */
+function readType(input = '') {
+    const type = String(input).toLowerCase();
+    return /[^\u0020-\u007E]/.test(type) ? '' : type;
 }
-//# sourceMappingURL=blob.js.map

package/dist/file/file-reader.js

@@ -1,59 +1,31 @@
 import { atob } from "../buffer/btoa.node.js";
 export class FileReaderPolyfill {
-  constructor() {
-    this.onload = void 0;
-    this.onabort = void 0;
-    this.onerror = void 0;
-    this.error = void 0;
-    this.onloadstart = void 0;
-    this.onloadend = void 0;
-    this.onprogress = void 0;
-    this.readyState = void 0;
-    this.result = void 0;
-    this.DONE = void 0;
-    this.EMPTY = void 0;
-    this.LOADING = void 0;
-    this.addEventListener = void 0;
-    this.removeEventListener = void 0;
-    this.dispatchEvent = void 0;
-    this.onload = null;
-  }
-  abort() {
-    return;
-  }
-  async readAsArrayBuffer(blob) {
-    const arrayBuffer = await blob.arrayBuffer();
-    if (this.onload) {
-      this.onload({
-        target: {
-          result: arrayBuffer
+    constructor() {
+        this.onload = null;
+    }
+    abort() {
+        return;
+    }
+    async readAsArrayBuffer(blob) {
+        const arrayBuffer = await blob.arrayBuffer();
+        if (this.onload) {
+            this.onload({ target: { result: arrayBuffer } });
         }
-      });
     }
-  }
-  async readAsBinaryString(blob) {
-    throw Error('Not implemented');
-  }
-  async readAsDataURL(blob) {
-    const text = await blob.text();
-    const dataUrl = `data://;base64,${atob(text)}`;
-    if (this.onload) {
-      this.onload({
-        target: {
-          result: dataUrl
+    async readAsBinaryString(blob) {
+        throw Error('Not implemented');
+    }
+    async readAsDataURL(blob) {
+        const text = await blob.text();
+        const dataUrl = `data://;base64,${atob(text)}`;
+        if (this.onload) {
+            this.onload({ target: { result: dataUrl } });
         }
-      });
     }
-  }
-  async readAsText(blob) {
-    const text = await blob.text();
-    if (this.onload) {
-      this.onload({
-        target: {
-          result: text
+    async readAsText(blob) {
+        const text = await blob.text();
+        if (this.onload) {
+            this.onload({ target: { result: text } });
         }
-      });
     }
-  }
 }
-//# sourceMappingURL=file-reader.js.map

package/dist/file/file.js

@@ -1,17 +1,32 @@
-let _Symbol$toStringTag;
-_Symbol$toStringTag = Symbol.toStringTag;
+// Forked from @gozala's web-file under MIT license https://github.com/Gozala/web-file
+/**
+ * Forked from @gozala's web-file under MIT license
+ * @see https://github.com/Gozala/web-file
+ */
+// @ts-ignore
 export class FilePolyfill extends globalThis.Blob {
-  constructor(init, name) {
-    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    super(init, options);
-    this.name = '';
-    this.webkitRelativePath = '';
-    this.lastModified = void 0;
-    this.name = String(name).replace(/\//g, ':');
-    this.lastModified = (options === null || options === void 0 ? void 0 : options.lastModified) || Date.now();
-  }
-  get [_Symbol$toStringTag]() {
-    return 'File';
-  }
+    /**
+     * @param init
+     * @param name - A USVString representing the file name or the path
+     * to the file.
+     * @param [options]
+     */
+    constructor(init, name, options = {}) {
+        super(init, options);
+        // implements File {
+        // public API
+        /** The name of the file referenced by the File object. */
+        this.name = '';
+        /** The path the URL of the File is relative to. */
+        this.webkitRelativePath = '';
+        // Per File API spec https://w3c.github.io/FileAPI/#file-constructor
+        // Every "/" character of file name must be replaced with a ":".
+        /** @private */
+        this.name = String(name).replace(/\//g, ':');
+        /** @private */
+        this.lastModified = options?.lastModified || Date.now();
+    }
+    get [Symbol.toStringTag]() {
+        return 'File';
+    }
 }
-//# sourceMappingURL=file.js.map

package/dist/file/install-blob-polyfills.js

@@ -1,9 +1,10 @@
+// import {ReadableStreamPolyfill} from './readable-stream';
 import { BlobPolyfill } from "./blob.js";
 export function instalBlobPolyfills() {
-  if (typeof Blob === 'undefined' && !globalThis.Blob) {
-    globalThis.Blob = BlobPolyfill;
-  }
-  return globalThis.Blob;
+    if (typeof Blob === 'undefined' && !globalThis.Blob) {
+        // @ts-ignore;
+        globalThis.Blob = BlobPolyfill;
+    }
+    return globalThis.Blob;
 }
 export const Blob_ = instalBlobPolyfills();
-//# sourceMappingURL=install-blob-polyfills.js.map

package/dist/file/install-file-polyfills.js

@@ -1,13 +1,16 @@
+// import {ReadableStreamPolyfill} from './readable-stream';
 import { FileReaderPolyfill } from "./file-reader.js";
 import { FilePolyfill } from "./file.js";
 export function installFilePolyfills() {
-  if (typeof FileReader === 'undefined' && !globalThis.FileReader) {
-    globalThis.FileReader = FileReaderPolyfill;
-  }
-  if (typeof File === 'undefined' && !globalThis.File) {
-    globalThis.File = FilePolyfill;
-  }
-  return global;
+    if (typeof FileReader === 'undefined' && !globalThis.FileReader) {
+        // @ts-ignore;
+        globalThis.FileReader = FileReaderPolyfill;
+    }
+    // Install minimal Node.js File polyfill
+    if (typeof File === 'undefined' && !globalThis.File) {
+        // @ts-ignore;
+        globalThis.File = FilePolyfill;
+    }
+    return global;
 }
 export const File_ = installFilePolyfills();
-//# sourceMappingURL=install-file-polyfills.js.map

package/dist/file/readable-stream.js

@@ -1,4 +1,7 @@
 import { ReadableStream as WSPReadableStream } from 'web-streams-polyfill';
+// Want a polyfill, but please don't install it
+// @ts-ignore
 delete globalThis.ReadableStream;
-export class ReadableStreamPolyfill extends WSPReadableStream {}
-//# sourceMappingURL=readable-stream.js.map
+// @ts-ignore
+export class ReadableStreamPolyfill extends WSPReadableStream {
+}

package/dist/filesystems/fetch-node.js

@@ -1,77 +1,87 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import fs from 'fs';
 import { Readable } from 'stream';
 import { resolvePath } from '@loaders.gl/loader-utils';
 import { decompressReadStream } from "./stream-utils.node.js";
-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);
+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);
+/**
+ * Enables
+ * @param url
+ * @param options
+ * @returns
+ */
+// eslint-disable-next-line max-statements
 export async function fetchNode(url, options) {
-  const FILE_PROTOCOL_REGEX = /^file:\/\//;
-  url.replace(FILE_PROTOCOL_REGEX, '/');
-  let noqueryUrl = url.split('?')[0];
-  noqueryUrl = resolvePath(noqueryUrl);
-  const responseHeaders = new Headers();
-  if (url.endsWith('.gz')) {
-    responseHeaders['content-encoding'] = 'gzip';
-  }
-  if (url.endsWith('.br')) {
-    responseHeaders['content-encoding'] = 'br';
-  }
-  try {
-    const body = await new Promise((resolve, reject) => {
-      const stream = fs.createReadStream(noqueryUrl, {
-        encoding: null
-      });
-      stream.once('readable', () => resolve(stream));
-      stream.on('error', error => reject(error));
-    });
-    let bodyStream = body;
-    if (isReadableNodeStream(body)) {
-      bodyStream = decompressReadStream(body, responseHeaders);
-    } else if (typeof body === 'string') {
-      bodyStream = Readable.from([new TextEncoder().encode(body)]);
-    } else {
-      bodyStream = Readable.from([body || new ArrayBuffer(0)]);
+    // Support `file://` protocol
+    const FILE_PROTOCOL_REGEX = /^file:\/\//;
+    url.replace(FILE_PROTOCOL_REGEX, '/');
+    // Remove any query parameters, as they have no meaning
+    let noqueryUrl = url.split('?')[0];
+    noqueryUrl = resolvePath(noqueryUrl);
+    const responseHeaders = new Headers();
+    // Automatically decompress gzipped files with .gz extension
+    if (url.endsWith('.gz')) {
+        // url = url.slice(0, -3);
+        responseHeaders['content-encoding'] = 'gzip';
+    }
+    if (url.endsWith('.br')) {
+        // url = url.slice(0, -3);
+        responseHeaders['content-encoding'] = 'br';
+    }
+    try {
+        // Now open the stream
+        const body = await new Promise((resolve, reject) => {
+            // @ts-ignore
+            const stream = fs.createReadStream(noqueryUrl, { encoding: null });
+            stream.once('readable', () => resolve(stream));
+            stream.on('error', (error) => reject(error));
+        });
+        let bodyStream = body;
+        // Check for content-encoding and create a decompression stream
+        if (isReadableNodeStream(body)) {
+            bodyStream = decompressReadStream(body, responseHeaders);
+        }
+        else if (typeof body === 'string') {
+            bodyStream = Readable.from([new TextEncoder().encode(body)]);
+        }
+        else {
+            bodyStream = Readable.from([body || new ArrayBuffer(0)]);
+        }
+        const status = 200;
+        const statusText = 'OK';
+        const headers = getHeadersForFile(noqueryUrl);
+        // @ts-expect-error
+        const response = new Response(bodyStream, { headers, status, statusText });
+        Object.defineProperty(response, 'url', { value: url });
+        return response;
+    }
+    catch (error) {
+        // console.error(error);
+        const errorMessage = error.message;
+        const status = 400;
+        const statusText = errorMessage;
+        const headers = {};
+        const response = new Response(errorMessage, { headers, status, statusText });
+        Object.defineProperty(response, 'url', { value: url });
+        return response;
     }
-    const status = 200;
-    const statusText = 'OK';
-    const headers = getHeadersForFile(noqueryUrl);
-    const response = new Response(bodyStream, {
-      headers,
-      status,
-      statusText
-    });
-    Object.defineProperty(response, 'url', {
-      value: url
-    });
-    return response;
-  } catch (error) {
-    const errorMessage = error.message;
-    const status = 400;
-    const statusText = errorMessage;
-    const headers = {};
-    const response = new Response(errorMessage, {
-      headers,
-      status,
-      statusText
-    });
-    Object.defineProperty(response, 'url', {
-      value: url
-    });
-    return response;
-  }
 }
 function getHeadersForFile(noqueryUrl) {
-  const headers = {};
-  if (!headers['content-length']) {
-    const stats = fs.statSync(noqueryUrl);
-    headers['content-length'] = stats.size;
-  }
-  if (noqueryUrl.endsWith('.gz')) {
-    noqueryUrl = noqueryUrl.slice(0, -3);
-    headers['content-encoding'] = 'gzip';
-  }
-  return new Headers(headers);
+    const headers = {};
+    // Fix up content length if we can for best progress experience
+    if (!headers['content-length']) {
+        const stats = fs.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(headers);
 }
-//# sourceMappingURL=fetch-node.js.map