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

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

@@ -1,59 +1,57 @@
-"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);
+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);
 }
-exports.parseSync = parseSync;
-// TODO - should accept loader.parseSync/parse and generate 1 chunk asyncIterator
+
 function parseWithLoaderSync(loader, data, options, context) {
-    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 || ''}`);
+  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 || ''));
 }
+//# sourceMappingURL=parse-sync.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/api/parse-sync.ts"],"names":["assert","selectLoaderSync","isLoaderObject","normalizeOptions","getArrayBufferOrStringFromDataSync","getLoaderContext","getLoadersFromContext","getResourceUrlAndType","parseSync","data","loaders","options","context","Array","isArray","undefined","typedLoaders","candidateLoaders","loader","url","parse","Error","parseWithLoaderSync","parseTextSync","ArrayBuffer","name"],"mappings":"AAOA,SAAQA,MAAR,QAAqB,0BAArB;AACA,SAAQC,gBAAR,QAA+B,iBAA/B;AACA,SAAQC,cAAR,QAA6B,kCAA7B;AACA,SAAQC,gBAAR,QAA+B,8BAA/B;AACA,SAAQC,kCAAR,QAAiD,0BAAjD;AACA,SAAQC,gBAAR,EAA0BC,qBAA1B,QAAsD,gCAAtD;AACA,SAAQC,qBAAR,QAAoC,yBAApC;AASA,OAAO,SAASC,SAAT,CACLC,IADK,EAELC,OAFK,EAGLC,OAHK,EAILC,OAJK,EAKA;AACLZ,EAAAA,MAAM,CAAC,CAACY,OAAD,IAAY,OAAOA,OAAP,KAAmB,QAAhC,CAAN;;AAIA,MAAI,CAACC,KAAK,CAACC,OAAN,CAAcJ,OAAd,CAAD,IAA2B,CAACR,cAAc,CAACQ,OAAD,CAA9C,EAAyD;AACvDE,IAAAA,OAAO,GAAGG,SAAV;AACAJ,IAAAA,OAAO,GAAGD,OAAV;AACAA,IAAAA,OAAO,GAAGK,SAAV;AACD;;AAEDJ,EAAAA,OAAO,GAAGA,OAAO,IAAI,EAArB;AAIA,QAAMK,YAAY,GAAGN,OAArB;AACA,QAAMO,gBAAgB,GAAGX,qBAAqB,CAACU,YAAD,EAAeJ,OAAf,CAA9C;AACA,QAAMM,MAAM,GAAGjB,gBAAgB,CAACQ,IAAD,EAAOQ,gBAAP,EAAyBN,OAAzB,CAA/B;;AAEA,MAAI,CAACO,MAAL,EAAa;AACX,WAAO,IAAP;AACD;;AAGDP,EAAAA,OAAO,GAAGR,gBAAgB,CAACQ,OAAD,EAAUO,MAAV,EAAkBD,gBAAlB,CAA1B;AAGA,QAAM;AAACE,IAAAA;AAAD,MAAQZ,qBAAqB,CAACE,IAAD,CAAnC;;AAEA,QAAMW,KAAK,GAAG,MAAM;AAClB,UAAM,IAAIC,KAAJ,CAAU,wBAAV,CAAN;AACD,GAFD;;AAGAT,EAAAA,OAAO,GAAGP,gBAAgB,CAAC;AAACc,IAAAA,GAAD;AAAMX,IAAAA,SAAN;AAAiBY,IAAAA,KAAjB;AAAwBV,IAAAA,OAAO,EAAEA;AAAjC,GAAD,EAAwDC,OAAxD,CAA1B;AAEA,SAAOW,mBAAmB,CAACJ,MAAD,EAA6BT,IAA7B,EAAmCE,OAAnC,EAA4CC,OAA5C,CAA1B;AACD;;AAGD,SAASU,mBAAT,CACEJ,MADF,EAEET,IAFF,EAGEE,OAHF,EAIEC,OAJF,EAKE;AACAH,EAAAA,IAAI,GAAGL,kCAAkC,CAACK,IAAD,EAAOS,MAAP,EAAeP,OAAf,CAAzC;;AAEA,MAAIO,MAAM,CAACK,aAAP,IAAwB,OAAOd,IAAP,KAAgB,QAA5C,EAAsD;AACpD,WAAOS,MAAM,CAACK,aAAP,CAAqBd,IAArB,EAA2BE,OAA3B,CAAP;AACD;;AAED,MAAIO,MAAM,CAACV,SAAP,IAAoBC,IAAI,YAAYe,WAAxC,EAAqD;AACnD,WAAON,MAAM,CAACV,SAAP,CAAiBC,IAAjB,EAAuBE,OAAvB,EAAgCC,OAAhC,CAAP;AACD;;AAGD,QAAM,IAAIS,KAAJ,WACDH,MAAM,CAACO,IADN,qFAEFb,OAAO,CAACO,GAAR,IAAe,EAFb,EAAN;AAKD","sourcesContent":["import type {\n  SyncDataType,\n  Loader,\n  LoaderWithParser,\n  LoaderContext,\n  LoaderOptions\n} from '@loaders.gl/loader-utils';\nimport {assert} from '@loaders.gl/loader-utils';\nimport {selectLoaderSync} from './select-loader';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {normalizeOptions} from '../loader-utils/option-utils';\nimport {getArrayBufferOrStringFromDataSync} from '../loader-utils/get-data';\nimport {getLoaderContext, getLoadersFromContext} from '../loader-utils/loader-context';\nimport {getResourceUrlAndType} from '../utils/resource-utils';\n\n/**\n * Parses `data` synchronously using a specified loader\n * @param data\n * @param loaders\n * @param options\n * @param context\n */\nexport function parseSync(\n  data: SyncDataType,\n  loaders?: Loader | Loader[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): any {\n  assert(!context || typeof context === 'object'); // parseSync no longer accepts final url\n\n  // Signature: parseSync(data, options)\n  // Uses registered loaders\n  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {\n    context = undefined; // context not supported in short signature\n    options = loaders as LoaderOptions;\n    loaders = undefined;\n  }\n\n  options = options || {};\n\n  // Chooses a loader (and normalizes it)\n  // Also use any loaders in the context, new loaders take priority\n  const typedLoaders = loaders as Loader | Loader[] | undefined;\n  const candidateLoaders = getLoadersFromContext(typedLoaders, context);\n  const loader = selectLoaderSync(data, candidateLoaders, options);\n  // Note: if nothrow option was set, it is possible that no loader was found, if so just return null\n  if (!loader) {\n    return null;\n  }\n\n  // Normalize options\n  options = normalizeOptions(options, loader, candidateLoaders);\n\n  // Extract a url for auto detection\n  const {url} = getResourceUrlAndType(data);\n\n  const parse = () => {\n    throw new Error('parseSync called parse');\n  };\n  context = getLoaderContext({url, parseSync, parse, loaders: loaders as Loader[]}, options);\n\n  return parseWithLoaderSync(loader as LoaderWithParser, data, options, context);\n}\n\n// TODO - should accept loader.parseSync/parse and generate 1 chunk asyncIterator\nfunction parseWithLoaderSync(\n  loader: LoaderWithParser,\n  data: SyncDataType,\n  options: LoaderOptions,\n  context: LoaderContext\n) {\n  data = getArrayBufferOrStringFromDataSync(data, loader, options);\n\n  if (loader.parseTextSync && typeof data === 'string') {\n    return loader.parseTextSync(data, options); // , context, loader);\n  }\n\n  if (loader.parseSync && data instanceof ArrayBuffer) {\n    return loader.parseSync(data, options, context); // , loader);\n  }\n\n  // TBD - If synchronous parser not available, return null\n  throw new Error(\n    `${loader.name} loader: 'parseSync' not supported by this loader, use 'parse' instead. ${\n      context.url || ''\n    }`\n  );\n}\n"],"file":"parse-sync.js"}

package/dist/lib/api/parse.js

@@ -1,74 +1,64 @@
-"use strict";
-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 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
- */
-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 || {};
-    // 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);
-    // 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);
+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);
 }
-exports.parse = parse;
-// TODO: support progress and abort
-// TODO - should accept loader.parseAsyncIterator and concatenate.
+
 async function parseWithLoader(loader, data, options, context) {
-    (0, worker_utils_1.validateWorkerVersion)(loader);
-    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`);
+  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"));
 }
