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

package/dist/lib/api/encode-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode-table.d.ts","sourceRoot":"","sources":["../../../src/lib/api/encode-table.ts"],"names":[],"mappings":"AAIA,OAAO,EAA0B,MAAM,EAAE,iBAAiB,EAAC,MAAM,0BAA0B,CAAC;AAC5F,OAAO,EAAC,KAAK,EAAC,MAAM,oBAAoB,CAAC;AAEzC,wBAAsB,WAAW,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,EAC/D,IAAI,EAAE,KAAK,EACX,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,iBAAiB,CAAC,OAAO,CAAC,GACnC,OAAO,CAAC,WAAW,CAAC,CAwBtB;AAED,wBAAsB,iBAAiB,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,EACrE,IAAI,EAAE,KAAK,EACX,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,iBAAiB,CAAC,OAAO,CAAC,GACnC,OAAO,CAAC,MAAM,CAAC,CAUjB;AAED,wBAAgB,oBAAoB,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,EAClE,IAAI,EAAE,KAAK,EACX,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,iBAAiB,CAAC,OAAO,CAAC,GACnC,aAAa,CAAC,WAAW,CAAC,CAQ5B"}

package/dist/lib/api/encode-table.js

@@ -0,0 +1,54 @@
+"use strict";
+// loaders.gl, MIT license
+// Copyright 2022 Foursquare Labs, Inc
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeTableInBatches = exports.encodeTableAsText = exports.encodeTable = void 0;
+/* global TextEncoder, TextDecoder */
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+async function encodeTable(data, writer, options) {
+    if (writer.encode) {
+        return await writer.encode(data, options);
+    }
+    if (writer.encodeText) {
+        const text = await writer.encodeText(data, options);
+        return new TextEncoder().encode(text);
+    }
+    if (writer.encodeInBatches) {
+        // Create an iterator representing the data
+        // TODO - Assumes this is a table
+        const batches = encodeTableInBatches(data, writer, options);
+        // Concatenate the output
+        const chunks = [];
+        for await (const batch of batches) {
+            chunks.push(batch);
+        }
+        return (0, loader_utils_1.concatenateArrayBuffers)(...chunks);
+    }
+    throw new Error('Writer could not encode data');
+}
+exports.encodeTable = encodeTable;
+async function encodeTableAsText(data, writer, options) {
+    if (writer.text && writer.encodeText) {
+        return await writer.encodeText(data, options);
+    }
+    if (writer.text && (writer.encode || writer.encodeInBatches)) {
+        const arrayBuffer = await encodeTable(data, writer, options);
+        return new TextDecoder().decode(arrayBuffer);
+    }
+    throw new Error('Writer could not encode data as text');
+}
+exports.encodeTableAsText = encodeTableAsText;
+function encodeTableInBatches(data, writer, options) {
+    if (writer.encodeInBatches) {
+        const dataIterator = getIterator(data);
+        // @ts-expect-error
+        return writer.encodeInBatches(dataIterator, options);
+    }
+    // TODO -fall back to atomic encode?
+    throw new Error('Writer could not encode data in batches');
+}
+exports.encodeTableInBatches = encodeTableInBatches;
+function getIterator(data) {
+    const dataIterator = [{ table: data, start: 0, end: data.length }];
+    return dataIterator;
+}

package/dist/lib/api/encode.d.ts

@@ -0,0 +1,26 @@
+import { Writer, WriterOptions } from '@loaders.gl/loader-utils';
+/**
+ * Encode loaded data into a binary ArrayBuffer using the specified Writer.
+ */
+export declare function encode(data: any, writer: Writer, options?: WriterOptions): Promise<ArrayBuffer>;
+/**
+ * Encode loaded data into a binary ArrayBuffer using the specified Writer.
+ */
+export declare function encodeSync(data: any, writer: Writer, options?: WriterOptions): ArrayBuffer;
+/**
+ * Encode loaded data to text using the specified Writer
+ * @note This is a convenience function not intended for production use on large input data.
+ * It is not optimized for performance. Data maybe converted from text to binary and back.
+ * @throws if the writer does not generate text output
+ */
+export declare function encodeText(data: any, writer: Writer, options?: WriterOptions): Promise<string>;
+/**
+ * Encode loaded data into a sequence (iterator) of binary ArrayBuffers using the specified Writer.
+ */
+export declare function encodeInBatches(data: any, writer: Writer, options?: WriterOptions): AsyncIterable<ArrayBuffer>;
+/**
+ * Encode data stored in a file (on disk) to another file.
+ * @note Node.js only. This function enables using command-line converters as "writers".
+ */
+export declare function encodeURLtoURL(inputUrl: any, outputUrl: any, writer: Writer, options: any): Promise<string>;
+//# sourceMappingURL=encode.d.ts.map

