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

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

package/dist/lib/api/parse-sync.d.ts

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

package/dist/lib/api/parse-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-sync.d.ts","sourceRoot":"","sources":["../../../src/lib/api/parse-sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,MAAM,EAEN,aAAa,EACb,aAAa,EACd,MAAM,0BAA0B,CAAC;AASlC;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,YAAY,EAClB,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,aAAa,EAC3C,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,aAAa,GACtB,GAAG,CAmCL"}

package/dist/lib/api/parse-sync.js

@@ -1,57 +1,59 @@
-import { assert } from '@loaders.gl/loader-utils';
-import { selectLoaderSync } from './select-loader';
-import { isLoaderObject } from '../loader-utils/normalize-loader';
-import { normalizeOptions } from '../loader-utils/option-utils';
-import { getArrayBufferOrStringFromDataSync } from '../loader-utils/get-data';
-import { getLoaderContext, getLoadersFromContext } from '../loader-utils/loader-context';
-import { getResourceUrlAndType } from '../utils/resource-utils';
-export function parseSync(data, loaders, options, context) {
-  assert(!context || typeof context === 'object');
-
-  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
-    context = undefined;
-    options = loaders;
-    loaders = undefined;
-  }
-
-  options = options || {};
-  const typedLoaders = loaders;
-  const candidateLoaders = getLoadersFromContext(typedLoaders, context);
-  const loader = selectLoaderSync(data, candidateLoaders, options);
-
-  if (!loader) {
-    return null;
-  }
-
-  options = normalizeOptions(options, loader, candidateLoaders);
-  const {
-    url
-  } = getResourceUrlAndType(data);
-
-  const parse = () => {
-    throw new Error('parseSync called parse');
-  };
-
-  context = getLoaderContext({
-    url,
-    parseSync,
-    parse,
-    loaders: loaders
-  }, options);
-  return parseWithLoaderSync(loader, data, options, context);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSync = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const select_loader_1 = require("./select-loader");
+const normalize_loader_1 = require("../loader-utils/normalize-loader");
+const option_utils_1 = require("../loader-utils/option-utils");
+const get_data_1 = require("../loader-utils/get-data");
+const loader_context_1 = require("../loader-utils/loader-context");
+const resource_utils_1 = require("../utils/resource-utils");
+/**
+ * Parses `data` synchronously using a specified loader
+ * @param data
+ * @param loaders
+ * @param options
+ * @param context
+ */
+function parseSync(data, loaders, options, context) {
+    (0, loader_utils_1.assert)(!context || typeof context === 'object'); // parseSync no longer accepts final url
+    // Signature: parseSync(data, options)
+    // 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;
+    }
+    options = options || {};
+    // Chooses a loader (and normalizes it)
+    // Also use any loaders in the context, new loaders take priority
+    const typedLoaders = loaders;
+    const candidateLoaders = (0, loader_context_1.getLoadersFromContext)(typedLoaders, context);
+    const loader = (0, select_loader_1.selectLoaderSync)(data, candidateLoaders, options);
+    // Note: if nothrow option was set, it is possible that no loader was found, if so just return null
+    if (!loader) {
+        return null;
+    }
+    // Normalize options
+    options = (0, option_utils_1.normalizeOptions)(options, loader, candidateLoaders);
+    // Extract a url for auto detection
+    const { url } = (0, resource_utils_1.getResourceUrlAndType)(data);
+    const parse = () => {
+        throw new Error('parseSync called parse');
+    };
+    context = (0, loader_context_1.getLoaderContext)({ url, parseSync, parse, loaders: loaders }, options);
+    return parseWithLoaderSync(loader, data, options, context);
 }
-
+exports.parseSync = parseSync;
+// TODO - should accept loader.parseSync/parse and generate 1 chunk asyncIterator
 function parseWithLoaderSync(loader, data, options, context) {
-  data = getArrayBufferOrStringFromDataSync(data, loader, options);
-
-  if (loader.parseTextSync && typeof data === 'string') {
-    return loader.parseTextSync(data, options);
-  }
-
-  if (loader.parseSync && data instanceof ArrayBuffer) {
-    return loader.parseSync(data, options, context);
-  }
-
-  throw new Error("".concat(loader.name, " loader: 'parseSync' not supported by this loader, use 'parse' instead. ").concat(context.url || ''));
+    data = (0, get_data_1.getArrayBufferOrStringFromDataSync)(data, loader, options);
+    if (loader.parseTextSync && typeof data === 'string') {
+        return loader.parseTextSync(data, options); // , context, loader);
+    }
+    if (loader.parseSync && data instanceof ArrayBuffer) {
+        return loader.parseSync(data, options, context); // , loader);
+    }
+    // TBD - If synchronous parser not available, return null
+    throw new Error(`${loader.name} loader: 'parseSync' not supported by this loader, use 'parse' instead. ${context.url || ''}`);
 }
