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

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

@@ -1,5 +1,5 @@
 import type { LoaderWithParser, LoaderOptions, LoaderContext } from '@loaders.gl/loader-utils';
-declare type FileType = string | File | Blob | Response | (string | File | Blob | Response)[] | FileList;
+type FileType = string | File | Blob | Response | (string | File | Blob | Response)[] | FileList;
 /**
  * Parses `data` using a specified loader
  * @param data

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

@@ -1 +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,aAAK,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"}
+{"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

@@ -1,4 +1,5 @@
 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.
@@ -8,5 +9,6 @@ import type { DataType, Loader, LoaderContext, LoaderOptions } from '@loaders.gl
  * @param options
  * @param context
  */
-export declare function load(url: string | DataType, loaders?: Loader | Loader[] | LoaderOptions, options?: LoaderOptions, context?: LoaderContext): Promise<any>;
+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

@@ -1 +1 @@
-{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../../src/lib/api/load.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAO7F;;;;;;;;GAQG;AAEH,wBAAsB,IAAI,CACxB,GAAG,EAAE,MAAM,GAAG,QAAQ,EACtB,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,aAAa,EAC3C,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,GAAG,CAAC,CA0Bd"}
+{"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.js

@@ -1,99 +1,120 @@
-import { assert, concatenateArrayBuffersAsync } from '@loaders.gl/loader-utils';
-import { isLoaderObject } from '../loader-utils/normalize-loader';
-import { normalizeOptions } from '../loader-utils/option-utils';
-import { getLoaderContext } from '../loader-utils/loader-context';
-import { getAsyncIterableFromData } from '../loader-utils/get-data';
-import { getResourceUrlAndType } from '../utils/resource-utils';
-import { selectLoader } from './select-loader';
-import { parse } from './parse';
-export async function parseInBatches(data, loaders, options, context) {
-  assert(!context || typeof context === 'object');
-
-  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
-    context = undefined;
-    options = loaders;
-    loaders = undefined;
-  }
-
-  data = await data;
-  options = options || {};
-  const {
-    url
-  } = getResourceUrlAndType(data);
-  const loader = await selectLoader(data, loaders, options);
-
-  if (!loader) {
-    return null;
-  }
-
-  options = normalizeOptions(options, loader, loaders, url);
-  context = getLoaderContext({
-    url,
-    parseInBatches,
-    parse,
-    loaders: loaders
-  }, options, context);
-  return await parseWithLoaderInBatches(loader, data, options, context);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInBatches = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const normalize_loader_1 = require("../loader-utils/normalize-loader");
+const option_utils_1 = require("../loader-utils/option-utils");
+const loader_context_1 = require("../loader-utils/loader-context");
+const get_data_1 = require("../loader-utils/get-data");
+const resource_utils_1 = require("../utils/resource-utils");
+const select_loader_1 = require("./select-loader");
+// Ensure `parse` is available in context if loader falls back to `parse`
+const parse_1 = require("./parse");
+/**
+ * Parses `data` using a specified loader
+ * @param data
+ * @param loaders
+ * @param options
+ * @param context
+ */
+async function parseInBatches(data, loaders, options, context) {
+    (0, loader_utils_1.assert)(!context || typeof context === 'object'); // parseInBatches no longer accepts final url
+    // Signature: parseInBatches(data, options, url) - Uses registered loaders
+    if (!Array.isArray(loaders) && !(0, normalize_loader_1.isLoaderObject)(loaders)) {
+        context = undefined; // context not supported in short signature
+        options = loaders;
+        loaders = undefined;
+    }
+    data = await data; // Resolve any promise
+    options = options || {};
+    // Extract a url for auto detection
+    const { url } = (0, resource_utils_1.getResourceUrlAndType)(data);
+    // Chooses a loader and normalizes it
+    // Note - only uses URL and contentType for streams and iterator inputs
+    const loader = await (0, select_loader_1.selectLoader)(data, loaders, options);
+    // Note: if options.nothrow was set, it is possible that no loader was found, if so just return null
+    if (!loader) {
+        // @ts-ignore
+        return null;
+    }
+    // Normalize options
+    // @ts-ignore
+    options = (0, option_utils_1.normalizeOptions)(options, loader, loaders, url);
+    // @ts-ignore
+    context = (0, loader_context_1.getLoaderContext)(
+    // @ts-ignore
+    { url, parseInBatches, parse: parse_1.parse, loaders: loaders }, options, context);
+    return await parseWithLoaderInBatches(loader, data, options, context);
 }
-
+exports.parseInBatches = parseInBatches;
+/**
+ * Loader has been selected and context has been prepared, see if we need to emit a metadata batch
+ */
 async function parseWithLoaderInBatches(loader, data, options, context) {
-  const outputIterator = await parseToOutputIterator(loader, data, options, context);
-
-  if (!options.metadata) {
-    return outputIterator;
-  }
-
-  const metadataBatch = {
-    batchType: 'metadata',
-    metadata: {
-      _loader: loader,
-      _context: context
-    },
-    data: [],
-    bytesUsed: 0
-  };
-
-  async function* makeMetadataBatchIterator(iterator) {
-    yield metadataBatch;
-    yield* iterator;
-  }
-
-  return makeMetadataBatchIterator(outputIterator);
+    const outputIterator = await parseToOutputIterator(loader, data, options, context);
+    // Generate metadata batch if requested
+    if (!options.metadata) {
+        return outputIterator;
+    }
+    const metadataBatch = {
+        batchType: 'metadata',
+        metadata: {
+            _loader: loader,
+            _context: context
+        },
+        // Populate with some default fields to avoid crashing
+        data: [],
+        bytesUsed: 0
+    };
+    async function* makeMetadataBatchIterator(iterator) {
+        yield metadataBatch;
+        yield* iterator;
+    }
+    return makeMetadataBatchIterator(outputIterator);
 }
-
+/**
+ * Prep work is done, now it is time to start parsing into an output operator
+ * The approach depends on which parse function the loader exposes
+ * `parseInBatches` (preferred), `parse` (fallback)
+ */
 async function parseToOutputIterator(loader, data, options, context) {
-  const inputIterator = await getAsyncIterableFromData(data, options);
-  const transformedIterator = await applyInputTransforms(inputIterator, (options === null || options === void 0 ? void 0 : options.transforms) || []);
-
-  if (loader.parseInBatches) {
-    return loader.parseInBatches(transformedIterator, options, context);
-  }
-
-  async function* parseChunkInBatches() {
-    const arrayBuffer = await concatenateArrayBuffersAsync(transformedIterator);
-    const parsedData = await parse(arrayBuffer, loader, { ...options,
-      mimeType: loader.mimeTypes[0]
-    }, context);
-    const batch = {
-      mimeType: loader.mimeTypes[0],
-      shape: Array.isArray(parsedData) ? 'row-table' : 'unknown',
-      batchType: 'data',
-      data: parsedData,
-      length: Array.isArray(parsedData) ? parsedData.length : 1
-    };
-    yield batch;
-  }
-
-  return parseChunkInBatches();
+    // Get an iterator from the input
+    const inputIterator = await (0, get_data_1.getAsyncIterableFromData)(data, options);
+    // Apply any iterator transforms (options.transforms)
+    const transformedIterator = await applyInputTransforms(inputIterator, options?.transforms || []);
+    // If loader supports parseInBatches, we are done
+    if (loader.parseInBatches) {
+        return loader.parseInBatches(transformedIterator, options, context);
+    }
+    // Fallback: load atomically using `parse` concatenating input iterator into single chunk
+    async function* parseChunkInBatches() {
+        const arrayBuffer = await (0, loader_utils_1.concatenateArrayBuffersAsync)(transformedIterator);
+        // Call `parse` instead of `loader.parse` to ensure we can call workers etc.
+        const parsedData = await (0, parse_1.parse)(arrayBuffer, loader, 
+        // TODO - Hack: supply loaders MIME type to ensure we match it
+        { ...options, mimeType: loader.mimeTypes[0] }, context);
+        // yield a single batch, the output from loader.parse()
+        // TODO - run through batch builder to apply options etc...
+        const batch = {
+            mimeType: loader.mimeTypes[0],
+            shape: Array.isArray(parsedData) ? 'row-table' : 'unknown',
+            batchType: 'data',
+            data: parsedData,
+            length: Array.isArray(parsedData) ? parsedData.length : 1
+        };
+        yield batch;
+    }
+    return parseChunkInBatches();
 }
-
+/**
+ * Create an iterator chain with any transform iterators (crypto, decompression)
+ * @param inputIterator
+ * @param options
+ */
 async function applyInputTransforms(inputIterator, transforms = []) {
-  let iteratorChain = inputIterator;
-
-  for await (const transformBatches of transforms) {
-    iteratorChain = transformBatches(iteratorChain);
-  }
-
-  return iteratorChain;
+    let iteratorChain = inputIterator;
+    for await (const transformBatches of transforms) {
+        iteratorChain = transformBatches(iteratorChain);
+    }
+    return iteratorChain;
 }
-//# sourceMappingURL=parse-in-batches.js.map