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

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;

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

@@ -0,0 +1,25 @@
+/**
+ * Forked from @gozala's web-blob under MIT license
+ * @see https://github.com/Gozala/web-blob
+ */
+import { ReadableStreamPolyfill } from './readable-stream';
+/**
+ * Blob stream is a `ReadableStream` extension optimized to have minimal
+ * overhead when consumed as `AsyncIterable<Uint8Array>`.
+ * extends {ReadableStream<Uint8Array>}
+ * implements {AsyncIterable<Uint8Array>}
+ */
+export declare class BlobStream<T> extends ReadableStreamPolyfill<T> {
+    private readonly _chunks;
+    /**
+     * @param chunks
+     */
+    constructor(chunks: any);
+    /**
+     * @property [_options.preventCancel]
+     */
+    [Symbol.asyncIterator](_options?: {
+        preventCancel?: boolean;
+    }): AsyncIterable<Uint8Array>;
+}
+//# sourceMappingURL=blob-stream.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blob-stream.d.ts","sourceRoot":"","sources":["../../../src/node/file/blob-stream.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAC,sBAAsB,EAAC,MAAM,mBAAmB,CAAC;AAGzD;;;;;GAKG;AAEH,qBAAa,UAAU,CAAC,CAAC,CAAE,SAAQ,sBAAsB,CAAC,CAAC,CAAC;IAC1D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IACvC;;OAEG;gBACS,MAAM,KAAA;IAOlB;;OAEG;IAEI,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,QAAQ,CAAC,EAAE;QAAC,aAAa,CAAC,EAAE,OAAO,CAAA;KAAC,GAAG,aAAa,CAAC,UAAU,CAAC;CAK/F"}

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

@@ -1,26 +1,37 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-
-let _Symbol$asyncIterator;
-
-import { ReadableStreamPolyfill } from './readable-stream';
-import { BlobStreamController } from './blob-stream-controller';
-_Symbol$asyncIterator = Symbol.asyncIterator;
-export class BlobStream extends ReadableStreamPolyfill {
-  constructor(chunks) {
-    super(new BlobStreamController(chunks.values()), {
-      type: 'bytes'
-    });
-
-    _defineProperty(this, "_chunks", void 0);
-
-    this._chunks = chunks;
-  }
-
-  async *[_Symbol$asyncIterator](_options) {
-    const reader = this.getReader();
-    yield* this._chunks;
-    reader.releaseLock();
-  }
-
+"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();
+    }
 }
-//# sourceMappingURL=blob-stream.js.map
+exports.BlobStream = BlobStream;

package/dist/node/file/blob.d.ts

@@ -0,0 +1,58 @@
+import { BlobStream } from './blob-stream';
+/**
+ * Forked from @gozala's web-blob under MIT license
+ * @see https://github.com/Gozala/web-blob
+ */
+export declare class BlobPolyfill {
+    /** The MIME type of the data contained in the Blob. If type is unknown, string is empty. */
+    readonly type: string;
+    /** The size, in bytes, of the data contained in the Blob object. */
+    size: number;
+    private parts;
+    /**
+     * @param [init]
+     * @param [options]
+     */
+    constructor(init?: BlobPart[], options?: BlobPropertyBag);
+    /**
+     * 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?: number, end?: number, type?: string): Blob;
+    /**
+     * Returns a promise that resolves with an ArrayBuffer containing the entire
+     * contents of the Blob as binary data.
+     */
+    arrayBuffer(): Promise<ArrayBuffer>;
+    /**
+     * Returns a promise that resolves with a USVString containing the entire
+     * contents of the Blob interpreted as UTF-8 text.
+     */
+    text(): Promise<string>;
+    /**
+     */
+    stream(): BlobStream<any>;
+    /**
+     * @returns {string}
+     */
+    toString(): string;
+    get [Symbol.toStringTag](): string;
+    _toArrayBuffer(): ArrayBuffer;
+}
+//# sourceMappingURL=blob.d.ts.map

