@loaders.gl/core 3.1.0-alpha.4 → 3.1.0-beta.3

package/dist/lib/filesystems/browser-filesystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-filesystem.d.ts","sourceRoot":"","sources":["../../../src/lib/filesystems/browser-filesystem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AAE7C,aAAK,wBAAwB,GAAG;IAC9B,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;CACtB,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,iBAAkB,YAAW,UAAU;IAC1D,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,KAAK,CAAkC;IAC/C,OAAO,CAAC,cAAc,CAAkC;IACxD,OAAO,CAAC,SAAS,CAAqC;IAEtD;;;;OAIG;gBACS,KAAK,EAAE,QAAQ,GAAG,IAAI,EAAE,EAAE,OAAO,CAAC,EAAE,wBAAwB;IAexE;;;OAGG;IACG,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;IAkCnE;;;;OAIG;IACG,OAAO,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IASlD;;OAEG;IACG,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC;IAQnE;;OAEG;IACG,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASnC,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,KAAA,EAAE,IAAI,CAAC,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC;IAIxD;;;;;;;OAOG;IACG,IAAI,CACR,EAAE,EAAE,GAAG,EACP,MAAM,EAAE,WAAW,EACnB,MAAM,GAAE,MAAU,EAClB,MAAM,GAAE,MAA0B,EAClC,QAAQ,GAAE,MAAM,GAAG,IAAW,GAC7B,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,WAAW,CAAA;KAAC,CAAC;IAQ9C,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAStC,QAAQ,CAAC,IAAI,KAAA,EAAE,IAAI,KAAA;CAQpB"}

package/dist/lib/filesystems/browser-filesystem.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * FileSystem adapter for a browser FileList.
+ * Holds a list of browser 'File' objects.
+ */
+class BrowserFileSystem {
+    /**
+     * A FileSystem API wrapper around a list of browser 'File' objects
+     * @param files
+     * @param options
+     */
+    constructor(files, options) {
+        this.files = {};
+        this.lowerCaseFiles = {};
+        this.usedFiles = {};
+        this._fetch = options?.fetch || fetch;
+        for (let i = 0; i < files.length; ++i) {
+            const file = files[i];
+            this.files[file.name] = file;
+            this.lowerCaseFiles[file.name.toLowerCase()] = file;
+            this.usedFiles[file.name] = false;
+        }
+        this.fetch = this.fetch.bind(this);
+    }
+    // implements IFileSystem
+    /**
+     * Implementation of fetch against this file system
+     * Delegates to global fetch for http{s}:// or data://
+     */
+    async fetch(path, options) {
+        // Fallback to handle https:/http:/data: etc fetches
+        if (path.includes('://')) {
+            return this._fetch(path, options);
+        }
+        // Local fetches are served from the list of files
+        const file = this.files[path];
+        if (!file) {
+            return new Response(path, { status: 400, statusText: 'NOT FOUND' });
+        }
+        const headers = new Headers(options?.headers);
+        const range = headers.get('Range');
+        const bytes = range && /bytes=($1)-($2)/.exec(range);
+        if (bytes) {
+            const start = parseInt(bytes[1]);
+            const end = parseInt(bytes[2]);
+            // The trick when reading File objects is to read successive "slices" of the File
+            // Per spec https://w3c.github.io/FileAPI/, slicing a File should only update the start and end fields
+            // Actually reading from file should happen in `readAsArrayBuffer` (and as far we can tell it does)
+            const data = await file.slice(start, end).arrayBuffer();
+            const response = new Response(data);
+            Object.defineProperty(response, 'url', { value: path });
+            return response;
+        }
+        // return makeResponse()
+        const response = new Response(file);
+        Object.defineProperty(response, 'url', { value: path });
+        return response;
+    }
+    /**
+     * List filenames in this filesystem
+     * @param dirname
+     * @returns
+     */
+    async readdir(dirname) {
+        const files = [];
+        for (const path in this.files) {
+            files.push(path);
+        }
+        // TODO filter by dirname
+        return files;
+    }
+    /**
+     * Return information (size) about files in this file system
+     */
+    async stat(path, options) {
+        const file = this.files[path];
+        if (!file) {
+            throw new Error(path);
+        }
+        return { size: file.size };
+    }
+    /**
+     * Just removes the file from the list
+     */
+    async unlink(path) {
+        delete this.files[path];
+        delete this.lowerCaseFiles[path];
+        this.usedFiles[path] = true;
+    }
+    // implements IRandomAccessFileSystem
+    // RANDOM ACCESS
+    async open(pathname, flags, mode) {
+        return this.files[pathname];
+    }
+    /**
+     * Read a range into a buffer
+     * @todo - handle position memory
+     * @param buffer is the buffer that the data (read from the fd) will be written to.
+     * @param offset is the offset in the buffer to start writing at.
+     * @param length is an integer specifying the number of bytes to read.
+     * @param position is an argument specifying where to begin reading from in the file. If position is null, data will be read from the current file position, and the file position will be updated. If position is an integer, the file position will remain unchanged.
+     */
+    async read(fd, buffer, offset = 0, length = buffer.byteLength, position = null) {
+        const file = fd;
+        const startPosition = 0; // position
+        const arrayBuffer = await file.slice(startPosition, startPosition + length).arrayBuffer();
+        // copy into target buffer
+        return { bytesRead: length, buffer: arrayBuffer };
+    }
+    async close(fd) {
+        // NO OP
+    }
+    // fstat(fd: number): Promise<object>; // Stat
+    // PRIVATE
+    // Supports case independent paths, and file usage tracking
+    _getFile(path, used) {
+        // Prefer case match, but fall back to case indepent.
+        const file = this.files[path] || this.lowerCaseFiles[path];
+        if (file && used) {
+            this.usedFiles[path] = true;
+        }
+        return file;
+    }
+}
+exports.default = BrowserFileSystem;