package/dist/lib/api/encode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../../src/lib/api/encode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAE,aAAa,EAAsB,MAAM,0BAA0B,CAAC;AAQpF;;GAEG;AACH,wBAAsB,MAAM,CAC1B,IAAI,EAAE,GAAG,EACT,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,WAAW,CAAC,CAsDtB;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,WAAW,CAK1F;AAED;;;;;GAKG;AACH,wBAAsB,UAAU,CAC9B,IAAI,EAAE,GAAG,EACT,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,MAAM,CAAC,CAWjB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,GAAG,EACT,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,aAAa,GACtB,aAAa,CAAC,WAAW,CAAC,CAQ5B;AAED;;;GAGG;AACH,wBAAsB,cAAc,CAClC,QAAQ,KAAA,EACR,SAAS,KAAA,EACT,MAAM,EAAE,MAAM,EACd,OAAO,KAAA,GACN,OAAO,CAAC,MAAM,CAAC,CAQjB"}

package/dist/lib/api/encode.js

@@ -1,91 +1,121 @@
-import { concatenateArrayBuffers, resolvePath } from '@loaders.gl/loader-utils';
-import { isBrowser } from '@loaders.gl/loader-utils';
-import { writeFile } from '../fetch/write-file';
-import { fetchFile } from '../fetch/fetch-file';
-export async function encode(data, writer, options) {
-  if (writer.encode) {
-    return await writer.encode(data, options);
-  }
-
-  if (writer.encodeSync) {
-    return writer.encodeSync(data, options);
-  }
-
-  if (writer.encodeText) {
-    return new TextEncoder().encode(await writer.encodeText(data, options));
-  }
-
-  if (writer.encodeInBatches) {
-    const batches = encodeInBatches(data, writer, options);
-    const chunks = [];
-
-    for await (const batch of batches) {
-      chunks.push(batch);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeURLtoURL = exports.encodeInBatches = exports.encodeText = exports.encodeSync = exports.encode = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const worker_utils_1 = require("@loaders.gl/worker-utils");
+const loader_utils_2 = require("@loaders.gl/loader-utils");
+const loader_utils_3 = require("@loaders.gl/loader-utils");
+const write_file_1 = require("../fetch/write-file");
+const fetch_file_1 = require("../fetch/fetch-file");
+const loader_options_1 = require("./loader-options");
+/**
+ * Encode loaded data into a binary ArrayBuffer using the specified Writer.
+ */
+async function encode(data, writer, options) {
+    const globalOptions = (0, loader_options_1.getLoaderOptions)();
+    // const globalOptions: WriterOptions = {}; // getWriterOptions();
+    options = { ...globalOptions, ...options };
+    if ((0, loader_utils_1.canEncodeWithWorker)(writer, options)) {
+        return await (0, worker_utils_1.processOnWorker)(writer, data, options);
     }
-
-    return concatenateArrayBuffers(...chunks);
-  }
-
-  if (!isBrowser && writer.encodeURLtoURL) {
-    const tmpInputFilename = getTemporaryFilename('input');
-    await writeFile(tmpInputFilename, data);
-    const tmpOutputFilename = getTemporaryFilename('output');
-    const outputFilename = await encodeURLtoURL(tmpInputFilename, tmpOutputFilename, writer, options);
-    const response = await fetchFile(outputFilename);
-    return response.arrayBuffer();
-  }
-
-  throw new Error('Writer could not encode data');
+    // TODO Merge default writer options with options argument like it is done in load module.
+    if (writer.encode) {
+        return await writer.encode(data, options);
+    }
+    if (writer.encodeSync) {
+        return writer.encodeSync(data, options);
+    }
+    if (writer.encodeText) {
+        return new TextEncoder().encode(await writer.encodeText(data, options));
+    }
+    if (writer.encodeInBatches) {
+        // Create an iterator representing the data
+        // TODO - Assumes this is a table
+        const batches = encodeInBatches(data, writer, options);
+        // Concatenate the output
+        const chunks = [];
+        for await (const batch of batches) {
+            chunks.push(batch);
+        }
+        // @ts-ignore
+        return (0, loader_utils_2.concatenateArrayBuffers)(...chunks);
+    }
+    if (!loader_utils_3.isBrowser && writer.encodeURLtoURL) {
+        // TODO - how to generate filenames with correct extensions?
+        const tmpInputFilename = getTemporaryFilename('input');
+        await (0, write_file_1.writeFile)(tmpInputFilename, data);
+        const tmpOutputFilename = getTemporaryFilename('output');
+        const outputFilename = await encodeURLtoURL(tmpInputFilename, tmpOutputFilename, writer, options);
+        const response = await (0, fetch_file_1.fetchFile)(outputFilename);
+        return response.arrayBuffer();
+    }
+    throw new Error('Writer could not encode data');
 }
-export function encodeSync(data, writer, options) {
-  if (writer.encodeSync) {
-    return writer.encodeSync(data, options);
-  }
-
-  throw new Error('Writer could not synchronously encode data');
+exports.encode = encode;
+/**
+ * Encode loaded data into a binary ArrayBuffer using the specified Writer.
+ */
+function encodeSync(data, writer, options) {
+    if (writer.encodeSync) {
+        return writer.encodeSync(data, options);
+    }
+    throw new Error('Writer could not synchronously encode data');
 }
-export async function encodeText(data, writer, options) {
-  if (writer.text && writer.encodeText) {
-    return await writer.encodeText(data, options);
-  }
-
-  if (writer.text && (writer.encode || writer.encodeInBatches)) {
-    const arrayBuffer = await encode(data, writer, options);
-    return new TextDecoder().decode(arrayBuffer);
-  }
-
-  throw new Error('Writer could not encode data as text');
+exports.encodeSync = encodeSync;
+/**
+ * Encode loaded data to text using the specified Writer
+ * @note This is a convenience function not intended for production use on large input data.
+ * It is not optimized for performance. Data maybe converted from text to binary and back.
+ * @throws if the writer does not generate text output
+ */
+async function encodeText(data, writer, options) {
+    if (writer.text && writer.encodeText) {
+        return await writer.encodeText(data, options);
+    }
+    if (writer.text && (writer.encode || writer.encodeInBatches)) {
+        const arrayBuffer = await encode(data, writer, options);
+        return new TextDecoder().decode(arrayBuffer);
+    }
+    throw new Error('Writer could not encode data as text');
 }
-export function encodeInBatches(data, writer, options) {
-  if (writer.encodeInBatches) {
-    const dataIterator = getIterator(data);
-    return writer.encodeInBatches(dataIterator, options);
-  }
-
-  throw new Error('Writer could not encode data in batches');
+exports.encodeText = encodeText;
+/**
+ * Encode loaded data into a sequence (iterator) of binary ArrayBuffers using the specified Writer.
+ */
+function encodeInBatches(data, writer, options) {
+    if (writer.encodeInBatches) {
+        const dataIterator = getIterator(data);
+        // @ts-expect-error
+        return writer.encodeInBatches(dataIterator, options);
+    }
+    // TODO -fall back to atomic encode?
+    throw new Error('Writer could not encode data in batches');
 }
-export async function encodeURLtoURL(inputUrl, outputUrl, writer, options) {
-  inputUrl = resolvePath(inputUrl);
-  outputUrl = resolvePath(outputUrl);
-
-  if (isBrowser || !writer.encodeURLtoURL) {
-    throw new Error();
-  }
-
-  const outputFilename = await writer.encodeURLtoURL(inputUrl, outputUrl, options);
-  return outputFilename;
+exports.encodeInBatches = encodeInBatches;
+/**
+ * Encode data stored in a file (on disk) to another file.
+ * @note Node.js only. This function enables using command-line converters as "writers".
+ */
+async function encodeURLtoURL(inputUrl, outputUrl, writer, options) {
+    inputUrl = (0, loader_utils_2.resolvePath)(inputUrl);
+    outputUrl = (0, loader_utils_2.resolvePath)(outputUrl);
+    if (loader_utils_3.isBrowser || !writer.encodeURLtoURL) {
+        throw new Error();
+    }
+    const outputFilename = await writer.encodeURLtoURL(inputUrl, outputUrl, options);
+    return outputFilename;
 }
-
+exports.encodeURLtoURL = encodeURLtoURL;
+/**
+ * @todo TODO - this is an unacceptable hack!!!
+ */
 function getIterator(data) {
-  const dataIterator = [{
-    table: data,
-    start: 0,
-    end: data.length
-  }];
-  return dataIterator;
+    const dataIterator = [{ table: data, start: 0, end: data.length }];
+    return dataIterator;
 }
-
+/**
+ * @todo Move to utils
+ */
 function getTemporaryFilename(filename) {
-  return "/tmp/".concat(filename);
+    return `/tmp/${filename}`;
 }
-//# sourceMappingURL=encode.js.map

package/dist/lib/api/load-in-batches.d.ts

@@ -0,0 +1,13 @@
+import type { LoaderWithParser, LoaderOptions, LoaderContext } from '@loaders.gl/loader-utils';
+type FileType = string | File | Blob | Response | (string | File | Blob | Response)[] | FileList;
+/**
+ * Parses `data` using a specified loader
+ * @param data
+ * @param loaders
+ * @param options
+ * @param context
+ */
+export declare function loadInBatches(files: FileType, loaders?: LoaderWithParser | LoaderWithParser[] | LoaderOptions, options?: LoaderOptions, context?: LoaderContext): Promise<AsyncIterable<any>>;
+export declare function loadInBatches(files: FileType[] | FileList, loaders?: LoaderWithParser | LoaderWithParser[] | LoaderOptions, options?: LoaderOptions, context?: LoaderContext): Promise<AsyncIterable<any>>;
+export {};
+//# sourceMappingURL=load-in-batches.d.ts.map

package/dist/lib/api/load-in-batches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-in-batches.d.ts","sourceRoot":"","sources":["../../../src/lib/api/load-in-batches.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAE,aAAa,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAM7F,KAAK,QAAQ,GAAG,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,QAAQ,GAAG,CAAC,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,QAAQ,CAAC,EAAE,GAAG,QAAQ,CAAC;AAEjG;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,QAAQ,EACf,OAAO,CAAC,EAAE,gBAAgB,GAAG,gBAAgB,EAAE,GAAG,aAAa,EAC/D,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC;AAE/B,wBAAgB,aAAa,CAC3B,KAAK,EAAE,QAAQ,EAAE,GAAG,QAAQ,EAC5B,OAAO,CAAC,EAAE,gBAAgB,GAAG,gBAAgB,EAAE,GAAG,aAAa,EAC/D,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC"}

package/dist/lib/api/load-in-batches.js

@@ -1,30 +1,33 @@
-import { isLoaderObject } from '../loader-utils/normalize-loader';
-import { getFetchFunction } from '../loader-utils/option-utils';
-import { parseInBatches } from './parse-in-batches';
-export function loadInBatches(files, loaders, options, context) {
-  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
-    context = undefined;
-    options = loaders;
-    loaders = null;
-  }
-
-  const fetch = getFetchFunction(options || {});
-
-  if (!Array.isArray(files)) {
-    return loadOneFileInBatches(files, loaders, options, fetch);
-  }
-
-  const promises = files.map(file => loadOneFileInBatches(file, loaders, options, fetch));
-  return promises;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadInBatches = void 0;
+const normalize_loader_1 = require("../loader-utils/normalize-loader");
+const get_fetch_function_1 = require("../loader-utils/get-fetch-function");
+const parse_in_batches_1 = require("./parse-in-batches");
+function loadInBatches(files, loaders, options, context) {
+    // Signature: load(url, options)
+    if (!Array.isArray(loaders) && !(0, normalize_loader_1.isLoaderObject)(loaders)) {
+        context = undefined; // context not supported in short signature
+        options = loaders;
+        loaders = null;
+    }
+    // Select fetch function
+    const fetch = (0, get_fetch_function_1.getFetchFunction)(options || {});
+    // Single url/file
+    if (!Array.isArray(files)) {
+        return loadOneFileInBatches(files, loaders, options, fetch);
+    }
+    // Multiple URLs / files
+    const promises = files.map((file) => loadOneFileInBatches(file, loaders, options, fetch));
+    // No point in waiting here for all responses before starting to stream individual streams?
+    return promises;
 }
-
+exports.loadInBatches = loadInBatches;
 async function loadOneFileInBatches(file, loaders, options, fetch) {
-  if (typeof file === 'string') {
-    const url = file;
-    const response = await fetch(url);
-    return await parseInBatches(response, loaders, options);
-  }
-
-  return await parseInBatches(file, loaders, options);
+    if (typeof file === 'string') {
+        const url = file;
+        const response = await fetch(url);
+        return await (0, parse_in_batches_1.parseInBatches)(response, loaders, options);
+    }
+    return await (0, parse_in_batches_1.parseInBatches)(file, loaders, options);
 }
-//# sourceMappingURL=load-in-batches.js.map

package/dist/lib/api/load.d.ts

@@ -0,0 +1,14 @@
+import type { DataType, Loader, LoaderContext, LoaderOptions } from '@loaders.gl/loader-utils';
+import type { LoaderOptionsType, LoaderReturnType } from '@loaders.gl/loader-utils';
+/**
+ * Parses `data` using a specified loader
+ * Note: Load does duplicate a lot of parse.
+ * it can also call fetchFile on string urls, which `parse` won't do.
+ * @param data
+ * @param loaders
+ * @param options
+ * @param context
+ */
+export declare function load<LoaderT extends Loader>(url: string | DataType, loader: LoaderT, options?: LoaderOptionsType<LoaderT>, context?: LoaderContext): Promise<LoaderReturnType<LoaderT>>;
+export declare function load<LoaderT extends Loader, LoaderOptionsT extends LoaderOptions = LoaderOptions>(url: string | DataType, loaders: Loader[] | LoaderOptions, options?: LoaderOptionsT, context?: LoaderContext): Promise<any>;
+//# sourceMappingURL=load.d.ts.map

package/dist/lib/api/load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../../src/lib/api/load.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAC7F,OAAO,KAAK,EAAC,iBAAiB,EAAE,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAOlF;;;;;;;;GAQG;AAEH,wBAAsB,IAAI,CAAC,OAAO,SAAS,MAAM,EAC/C,GAAG,EAAE,MAAM,GAAG,QAAQ,EACtB,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,iBAAiB,CAAC,OAAO,CAAC,EACpC,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC;AAEtC,wBAAsB,IAAI,CACxB,OAAO,SAAS,MAAM,EACtB,cAAc,SAAS,aAAa,GAAG,aAAa,EAEpD,GAAG,EAAE,MAAM,GAAG,QAAQ,EACtB,OAAO,EAAE,MAAM,EAAE,GAAG,aAAa,EACjC,OAAO,CAAC,EAAE,cAAc,EACxB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,GAAG,CAAC,CAAC"}

package/dist/lib/api/load.js

@@ -1,25 +1,43 @@
-import { isBlob } from '../../javascript-utils/is-type';
-import { isLoaderObject } from '../loader-utils/normalize-loader';
-import { getFetchFunction } from '../loader-utils/option-utils';
-import { parse } from './parse';
-export async function load(url, loaders, options, context) {
-  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
-    context = undefined;
-    options = loaders;
-    loaders = undefined;
-  }
-
-  const fetch = getFetchFunction(options);
-  let data = url;
-
-  if (typeof url === 'string') {
-    data = await fetch(url);
-  }
-
-  if (isBlob(url)) {
-    data = await fetch(url);
-  }
-
-  return await parse(data, loaders, options);
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.load = void 0;
+const is_type_1 = require("../../javascript-utils/is-type");
+const normalize_loader_1 = require("../loader-utils/normalize-loader");
+const get_fetch_function_1 = require("../loader-utils/get-fetch-function");
+const parse_1 = require("./parse");
+// implementation signature
+async function load(url, loaders, options, context) {
+    let resolvedLoaders;
+    let resolvedOptions;
+    // Signature: load(url, options)
+    if (!Array.isArray(loaders) && !(0, normalize_loader_1.isLoaderObject)(loaders)) {
+        resolvedLoaders = [];
+        resolvedOptions = loaders;
+        context = undefined; // context not supported in short signature
+    }
+    else {
+        resolvedLoaders = loaders;
+        resolvedOptions = options;
+    }
+    // Select fetch function
+    const fetch = (0, get_fetch_function_1.getFetchFunction)(resolvedOptions);
+    // at this point, `url` could be already loaded binary data
+    let data = url;
+    // url is a string, fetch the url
+    if (typeof url === 'string') {
+        data = await fetch(url);
+        // URL is Blob or File, fetchFile handles it (alt: we could generate ObjectURL here)
+    }
+    if ((0, is_type_1.isBlob)(url)) {
+        // The fetch response object will contain blob.name
+        // @ts-expect-error TODO - This may not work for overridden fetch functions
+        data = await fetch(url);
+    }
+    // Data is loaded (at least we have a `Response` object) so time to hand over to `parse`
+    // return await parse(data, loaders as Loader[], options);
+    return Array.isArray(resolvedLoaders)
+        ? await (0, parse_1.parse)(data, resolvedLoaders, resolvedOptions) // loader array overload
+        : await (0, parse_1.parse)(data, resolvedLoaders, resolvedOptions); // single loader overload
 }
-//# sourceMappingURL=load.js.map
+exports.load = load;

package/dist/lib/api/loader-options.d.ts

@@ -0,0 +1,3 @@
+export { setGlobalOptions as setLoaderOptions } from '../loader-utils/option-utils';
+export { getGlobalLoaderOptions as getLoaderOptions } from '../loader-utils/option-utils';
+//# sourceMappingURL=loader-options.d.ts.map

package/dist/lib/api/loader-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader-options.d.ts","sourceRoot":"","sources":["../../../src/lib/api/loader-options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,gBAAgB,IAAI,gBAAgB,EAAC,MAAM,8BAA8B,CAAC;AAClF,OAAO,EAAC,sBAAsB,IAAI,gBAAgB,EAAC,MAAM,8BAA8B,CAAC"}

package/dist/lib/api/loader-options.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLoaderOptions = exports.setLoaderOptions = void 0;
+var option_utils_1 = require("../loader-utils/option-utils");
+Object.defineProperty(exports, "setLoaderOptions", { enumerable: true, get: function () { return option_utils_1.setGlobalOptions; } });
+var option_utils_2 = require("../loader-utils/option-utils");
+Object.defineProperty(exports, "getLoaderOptions", { enumerable: true, get: function () { return option_utils_2.getGlobalLoaderOptions; } });

package/dist/lib/api/parse-in-batches.d.ts

@@ -0,0 +1,10 @@
+import type { BatchableDataType, Loader, LoaderContext, LoaderOptions } from '@loaders.gl/loader-utils';
+/**
+ * Parses `data` using a specified loader
+ * @param data
+ * @param loaders
+ * @param options
+ * @param context
+ */
+export declare function parseInBatches(data: BatchableDataType, loaders?: Loader | Loader[] | LoaderOptions, options?: LoaderOptions, context?: LoaderContext): Promise<AsyncIterable<any>>;
+//# sourceMappingURL=parse-in-batches.d.ts.map

package/dist/lib/api/parse-in-batches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-in-batches.d.ts","sourceRoot":"","sources":["../../../src/lib/api/parse-in-batches.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,iBAAiB,EACjB,MAAM,EAEN,aAAa,EACb,aAAa,EACd,MAAM,0BAA0B,CAAC;AAYlC;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,iBAAiB,EACvB,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,aAAa,EAC3C,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAqC7B"}