+//# sourceMappingURL=parse.js.map

package/dist/lib/api/parse.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/api/parse.ts"],"names":["assert","validateWorkerVersion","parseWithWorker","canParseWithWorker","isLoaderObject","normalizeOptions","getArrayBufferOrStringFromData","getLoaderContext","getLoadersFromContext","getResourceUrlAndType","selectLoader","parse","data","loaders","options","context","Array","isArray","undefined","url","typedLoaders","candidateLoaders","loader","parseWithLoader","parseTextSync","dataType","parseText","parseSync","Error","id"],"mappings":"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","sourcesContent":["import type {DataType, Loader, LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';\nimport {assert, validateWorkerVersion} from '@loaders.gl/worker-utils';\nimport {parseWithWorker, canParseWithWorker} from '@loaders.gl/loader-utils';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {normalizeOptions} from '../loader-utils/option-utils';\nimport {getArrayBufferOrStringFromData} from '../loader-utils/get-data';\nimport {getLoaderContext, getLoadersFromContext} from '../loader-utils/loader-context';\nimport {getResourceUrlAndType} from '../utils/resource-utils';\nimport {selectLoader} from './select-loader';\n\n/**\n * Parses `data` using a specified loader\n * @param data\n * @param loaders\n * @param options\n * @param context\n */\nexport async function parse(\n  data: DataType | Promise<DataType>,\n  loaders?: Loader | Loader[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<any> {\n  assert(!context || typeof context === 'object'); // parse no longer accepts final url\n\n  // Signature: parse(data, options, context | url)\n  // Uses registered loaders\n  if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {\n    context = undefined; // context not supported in short signature\n    options = loaders as LoaderOptions;\n    loaders = undefined;\n  }\n\n  data = await data; // Resolve any promise\n  options = options || {};\n\n  // Extract a url for auto detection\n  const {url} = getResourceUrlAndType(data);\n\n  // Chooses a loader (and normalizes it)\n  // Also use any loaders in the context, new loaders take priority\n  const typedLoaders = loaders as Loader | Loader[] | undefined;\n  const candidateLoaders = getLoadersFromContext(typedLoaders, context);\n  // todo hacky type cast\n  const loader = await selectLoader(data as ArrayBuffer, candidateLoaders, options);\n  // Note: if no loader was found, if so just return null\n  if (!loader) {\n    return null;\n  }\n\n  // Normalize options\n  options = normalizeOptions(options, loader, candidateLoaders, url);\n\n  // Get a context (if already present, will be unchanged)\n  context = getLoaderContext({url, parse, loaders: candidateLoaders}, options, context);\n\n  return await parseWithLoader(loader, data, options, context);\n}\n\n// TODO: support progress and abort\n// TODO - should accept loader.parseAsyncIterator and concatenate.\nasync function parseWithLoader(loader, data, options, context) {\n  validateWorkerVersion(loader);\n\n  data = await getArrayBufferOrStringFromData(data, loader, options);\n\n  // First check for synchronous text parser, wrap results in promises\n  if (loader.parseTextSync && typeof data === 'string') {\n    options.dataType = 'text';\n    return loader.parseTextSync(data, options, context, loader);\n  }\n\n  // If we have a workerUrl and the loader can parse the given options efficiently in a worker\n  if (canParseWithWorker(loader, options)) {\n    return await parseWithWorker(loader, data, options, context, parse);\n  }\n\n  // Check for asynchronous parser\n  if (loader.parseText && typeof data === 'string') {\n    return await loader.parseText(data, options, context, loader);\n  }\n\n  if (loader.parse) {\n    return await loader.parse(data, options, context, loader);\n  }\n\n  // This should not happen, all sync loaders should also offer `parse` function\n  assert(!loader.parseSync);\n\n  // TBD - If asynchronous parser not available, return null\n  throw new Error(`${loader.id} loader - no parser found and worker is disabled`);\n}\n"],"file":"parse.js"}

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

@@ -1,35 +1,29 @@
-"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
+import { normalizeLoader } from '../loader-utils/normalize-loader';
+import { getGlobalLoaderState } from '../loader-utils/option-utils';
+
 const getGlobalLoaderRegistry = () => {
-    const state = (0, option_utils_1.getGlobalLoaderState)();
-    state.loaderRegistry = state.loaderRegistry || [];
-    return state.loaderRegistry;
+  const state = getGlobalLoaderState();
+  state.loaderRegistry = state.loaderRegistry || [];
+  return state.loaderRegistry;
 };
-/** 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 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);
     }
+  }
 }
-exports.registerLoaders = registerLoaders;
-function getRegisteredLoaders() {
-    return getGlobalLoaderRegistry();
+export function getRegisteredLoaders() {
+  return getGlobalLoaderRegistry();
 }
-exports.getRegisteredLoaders = getRegisteredLoaders;
-/** @deprecated For testing only  */
-function _unregisterLoaders() {
-    const state = (0, option_utils_1.getGlobalLoaderState)();
-    state.loaderRegistry = [];
+export function _unregisterLoaders() {
+  const state = getGlobalLoaderState();
+  state.loaderRegistry = [];
 }
-exports._unregisterLoaders = _unregisterLoaders;
+//# sourceMappingURL=register-loaders.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/api/register-loaders.ts"],"names":["normalizeLoader","getGlobalLoaderState","getGlobalLoaderRegistry","state","loaderRegistry","registerLoaders","loaders","Array","isArray","loader","normalizedLoader","find","registeredLoader","unshift","getRegisteredLoaders","_unregisterLoaders"],"mappings":"AACA,SAAQA,eAAR,QAA8B,kCAA9B;AACA,SAAQC,oBAAR,QAAmC,8BAAnC;;AAIA,MAAMC,uBAAuB,GAAG,MAAM;AACpC,QAAMC,KAAK,GAAGF,oBAAoB,EAAlC;AACAE,EAAAA,KAAK,CAACC,cAAN,GAAuBD,KAAK,CAACC,cAAN,IAAwB,EAA/C;AACA,SAAOD,KAAK,CAACC,cAAb;AACD,CAJD;;AAOA,OAAO,SAASC,eAAT,CAAyBC,OAAzB,EAA4C;AACjD,QAAMF,cAAc,GAAGF,uBAAuB,EAA9C;AAEAI,EAAAA,OAAO,GAAGC,KAAK,CAACC,OAAN,CAAcF,OAAd,IAAyBA,OAAzB,GAAmC,CAACA,OAAD,CAA7C;;AAEA,OAAK,MAAMG,MAAX,IAAqBH,OAArB,EAA8B;AAC5B,UAAMI,gBAAgB,GAAGV,eAAe,CAACS,MAAD,CAAxC;;AACA,QAAI,CAACL,cAAc,CAACO,IAAf,CAAqBC,gBAAD,IAAsBF,gBAAgB,KAAKE,gBAA/D,CAAL,EAAuF;AAErFR,MAAAA,cAAc,CAACS,OAAf,CAAuBH,gBAAvB;AACD;AACF;AACF;AAED,OAAO,SAASI,oBAAT,GAA0C;AAC/C,SAAOZ,uBAAuB,EAA9B;AACD;AAGD,OAAO,SAASa,kBAAT,GAA8B;AACnC,QAAMZ,KAAK,GAAGF,oBAAoB,EAAlC;AACAE,EAAAA,KAAK,CAACC,cAAN,GAAuB,EAAvB;AACD","sourcesContent":["import {Loader} from '@loaders.gl/loader-utils';\nimport {normalizeLoader} from '../loader-utils/normalize-loader';\nimport {getGlobalLoaderState} from '../loader-utils/option-utils';\n\n// Store global registered loaders on the global object to increase chances of cross loaders-version interoperability\n// This use case is not reliable but can help when testing new versions of loaders.gl with existing frameworks\nconst getGlobalLoaderRegistry = () => {\n  const state = getGlobalLoaderState();\n  state.loaderRegistry = state.loaderRegistry || [];\n  return state.loaderRegistry;\n};\n\n/** Register a list of global loaders */\nexport function registerLoaders(loaders: Loader[]) {\n  const loaderRegistry = getGlobalLoaderRegistry();\n\n  loaders = Array.isArray(loaders) ? loaders : [loaders];\n\n  for (const loader of loaders) {\n    const normalizedLoader = normalizeLoader(loader);\n    if (!loaderRegistry.find((registeredLoader) => normalizedLoader === registeredLoader)) {\n      // add to the beginning of the loaderRegistry, so the last registeredLoader get picked\n      loaderRegistry.unshift(normalizedLoader);\n    }\n  }\n}\n\nexport function getRegisteredLoaders(): Loader[] {\n  return getGlobalLoaderRegistry();\n}\n\n/** @deprecated For testing only  */\nexport function _unregisterLoaders() {\n  const state = getGlobalLoaderState();\n  state.loaderRegistry = [];\n}\n"],"file":"register-loaders.js"}

package/dist/lib/api/save.js

@@ -1,15 +1,11 @@
-"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);
+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);
 }