package/dist/lib/filesystems/filesystem.d.ts

@@ -0,0 +1,46 @@
+export declare type ReadOptions = {};
+export declare type Stat = {
+    size: number;
+    isDirectory: () => boolean;
+};
+/**
+ * A FileSystem interface can encapsulate various file sources,
+ * a FileList, a ZipFile, a GoogleDrive etc.
+ */
+export interface FileSystem {
+    /**
+     * Return a list of file names
+     * @param dirname directory name. file system root directory if omitted
+     */
+    readdir(dirname?: string, options?: {
+        recursive?: boolean;
+    }): Promise<string[]>;
+    /**
+     * Gets information from a local file from the filesystem
+     * @param filename file name to stat
+     * @param options currently unused
+     * @throws if filename is not in local filesystem
+     */
+    stat(filename: string, options?: object): Promise<{
+        size: number;
+    }>;
+    /**
+     * Fetches a local file from the filesystem (or a URL)
+     * @param filename
+     * @param options
+     */
+    fetch(filename: RequestInfo, options?: RequestInit): Promise<Response>;
+}
+/**
+ * A random access file system
+ */
+export interface RandomAccessReadFileSystem extends FileSystem {
+    open(path: string, flags: any, mode?: any): Promise<any>;
+    close(fd: any): Promise<void>;
+    fstat(fd: any): Promise<Stat>;
+    read(fd: any, buffer: ArrayBuffer | ArrayBufferView, offset?: number, length?: number, position?: number): Promise<{
+        bytesRead: number;
+        buffer: ArrayBuffer;
+    }>;
+}
+//# sourceMappingURL=filesystem.d.ts.map

package/dist/lib/filesystems/filesystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystem.d.ts","sourceRoot":"","sources":["../../../src/lib/filesystems/filesystem.ts"],"names":[],"mappings":"AAAA,oBAAY,WAAW,GAAG,EAAE,CAAC;AAE7B,oBAAY,IAAI,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,OAAO,CAAC;CAC5B,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB;;;OAGG;IACH,OAAO,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAE9E;;;;;OAKG;IACH,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAElE;;;;OAIG;IACH,KAAK,CAAC,QAAQ,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;CACxE;AAED;;GAEG;AACH,MAAM,WAAW,0BAA2B,SAAQ,UAAU;IAC5D,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,KAAA,EAAE,IAAI,CAAC,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAC/C,KAAK,CAAC,EAAE,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,KAAK,CAAC,EAAE,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,IAAI,CACF,EAAE,EAAE,GAAG,EACP,MAAM,EAAE,WAAW,GAAG,eAAe,EACrC,MAAM,CAAC,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,WAAW,CAAA;KAAC,CAAC,CAAC;CACtD"}