-//# sourceMappingURL=parse-sync.js.map

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

@@ -0,0 +1,6 @@
+import type { DataType, Loader, LoaderContext, LoaderOptions } from '@loaders.gl/loader-utils';
+import type { LoaderOptionsType, LoaderReturnType } from '@loaders.gl/loader-utils';
+export declare function parse<LoaderT extends Loader, OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>>(data: DataType | Promise<DataType>, loader: LoaderT, options?: OptionsT, context?: LoaderContext): Promise<LoaderReturnType<LoaderT>>;
+export declare function parse(data: DataType | Promise<DataType>, loaders: Loader[], options?: LoaderOptions, context?: LoaderContext): Promise<any>;
+export declare function parse(data: DataType | Promise<DataType>, options?: LoaderOptions): Promise<any>;
+//# sourceMappingURL=parse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../src/lib/api/parse.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;AAalF,wBAAsB,KAAK,CACzB,OAAO,SAAS,MAAM,EACtB,QAAQ,SAAS,aAAa,GAAG,iBAAiB,CAAC,OAAO,CAAC,EAE3D,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,EAClC,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC;AAEtC,wBAAsB,KAAK,CACzB,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,EAClC,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,GAAG,CAAC,CAAC;AAEhB,wBAAsB,KAAK,CACzB,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,EAClC,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,GAAG,CAAC,CAAC"}

package/dist/lib/api/parse.js

