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

package/dist/esm/lib/api/parse-in-batches.js

@@ -5,7 +5,9 @@ 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');
 
@@ -14,20 +16,21 @@ export async function parseInBatches(data, loaders, options, context) {
     options = loaders;
     loaders = undefined;
   }
-
   data = await data;
   options = options || {};
+
   const {
     url
   } = getResourceUrlAndType(data);
-  const loader = await selectLoader(data, loaders, options);
 
+  const loader = await selectLoader(data, loaders, options);
   if (!loader) {
     return null;
   }
 
   options = normalizeOptions(options, loader, loaders, url);
-  context = getLoaderContext({
+  context = getLoaderContext(
+  {
     url,
     parseInBatches,
     parse,
@@ -42,7 +45,6 @@ async function parseWithLoaderInBatches(loader, data, options, context) {
   if (!options.metadata) {
     return outputIterator;
   }
-
   const metadataBatch = {
     batchType: 'metadata',
     metadata: {
@@ -52,17 +54,16 @@ async function parseWithLoaderInBatches(loader, data, options, context) {
     data: [],
     bytesUsed: 0
   };
-
   async function* makeMetadataBatchIterator(iterator) {
     yield metadataBatch;
     yield* iterator;
   }
-
   return makeMetadataBatchIterator(outputIterator);
 }
 
 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) {
@@ -71,7 +72,9 @@ async function parseToOutputIterator(loader, data, options, context) {
 
   async function* parseChunkInBatches() {
     const arrayBuffer = await concatenateArrayBuffersAsync(transformedIterator);
-    const parsedData = await parse(arrayBuffer, loader, { ...options,
+    const parsedData = await parse(arrayBuffer, loader,
+    {
+      ...options,
       mimeType: loader.mimeTypes[0]
     }, context);
     const batch = {
@@ -83,17 +86,14 @@ async function parseToOutputIterator(loader, data, options, context) {
     };
     yield batch;
   }
-
   return parseChunkInBatches();
 }
-
-async function applyInputTransforms(inputIterator, transforms = []) {
+async function applyInputTransforms(inputIterator) {
+  let transforms = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
   let iteratorChain = inputIterator;
-
   for await (const transformBatches of transforms) {
     iteratorChain = transformBatches(iteratorChain);
   }
-
   return iteratorChain;
 }
 //# sourceMappingURL=parse-in-batches.js.map

package/dist/esm/lib/api/parse-in-batches.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/api/parse-in-batches.ts"],"names":["assert","concatenateArrayBuffersAsync","isLoaderObject","normalizeOptions","getLoaderContext","getAsyncIterableFromData","getResourceUrlAndType","selectLoader","parse","parseInBatches","data","loaders","options","context","Array","isArray","undefined","url","loader","parseWithLoaderInBatches","outputIterator","parseToOutputIterator","metadata","metadataBatch","batchType","_loader","_context","bytesUsed","makeMetadataBatchIterator","iterator","inputIterator","transformedIterator","applyInputTransforms","transforms","parseChunkInBatches","arrayBuffer","parsedData","mimeType","mimeTypes","batch","shape","length","iteratorChain","transformBatches"],"mappings":"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","sourcesContent":["import type {Batch} from '@loaders.gl/schema';\nimport type {\n  BatchableDataType,\n  Loader,\n  LoaderWithParser,\n  LoaderContext,\n  LoaderOptions\n} from '@loaders.gl/loader-utils';\nimport {assert, concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {normalizeOptions} from '../loader-utils/option-utils';\nimport {getLoaderContext} from '../loader-utils/loader-context';\nimport {getAsyncIterableFromData} from '../loader-utils/get-data';\nimport {getResourceUrlAndType} from '../utils/resource-utils';\nimport {selectLoader} from './select-loader';\n\n// Ensure `parse` is available in context if loader falls back to `parse`\nimport {parse} from './parse';\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 parseInBatches(\n  data: BatchableDataType,\n  loaders?: Loader | Loader[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<AsyncIterable<any>> {\n  assert(!context || typeof context === 'object'); // parseInBatches no longer accepts final url\n\n  // Signature: parseInBatches(data, options, url) - 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  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  // Note - only uses URL and contentType for streams and iterator inputs\n  const loader = await selectLoader(data as ArrayBuffer, loaders as Loader[], options);\n  // Note: if options.nothrow was set, it is possible that no loader was found, if so just return null\n  if (!loader) {\n    // @ts-ignore\n    return null;\n  }\n\n  // Normalize options\n  // @ts-ignore\n  options = normalizeOptions(options, loader, loaders, url);\n  // @ts-ignore\n  context = getLoaderContext(\n    // @ts-ignore\n    {url, parseInBatches, parse, loaders: loaders as Loader[]},\n    options,\n    context\n  );\n\n  return await parseWithLoaderInBatches(loader as LoaderWithParser, data, options, context);\n}\n\n/**\n * Loader has been selected and context has been prepared, see if we need to emit a metadata batch\n */\nasync function parseWithLoaderInBatches(\n  loader: LoaderWithParser,\n  data: BatchableDataType,\n  options: LoaderOptions,\n  context: LoaderContext\n): Promise<AsyncIterable<any>> {\n  const outputIterator = await parseToOutputIterator(loader, data, options, context);\n\n  // Generate metadata batch if requested\n  if (!options.metadata) {\n    return outputIterator;\n  }\n\n  const metadataBatch = {\n    batchType: 'metadata',\n    metadata: {\n      _loader: loader,\n      _context: context\n    },\n    // Populate with some default fields to avoid crashing\n    data: [],\n    bytesUsed: 0\n  };\n\n  async function* makeMetadataBatchIterator(iterator) {\n    yield metadataBatch;\n    yield* iterator;\n  }\n\n  return makeMetadataBatchIterator(outputIterator);\n}\n\n/**\n * Prep work is done, now it is time to start parsing into an output operator\n * The approach depends on which parse function the loader exposes\n * `parseInBatches` (preferred), `parse` (fallback)\n */\nasync function parseToOutputIterator(\n  loader: LoaderWithParser,\n  data: BatchableDataType,\n  options: LoaderOptions,\n  context: LoaderContext\n): Promise<AsyncIterable<any>> {\n  // Get an iterator from the input\n  const inputIterator = await getAsyncIterableFromData(data, options);\n\n  // Apply any iterator transforms (options.transforms)\n  const transformedIterator = await applyInputTransforms(inputIterator, options?.transforms || []);\n\n  // If loader supports parseInBatches, we are done\n  if (loader.parseInBatches) {\n    return loader.parseInBatches(transformedIterator, options, context);\n  }\n\n  // Fallback: load atomically using `parse` concatenating input iterator into single chunk\n  async function* parseChunkInBatches() {\n    const arrayBuffer = await concatenateArrayBuffersAsync(transformedIterator);\n    // Call `parse` instead of `loader.parse` to ensure we can call workers etc.\n    const parsedData = await parse(\n      arrayBuffer,\n      loader,\n      // TODO - Hack: supply loaders MIME type to ensure we match it\n      {...options, mimeType: loader.mimeTypes[0]},\n      context\n    );\n    // yield a single batch, the output from loader.parse()\n    // TODO - run through batch builder to apply options etc...\n    const batch: Batch = {\n      mimeType: loader.mimeTypes[0],\n      shape: Array.isArray(parsedData) ? 'row-table' : 'unknown',\n      batchType: 'data',\n      data: parsedData,\n      length: Array.isArray(parsedData) ? parsedData.length : 1\n    };\n    yield batch;\n  }\n\n  return parseChunkInBatches();\n}\n\ntype TransformBatches = (\n  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>\n) => AsyncIterable<ArrayBuffer>;\n\n/**\n * Create an iterator chain with any transform iterators (crypto, decompression)\n * @param inputIterator\n * @param options\n */\nasync function applyInputTransforms(\n  inputIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n  transforms: TransformBatches[] = []\n): Promise<AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>> {\n  let iteratorChain = inputIterator;\n  for await (const transformBatches of transforms) {\n    iteratorChain = transformBatches(iteratorChain);\n  }\n  return iteratorChain;\n}\n"],"file":"parse-in-batches.js"}
+{"version":3,"file":"parse-in-batches.js","names":["assert","concatenateArrayBuffersAsync","isLoaderObject","normalizeOptions","getLoaderContext","getAsyncIterableFromData","getResourceUrlAndType","selectLoader","parse","parseInBatches","data","loaders","options","context","Array","isArray","undefined","url","loader","parseWithLoaderInBatches","outputIterator","parseToOutputIterator","metadata","metadataBatch","batchType","_loader","_context","bytesUsed","makeMetadataBatchIterator","iterator","inputIterator","transformedIterator","applyInputTransforms","transforms","parseChunkInBatches","arrayBuffer","parsedData","mimeType","mimeTypes","batch","shape","length","iteratorChain","transformBatches"],"sources":["../../../../src/lib/api/parse-in-batches.ts"],"sourcesContent":["import type {Batch} from '@loaders.gl/schema';\nimport type {\n  BatchableDataType,\n  Loader,\n  LoaderWithParser,\n  LoaderContext,\n  LoaderOptions\n} from '@loaders.gl/loader-utils';\nimport {assert, concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {normalizeOptions} from '../loader-utils/option-utils';\nimport {getLoaderContext} from '../loader-utils/loader-context';\nimport {getAsyncIterableFromData} from '../loader-utils/get-data';\nimport {getResourceUrlAndType} from '../utils/resource-utils';\nimport {selectLoader} from './select-loader';\n\n// Ensure `parse` is available in context if loader falls back to `parse`\nimport {parse} from './parse';\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 parseInBatches(\n  data: BatchableDataType,\n  loaders?: Loader | Loader[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<AsyncIterable<any>> {\n  assert(!context || typeof context === 'object'); // parseInBatches no longer accepts final url\n\n  // Signature: parseInBatches(data, options, url) - 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  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  // Note - only uses URL and contentType for streams and iterator inputs\n  const loader = await selectLoader(data as ArrayBuffer, loaders as Loader[], options);\n  // Note: if options.nothrow was set, it is possible that no loader was found, if so just return null\n  if (!loader) {\n    // @ts-ignore\n    return null;\n  }\n\n  // Normalize options\n  // @ts-ignore\n  options = normalizeOptions(options, loader, loaders, url);\n  // @ts-ignore\n  context = getLoaderContext(\n    // @ts-ignore\n    {url, parseInBatches, parse, loaders: loaders as Loader[]},\n    options,\n    context\n  );\n\n  return await parseWithLoaderInBatches(loader as LoaderWithParser, data, options, context);\n}\n\n/**\n * Loader has been selected and context has been prepared, see if we need to emit a metadata batch\n */\nasync function parseWithLoaderInBatches(\n  loader: LoaderWithParser,\n  data: BatchableDataType,\n  options: LoaderOptions,\n  context: LoaderContext\n): Promise<AsyncIterable<any>> {\n  const outputIterator = await parseToOutputIterator(loader, data, options, context);\n\n  // Generate metadata batch if requested\n  if (!options.metadata) {\n    return outputIterator;\n  }\n\n  const metadataBatch = {\n    batchType: 'metadata',\n    metadata: {\n      _loader: loader,\n      _context: context\n    },\n    // Populate with some default fields to avoid crashing\n    data: [],\n    bytesUsed: 0\n  };\n\n  async function* makeMetadataBatchIterator(iterator) {\n    yield metadataBatch;\n    yield* iterator;\n  }\n\n  return makeMetadataBatchIterator(outputIterator);\n}\n\n/**\n * Prep work is done, now it is time to start parsing into an output operator\n * The approach depends on which parse function the loader exposes\n * `parseInBatches` (preferred), `parse` (fallback)\n */\nasync function parseToOutputIterator(\n  loader: LoaderWithParser,\n  data: BatchableDataType,\n  options: LoaderOptions,\n  context: LoaderContext\n): Promise<AsyncIterable<any>> {\n  // Get an iterator from the input\n  const inputIterator = await getAsyncIterableFromData(data, options);\n\n  // Apply any iterator transforms (options.transforms)\n  const transformedIterator = await applyInputTransforms(inputIterator, options?.transforms || []);\n\n  // If loader supports parseInBatches, we are done\n  if (loader.parseInBatches) {\n    return loader.parseInBatches(transformedIterator, options, context);\n  }\n\n  // Fallback: load atomically using `parse` concatenating input iterator into single chunk\n  async function* parseChunkInBatches() {\n    const arrayBuffer = await concatenateArrayBuffersAsync(transformedIterator);\n    // Call `parse` instead of `loader.parse` to ensure we can call workers etc.\n    const parsedData = await parse(\n      arrayBuffer,\n      loader,\n      // TODO - Hack: supply loaders MIME type to ensure we match it\n      {...options, mimeType: loader.mimeTypes[0]},\n      context\n    );\n    // yield a single batch, the output from loader.parse()\n    // TODO - run through batch builder to apply options etc...\n    const batch: Batch = {\n      mimeType: loader.mimeTypes[0],\n      shape: Array.isArray(parsedData) ? 'row-table' : 'unknown',\n      batchType: 'data',\n      data: parsedData,\n      length: Array.isArray(parsedData) ? parsedData.length : 1\n    };\n    yield batch;\n  }\n\n  return parseChunkInBatches();\n}\n\ntype TransformBatches = (\n  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>\n) => AsyncIterable<ArrayBuffer>;\n\n/**\n * Create an iterator chain with any transform iterators (crypto, decompression)\n * @param inputIterator\n * @param options\n */\nasync function applyInputTransforms(\n  inputIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,\n  transforms: TransformBatches[] = []\n): Promise<AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>> {\n  let iteratorChain = inputIterator;\n  for await (const transformBatches of transforms) {\n    iteratorChain = transformBatches(iteratorChain);\n  }\n  return iteratorChain;\n}\n"],"mappings":"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"}

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

@@ -5,6 +5,7 @@ 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');
 
@@ -13,25 +14,23 @@ export function parseSync(data, loaders, options, context) {
     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,
@@ -43,7 +42,6 @@ export function parseSync(data, loaders, options, context) {
 
 function parseWithLoaderSync(loader, data, options, context) {
   data = getArrayBufferOrStringFromDataSync(data, loader, options);
-
   if (loader.parseTextSync && typeof data === 'string') {
     return loader.parseTextSync(data, options);
   }

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

@@ -1 +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"}
+{"version":3,"file":"parse-sync.js","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"],"sources":["../../../../src/lib/api/parse-sync.ts"],"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"],"mappings":"AAOA,SAAQA,MAAM,QAAO,0BAA0B;AAC/C,SAAQC,gBAAgB,QAAO,iBAAiB;AAChD,SAAQC,cAAc,QAAO,kCAAkC;AAC/D,SAAQC,gBAAgB,QAAO,8BAA8B;AAC7D,SAAQC,kCAAkC,QAAO,0BAA0B;AAC3E,SAAQC,gBAAgB,EAAEC,qBAAqB,QAAO,gCAAgC;AACtF,SAAQC,qBAAqB,QAAO,yBAAyB;;AAS7D,OAAO,SAASC,SAAS,CACvBC,IAAkB,EAClBC,OAA2C,EAC3CC,OAAuB,EACvBC,OAAuB,EAClB;EACLZ,MAAM,CAAC,CAACY,OAAO,IAAI,OAAOA,OAAO,KAAK,QAAQ,CAAC;;EAI/C,IAAI,CAACC,KAAK,CAACC,OAAO,CAACJ,OAAO,CAAC,IAAI,CAACR,cAAc,CAACQ,OAAO,CAAC,EAAE;IACvDE,OAAO,GAAGG,SAAS;IACnBJ,OAAO,GAAGD,OAAwB;IAClCA,OAAO,GAAGK,SAAS;EACrB;EAEAJ,OAAO,GAAGA,OAAO,IAAI,CAAC,CAAC;;EAIvB,MAAMK,YAAY,GAAGN,OAAwC;EAC7D,MAAMO,gBAAgB,GAAGX,qBAAqB,CAACU,YAAY,EAAEJ,OAAO,CAAC;EACrE,MAAMM,MAAM,GAAGjB,gBAAgB,CAACQ,IAAI,EAAEQ,gBAAgB,EAAEN,OAAO,CAAC;EAEhE,IAAI,CAACO,MAAM,EAAE;IACX,OAAO,IAAI;EACb;;EAGAP,OAAO,GAAGR,gBAAgB,CAACQ,OAAO,EAAEO,MAAM,EAAED,gBAAgB,CAAC;;EAG7D,MAAM;IAACE;EAAG,CAAC,GAAGZ,qBAAqB,CAACE,IAAI,CAAC;EAEzC,MAAMW,KAAK,GAAG,MAAM;IAClB,MAAM,IAAIC,KAAK,CAAC,wBAAwB,CAAC;EAC3C,CAAC;EACDT,OAAO,GAAGP,gBAAgB,CAAC;IAACc,GAAG;IAAEX,SAAS;IAAEY,KAAK;IAAEV,OAAO,EAAEA;EAAmB,CAAC,EAAEC,OAAO,CAAC;EAE1F,OAAOW,mBAAmB,CAACJ,MAAM,EAAsBT,IAAI,EAAEE,OAAO,EAAEC,OAAO,CAAC;AAChF;;AAGA,SAASU,mBAAmB,CAC1BJ,MAAwB,EACxBT,IAAkB,EAClBE,OAAsB,EACtBC,OAAsB,EACtB;EACAH,IAAI,GAAGL,kCAAkC,CAACK,IAAI,EAAES,MAAM,EAAEP,OAAO,CAAC;EAEhE,IAAIO,MAAM,CAACK,aAAa,IAAI,OAAOd,IAAI,KAAK,QAAQ,EAAE;IACpD,OAAOS,MAAM,CAACK,aAAa,CAACd,IAAI,EAAEE,OAAO,CAAC;EAC5C;;EAEA,IAAIO,MAAM,CAACV,SAAS,IAAIC,IAAI,YAAYe,WAAW,EAAE;IACnD,OAAON,MAAM,CAACV,SAAS,CAACC,IAAI,EAAEE,OAAO,EAAEC,OAAO,CAAC;EACjD;;EAGA,MAAM,IAAIS,KAAK,WACVH,MAAM,CAACO,IAAI,qFACZb,OAAO,CAACO,GAAG,IAAI,EAAE,EAEpB;AACH"}

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

@@ -7,6 +7,7 @@ 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');
 
@@ -15,21 +16,22 @@ export async function parse(data, loaders, options, context) {
     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,
@@ -40,7 +42,6 @@ export async function parse(data, loaders, options, context) {
 
 async function parseWithLoader(loader, data, options, context) {
   validateWorkerVersion(loader);
-
   if (isResponse(data)) {
     const response = data;
     const {
@@ -62,7 +63,6 @@ async function parseWithLoader(loader, data, options, context) {
       url
     };
   }
-
   data = await getArrayBufferOrStringFromData(data, loader, options);
 
   if (loader.parseTextSync && typeof data === 'string') {
@@ -77,12 +77,12 @@ async function parseWithLoader(loader, data, options, context) {
   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/esm/lib/api/parse.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/api/parse.ts"],"names":["assert","validateWorkerVersion","parseWithWorker","canParseWithWorker","isLoaderObject","isResponse","normalizeOptions","getArrayBufferOrStringFromData","getLoaderContext","getLoadersFromContext","getResourceUrlAndType","selectLoader","parse","data","loaders","options","context","Array","isArray","undefined","url","typedLoaders","candidateLoaders","loader","parseWithLoader","response","ok","redirected","status","statusText","type","headers","Object","fromEntries","entries","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 {isResponse} from '../../javascript-utils/is-type';\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  if (isResponse(data)) {\n    // Serialize to support passing the response to web worker\n    const response = data as Response;\n    const {ok, redirected, status, statusText, type, url} = response;\n    const headers = Object.fromEntries(response.headers.entries());\n    context.response = {headers, ok, redirected, status, statusText, type, url};\n  }\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"}
+{"version":3,"file":"parse.js","names":["assert","validateWorkerVersion","parseWithWorker","canParseWithWorker","isLoaderObject","isResponse","normalizeOptions","getArrayBufferOrStringFromData","getLoaderContext","getLoadersFromContext","getResourceUrlAndType","selectLoader","parse","data","loaders","options","context","Array","isArray","undefined","url","typedLoaders","candidateLoaders","loader","parseWithLoader","response","ok","redirected","status","statusText","type","headers","Object","fromEntries","entries","parseTextSync","dataType","parseText","parseSync","Error","id"],"sources":["../../../../src/lib/api/parse.ts"],"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 {isResponse} from '../../javascript-utils/is-type';\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  if (isResponse(data)) {\n    // Serialize to support passing the response to web worker\n    const response = data as Response;\n    const {ok, redirected, status, statusText, type, url} = response;\n    const headers = Object.fromEntries(response.headers.entries());\n    context.response = {headers, ok, redirected, status, statusText, type, url};\n  }\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"],"mappings":"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"}

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

@@ -10,10 +10,8 @@ const getGlobalLoaderRegistry = () => {
 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);
     }
@@ -22,6 +20,7 @@ export function registerLoaders(loaders) {
 export function getRegisteredLoaders() {
   return getGlobalLoaderRegistry();
 }
+
 export function _unregisterLoaders() {
   const state = getGlobalLoaderState();
   state.loaderRegistry = [];

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

@@ -1 +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"}
+{"version":3,"file":"register-loaders.js","names":["normalizeLoader","getGlobalLoaderState","getGlobalLoaderRegistry","state","loaderRegistry","registerLoaders","loaders","Array","isArray","loader","normalizedLoader","find","registeredLoader","unshift","getRegisteredLoaders","_unregisterLoaders"],"sources":["../../../../src/lib/api/register-loaders.ts"],"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"],"mappings":"AACA,SAAQA,eAAe,QAAO,kCAAkC;AAChE,SAAQC,oBAAoB,QAAO,8BAA8B;;AAIjE,MAAMC,uBAAuB,GAAG,MAAM;EACpC,MAAMC,KAAK,GAAGF,oBAAoB,EAAE;EACpCE,KAAK,CAACC,cAAc,GAAGD,KAAK,CAACC,cAAc,IAAI,EAAE;EACjD,OAAOD,KAAK,CAACC,cAAc;AAC7B,CAAC;;AAGD,OAAO,SAASC,eAAe,CAACC,OAAiB,EAAE;EACjD,MAAMF,cAAc,GAAGF,uBAAuB,EAAE;EAEhDI,OAAO,GAAGC,KAAK,CAACC,OAAO,CAACF,OAAO,CAAC,GAAGA,OAAO,GAAG,CAACA,OAAO,CAAC;EAEtD,KAAK,MAAMG,MAAM,IAAIH,OAAO,EAAE;IAC5B,MAAMI,gBAAgB,GAAGV,eAAe,CAACS,MAAM,CAAC;IAChD,IAAI,CAACL,cAAc,CAACO,IAAI,CAAEC,gBAAgB,IAAKF,gBAAgB,KAAKE,gBAAgB,CAAC,EAAE;MAErFR,cAAc,CAACS,OAAO,CAACH,gBAAgB,CAAC;IAC1C;EACF;AACF;AAEA,OAAO,SAASI,oBAAoB,GAAa;EAC/C,OAAOZ,uBAAuB,EAAE;AAClC;;AAGA,OAAO,SAASa,kBAAkB,GAAG;EACnC,MAAMZ,KAAK,GAAGF,oBAAoB,EAAE;EACpCE,KAAK,CAACC,cAAc,GAAG,EAAE;AAC3B"}

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

@@ -1 +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"}
+{"version":3,"file":"save.js","names":["encode","encodeSync","writeFile","writeFileSync","save","data","url","writer","options","encodedData","saveSync"],"sources":["../../../../src/lib/api/save.ts"],"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"],"mappings":"AACA,SAAQA,MAAM,EAAEC,UAAU,QAAO,UAAU;AAC3C,SAAQC,SAAS,EAAEC,aAAa,QAAO,qBAAqB;AAE5D,OAAO,eAAeC,IAAI,CAACC,IAAI,EAAEC,GAAG,EAAEC,MAAc,EAAEC,OAAsB,EAAE;EAC5E,MAAMC,WAAW,GAAG,MAAMT,MAAM,CAACK,IAAI,EAAEE,MAAM,EAAEC,OAAO,CAAC;EACvD,OAAO,MAAMN,SAAS,CAACI,GAAG,EAAEG,WAAW,CAAC;AAC1C;AAEA,OAAO,SAASC,QAAQ,CAACL,IAAI,EAAEC,GAAG,EAAEC,MAAM,EAAEC,OAAO,EAAE;EACnD,MAAMC,WAAW,GAAGR,UAAU,CAACI,IAAI,EAAEE,MAAM,EAAEC,OAAO,CAAC;EACrD,OAAOL,aAAa,CAACG,GAAG,EAAEG,WAAW,CAAC;AACxC"}

package/dist/esm/lib/api/select-loader.js

@@ -5,15 +5,19 @@ import { getResourceUrlAndType } from '../utils/resource-utils';
 import { getRegisteredLoaders } from './register-loaders';
 import { isBlob } from '../../javascript-utils/is-type';
 const EXT_PATTERN = /\.([^.]+)$/;
-export async function selectLoader(data, loaders = [], options, context) {
+
+export async function selectLoader(data) {
+  let loaders = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  let options = arguments.length > 2 ? arguments[2] : undefined;
+  let context = arguments.length > 3 ? arguments[3] : undefined;
   if (!validHTTPResponse(data)) {
     return null;
   }
 
-  let loader = selectLoaderSync(data, loaders, { ...options,
+  let loader = selectLoaderSync(data, loaders, {
+    ...options,
     nothrow: true
   }, context);
-
   if (loader) {
     return loader;
   }
@@ -26,10 +30,13 @@ export async function selectLoader(data, loaders = [], options, context) {
   if (!loader && !(options !== null && options !== void 0 && options.nothrow)) {
     throw new Error(getNoValidLoaderMessage(data));
   }
-
   return loader;
 }
-export function selectLoaderSync(data, loaders = [], options, context) {
+
+export function selectLoaderSync(data) {
+  let loaders = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  let options = arguments.length > 2 ? arguments[2] : undefined;
+  let context = arguments.length > 3 ? arguments[3] : undefined;
   if (!validHTTPResponse(data)) {
     return null;
   }
@@ -39,11 +46,9 @@ export function selectLoaderSync(data, loaders = [], options, context) {
   }
 
   let candidateLoaders = [];
-
   if (loaders) {
     candidateLoaders = candidateLoaders.concat(loaders);
   }
-
   if (!(options !== null && options !== void 0 && options.ignoreRegisteredLoaders)) {
     candidateLoaders.push(...getRegisteredLoaders());
   }
@@ -54,7 +59,6 @@ export function selectLoaderSync(data, loaders = [], options, context) {
   if (!loader && !(options !== null && options !== void 0 && options.nothrow)) {
     throw new Error(getNoValidLoaderMessage(data));
   }
-
   return loader;
 }
 
@@ -74,19 +78,19 @@ function selectLoaderInternal(data, loaders, options, context) {
 
   loader = loader || findLoaderByUrl(loaders, testUrl);
   reason = reason || (loader ? "matched url ".concat(testUrl) : '');
+
   loader = loader || findLoaderByMIMEType(loaders, type);
   reason = reason || (loader ? "matched MIME type ".concat(type) : '');
+
   loader = loader || findLoaderByInitialBytes(loaders, data);
   reason = reason || (loader ? "matched initial data ".concat(getFirstCharacters(data)) : '');
+
   loader = loader || findLoaderByMIMEType(loaders, options === null || options === void 0 ? void 0 : options.fallbackMimeType);
   reason = reason || (loader ? "matched fallback MIME type ".concat(type) : '');
-
   if (reason) {
     var _loader;
-
     log.log(1, "selectLoader selected ".concat((_loader = loader) === null || _loader === void 0 ? void 0 : _loader.name, ": ").concat(reason, "."));
   }
-
   return loader;
 }
 
@@ -96,7 +100,6 @@ function validHTTPResponse(data) {
       return false;
     }
   }
-
   return true;
 }
 
@@ -113,7 +116,6 @@ function getNoValidLoaderMessage(data) {
   message += ')';
   return message;
 }
-
 function normalizeLoaders(loaders) {
   for (const loader of loaders) {
     normalizeLoader(loader);
@@ -125,10 +127,8 @@ function findLoaderByUrl(loaders, url) {
   const extension = match && match[1];
   return extension ? findLoaderByExtension(loaders, extension) : null;
 }
-
 function findLoaderByExtension(loaders, extension) {
   extension = extension.toLowerCase();
-
   for (const loader of loaders) {
     for (const loaderExtension of loader.extensions) {
       if (loaderExtension.toLowerCase() === extension) {
@@ -136,10 +136,8 @@ function findLoaderByExtension(loaders, extension) {
       }
     }
   }
-
   return null;
 }
-
 function findLoaderByMIMEType(loaders, mimeType) {
   for (const loader of loaders) {
     if (loader.mimeTypes && loader.mimeTypes.includes(mimeType)) {
@@ -150,15 +148,12 @@ function findLoaderByMIMEType(loaders, mimeType) {
       return loader;
     }
   }
-
   return null;
 }
-
 function findLoaderByInitialBytes(loaders, data) {
   if (!data) {
     return null;
   }
-
   for (const loader of loaders) {
     if (typeof data === 'string') {
       if (testDataAgainstText(data, loader)) {
@@ -170,7 +165,6 @@ function findLoaderByInitialBytes(loaders, data) {
       }
     } else if (data instanceof ArrayBuffer) {
       const byteOffset = 0;
-
       if (testDataAgainstBinary(data, byteOffset, loader)) {
         return loader;
       }
@@ -179,40 +173,33 @@ function findLoaderByInitialBytes(loaders, data) {
 
   return null;
 }
-
 function testDataAgainstText(data, loader) {
   if (loader.testText) {
     return loader.testText(data);
   }
-
   const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];
   return tests.some(test => data.startsWith(test));
 }
-
 function testDataAgainstBinary(data, byteOffset, loader) {
   const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];
   return tests.some(test => testBinary(data, byteOffset, loader, test));
 }
-
 function testBinary(data, byteOffset, loader, test) {
   if (test instanceof ArrayBuffer) {
     return compareArrayBuffers(test, data, test.byteLength);
   }
-
   switch (typeof test) {
     case 'function':
       return test(data, loader);
-
     case 'string':
       const magic = getMagicString(data, byteOffset, test.length);
       return test === magic;
-
     default:
       return false;
   }
 }
-
-function getFirstCharacters(data, length = 5) {
+function getFirstCharacters(data) {
+  let length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 5;
   if (typeof data === 'string') {
     return data.slice(0, length);
   } else if (ArrayBuffer.isView(data)) {
@@ -221,22 +208,17 @@ function getFirstCharacters(data, length = 5) {
     const byteOffset = 0;
     return getMagicString(data, byteOffset, length);
   }
-
   return '';
 }
-
 function getMagicString(arrayBuffer, byteOffset, length) {
   if (arrayBuffer.byteLength < byteOffset + length) {
     return '';
   }
-
   const dataView = new DataView(arrayBuffer);
   let magic = '';
-
   for (let i = 0; i < length; i++) {
     magic += String.fromCharCode(dataView.getUint8(byteOffset + i));
   }
-
   return magic;
 }
 //# sourceMappingURL=select-loader.js.map