package/dist/lib/filesystems/filesystem.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/filesystems/read-array-buffer.d.ts

@@ -0,0 +1,19 @@
+export declare function readArrayBuffer(file: Blob | ArrayBuffer | any, start: number, length: number): Promise<ArrayBuffer>;
+/**
+ * Read a slice of a Blob or File, without loading the entire file into memory
+ * The trick when reading File objects is to read successive "slices" of the File
+ * Per spec https://w3c.github.io/FileAPI/, slicing a File only updates the start and end fields
+ * Actually reading from file happens in `readAsArrayBuffer`
+ * @param blob to read
+ export async function readBlob(blob: Blob): Promise<ArrayBuffer> {
+  return await new Promise((resolve, reject) => {
+    const fileReader = new FileReader();
+    fileReader.onload = (event: ProgressEvent<FileReader>) =>
+      resolve(event?.target?.result as ArrayBuffer);
+    // TODO - reject with a proper Error
+    fileReader.onerror = (error: ProgressEvent<FileReader>) => reject(error);
+    fileReader.readAsArrayBuffer(blob);
+  });
+}
+*/
+//# sourceMappingURL=read-array-buffer.d.ts.map

package/dist/lib/filesystems/read-array-buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-array-buffer.d.ts","sourceRoot":"","sources":["../../../src/lib/filesystems/read-array-buffer.ts"],"names":[],"mappings":"AAEA,wBAAsB,eAAe,CACnC,IAAI,EAAE,IAAI,GAAG,WAAW,GAAG,GAAG,EAC9B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,WAAW,CAAC,CAMtB;AAED;;;;;;;;;;;;;;;;EAgBE"}

package/dist/lib/filesystems/read-array-buffer.js

@@ -0,0 +1,29 @@
+"use strict";
+// Random-Access read
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readArrayBuffer = void 0;
+async function readArrayBuffer(file, start, length) {
+    if (file instanceof Blob) {
+        const slice = file.slice(start, start + length);
+        return await slice.arrayBuffer();
+    }
+    return await file.read(start, start + length);
+}
+exports.readArrayBuffer = readArrayBuffer;
+/**
+ * Read a slice of a Blob or File, without loading the entire file into memory
+ * The trick when reading File objects is to read successive "slices" of the File
+ * Per spec https://w3c.github.io/FileAPI/, slicing a File only updates the start and end fields
+ * Actually reading from file happens in `readAsArrayBuffer`
+ * @param blob to read
+ export async function readBlob(blob: Blob): Promise<ArrayBuffer> {
+  return await new Promise((resolve, reject) => {
+    const fileReader = new FileReader();
+    fileReader.onload = (event: ProgressEvent<FileReader>) =>
+      resolve(event?.target?.result as ArrayBuffer);
+    // TODO - reject with a proper Error
+    fileReader.onerror = (error: ProgressEvent<FileReader>) => reject(error);
+    fileReader.readAsArrayBuffer(blob);
+  });
+}
+*/

package/dist/lib/init.d.ts

@@ -0,0 +1,3 @@
+declare const _default: any;
+export default _default;
+//# sourceMappingURL=init.d.ts.map

package/dist/lib/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/lib/init.ts"],"names":[],"mappings":";AASA,wBAAkC"}

package/dist/lib/init.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const version = typeof __VERSION__ !== 'undefined' ? __VERSION__ : '';
+// @ts-ignore
+globalThis.loaders = Object.assign(globalThis.loaders || {}, {
+    VERSION: version
+});
+// @ts-ignore
+exports.default = globalThis.loaders;

package/dist/lib/loader-utils/check-errors.d.ts

@@ -0,0 +1,3 @@
+export declare function checkFetchResponseStatus(response: any): Promise<void>;
+export declare function checkFetchResponseStatusSync(response: any): void;
+//# sourceMappingURL=check-errors.d.ts.map

package/dist/lib/loader-utils/check-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-errors.d.ts","sourceRoot":"","sources":["../../../src/lib/loader-utils/check-errors.ts"],"names":[],"mappings":"AAAA,wBAAsB,wBAAwB,CAAC,QAAQ,KAAA,iBAatD;AAED,wBAAgB,4BAA4B,CAAC,QAAQ,KAAA,QAIpD"}