@@ -1,64 +1,84 @@
-import { assert, validateWorkerVersion } from '@loaders.gl/worker-utils';
-import { parseWithWorker, canParseWithWorker } from '@loaders.gl/loader-utils';
-import { isLoaderObject } from '../loader-utils/normalize-loader';
-import { normalizeOptions } from '../loader-utils/option-utils';
-import { getArrayBufferOrStringFromData } from '../loader-utils/get-data';
-import { getLoaderContext, getLoadersFromContext } from '../loader-utils/loader-context';
-import { getResourceUrlAndType } from '../utils/resource-utils';
-import { selectLoader } from './select-loader';
-export async function parse(data, loaders, options, context) {
-  assert(!context || typeof context === 'object');
-
-  if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
-    context = undefined;
-    options = loaders;
-    loaders = undefined;
-  }
-
-  data = await data;
-  options = options || {};
-  const {
-    url
-  } = getResourceUrlAndType(data);
-  const typedLoaders = loaders;
-  const candidateLoaders = getLoadersFromContext(typedLoaders, context);
-  const loader = await selectLoader(data, candidateLoaders, options);
-
-  if (!loader) {
-    return null;
-  }
-
-  options = normalizeOptions(options, loader, candidateLoaders, url);
-  context = getLoaderContext({
-    url,
-    parse,
-    loaders: candidateLoaders
-  }, options, context);
-  return await parseWithLoader(loader, data, options, context);
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const worker_utils_1 = require("@loaders.gl/worker-utils");
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const normalize_loader_1 = require("../loader-utils/normalize-loader");
+const is_type_1 = require("../../javascript-utils/is-type");
+const option_utils_1 = require("../loader-utils/option-utils");
+const get_data_1 = require("../loader-utils/get-data");
+const loader_context_1 = require("../loader-utils/loader-context");
+const resource_utils_1 = require("../utils/resource-utils");
+const select_loader_1 = require("./select-loader");
+/**
+ * Parses `data` using a specified loader
+ * @param data
+ * @param loaders
+ * @param options
+ * @param context
+ */
+// implementation signature
+async function parse(data, loaders, options, context) {
+    (0, worker_utils_1.assert)(!context || typeof context === 'object'); // parse no longer accepts final url
+    // Signature: parse(data, options, context | url)
+    // Uses registered loaders
+    if (loaders && !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 || {}; // Could be invalid...
+    // Extract a url for auto detection
+    const { url } = (0, resource_utils_1.getResourceUrlAndType)(data);
+    // Chooses a loader (and normalizes it)
+    // Also use any loaders in the context, new loaders take priority
+    const typedLoaders = loaders;
+    const candidateLoaders = (0, loader_context_1.getLoadersFromContext)(typedLoaders, context);
+    // todo hacky type cast
+    const loader = await (0, select_loader_1.selectLoader)(data, candidateLoaders, options);
+    // Note: if no loader was found, if so just return null
+    if (!loader) {
+        return null;
+    }
+    // Normalize options
+    options = (0, option_utils_1.normalizeOptions)(options, loader, candidateLoaders, url); // Could be invalid...
+    // Get a context (if already present, will be unchanged)
+    context = (0, loader_context_1.getLoaderContext)({ url, parse, loaders: candidateLoaders }, options, context);
+    return await parseWithLoader(loader, data, options, context);
 }
-
+exports.parse = parse;
+// TODO: support progress and abort
+// TODO - should accept loader.parseAsyncIterator and concatenate.
 async function parseWithLoader(loader, data, options, context) {
-  validateWorkerVersion(loader);
-  data = await getArrayBufferOrStringFromData(data, loader, options);
-
-  if (loader.parseTextSync && typeof data === 'string') {
-    options.dataType = 'text';
-    return loader.parseTextSync(data, options, context, loader);
-  }
-
-  if (canParseWithWorker(loader, options)) {
-    return await parseWithWorker(loader, data, options, context, parse);
-  }
-
-  if (loader.parseText && typeof data === 'string') {
-    return await loader.parseText(data, options, context, loader);
-  }
-
-  if (loader.parse) {
-    return await loader.parse(data, options, context, loader);
-  }
-
-  assert(!loader.parseSync);
-  throw new Error("".concat(loader.id, " loader - no parser found and worker is disabled"));
+    (0, worker_utils_1.validateWorkerVersion)(loader);
+    if ((0, is_type_1.isResponse)(data)) {
+        // Serialize to support passing the response to web worker
+        const response = data;
+        const { ok, redirected, status, statusText, type, url } = response;
+        const headers = Object.fromEntries(response.headers.entries());
+        context.response = { headers, ok, redirected, status, statusText, type, url };
+    }
+    data = await (0, get_data_1.getArrayBufferOrStringFromData)(data, loader, options);
+    // First check for synchronous text parser, wrap results in promises
+    if (loader.parseTextSync && typeof data === 'string') {
+        options.dataType = 'text';
+        return loader.parseTextSync(data, options, context, loader);
+    }
+    // If we have a workerUrl and the loader can parse the given options efficiently in a worker
+    if ((0, loader_utils_1.canParseWithWorker)(loader, options)) {
+        return await (0, loader_utils_1.parseWithWorker)(loader, data, options, context, parse);
+    }
+    // Check for asynchronous parser
+    if (loader.parseText && typeof data === 'string') {
+        return await loader.parseText(data, options, context, loader);
+    }
+    if (loader.parse) {
+        return await loader.parse(data, options, context, loader);
+    }
+    // This should not happen, all sync loaders should also offer `parse` function
+    (0, worker_utils_1.assert)(!loader.parseSync);
+    // TBD - If asynchronous parser not available, return null
+    throw new Error(`${loader.id} loader - no parser found and worker is disabled`);
 }
-//# sourceMappingURL=parse.js.map

package/dist/lib/api/register-loaders.d.ts

@@ -0,0 +1,7 @@
+import { Loader } from '@loaders.gl/loader-utils';
+/** Register a list of global loaders */
+export declare function registerLoaders(loaders: Loader[] | Loader): void;
+export declare function getRegisteredLoaders(): Loader[];
+/** @deprecated For testing only  */
+export declare function _unregisterLoaders(): void;
+//# sourceMappingURL=register-loaders.d.ts.map

package/dist/lib/api/register-loaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-loaders.d.ts","sourceRoot":"","sources":["../../../src/lib/api/register-loaders.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAYhD,wCAAwC;AACxC,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,QAYzD;AAED,wBAAgB,oBAAoB,IAAI,MAAM,EAAE,CAE/C;AAED,oCAAoC;AACpC,wBAAgB,kBAAkB,SAGjC"}

package/dist/lib/api/register-loaders.js

@@ -1,29 +1,35 @@
-import { normalizeLoader } from '../loader-utils/normalize-loader';
-import { getGlobalLoaderState } from '../loader-utils/option-utils';
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._unregisterLoaders = exports.getRegisteredLoaders = exports.registerLoaders = void 0;
+const normalize_loader_1 = require("../loader-utils/normalize-loader");
+const option_utils_1 = require("../loader-utils/option-utils");
+// Store global registered loaders on the global object to increase chances of cross loaders-version interoperability
+// This use case is not reliable but can help when testing new versions of loaders.gl with existing frameworks
 const getGlobalLoaderRegistry = () => {
-  const state = getGlobalLoaderState();
-  state.loaderRegistry = state.loaderRegistry || [];
-  return state.loaderRegistry;
+    const state = (0, option_utils_1.getGlobalLoaderState)();
+    state.loaderRegistry = state.loaderRegistry || [];
+    return state.loaderRegistry;
 };
-
-export function registerLoaders(loaders) {
-  const loaderRegistry = getGlobalLoaderRegistry();
-  loaders = Array.isArray(loaders) ? loaders : [loaders];
-
-  for (const loader of loaders) {
-    const normalizedLoader = normalizeLoader(loader);
-
-    if (!loaderRegistry.find(registeredLoader => normalizedLoader === registeredLoader)) {
-      loaderRegistry.unshift(normalizedLoader);
+/** Register a list of global loaders */
+function registerLoaders(loaders) {
+    const loaderRegistry = getGlobalLoaderRegistry();
+    loaders = Array.isArray(loaders) ? loaders : [loaders];
+    for (const loader of loaders) {
+        const normalizedLoader = (0, normalize_loader_1.normalizeLoader)(loader);
+        if (!loaderRegistry.find((registeredLoader) => normalizedLoader === registeredLoader)) {
+            // add to the beginning of the loaderRegistry, so the last registeredLoader get picked
+            loaderRegistry.unshift(normalizedLoader);
+        }
     }
-  }
 }
-export function getRegisteredLoaders() {
-  return getGlobalLoaderRegistry();
+exports.registerLoaders = registerLoaders;
+function getRegisteredLoaders() {
+    return getGlobalLoaderRegistry();
 }
-export function _unregisterLoaders() {
-  const state = getGlobalLoaderState();
-  state.loaderRegistry = [];
+exports.getRegisteredLoaders = getRegisteredLoaders;
+/** @deprecated For testing only  */
+function _unregisterLoaders() {
+    const state = (0, option_utils_1.getGlobalLoaderState)();
+    state.loaderRegistry = [];
 }
-//# sourceMappingURL=register-loaders.js.map
+exports._unregisterLoaders = _unregisterLoaders;

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

@@ -0,0 +1,4 @@
+import type { Writer, WriterOptions } from '@loaders.gl/loader-utils';
+export declare function save(data: any, url: any, writer: Writer, options: WriterOptions): Promise<void>;
+export declare function saveSync(data: any, url: any, writer: any, options: any): void;
+//# sourceMappingURL=save.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"save.d.ts","sourceRoot":"","sources":["../../../src/lib/api/save.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAIpE,wBAAsB,IAAI,CAAC,IAAI,KAAA,EAAE,GAAG,KAAA,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,iBAG3E;AAED,wBAAgB,QAAQ,CAAC,IAAI,KAAA,EAAE,GAAG,KAAA,EAAE,MAAM,KAAA,EAAE,OAAO,KAAA,QAGlD"}

package/dist/lib/api/save.js

@@ -1,11 +1,15 @@
-import { encode, encodeSync } from './encode';
-import { writeFile, writeFileSync } from '../fetch/write-file';
-export async function save(data, url, writer, options) {
-  const encodedData = await encode(data, writer, options);
-  return await writeFile(url, encodedData);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveSync = exports.save = void 0;
+const encode_1 = require("./encode");
+const write_file_1 = require("../fetch/write-file");
+async function save(data, url, writer, options) {
+    const encodedData = await (0, encode_1.encode)(data, writer, options);
+    return await (0, write_file_1.writeFile)(url, encodedData);
 }
-export function saveSync(data, url, writer, options) {
-  const encodedData = encodeSync(data, writer, options);
-  return writeFileSync(url, encodedData);
+exports.save = save;
+function saveSync(data, url, writer, options) {
+    const encodedData = (0, encode_1.encodeSync)(data, writer, options);
+    return (0, write_file_1.writeFileSync)(url, encodedData);
 }
-//# sourceMappingURL=save.js.map
+exports.saveSync = saveSync;