-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);
+export function saveSync(data, url, writer, options) {
+  const encodedData = encodeSync(data, writer, options);
+  return writeFileSync(url, encodedData);
 }
-exports.saveSync = saveSync;
+//# sourceMappingURL=save.js.map

package/dist/lib/api/save.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/api/save.ts"],"names":["encode","encodeSync","writeFile","writeFileSync","save","data","url","writer","options","encodedData","saveSync"],"mappings":"AACA,SAAQA,MAAR,EAAgBC,UAAhB,QAAiC,UAAjC;AACA,SAAQC,SAAR,EAAmBC,aAAnB,QAAuC,qBAAvC;AAEA,OAAO,eAAeC,IAAf,CAAoBC,IAApB,EAA0BC,GAA1B,EAA+BC,MAA/B,EAA+CC,OAA/C,EAAuE;AAC5E,QAAMC,WAAW,GAAG,MAAMT,MAAM,CAACK,IAAD,EAAOE,MAAP,EAAeC,OAAf,CAAhC;AACA,SAAO,MAAMN,SAAS,CAACI,GAAD,EAAMG,WAAN,CAAtB;AACD;AAED,OAAO,SAASC,QAAT,CAAkBL,IAAlB,EAAwBC,GAAxB,EAA6BC,MAA7B,EAAqCC,OAArC,EAA8C;AACnD,QAAMC,WAAW,GAAGR,UAAU,CAACI,IAAD,EAAOE,MAAP,EAAeC,OAAf,CAA9B;AACA,SAAOL,aAAa,CAACG,GAAD,EAAMG,WAAN,CAApB;AACD","sourcesContent":["import type {Writer, WriterOptions} from '@loaders.gl/loader-utils';\nimport {encode, encodeSync} from './encode';\nimport {writeFile, writeFileSync} from '../fetch/write-file';\n\nexport async function save(data, url, writer: Writer, options: WriterOptions) {\n  const encodedData = await encode(data, writer, options);\n  return await writeFile(url, encodedData);\n}\n\nexport function saveSync(data, url, writer, options) {\n  const encodedData = encodeSync(data, writer, options);\n  return writeFileSync(url, encodedData);\n}\n"],"file":"save.js"}