package/dist/lib/loader-utils/check-errors.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkFetchResponseStatusSync = exports.checkFetchResponseStatus = void 0;
+async function checkFetchResponseStatus(response) {
+    if (!response.ok) {
+        let errorMessage = `fetch failed ${response.status} ${response.statusText}`;
+        try {
+            const text = await response.text();
+            if (text) {
+                errorMessage += `: ${getErrorText(text)}`;
+            }
+        }
+        catch (error) {
+            // ignore error
+        }
+        throw new Error(errorMessage);
+    }
+}
+exports.checkFetchResponseStatus = checkFetchResponseStatus;
+function checkFetchResponseStatusSync(response) {
+    if (!response.ok) {
+        throw new Error(`fetch failed ${response.status}`);
+    }
+}
+exports.checkFetchResponseStatusSync = checkFetchResponseStatusSync;
+function getErrorText(text) {
+    // Look for HTML error texts
+    const matches = text.match('<pre>(.*)</pre>');
+    return matches ? matches[1] : ` ${text.slice(0, 10)}...`;
+}

package/dist/lib/loader-utils/get-data.d.ts

@@ -0,0 +1,6 @@
+import type { DataType, SyncDataType, BatchableDataType, Loader, LoaderOptions } from '@loaders.gl/loader-utils';
+export declare function getArrayBufferOrStringFromDataSync(data: SyncDataType, loader: Loader, options: LoaderOptions): ArrayBuffer | string;
+export declare function getArrayBufferOrStringFromData(data: DataType, loader: Loader, options: LoaderOptions): Promise<ArrayBuffer | string>;
+export declare function getAsyncIterableFromData(data: BatchableDataType, options: LoaderOptions): Promise<AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>>;
+export declare function getReadableStream(data: BatchableDataType): Promise<ReadableStream>;
+//# sourceMappingURL=get-data.d.ts.map

package/dist/lib/loader-utils/get-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-data.d.ts","sourceRoot":"","sources":["../../../src/lib/loader-utils/get-data.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,YAAY,EACZ,iBAAiB,EACjB,MAAM,EACN,aAAa,EACd,MAAM,0BAA0B,CAAC;AAiBlC,wBAAgB,kCAAkC,CAChD,IAAI,EAAE,YAAY,EAClB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,aAAa,GACrB,WAAW,GAAG,MAAM,CAyCtB;AAGD,wBAAsB,8BAA8B,CAClD,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,WAAW,GAAG,MAAM,CAAC,CA4B/B;AAED,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,aAAa,CAAC,WAAW,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC,CAAC,CAyB7D;AAED,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,cAAc,CAAC,CAWxF"}