package/dist/node/file/blob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blob.d.ts","sourceRoot":"","sources":["../../../src/node/file/blob.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAEzC;;;GAGG;AACH,qBAAa,YAAY;IAEvB,4FAA4F;IAC5F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,KAAK,CAAe;IAC5B;;;OAGG;gBACS,IAAI,GAAE,QAAQ,EAAO,EAAE,OAAO,GAAE,eAAoB;IAmChE;;;;;;;;;;;;;;;;;;;OAmBG;IACH,KAAK,CAAC,KAAK,GAAE,MAAU,EAAE,GAAG,GAAE,MAAkB,EAAE,IAAI,GAAE,MAAW,GAAG,IAAI;IAyC1E;;;OAGG;IAEG,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC;IAIzC;;;OAGG;IAEG,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;IAS7B;OACG;IAEH,MAAM,IAAI,UAAU,CAAC,GAAG,CAAC;IAIzB;;OAEG;IACH,QAAQ;IAIR,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,WAEvB;IAED,cAAc,IAAI,WAAW;CAU9B"}

package/dist/node/file/blob.js

@@ -1,140 +1,160 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-
-let _Symbol$toStringTag;
-
-import { BlobStream } from './blob-stream';
-_Symbol$toStringTag = Symbol.toStringTag;
-export class BlobPolyfill {
-  constructor(init = [], options = {}) {
-    _defineProperty(this, "type", void 0);
-
-    _defineProperty(this, "size", void 0);
-
-    _defineProperty(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;
-      }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlobPolyfill = void 0;
+// Forked from @gozala's web-blob under MIT license https://github.com/Gozala/web-blob
+const blob_stream_1 = require("./blob-stream");
+/**
+ * Forked from @gozala's web-blob under MIT license
+ * @see https://github.com/Gozala/web-blob
+ */
+class BlobPolyfill {
+    /**
+     * @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(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) {
-      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 blob_stream_1.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;
-  }
-
 }
-
+exports.BlobPolyfill = BlobPolyfill;
+/**
+ */
 function readType(input = '') {
-  const type = String(input).toLowerCase();
-  return /[^\u0020-\u007E]/.test(type) ? '' : type;
+    const type = String(input).toLowerCase();
+    return /[^\u0020-\u007E]/.test(type) ? '' : type;
 }
-//# sourceMappingURL=blob.js.map

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

@@ -0,0 +1,24 @@
+export declare class FileReaderPolyfill implements FileReader {
+    onload: any;
+    onabort: any;
+    onerror: any;
+    error: any;
+    onloadstart: any;
+    onloadend: any;
+    onprogress: any;
+    readyState: any;
+    result: any;
+    DONE: any;
+    EMPTY: any;
+    LOADING: any;
+    addEventListener: any;
+    removeEventListener: any;
+    dispatchEvent: any;
+    constructor();
+    abort(): void;
+    readAsArrayBuffer(blob: Blob): Promise<void>;
+    readAsBinaryString(blob: any): Promise<void>;
+    readAsDataURL(blob: any): Promise<void>;
+    readAsText(blob: any): Promise<void>;
+}
+//# sourceMappingURL=file-reader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"file-reader.d.ts","sourceRoot":"","sources":["../../../src/node/file/file-reader.ts"],"names":[],"mappings":"AAEA,qBAAa,kBAAmB,YAAW,UAAU;IAEnD,MAAM,MAAC;IACP,OAAO,MAAC;IACR,OAAO,MAAC;IACR,KAAK,MAAC;IACN,WAAW,MAAC;IACZ,SAAS,MAAC;IACV,UAAU,MAAC;IAEX,UAAU,MAAC;IACX,MAAM,MAAC;IACP,IAAI,MAAC;IACL,KAAK,MAAC;IACN,OAAO,MAAC;IACR,gBAAgB,MAAC;IACjB,mBAAmB,MAAC;IACpB,aAAa,MAAC;;IAMd,KAAK,IAAI,IAAI;IAIP,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAO5C,kBAAkB,CAAC,IAAI,KAAA;IAIvB,aAAa,CAAC,IAAI,KAAA;IAQlB,UAAU,CAAC,IAAI,KAAA;CAMtB"}