package/dist/lib/loader-utils/get-data.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReadableStream = exports.getAsyncIterableFromData = exports.getArrayBufferOrStringFromData = exports.getArrayBufferOrStringFromDataSync = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const is_type_1 = require("../../javascript-utils/is-type");
+const make_iterator_1 = require("../../iterators/make-iterator/make-iterator");
+const response_utils_1 = require("../utils/response-utils");
+const ERR_DATA = 'Cannot convert supplied data type';
+// eslint-disable-next-line complexity
+function getArrayBufferOrStringFromDataSync(data, loader, options) {
+    if (loader.text && typeof data === 'string') {
+        return data;
+    }
+    if ((0, is_type_1.isBuffer)(data)) {
+        // @ts-ignore
+        data = data.buffer;
+    }
+    if (data instanceof ArrayBuffer) {
+        const arrayBuffer = data;
+        if (loader.text && !loader.binary) {
+            const textDecoder = new TextDecoder('utf8');
+            return textDecoder.decode(arrayBuffer);
+        }
+        return arrayBuffer;
+    }
+    // We may need to handle offsets
+    if (ArrayBuffer.isView(data)) {
+        // TextDecoder is invoked on typed arrays and will handle offsets
+        if (loader.text && !loader.binary) {
+            const textDecoder = new TextDecoder('utf8');
+            return textDecoder.decode(data);
+        }
+        let arrayBuffer = data.buffer;
+        // Since we are returning the underlying arrayBuffer, we must create a new copy
+        // if this typed array / Buffer is a partial view into the ArryayBuffer
+        // TODO - this is a potentially unnecessary copy
+        const byteLength = data.byteLength || data.length;
+        if (data.byteOffset !== 0 || byteLength !== arrayBuffer.byteLength) {
+            // console.warn(`loaders.gl copying arraybuffer of length ${byteLength}`);
+            arrayBuffer = arrayBuffer.slice(data.byteOffset, data.byteOffset + byteLength);
+        }
+        return arrayBuffer;
+    }
+    throw new Error(ERR_DATA);
+}
+exports.getArrayBufferOrStringFromDataSync = getArrayBufferOrStringFromDataSync;
+// Convert async iterator to a promise
+async function getArrayBufferOrStringFromData(data, loader, options) {
+    const isArrayBuffer = data instanceof ArrayBuffer || ArrayBuffer.isView(data);
+    if (typeof data === 'string' || isArrayBuffer) {
+        return getArrayBufferOrStringFromDataSync(data, loader, options);
+    }
+    // Blobs and files are FileReader compatible
+    if ((0, is_type_1.isBlob)(data)) {
+        data = await (0, response_utils_1.makeResponse)(data);
+    }
+    if ((0, is_type_1.isResponse)(data)) {
+        const response = data;
+        await (0, response_utils_1.checkResponse)(response);
+        return loader.binary ? await response.arrayBuffer() : await response.text();
+    }
+    if ((0, is_type_1.isReadableStream)(data)) {
+        // @ts-expect-error TS2559 options type
+        data = (0, make_iterator_1.makeIterator)(data, options);
+    }
+    if ((0, is_type_1.isIterable)(data) || (0, is_type_1.isAsyncIterable)(data)) {
+        // Assume arrayBuffer iterator - attempt to concatenate
+        return (0, loader_utils_1.concatenateArrayBuffersAsync)(data);
+    }
+    throw new Error(ERR_DATA);
+}
+exports.getArrayBufferOrStringFromData = getArrayBufferOrStringFromData;
+async function getAsyncIterableFromData(data, options) {
+    if ((0, is_type_1.isIterator)(data)) {
+        return data;
+    }
+    if ((0, is_type_1.isResponse)(data)) {
+        const response = data;
+        // Note Since this function is not async, we currently can't load error message, just status
+        await (0, response_utils_1.checkResponse)(response);
+        // TODO - bug in polyfill, body can be a Promise under Node.js
+        // eslint-disable-next-line @typescript-eslint/await-thenable
+        const body = await response.body;
+        // TODO - body can be null?
+        return (0, make_iterator_1.makeIterator)(body, options);
+    }
+    if ((0, is_type_1.isBlob)(data) || (0, is_type_1.isReadableStream)(data)) {
+        return (0, make_iterator_1.makeIterator)(data, options);
+    }
+    if ((0, is_type_1.isAsyncIterable)(data)) {
+        return data[Symbol.asyncIterator]();
+    }
+    return getIterableFromData(data);
+}
+exports.getAsyncIterableFromData = getAsyncIterableFromData;
+async function getReadableStream(data) {
+    if ((0, is_type_1.isReadableStream)(data)) {
+        return data;
+    }
+    if ((0, is_type_1.isResponse)(data)) {
+        // @ts-ignore
+        return data.body;
+    }
+    const response = await (0, response_utils_1.makeResponse)(data);
+    // @ts-ignore
+    return response.body;
+}
+exports.getReadableStream = getReadableStream;
+// HELPERS
+function getIterableFromData(data) {
+    // generate an iterator that emits a single chunk
+    if (ArrayBuffer.isView(data)) {
+        return (function* oneChunk() {
+            yield data.buffer;
+        })();
+    }
+    if (data instanceof ArrayBuffer) {
+        return (function* oneChunk() {
+            yield data;
+        })();
+    }
+    if ((0, is_type_1.isIterator)(data)) {
+        return data;
+    }
+    if ((0, is_type_1.isIterable)(data)) {
+        return data[Symbol.iterator]();
+    }
+    throw new Error(ERR_DATA);
+}

package/dist/lib/loader-utils/loader-context.d.ts

@@ -0,0 +1,13 @@
+import type { Loader, LoaderOptions, LoaderContext } from '@loaders.gl/loader-utils';
+/**
+ * "sub" loaders invoked by other loaders get a "context" injected on `this`
+ * The context will inject core methods like `parse` and contain information
+ * about loaders and options passed in to the top-level `parse` call.
+ *
+ * @param context
+ * @param options
+ * @param previousContext
+ */
+export declare function getLoaderContext(context: Omit<LoaderContext, 'fetch'> & Partial<Pick<LoaderContext, 'fetch'>>, options?: LoaderOptions, previousContext?: LoaderContext | null): LoaderContext;
+export declare function getLoadersFromContext(loaders: Loader[] | Loader | undefined, context?: LoaderContext): any;
+//# sourceMappingURL=loader-context.d.ts.map

package/dist/lib/loader-utils/loader-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader-context.d.ts","sourceRoot":"","sources":["../../../src/lib/loader-utils/loader-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAE,aAAa,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAGnF;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,EAC7E,OAAO,CAAC,EAAE,aAAa,EACvB,eAAe,GAAE,aAAa,GAAG,IAAW,GAC3C,aAAa,CAkBf;AAGD,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,EACtC,OAAO,CAAC,EAAE,aAAa,OAkBxB"}

package/dist/lib/loader-utils/loader-context.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLoadersFromContext = exports.getLoaderContext = void 0;
+const option_utils_1 = require("./option-utils");
+/**
+ * "sub" loaders invoked by other loaders get a "context" injected on `this`
+ * The context will inject core methods like `parse` and contain information
+ * about loaders and options passed in to the top-level `parse` call.
+ *
+ * @param context
+ * @param options
+ * @param previousContext
+ */
+function getLoaderContext(context, options, previousContext = null) {
+    // For recursive calls, we already have a context
+    // TODO - add any additional loaders to context?
+    if (previousContext) {
+        return previousContext;
+    }
+    const resolvedContext = {
+        fetch: (0, option_utils_1.getFetchFunction)(options, context),
+        ...context
+    };
+    // Recursive loading does not use single loader
+    if (!Array.isArray(resolvedContext.loaders)) {
+        resolvedContext.loaders = null;
+    }
+    return resolvedContext;
+}
+exports.getLoaderContext = getLoaderContext;
+// eslint-disable-next-line complexity
+function getLoadersFromContext(loaders, context) {
+    // A single non-array loader is force selected, but only on top-level (context === null)
+    if (!context && loaders && !Array.isArray(loaders)) {
+        return loaders;
+    }
+    // Create a merged list
+    let candidateLoaders;
+    if (loaders) {
+        candidateLoaders = Array.isArray(loaders) ? loaders : [loaders];
+    }
+    if (context && context.loaders) {
+        const contextLoaders = Array.isArray(context.loaders) ? context.loaders : [context.loaders];
+        candidateLoaders = candidateLoaders ? [...candidateLoaders, ...contextLoaders] : contextLoaders;
+    }
+    // If no loaders, return null to look in globally registered loaders
+    return candidateLoaders && candidateLoaders.length ? candidateLoaders : null;
+}
+exports.getLoadersFromContext = getLoadersFromContext;

package/dist/lib/loader-utils/loggers.d.ts

@@ -0,0 +1,16 @@
+export declare const probeLog: any;
+export declare class NullLog {
+    log(): () => void;
+    info(): () => void;
+    warn(): () => void;
+    error(): () => void;
+}
+export declare class ConsoleLog {
+    console: any;
+    constructor();
+    log(...args: any[]): any;
+    info(...args: any[]): any;
+    warn(...args: any[]): any;
+    error(...args: any[]): any;
+}
+//# sourceMappingURL=loggers.d.ts.map

package/dist/lib/loader-utils/loggers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loggers.d.ts","sourceRoot":"","sources":["../../../src/lib/loader-utils/loggers.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,QAAQ,KAA8B,CAAC;AAGpD,qBAAa,OAAO;IAClB,GAAG;IAGH,IAAI;IAGJ,IAAI;IAGJ,KAAK;CAGN;AAGD,qBAAa,UAAU;IACrB,OAAO,MAAC;;IAKR,GAAG,CAAC,GAAG,IAAI,OAAA;IAGX,IAAI,CAAC,GAAG,IAAI,OAAA;IAGZ,IAAI,CAAC,GAAG,IAAI,OAAA;IAGZ,KAAK,CAAC,GAAG,IAAI,OAAA;CAGd"}

package/dist/lib/loader-utils/loggers.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLog = exports.NullLog = exports.probeLog = void 0;
+// probe.gl Log compatible loggers
+const probe_gl_1 = require("probe.gl");
+exports.probeLog = new probe_gl_1.Log({ id: 'loaders.gl' });
+// Logs nothing
+class NullLog {
+    log() {
+        return () => { };
+    }
+    info() {
+        return () => { };
+    }
+    warn() {
+        return () => { };
+    }
+    error() {
+        return () => { };
+    }
+}
+exports.NullLog = NullLog;
+// Logs to console
+class ConsoleLog {
+    constructor() {
+        this.console = console; // eslint-disable-line
+    }
+    log(...args) {
+        return this.console.log.bind(this.console, ...args);
+    }
+    info(...args) {
+        return this.console.info.bind(this.console, ...args);
+    }
+    warn(...args) {
+        return this.console.warn.bind(this.console, ...args);
+    }
+    error(...args) {
+        return this.console.error.bind(this.console, ...args);
+    }
+}
+exports.ConsoleLog = ConsoleLog;

package/dist/lib/loader-utils/normalize-loader.d.ts

@@ -0,0 +1,4 @@
+import type { Loader } from '@loaders.gl/loader-utils';
+export declare function isLoaderObject(loader?: any): boolean;
+export declare function normalizeLoader(loader: Loader): Loader;
+//# sourceMappingURL=normalize-loader.d.ts.map

package/dist/lib/loader-utils/normalize-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-loader.d.ts","sourceRoot":"","sources":["../../../src/lib/loader-utils/normalize-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAGrD,wBAAgB,cAAc,CAAC,MAAM,CAAC,EAAE,GAAG,GAAG,OAAO,CAqBpD;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAiCtD"}

package/dist/lib/loader-utils/normalize-loader.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeLoader = exports.isLoaderObject = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+function isLoaderObject(loader) {
+    if (!loader) {
+        return false;
+    }
+    if (Array.isArray(loader)) {
+        loader = loader[0];
+    }
+    const hasExtensions = Array.isArray(loader?.extensions);
+    /* Now handled by types and worker loaders do not have these
+    let hasParser =
+      loader.parseTextSync ||
+      loader.parseSync ||
+      loader.parse ||
+      loader.parseStream || // TODO Remove, Replace with parseInBatches
+      loader.parseInBatches;
+    */
+    return hasExtensions;
+}
+exports.isLoaderObject = isLoaderObject;
+function normalizeLoader(loader) {
+    // This error is fairly easy to trigger by mixing up import statements etc
+    // So we make an exception and add a developer error message for this case
+    // To help new users from getting stuck here
+    (0, loader_utils_1.assert)(loader, 'null loader');
+    (0, loader_utils_1.assert)(isLoaderObject(loader), 'invalid loader');
+    // NORMALIZE [LOADER, OPTIONS] => LOADER
+    // If [loader, options], create a new loaders object with options merged in
+    let options;
+    if (Array.isArray(loader)) {
+        options = loader[1];
+        loader = loader[0];
+        loader = {
+            ...loader,
+            options: { ...loader.options, ...options }
+        };
+    }
+    // NORMALIZE text and binary flags
+    // Ensure at least one of text/binary flags are properly set
+    // @ts-expect-error
+    if (loader?.parseTextSync || loader?.parseText) {
+        loader.text = true;
+    }
+    if (!loader.text) {
+        loader.binary = true;
+    }
+    return loader;
+}
+exports.normalizeLoader = normalizeLoader;

package/dist/lib/loader-utils/option-defaults.d.ts

@@ -0,0 +1,20 @@
+import type { LoaderOptions } from '@loaders.gl/loader-utils';
+export declare const DEFAULT_LOADER_OPTIONS: LoaderOptions;
+export declare const REMOVED_LOADER_OPTIONS: {
+    throws: string;
+    dataType: string;
+    uri: string;
+    method: string;
+    headers: string;
+    body: string;
+    mode: string;
+    credentials: string;
+    cache: string;
+    redirect: string;
+    referrer: string;
+    referrerPolicy: string;
+    integrity: string;
+    keepalive: string;
+    signal: string;
+};
+//# sourceMappingURL=option-defaults.d.ts.map

package/dist/lib/loader-utils/option-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"option-defaults.d.ts","sourceRoot":"","sources":["../../../src/lib/loader-utils/option-defaults.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAG5D,eAAO,MAAM,sBAAsB,EAAE,aAoBpC,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;CAiBlC,CAAC"}