@loaders.gl/core 4.0.0-alpha.22 → 4.0.0-alpha.24

package/dist/dist.min.js

@@ -1043,41 +1043,41 @@
           return Object.keys(this.stats).length;
         }
         reset() {
-          for (const stat2 of Object.values(this.stats)) {
-            stat2.reset();
+          for (const stat of Object.values(this.stats)) {
+            stat.reset();
           }
           return this;
         }
         forEach(fn) {
-          for (const stat2 of Object.values(this.stats)) {
-            fn(stat2);
+          for (const stat of Object.values(this.stats)) {
+            fn(stat);
           }
         }
         getTable() {
           const table = {};
-          this.forEach((stat2) => {
-            table[stat2.name] = {
-              time: stat2.time || 0,
-              count: stat2.count || 0,
-              average: stat2.getAverageTime() || 0,
-              hz: stat2.getHz() || 0
+          this.forEach((stat) => {
+            table[stat.name] = {
+              time: stat.time || 0,
+              count: stat.count || 0,
+              average: stat.getAverageTime() || 0,
+              hz: stat.getHz() || 0
             };
           });
           return table;
         }
         _initializeStats() {
           let stats = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
-          stats.forEach((stat2) => this._getOrCreate(stat2));
+          stats.forEach((stat) => this._getOrCreate(stat));
         }
-        _getOrCreate(stat2) {
+        _getOrCreate(stat) {
           const {
             name,
             type
-          } = stat2;
+          } = stat;
           let result = this.stats[name];
           if (!result) {
-            if (stat2 instanceof Stat) {
-              result = stat2;
+            if (stat instanceof Stat) {
+              result = stat;
             } else {
               result = new Stat(name, type);
             }
@@ -1301,18 +1301,6 @@
     }
   });
 
-  // ../loader-utils/src/lib/node/promisify.ts
-  function promisify2(fn) {
-    return (arg1, arg2) => new Promise((resolve2, reject) => fn(arg1, arg2, (error, callbackArgs) => error ? reject(error) : resolve2(callbackArgs)));
-  }
-  function promisify3(fn) {
-    return (arg1, arg2, arg3) => new Promise((resolve2, reject) => fn(arg1, arg2, arg3, (error, callbackArgs) => error ? reject(error) : resolve2(callbackArgs)));
-  }
-  var init_promisify = __esm({
-    "../loader-utils/src/lib/node/promisify.ts"() {
-    }
-  });
-
   // ../loader-utils/src/lib/path-utils/get-cwd.ts
   function getCWD() {
     if (typeof process !== "undefined" && typeof process.cwd !== "undefined") {
@@ -1464,63 +1452,15 @@
     }
   });
 
-  // (disabled):fs
-  var require_fs = __commonJS({
-    "(disabled):fs"() {
-    }
-  });
-
-  // ../loader-utils/src/lib/node/fs.ts
-  var fs_exports = {};
-  __export(fs_exports, {
-    _readToArrayBuffer: () => _readToArrayBuffer,
-    close: () => close,
-    createReadStream: () => createReadStream,
-    createWriteStream: () => createWriteStream,
-    fstat: () => fstat,
-    isSupported: () => isSupported,
-    open: () => open,
-    read: () => read,
-    readFile: () => readFile,
-    readFileSync: () => readFileSync,
-    readdir: () => readdir,
-    stat: () => stat,
-    statSync: () => statSync,
-    writeFile: () => writeFile,
-    writeFileSync: () => writeFileSync
+  // ../loader-utils/src/lib/node/fs.browser.ts
+  var fs_browser_exports = {};
+  __export(fs_browser_exports, {
+    isSupported: () => isSupported
   });
-  async function _readToArrayBuffer(fd, start, length) {
-    const buffer = Buffer.alloc(length);
-    const { bytesRead } = await read(fd, buffer, 0, length, start);
-    if (bytesRead !== length) {
-      throw new Error("fs.read failed");
-    }
-    return toArrayBuffer(buffer);
-  }
-  var import_fs, readdir, stat, statSync, readFile, readFileSync, writeFile, writeFileSync, open, close, read, fstat, createReadStream, createWriteStream, isSupported;
-  var init_fs = __esm({
-    "../loader-utils/src/lib/node/fs.ts"() {
-      import_fs = __toModule(require_fs());
-      init_buffer_browser();
-      init_promisify();
-      isSupported = Boolean(import_fs.default);
-      try {
-        readdir = promisify2(import_fs.default.readdir);
-        stat = promisify2(import_fs.default.stat);
-        statSync = import_fs.default.statSync;
-        readFile = import_fs.default.readFile;
-        readFileSync = import_fs.default.readFileSync;
-        writeFile = promisify3(import_fs.default.writeFile);
-        writeFileSync = import_fs.default.writeFileSync;
-        open = import_fs.default.open;
-        close = (fd) => new Promise((resolve2, reject) => import_fs.default.close(fd, (err) => err ? reject(err) : resolve2()));
-        read = import_fs.default.read;
-        fstat = import_fs.default.fstat;
-        createReadStream = import_fs.default.createReadStream;
-        createWriteStream = import_fs.default.createWriteStream;
-        isSupported = Boolean(import_fs.default);
-      } catch {
-      }
+  var isSupported;
+  var init_fs_browser = __esm({
+    "../loader-utils/src/lib/node/fs.browser.ts"() {
+      isSupported = false;
     }
   });
 
@@ -1539,7 +1479,7 @@
       init_json_loader();
       init_memory_conversion_utils();
       init_path();
-      init_fs();
+      init_fs_browser();
     }
   });
 
@@ -1783,7 +1723,7 @@
   // src/lib/fetch/read-array-buffer.ts
   async function readArrayBuffer(file, start, length) {
     if (typeof file === "number") {
-      return await fs_exports._readToArrayBuffer(file, start, length);
+      return await fs_browser_exports._readToArrayBuffer(file, start, length);
     }
     if (!(file instanceof Blob)) {
       file = new Blob([file]);
@@ -1806,10 +1746,10 @@
   });
 
   // src/lib/fetch/read-file.ts
-  function readFileSync2(url, options = {}) {
+  function readFileSync(url, options = {}) {
     url = resolvePath(url);
     if (!isBrowser) {
-      const buffer = fs_exports.readFileSync(url, options);
+      const buffer = fs_browser_exports.readFileSync(url, options);
       return typeof buffer !== "string" ? toArrayBuffer2(buffer) : buffer;
     }
     if (!options.nothrow) {
@@ -1825,17 +1765,17 @@
   });
 
   // src/lib/fetch/write-file.ts
-  async function writeFile2(filePath, arrayBufferOrString, options) {
+  async function writeFile(filePath, arrayBufferOrString, options) {
     filePath = resolvePath(filePath);
     if (!isBrowser) {
-      await fs_exports.writeFile(filePath, toBuffer2(arrayBufferOrString), { flag: "w" });
+      await fs_browser_exports.writeFile(filePath, toBuffer2(arrayBufferOrString), { flag: "w" });
     }
     assert(false);
   }
-  function writeFileSync2(filePath, arrayBufferOrString, options) {
+  function writeFileSync(filePath, arrayBufferOrString, options) {
     filePath = resolvePath(filePath);
     if (!isBrowser) {
-      fs_exports.writeFileSync(filePath, toBuffer2(arrayBufferOrString), { flag: "w" });
+      fs_browser_exports.writeFileSync(filePath, toBuffer2(arrayBufferOrString), { flag: "w" });
     }
     assert(false);
   }
@@ -3533,7 +3473,7 @@
     }
     if (!isBrowser && writer.encodeURLtoURL) {
       const tmpInputFilename = getTemporaryFilename("input");
-      await writeFile2(tmpInputFilename, data);
+      await writeFile(tmpInputFilename, data);
       const tmpOutputFilename = getTemporaryFilename("output");
       const outputFilename = await encodeURLtoURL(tmpInputFilename, tmpOutputFilename, writer, options);
       const response = await fetchFile(outputFilename);
@@ -3595,11 +3535,11 @@
   // src/lib/api/save.ts
   async function save(data, url, writer, options) {
     const encodedData = await encode(data, writer, options);
-    return await writeFile2(url, encodedData);
+    return await writeFile(url, encodedData);
   }
   function saveSync(data, url, writer, options) {
     const encodedData = encodeSync(data, writer, options);
-    return writeFileSync2(url, encodedData);
+    return writeFileSync(url, encodedData);
   }
   var init_save = __esm({
     "src/lib/api/save.ts"() {
@@ -3704,12 +3644,12 @@
     const progressStream = new ReadableStream({
       async start(controller) {
         const reader = body.getReader();
-        await read2(controller, reader, 0, totalBytes, onProgress, onDone, onError);
+        await read(controller, reader, 0, totalBytes, onProgress, onDone, onError);
       }
     });
     return new Response(progressStream);
   }
-  async function read2(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError) {
+  async function read(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError) {
     try {
       const { done, value } = await reader.read();
       if (done) {
@@ -3721,7 +3661,7 @@
       const percent = Math.round(loadedBytes / totalBytes * 100);
       onProgress(percent, { loadedBytes, totalBytes });
       controller.enqueue(value);
-      await read2(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError);
+      await read(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError);
     } catch (error) {
       controller.error(error);
       onError(error);
@@ -3862,7 +3802,7 @@
     parseInBatches: () => parseInBatches,
     parseSync: () => parseSync,
     readArrayBuffer: () => readArrayBuffer,
-    readFileSync: () => readFileSync2,
+    readFileSync: () => readFileSync,
     registerLoaders: () => registerLoaders,
     resolvePath: () => resolvePath,
     save: () => save,
@@ -3873,8 +3813,8 @@
     setLoaderOptions: () => setGlobalOptions,
     setPathPrefix: () => setPathPrefix,
     window: () => window_,
-    writeFile: () => writeFile2,
-    writeFileSync: () => writeFileSync2
+    writeFile: () => writeFile,
+    writeFileSync: () => writeFileSync
   });
   var init_src3 = __esm({
     "src/index.ts"() {

package/dist/es5/index.js

@@ -1,6 +1,5 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -31,13 +30,13 @@ Object.defineProperty(exports, "RequestScheduler", {
 Object.defineProperty(exports, "_BrowserFileSystem", {
   enumerable: true,
   get: function get() {
-    return _browserFilesystem.default;
+    return _browserFilesystem.BrowserFileSystem;
   }
 });
 Object.defineProperty(exports, "_fetchProgress", {
   enumerable: true,
   get: function get() {
-    return _fetchProgress.default;
+    return _fetchProgress.fetchProgress;
   }
 });
 Object.defineProperty(exports, "_unregisterLoaders", {
@@ -371,7 +370,7 @@ var _loaderUtils = require("@loaders.gl/loader-utils");
 var _makeIterator = require("./iterators/make-iterator/make-iterator");
 var _makeNodeStream = require("./iterators/make-stream/make-node-stream");
 var _nullLoader = require("./null-loader");
-var _fetchProgress = _interopRequireDefault(require("./lib/progress/fetch-progress"));
-var _browserFilesystem = _interopRequireDefault(require("./lib/filesystems/browser-filesystem"));
+var _fetchProgress = require("./lib/progress/fetch-progress");
+var _browserFilesystem = require("./lib/filesystems/browser-filesystem");
 var _isType = require("./javascript-utils/is-type");
 //# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["_fetchFile","require","_readArrayBuffer","_readFile","_writeFile","_loaderOptions","_registerLoaders","_selectLoader","_parse","_parseSync","_parseInBatches","_load","_loadInBatches","_encodeTable","_encode","_save","_loaderUtils","_makeIterator","_makeNodeStream","_nullLoader","_fetchProgress","_interopRequireDefault","_browserFilesystem","_isType"],"sources":["../../src/index.ts"],"sourcesContent":["// loaders.gl, MIT license\n\n// TYPES\nexport type {\n  Loader,\n  LoaderWithParser,\n  LoaderContext,\n  LoaderOptions,\n  Writer,\n  WriterOptions,\n  DataType,\n  SyncDataType,\n  BatchableDataType,\n  IFileSystem,\n  IRandomAccessReadFileSystem\n} from '@loaders.gl/loader-utils';\n\n// FILE READING AND WRITING\nexport {fetchFile} from './lib/fetch/fetch-file';\n\nexport {readArrayBuffer} from './lib/fetch/read-array-buffer';\nexport {readFileSync} from './lib/fetch/read-file';\nexport {writeFile, writeFileSync} from './lib/fetch/write-file';\n\n// CONFIGURATION\nexport {setLoaderOptions, getLoaderOptions} from './lib/api/loader-options';\nexport {registerLoaders} from './lib/api/register-loaders';\nexport {selectLoader, selectLoaderSync} from './lib/api/select-loader';\n\n// LOADING (READING + PARSING)\nexport {parse} from './lib/api/parse';\nexport {parseSync} from './lib/api/parse-sync';\nexport {parseInBatches} from './lib/api/parse-in-batches';\n\nexport {load} from './lib/api/load';\nexport {loadInBatches} from './lib/api/load-in-batches';\n\n// ENCODING (ENCODING AND WRITING)\nexport {encodeTable, encodeTableAsText, encodeTableInBatches} from './lib/api/encode-table';\nexport {encode, encodeSync, encodeInBatches, encodeText, encodeURLtoURL} from './lib/api/encode';\nexport {save, saveSync} from './lib/api/save';\n\n// CORE UTILS SHARED WITH LOADERS (RE-EXPORTED FROM LOADER-UTILS)\nexport {setPathPrefix, getPathPrefix, resolvePath} from '@loaders.gl/loader-utils';\nexport {RequestScheduler} from '@loaders.gl/loader-utils';\n\n// ITERATOR UTILS\nexport {makeIterator} from './iterators/make-iterator/make-iterator';\nexport {makeStream} from './iterators/make-stream/make-node-stream';\n\n// CORE LOADERS\nexport {NullWorkerLoader, NullLoader} from './null-loader';\nexport {JSONLoader} from '@loaders.gl/loader-utils';\n\n// EXPERIMENTAL\nexport {default as _fetchProgress} from './lib/progress/fetch-progress';\nexport {default as _BrowserFileSystem} from './lib/filesystems/browser-filesystem';\nexport type {FileSystem} from './lib/filesystems/filesystem';\n\n// FOR TESTING\nexport {_unregisterLoaders} from './lib/api/register-loaders';\n\n//\n// TODO - MOVE TO LOADER-UTILS AND DEPRECATE IN CORE?\n//\n\nexport {isBrowser, isWorker, self, window, global, document} from '@loaders.gl/loader-utils';\nexport {assert} from '@loaders.gl/loader-utils';\nexport {forEach, concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';\n\nexport {\n  makeTextDecoderIterator,\n  makeTextEncoderIterator,\n  makeLineIterator,\n  makeNumberedLineIterator\n} from '@loaders.gl/loader-utils';\n\n// \"JAVASCRIPT\" UTILS - move to loader-utils?\nexport {\n  isPureObject,\n  isPromise,\n  isIterable,\n  isAsyncIterable,\n  isIterator,\n  isResponse,\n  isReadableStream,\n  isWritableStream\n} from './javascript-utils/is-type';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA,IAAAA,UAAA,GAAAC,OAAA;AAEA,IAAAC,gBAAA,GAAAD,OAAA;AACA,IAAAE,SAAA,GAAAF,OAAA;AACA,IAAAG,UAAA,GAAAH,OAAA;AAGA,IAAAI,cAAA,GAAAJ,OAAA;AACA,IAAAK,gBAAA,GAAAL,OAAA;AACA,IAAAM,aAAA,GAAAN,OAAA;AAGA,IAAAO,MAAA,GAAAP,OAAA;AACA,IAAAQ,UAAA,GAAAR,OAAA;AACA,IAAAS,eAAA,GAAAT,OAAA;AAEA,IAAAU,KAAA,GAAAV,OAAA;AACA,IAAAW,cAAA,GAAAX,OAAA;AAGA,IAAAY,YAAA,GAAAZ,OAAA;AACA,IAAAa,OAAA,GAAAb,OAAA;AACA,IAAAc,KAAA,GAAAd,OAAA;AAGA,IAAAe,YAAA,GAAAf,OAAA;AAIA,IAAAgB,aAAA,GAAAhB,OAAA;AACA,IAAAiB,eAAA,GAAAjB,OAAA;AAGA,IAAAkB,WAAA,GAAAlB,OAAA;AAIA,IAAAmB,cAAA,GAAAC,sBAAA,CAAApB,OAAA;AACA,IAAAqB,kBAAA,GAAAD,sBAAA,CAAApB,OAAA;AAsBA,IAAAsB,OAAA,GAAAtB,OAAA"}
+{"version":3,"file":"index.js","names":["_fetchFile","require","_readArrayBuffer","_readFile","_writeFile","_loaderOptions","_registerLoaders","_selectLoader","_parse","_parseSync","_parseInBatches","_load","_loadInBatches","_encodeTable","_encode","_save","_loaderUtils","_makeIterator","_makeNodeStream","_nullLoader","_fetchProgress","_browserFilesystem","_isType"],"sources":["../../src/index.ts"],"sourcesContent":["// loaders.gl, MIT license\n\n// TYPES\nexport type {\n  Loader,\n  LoaderWithParser,\n  LoaderContext,\n  LoaderOptions,\n  Writer,\n  WriterOptions,\n  DataType,\n  SyncDataType,\n  BatchableDataType,\n  FileSystem,\n  RandomAccessReadFileSystem\n} from '@loaders.gl/loader-utils';\n\n// FILE READING AND WRITING\nexport {fetchFile} from './lib/fetch/fetch-file';\n\nexport {readArrayBuffer} from './lib/fetch/read-array-buffer';\nexport {readFileSync} from './lib/fetch/read-file';\nexport {writeFile, writeFileSync} from './lib/fetch/write-file';\n\n// CONFIGURATION\nexport {setLoaderOptions, getLoaderOptions} from './lib/api/loader-options';\nexport {registerLoaders} from './lib/api/register-loaders';\nexport {selectLoader, selectLoaderSync} from './lib/api/select-loader';\n\n// LOADING (READING + PARSING)\nexport {parse} from './lib/api/parse';\nexport {parseSync} from './lib/api/parse-sync';\nexport {parseInBatches} from './lib/api/parse-in-batches';\n\nexport {load} from './lib/api/load';\nexport {loadInBatches} from './lib/api/load-in-batches';\n\n// ENCODING (ENCODING AND WRITING)\nexport {encodeTable, encodeTableAsText, encodeTableInBatches} from './lib/api/encode-table';\nexport {encode, encodeSync, encodeInBatches, encodeText, encodeURLtoURL} from './lib/api/encode';\nexport {save, saveSync} from './lib/api/save';\n\n// CORE UTILS SHARED WITH LOADERS (RE-EXPORTED FROM LOADER-UTILS)\nexport {setPathPrefix, getPathPrefix, resolvePath} from '@loaders.gl/loader-utils';\nexport {RequestScheduler} from '@loaders.gl/loader-utils';\n\n// ITERATOR UTILS\nexport {makeIterator} from './iterators/make-iterator/make-iterator';\nexport {makeStream} from './iterators/make-stream/make-node-stream';\n\n// CORE LOADERS\nexport {NullWorkerLoader, NullLoader} from './null-loader';\nexport {JSONLoader} from '@loaders.gl/loader-utils';\n\n// EXPERIMENTAL\nexport {fetchProgress as _fetchProgress} from './lib/progress/fetch-progress';\nexport {BrowserFileSystem as _BrowserFileSystem} from './lib/filesystems/browser-filesystem';\n\n// FOR TESTING\nexport {_unregisterLoaders} from './lib/api/register-loaders';\n\n//\n// TODO - MOVE TO LOADER-UTILS AND DEPRECATE IN CORE?\n//\n\nexport {isBrowser, isWorker, self, window, global, document} from '@loaders.gl/loader-utils';\nexport {assert} from '@loaders.gl/loader-utils';\nexport {forEach, concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';\n\nexport {\n  makeTextDecoderIterator,\n  makeTextEncoderIterator,\n  makeLineIterator,\n  makeNumberedLineIterator\n} from '@loaders.gl/loader-utils';\n\n// \"JAVASCRIPT\" UTILS - move to loader-utils?\nexport {\n  isPureObject,\n  isPromise,\n  isIterable,\n  isAsyncIterable,\n  isIterator,\n  isResponse,\n  isReadableStream,\n  isWritableStream\n} from './javascript-utils/is-type';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA,IAAAA,UAAA,GAAAC,OAAA;AAEA,IAAAC,gBAAA,GAAAD,OAAA;AACA,IAAAE,SAAA,GAAAF,OAAA;AACA,IAAAG,UAAA,GAAAH,OAAA;AAGA,IAAAI,cAAA,GAAAJ,OAAA;AACA,IAAAK,gBAAA,GAAAL,OAAA;AACA,IAAAM,aAAA,GAAAN,OAAA;AAGA,IAAAO,MAAA,GAAAP,OAAA;AACA,IAAAQ,UAAA,GAAAR,OAAA;AACA,IAAAS,eAAA,GAAAT,OAAA;AAEA,IAAAU,KAAA,GAAAV,OAAA;AACA,IAAAW,cAAA,GAAAX,OAAA;AAGA,IAAAY,YAAA,GAAAZ,OAAA;AACA,IAAAa,OAAA,GAAAb,OAAA;AACA,IAAAc,KAAA,GAAAd,OAAA;AAGA,IAAAe,YAAA,GAAAf,OAAA;AAIA,IAAAgB,aAAA,GAAAhB,OAAA;AACA,IAAAiB,eAAA,GAAAjB,OAAA;AAGA,IAAAkB,WAAA,GAAAlB,OAAA;AAIA,IAAAmB,cAAA,GAAAnB,OAAA;AACA,IAAAoB,kBAAA,GAAApB,OAAA;AAqBA,IAAAqB,OAAA,GAAArB,OAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"load-in-batches.js","names":["_normalizeLoader","require","_getFetchFunction","_parseInBatches","loadInBatches","files","loaders","options","context","loadersArray","Array","isArray","isLoaderObject","undefined","fetch","getFetchFunction","loadOneFileInBatches","promises","map","file","_x","_x2","_x3","_x4","_loadOneFileInBatches","apply","arguments","_asyncToGenerator2","default","_regenerator","mark","_callee","url","response","wrap","_callee$","_context","prev","next","sent","parseInBatches","abrupt","stop"],"sources":["../../../../src/lib/api/load-in-batches.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport type {\n  LoaderWithParser,\n  LoaderOptions,\n  LoaderContext,\n  FetchLike\n} from '@loaders.gl/loader-utils';\nimport type {LoaderBatchType, LoaderOptionsType} from '@loaders.gl/loader-utils';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {getFetchFunction} from '../loader-utils/get-fetch-function';\n\nimport {parseInBatches} from './parse-in-batches';\n\ntype FileType = string | File | Blob | Response | (string | File | Blob | Response)[] | FileList;\n\n/**\n * Parses `data` synchronously using a specified loader\n */\nexport async function loadInBatches<\n  LoaderT extends LoaderWithParser,\n  OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>\n>(\n  files: FileType,\n  loader: LoaderT,\n  options?: OptionsT,\n  context?: LoaderContext\n): Promise<AsyncIterable<LoaderBatchType<LoaderT>>>;\n\n/**\n * Parses `data` using a specified loader\n * @param data\n * @param loaders\n * @param options\n * @param context\n */\nexport function loadInBatches(\n  files: FileType,\n  loaders?: LoaderWithParser | LoaderWithParser[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<AsyncIterable<any>>;\n\nexport function loadInBatches(\n  files: FileType[] | FileList,\n  loaders?: LoaderWithParser | LoaderWithParser[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<AsyncIterable<any>>;\n\nexport function loadInBatches(\n  files: FileType | FileType[] | FileList,\n  loaders?: LoaderWithParser | LoaderWithParser[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n) {\n  let loadersArray: LoaderWithParser | LoaderWithParser[] | undefined;\n  // Signature: load(url, options)\n  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {\n    context = undefined; // context not supported in short signature\n    options = loaders as LoaderOptions;\n    loadersArray = undefined;\n  } else {\n    loadersArray = loaders as LoaderWithParser | LoaderWithParser[] | undefined;\n  }\n\n  // Select fetch function\n  const fetch = getFetchFunction(options || {});\n\n  // Single url/file\n  if (!Array.isArray(files)) {\n    return loadOneFileInBatches(files, loadersArray!, options || {}, fetch);\n  }\n\n  // Multiple URLs / files\n  const promises = files.map((file) =>\n    loadOneFileInBatches(file, loadersArray!, options || {}, fetch)\n  );\n\n  // No point in waiting here for all responses before starting to stream individual streams?\n  return promises;\n}\n\nasync function loadOneFileInBatches(\n  file: FileType,\n  loaders: LoaderWithParser | LoaderWithParser[],\n  options: LoaderOptions,\n  fetch: FetchLike\n) {\n  if (typeof file === 'string') {\n    const url = file;\n    const response = await fetch(url);\n    // @ts-expect-error\n    return await parseInBatches(response, loaders, options);\n  }\n  // @ts-expect-error TODO\n  return await parseInBatches(file, loaders, options);\n}\n"],"mappings":";;;;;;;;;AASA,IAAAA,gBAAA,GAAAC,OAAA;AACA,IAAAC,iBAAA,GAAAD,OAAA;AAEA,IAAAE,eAAA,GAAAF,OAAA;AAsCO,SAASG,aAAaA,CAC3BC,KAAuC,EACvCC,OAA+D,EAC/DC,OAAuB,EACvBC,OAAuB,EACvB;EACA,IAAIC,YAA+D;EAEnE,IAAI,CAACC,KAAK,CAACC,OAAO,CAACL,OAAO,CAAC,IAAI,CAAC,IAAAM,+BAAc,EAACN,OAAO,CAAC,EAAE;IACvDE,OAAO,GAAGK,SAAS;IACnBN,OAAO,GAAGD,OAAwB;IAClCG,YAAY,GAAGI,SAAS;EAC1B,CAAC,MAAM;IACLJ,YAAY,GAAGH,OAA4D;EAC7E;EAGA,IAAMQ,KAAK,GAAG,IAAAC,kCAAgB,EAACR,OAAO,IAAI,CAAC,CAAC,CAAC;EAG7C,IAAI,CAACG,KAAK,CAACC,OAAO,CAACN,KAAK,CAAC,EAAE;IACzB,OAAOW,oBAAoB,CAACX,KAAK,EAAEI,YAAY,EAAGF,OAAO,IAAI,CAAC,CAAC,EAAEO,KAAK,CAAC;EACzE;EAGA,IAAMG,QAAQ,GAAGZ,KAAK,CAACa,GAAG,CAAC,UAACC,IAAI;IAAA,OAC9BH,oBAAoB,CAACG,IAAI,EAAEV,YAAY,EAAGF,OAAO,IAAI,CAAC,CAAC,EAAEO,KAAK,CAAC;EAAA,CACjE,CAAC;EAGD,OAAOG,QAAQ;AACjB;AAAC,SAEcD,oBAAoBA,CAAAI,EAAA,EAAAC,GAAA,EAAAC,GAAA,EAAAC,GAAA;EAAA,OAAAC,qBAAA,CAAAC,KAAA,OAAAC,SAAA;AAAA;AAAA,SAAAF,sBAAA;EAAAA,qBAAA,OAAAG,kBAAA,CAAAC,OAAA,EAAAC,YAAA,CAAAD,OAAA,CAAAE,IAAA,CAAnC,SAAAC,QACEZ,IAAc,EACdb,OAA8C,EAC9CC,OAAsB,EACtBO,KAAgB;IAAA,IAAAkB,GAAA,EAAAC,QAAA;IAAA,OAAAJ,YAAA,CAAAD,OAAA,CAAAM,IAAA,UAAAC,SAAAC,QAAA;MAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;QAAA;UAAA,MAEZ,OAAOnB,IAAI,KAAK,QAAQ;YAAAiB,QAAA,CAAAE,IAAA;YAAA;UAAA;UACpBN,GAAG,GAAGb,IAAI;UAAAiB,QAAA,CAAAE,IAAA;UAAA,OACOxB,KAAK,CAACkB,GAAG,CAAC;QAAA;UAA3BC,QAAQ,GAAAG,QAAA,CAAAG,IAAA;UAAAH,QAAA,CAAAE,IAAA;UAAA,OAED,IAAAE,8BAAc,EAACP,QAAQ,EAAE3B,OAAO,EAAEC,OAAO,CAAC;QAAA;UAAA,OAAA6B,QAAA,CAAAK,MAAA,WAAAL,QAAA,CAAAG,IAAA;QAAA;UAAAH,QAAA,CAAAE,IAAA;UAAA,OAG5C,IAAAE,8BAAc,EAACrB,IAAI,EAAEb,OAAO,EAAEC,OAAO,CAAC;QAAA;UAAA,OAAA6B,QAAA,CAAAK,MAAA,WAAAL,QAAA,CAAAG,IAAA;QAAA;QAAA;UAAA,OAAAH,QAAA,CAAAM,IAAA;MAAA;IAAA,GAAAX,OAAA;EAAA,CACpD;EAAA,OAAAP,qBAAA,CAAAC,KAAA,OAAAC,SAAA;AAAA"}
+{"version":3,"file":"load-in-batches.js","names":["_normalizeLoader","require","_getFetchFunction","_parseInBatches","loadInBatches","files","loaders","options","context","loadersArray","Array","isArray","isLoaderObject","undefined","fetch","getFetchFunction","loadOneFileInBatches","promises","map","file","_x","_x2","_x3","_x4","_loadOneFileInBatches","apply","arguments","_asyncToGenerator2","default","_regenerator","mark","_callee","url","response","wrap","_callee$","_context","prev","next","sent","parseInBatches","abrupt","stop"],"sources":["../../../../src/lib/api/load-in-batches.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport type {\n  LoaderWithParser,\n  LoaderOptions,\n  LoaderContext,\n  FetchLike\n} from '@loaders.gl/loader-utils';\nimport type {LoaderBatchType, LoaderOptionsType} from '@loaders.gl/loader-utils';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {getFetchFunction} from '../loader-utils/get-fetch-function';\n\nimport {parseInBatches} from './parse-in-batches';\n\ntype FileType = string | File | Blob | Response | (string | File | Blob | Response)[] | FileList;\n\n/**\n * Parses `data` synchronously using a specified loader\n */\nexport async function loadInBatches<\n  LoaderT extends LoaderWithParser,\n  OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>\n>(\n  files: FileType,\n  loader: LoaderT,\n  options?: OptionsT,\n  context?: LoaderContext\n): Promise<AsyncIterable<LoaderBatchType<LoaderT>>>;\n\n/**\n * Parses `data` using a specified loader\n * @param data\n * @param loaders\n * @param options\n * @param context\n */\nexport function loadInBatches(\n  files: FileType,\n  loaders?: LoaderWithParser | LoaderWithParser[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<AsyncIterable<unknown>>;\n\nexport function loadInBatches(\n  files: FileType[] | FileList,\n  loaders?: LoaderWithParser | LoaderWithParser[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<AsyncIterable<unknown>>[];\n\nexport function loadInBatches(\n  files: FileType | FileType[] | FileList,\n  loaders?: LoaderWithParser | LoaderWithParser[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<AsyncIterable<unknown>> | Promise<AsyncIterable<unknown>>[] {\n  let loadersArray: LoaderWithParser | LoaderWithParser[] | undefined;\n  // Signature: load(url, options)\n  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {\n    context = undefined; // context not supported in short signature\n    options = loaders as LoaderOptions;\n    loadersArray = undefined;\n  } else {\n    loadersArray = loaders as LoaderWithParser | LoaderWithParser[] | undefined;\n  }\n\n  // Select fetch function\n  const fetch = getFetchFunction(options || {});\n\n  // Single url/file\n  if (!Array.isArray(files)) {\n    return loadOneFileInBatches(files, loadersArray!, options || {}, fetch);\n  }\n\n  // Multiple URLs / files\n  const promises = files.map((file) =>\n    loadOneFileInBatches(file, loadersArray!, options || {}, fetch)\n  );\n\n  // No point in waiting here for all responses before starting to stream individual streams?\n  return promises;\n}\n\nasync function loadOneFileInBatches(\n  file: FileType,\n  loaders: LoaderWithParser | LoaderWithParser[],\n  options: LoaderOptions,\n  fetch: FetchLike\n): Promise<AsyncIterable<unknown>> {\n  if (typeof file === 'string') {\n    const url = file;\n    const response = await fetch(url);\n    // @ts-expect-error\n    return await parseInBatches(response, loaders, options);\n  }\n  // @ts-expect-error TODO\n  return await parseInBatches(file, loaders, options);\n}\n"],"mappings":";;;;;;;;;AASA,IAAAA,gBAAA,GAAAC,OAAA;AACA,IAAAC,iBAAA,GAAAD,OAAA;AAEA,IAAAE,eAAA,GAAAF,OAAA;AAsCO,SAASG,aAAaA,CAC3BC,KAAuC,EACvCC,OAA+D,EAC/DC,OAAuB,EACvBC,OAAuB,EAC8C;EACrE,IAAIC,YAA+D;EAEnE,IAAI,CAACC,KAAK,CAACC,OAAO,CAACL,OAAO,CAAC,IAAI,CAAC,IAAAM,+BAAc,EAACN,OAAO,CAAC,EAAE;IACvDE,OAAO,GAAGK,SAAS;IACnBN,OAAO,GAAGD,OAAwB;IAClCG,YAAY,GAAGI,SAAS;EAC1B,CAAC,MAAM;IACLJ,YAAY,GAAGH,OAA4D;EAC7E;EAGA,IAAMQ,KAAK,GAAG,IAAAC,kCAAgB,EAACR,OAAO,IAAI,CAAC,CAAC,CAAC;EAG7C,IAAI,CAACG,KAAK,CAACC,OAAO,CAACN,KAAK,CAAC,EAAE;IACzB,OAAOW,oBAAoB,CAACX,KAAK,EAAEI,YAAY,EAAGF,OAAO,IAAI,CAAC,CAAC,EAAEO,KAAK,CAAC;EACzE;EAGA,IAAMG,QAAQ,GAAGZ,KAAK,CAACa,GAAG,CAAC,UAACC,IAAI;IAAA,OAC9BH,oBAAoB,CAACG,IAAI,EAAEV,YAAY,EAAGF,OAAO,IAAI,CAAC,CAAC,EAAEO,KAAK,CAAC;EAAA,CACjE,CAAC;EAGD,OAAOG,QAAQ;AACjB;AAAC,SAEcD,oBAAoBA,CAAAI,EAAA,EAAAC,GAAA,EAAAC,GAAA,EAAAC,GAAA;EAAA,OAAAC,qBAAA,CAAAC,KAAA,OAAAC,SAAA;AAAA;AAAA,SAAAF,sBAAA;EAAAA,qBAAA,OAAAG,kBAAA,CAAAC,OAAA,EAAAC,YAAA,CAAAD,OAAA,CAAAE,IAAA,CAAnC,SAAAC,QACEZ,IAAc,EACdb,OAA8C,EAC9CC,OAAsB,EACtBO,KAAgB;IAAA,IAAAkB,GAAA,EAAAC,QAAA;IAAA,OAAAJ,YAAA,CAAAD,OAAA,CAAAM,IAAA,UAAAC,SAAAC,QAAA;MAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;QAAA;UAAA,MAEZ,OAAOnB,IAAI,KAAK,QAAQ;YAAAiB,QAAA,CAAAE,IAAA;YAAA;UAAA;UACpBN,GAAG,GAAGb,IAAI;UAAAiB,QAAA,CAAAE,IAAA;UAAA,OACOxB,KAAK,CAACkB,GAAG,CAAC;QAAA;UAA3BC,QAAQ,GAAAG,QAAA,CAAAG,IAAA;UAAAH,QAAA,CAAAE,IAAA;UAAA,OAED,IAAAE,8BAAc,EAACP,QAAQ,EAAE3B,OAAO,EAAEC,OAAO,CAAC;QAAA;UAAA,OAAA6B,QAAA,CAAAK,MAAA,WAAAL,QAAA,CAAAG,IAAA;QAAA;UAAAH,QAAA,CAAAE,IAAA;UAAA,OAG5C,IAAAE,8BAAc,EAACrB,IAAI,EAAEb,OAAO,EAAEC,OAAO,CAAC;QAAA;UAAA,OAAA6B,QAAA,CAAAK,MAAA,WAAAL,QAAA,CAAAG,IAAA;QAAA;QAAA;UAAA,OAAAH,QAAA,CAAAM,IAAA;MAAA;IAAA,GAAAX,OAAA;EAAA,CACpD;EAAA,OAAAP,qBAAA,CAAAC,KAAA,OAAAC,SAAA;AAAA"}

package/dist/es5/lib/api/load.js.map

@@ -1 +1 @@
-{"version":3,"file":"load.js","names":["_isType","require","_normalizeLoader","_getFetchFunction","_parse","load","_x","_x2","_x3","_x4","_load","apply","arguments","_asyncToGenerator2","default","_regenerator","mark","_callee","url","loaders","options","context","resolvedLoaders","resolvedOptions","fetch","data","wrap","_callee$","_context","prev","next","Array","isArray","isLoaderObject","undefined","getFetchFunction","sent","isBlob","parse","t0","abrupt","stop"],"sources":["../../../../src/lib/api/load.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport type {DataType, Loader, LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';\nimport type {LoaderOptionsType, LoaderReturnType} from '@loaders.gl/loader-utils';\nimport {isBlob} from '../../javascript-utils/is-type';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {getFetchFunction} from '../loader-utils/get-fetch-function';\n\nimport {parse} from './parse';\n\n/**\n * Parses `data` using a specified loader\n * Note: Load does duplicate a lot of parse.\n * it can also call fetchFile on string urls, which `parse` won't do.\n * @param data\n * @param loaders\n * @param options\n * @param context\n */\n\nexport async function load<LoaderT extends Loader>(\n  url: string | DataType,\n  loader: LoaderT,\n  options?: LoaderOptionsType<LoaderT>,\n  context?: LoaderContext\n): Promise<LoaderReturnType<LoaderT>>;\n\nexport async function load<LoaderOptionsT extends LoaderOptions = LoaderOptions>(\n  url: string | DataType,\n  loaders: Loader[] | LoaderOptions,\n  options?: LoaderOptionsT,\n  context?: LoaderContext\n): Promise<any>;\n\n// implementation signature\nexport async function load<LoaderOptionsT extends LoaderOptions = LoaderOptions>(\n  url: string | DataType,\n  loaders?: Loader[] | LoaderOptions,\n  options?: LoaderOptionsT,\n  context?: LoaderContext\n): Promise<any> {\n  let resolvedLoaders: Loader | Loader[];\n  let resolvedOptions: LoaderOptionsT | undefined;\n\n  // Signature: load(url, options)\n  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {\n    resolvedLoaders = [];\n    resolvedOptions = loaders as LoaderOptionsT;\n    context = undefined; // context not supported in short signature\n  } else {\n    resolvedLoaders = loaders as Loader | Loader[];\n    resolvedOptions = options;\n  }\n\n  // Select fetch function\n  const fetch = getFetchFunction(resolvedOptions);\n\n  // at this point, `url` could be already loaded binary data\n  let data = url;\n  // url is a string, fetch the url\n  if (typeof url === 'string') {\n    data = await fetch(url);\n    // URL is Blob or File, fetchFile handles it (alt: we could generate ObjectURL here)\n  }\n\n  if (isBlob(url)) {\n    // The fetch response object will contain blob.name\n    // @ts-expect-error TODO - This may not work for overridden fetch functions\n    data = await fetch(url);\n  }\n\n  // Data is loaded (at least we have a `Response` object) so time to hand over to `parse`\n  // return await parse(data, loaders as Loader[], options);\n  return Array.isArray(resolvedLoaders)\n    ? await parse(data, resolvedLoaders, resolvedOptions) // loader array overload\n    : await parse(data, resolvedLoaders, resolvedOptions); // single loader overload\n}\n"],"mappings":";;;;;;;;;AAIA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,gBAAA,GAAAD,OAAA;AACA,IAAAE,iBAAA,GAAAF,OAAA;AAEA,IAAAG,MAAA,GAAAH,OAAA;AAA8B,SA2BRI,IAAIA,CAAAC,EAAA,EAAAC,GAAA,EAAAC,GAAA,EAAAC,GAAA;EAAA,OAAAC,KAAA,CAAAC,KAAA,OAAAC,SAAA;AAAA;AAAA,SAAAF,MAAA;EAAAA,KAAA,OAAAG,kBAAA,CAAAC,OAAA,EAAAC,YAAA,CAAAD,OAAA,CAAAE,IAAA,CAAnB,SAAAC,QACLC,GAAsB,EACtBC,OAAkC,EAClCC,OAAwB,EACxBC,OAAuB;IAAA,IAAAC,eAAA,EAAAC,eAAA,EAAAC,KAAA,EAAAC,IAAA;IAAA,OAAAV,YAAA,CAAAD,OAAA,CAAAY,IAAA,UAAAC,SAAAC,QAAA;MAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;QAAA;UAMvB,IAAI,CAACC,KAAK,CAACC,OAAO,CAACb,OAAO,CAAC,IAAI,CAAC,IAAAc,+BAAc,EAACd,OAAO,CAAC,EAAE;YACvDG,eAAe,GAAG,EAAE;YACpBC,eAAe,GAAGJ,OAAyB;YAC3CE,OAAO,GAAGa,SAAS;UACrB,CAAC,MAAM;YACLZ,eAAe,GAAGH,OAA4B;YAC9CI,eAAe,GAAGH,OAAO;UAC3B;UAGMI,KAAK,GAAG,IAAAW,kCAAgB,EAACZ,eAAe,CAAC;UAG3CE,IAAI,GAAGP,GAAG;UAAA,MAEV,OAAOA,GAAG,KAAK,QAAQ;YAAAU,QAAA,CAAAE,IAAA;YAAA;UAAA;UAAAF,QAAA,CAAAE,IAAA;UAAA,OACZN,KAAK,CAACN,GAAG,CAAC;QAAA;UAAvBO,IAAI,GAAAG,QAAA,CAAAQ,IAAA;QAAA;UAAA,KAIF,IAAAC,cAAM,EAACnB,GAAG,CAAC;YAAAU,QAAA,CAAAE,IAAA;YAAA;UAAA;UAAAF,QAAA,CAAAE,IAAA;UAAA,OAGAN,KAAK,CAACN,GAAG,CAAC;QAAA;UAAvBO,IAAI,GAAAG,QAAA,CAAAQ,IAAA;QAAA;UAAA,KAKCL,KAAK,CAACC,OAAO,CAACV,eAAe,CAAC;YAAAM,QAAA,CAAAE,IAAA;YAAA;UAAA;UAAAF,QAAA,CAAAE,IAAA;UAAA,OAC3B,IAAAQ,YAAK,EAACb,IAAI,EAAEH,eAAe,EAAEC,eAAe,CAAC;QAAA;UAAAK,QAAA,CAAAW,EAAA,GAAAX,QAAA,CAAAQ,IAAA;UAAAR,QAAA,CAAAE,IAAA;UAAA;QAAA;UAAAF,QAAA,CAAAE,IAAA;UAAA,OAC7C,IAAAQ,YAAK,EAACb,IAAI,EAAEH,eAAe,EAAEC,eAAe,CAAC;QAAA;UAAAK,QAAA,CAAAW,EAAA,GAAAX,QAAA,CAAAQ,IAAA;QAAA;UAAA,OAAAR,QAAA,CAAAY,MAAA,WAAAZ,QAAA,CAAAW,EAAA;QAAA;QAAA;UAAA,OAAAX,QAAA,CAAAa,IAAA;MAAA;IAAA,GAAAxB,OAAA;EAAA,CACxD;EAAA,OAAAP,KAAA,CAAAC,KAAA,OAAAC,SAAA;AAAA"}
+{"version":3,"file":"load.js","names":["_isType","require","_normalizeLoader","_getFetchFunction","_parse","load","_x","_x2","_x3","_x4","_load","apply","arguments","_asyncToGenerator2","default","_regenerator","mark","_callee","url","loaders","options","context","resolvedLoaders","resolvedOptions","fetch","data","wrap","_callee$","_context","prev","next","Array","isArray","isLoaderObject","undefined","getFetchFunction","sent","isBlob","parse","t0","abrupt","stop"],"sources":["../../../../src/lib/api/load.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport type {DataType, Loader, LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';\nimport type {LoaderOptionsType, LoaderReturnType} from '@loaders.gl/loader-utils';\nimport {isBlob} from '../../javascript-utils/is-type';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {getFetchFunction} from '../loader-utils/get-fetch-function';\n\nimport {parse} from './parse';\n\n/**\n * Parses `data` using a specified loader\n * Note: Load does duplicate a lot of parse.\n * it can also call fetchFile on string urls, which `parse` won't do.\n * @param data\n * @param loaders\n * @param options\n * @param context\n */\n\nexport async function load<\n  LoaderT extends Loader,\n  OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>\n>(\n  url: string | DataType,\n  loader: LoaderT,\n  options?: OptionsT,\n  context?: LoaderContext\n): Promise<LoaderReturnType<LoaderT>>;\n\nexport async function load(\n  url: string | DataType,\n  loaders: Loader[],\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<unknown>;\n\nexport async function load(\n  url: string | DataType,\n  loaders?: LoaderOptions,\n  context?: LoaderContext\n): Promise<unknown>;\n\nexport async function load(url: string | DataType, loaders: LoaderOptions): Promise<any>;\n\n// implementation signature\nexport async function load(\n  url: string | DataType,\n  loaders?: Loader[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<unknown> {\n  let resolvedLoaders: Loader | Loader[];\n  let resolvedOptions: LoaderOptions | undefined;\n\n  // Signature: load(url, options)\n  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {\n    resolvedLoaders = [];\n    resolvedOptions = loaders as LoaderOptions;\n    context = undefined; // context not supported in short signature\n  } else {\n    resolvedLoaders = loaders as Loader | Loader[];\n    resolvedOptions = options;\n  }\n\n  // Select fetch function\n  const fetch = getFetchFunction(resolvedOptions);\n\n  // at this point, `url` could be already loaded binary data\n  let data = url;\n  // url is a string, fetch the url\n  if (typeof url === 'string') {\n    data = await fetch(url);\n    // URL is Blob or File, fetchFile handles it (alt: we could generate ObjectURL here)\n  }\n\n  if (isBlob(url)) {\n    // The fetch response object will contain blob.name\n    // @ts-expect-error TODO - This may not work for overridden fetch functions\n    data = await fetch(url);\n  }\n\n  // Data is loaded (at least we have a `Response` object) so time to hand over to `parse`\n  // return await parse(data, loaders as Loader[], options);\n  return Array.isArray(resolvedLoaders)\n    ? await parse(data, resolvedLoaders, resolvedOptions) // loader array overload\n    : await parse(data, resolvedLoaders, resolvedOptions); // single loader overload\n}\n"],"mappings":";;;;;;;;;AAIA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,gBAAA,GAAAD,OAAA;AACA,IAAAE,iBAAA,GAAAF,OAAA;AAEA,IAAAG,MAAA,GAAAH,OAAA;AAA8B,SAsCRI,IAAIA,CAAAC,EAAA,EAAAC,GAAA,EAAAC,GAAA,EAAAC,GAAA;EAAA,OAAAC,KAAA,CAAAC,KAAA,OAAAC,SAAA;AAAA;AAAA,SAAAF,MAAA;EAAAA,KAAA,OAAAG,kBAAA,CAAAC,OAAA,EAAAC,YAAA,CAAAD,OAAA,CAAAE,IAAA,CAAnB,SAAAC,QACLC,GAAsB,EACtBC,OAAkC,EAClCC,OAAuB,EACvBC,OAAuB;IAAA,IAAAC,eAAA,EAAAC,eAAA,EAAAC,KAAA,EAAAC,IAAA;IAAA,OAAAV,YAAA,CAAAD,OAAA,CAAAY,IAAA,UAAAC,SAAAC,QAAA;MAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;QAAA;UAMvB,IAAI,CAACC,KAAK,CAACC,OAAO,CAACb,OAAO,CAAC,IAAI,CAAC,IAAAc,+BAAc,EAACd,OAAO,CAAC,EAAE;YACvDG,eAAe,GAAG,EAAE;YACpBC,eAAe,GAAGJ,OAAwB;YAC1CE,OAAO,GAAGa,SAAS;UACrB,CAAC,MAAM;YACLZ,eAAe,GAAGH,OAA4B;YAC9CI,eAAe,GAAGH,OAAO;UAC3B;UAGMI,KAAK,GAAG,IAAAW,kCAAgB,EAACZ,eAAe,CAAC;UAG3CE,IAAI,GAAGP,GAAG;UAAA,MAEV,OAAOA,GAAG,KAAK,QAAQ;YAAAU,QAAA,CAAAE,IAAA;YAAA;UAAA;UAAAF,QAAA,CAAAE,IAAA;UAAA,OACZN,KAAK,CAACN,GAAG,CAAC;QAAA;UAAvBO,IAAI,GAAAG,QAAA,CAAAQ,IAAA;QAAA;UAAA,KAIF,IAAAC,cAAM,EAACnB,GAAG,CAAC;YAAAU,QAAA,CAAAE,IAAA;YAAA;UAAA;UAAAF,QAAA,CAAAE,IAAA;UAAA,OAGAN,KAAK,CAACN,GAAG,CAAC;QAAA;UAAvBO,IAAI,GAAAG,QAAA,CAAAQ,IAAA;QAAA;UAAA,KAKCL,KAAK,CAACC,OAAO,CAACV,eAAe,CAAC;YAAAM,QAAA,CAAAE,IAAA;YAAA;UAAA;UAAAF,QAAA,CAAAE,IAAA;UAAA,OAC3B,IAAAQ,YAAK,EAACb,IAAI,EAAEH,eAAe,EAAEC,eAAe,CAAC;QAAA;UAAAK,QAAA,CAAAW,EAAA,GAAAX,QAAA,CAAAQ,IAAA;UAAAR,QAAA,CAAAE,IAAA;UAAA;QAAA;UAAAF,QAAA,CAAAE,IAAA;UAAA,OAC7C,IAAAQ,YAAK,EAACb,IAAI,EAAEH,eAAe,EAAEC,eAAe,CAAC;QAAA;UAAAK,QAAA,CAAAW,EAAA,GAAAX,QAAA,CAAAQ,IAAA;QAAA;UAAA,OAAAR,QAAA,CAAAY,MAAA,WAAAZ,QAAA,CAAAW,EAAA;QAAA;QAAA;UAAA,OAAAX,QAAA,CAAAa,IAAA;MAAA;IAAA,GAAAxB,OAAA;EAAA,CACxD;EAAA,OAAAP,KAAA,CAAAC,KAAA,OAAAC,SAAA;AAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"parse-in-batches.js","names":["_loaderUtils","require","_normalizeLoader","_optionUtils","_loaderContext","_getData","_resourceUtils","_selectLoader","_parse","ownKeys","object","enumerableOnly","keys","Object","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","target","i","arguments","length","source","forEach","key","_defineProperty2","default","getOwnPropertyDescriptors","defineProperties","defineProperty","_asyncIterator","iterable","method","async","sync","retry","Symbol","asyncIterator","iterator","call","AsyncFromSyncIterator","TypeError","s","AsyncFromSyncIteratorContinuation","r","Promise","reject","done","resolve","value","then","n","next","prototype","return","_return","ret","throw","_throw","thr","parseInBatches","_x2","_x3","_x4","_x5","_parseInBatches","_asyncToGenerator2","_regenerator","mark","_callee","data","loaders","options","context","loaderArray","url","loader","wrap","_callee$","_context","prev","Array","isArray","undefined","isLoaderObject","sent","getResourceUrl","selectLoader","abrupt","normalizeOptions","getLoaderContext","parse","parseWithLoaderInBatches","stop","_x6","_x7","_x8","_x9","_parseWithLoaderInBatches","_callee3","outputIterator","metadataBatch","makeMetadataBatchIterator","_makeMetadataBatchIterator","_callee3$","_context3","_makeMetadataBatchIte2","_wrapAsyncGenerator2","_callee2","_callee2$","_context2","delegateYield","_asyncGeneratorDelegate2","_awaitAsyncGenerator2","_makeMetadataBatchIte","_x","parseToOutputIterator","metadata","batchType","_loader","bytesUsed","_x10","_x11","_x12","_x13","_parseToOutputIterator","_callee5","inputIterator","transformedIterator","parseChunkInBatches","_parseChunkInBatches","_callee5$","_context5","_parseChunkInBatches3","_callee4","arrayBuffer","parsedData","batch","_callee4$","_context4","concatenateArrayBuffersAsync","mimeType","mimeTypes","shape","_parseChunkInBatches2","getAsyncIterableFromData","applyInputTransforms","transforms","_x14","_applyInputTransforms","_callee6","iteratorChain","_iteratorAbruptCompletion","_didIteratorError","_iteratorError","_iterator","_step","transformBatches","_args6","_callee6$","_context6","t0","finish"],"sources":["../../../../src/lib/api/parse-in-batches.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport type {Batch} from '@loaders.gl/schema';\nimport type {Loader, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport type {LoaderContext, BatchableDataType} from '@loaders.gl/loader-utils';\nimport type {LoaderBatchType, LoaderOptionsType} from '@loaders.gl/loader-utils';\nimport {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 {getResourceUrl} 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` synchronously using a specified loader\n */\nexport async function parseInBatches<\n  LoaderT extends Loader,\n  OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>\n>(\n  data: BatchableDataType,\n  loader: LoaderT,\n  options?: OptionsT,\n  context?: LoaderContext\n): Promise<AsyncIterable<LoaderBatchType<LoaderT>>>;\n\n/**\n * Parses `data` using one of the supplied loaders\n */\nexport async function parseInBatches(\n  data: BatchableDataType,\n  loaders: Loader[],\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<AsyncIterable<any>>;\n\n/**\n * Parses `data` in batches by selecting a pre-registered loader\n */\nexport async function parseInBatches(\n  data: BatchableDataType,\n  options?: LoaderOptions\n): Promise<AsyncIterable<any>>;\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<unknown>> {\n  const loaderArray = Array.isArray(loaders) ? loaders : undefined;\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 = getResourceUrl(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 | 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  options = normalizeOptions(options, loader, loaderArray, url);\n  context = getLoaderContext(\n    {url, _parseInBatches: parseInBatches, _parse: parse, loaders: loaderArray},\n    options,\n    context || null\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<unknown>> {\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(\n    iterator: Iterable<unknown> | AsyncIterable<unknown>\n  ): AsyncIterable<unknown> {\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<unknown>> {\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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"}
+{"version":3,"file":"parse-in-batches.js","names":["_loaderUtils","require","_normalizeLoader","_optionUtils","_loaderContext","_getData","_resourceUtils","_selectLoader","_parse","ownKeys","object","enumerableOnly","keys","Object","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","target","i","arguments","length","source","forEach","key","_defineProperty2","default","getOwnPropertyDescriptors","defineProperties","defineProperty","_asyncIterator","iterable","method","async","sync","retry","Symbol","asyncIterator","iterator","call","AsyncFromSyncIterator","TypeError","s","AsyncFromSyncIteratorContinuation","r","Promise","reject","done","resolve","value","then","n","next","prototype","return","_return","ret","throw","_throw","thr","parseInBatches","_x2","_x3","_x4","_x5","_parseInBatches","_asyncToGenerator2","_regenerator","mark","_callee","data","loaders","options","context","loaderArray","url","loader","wrap","_callee$","_context","prev","Array","isArray","undefined","isLoaderObject","sent","getResourceUrl","selectLoader","abrupt","normalizeOptions","getLoaderContext","parse","parseWithLoaderInBatches","stop","_x6","_x7","_x8","_x9","_parseWithLoaderInBatches","_callee3","outputIterator","metadataBatch","makeMetadataBatchIterator","_makeMetadataBatchIterator","_callee3$","_context3","_makeMetadataBatchIte2","_wrapAsyncGenerator2","_callee2","_callee2$","_context2","delegateYield","_asyncGeneratorDelegate2","_awaitAsyncGenerator2","_makeMetadataBatchIte","_x","parseToOutputIterator","metadata","batchType","_loader","bytesUsed","_x10","_x11","_x12","_x13","_parseToOutputIterator","_callee5","inputIterator","transformedIterator","parseChunkInBatches","_parseChunkInBatches","_callee5$","_context5","_parseChunkInBatches3","_callee4","arrayBuffer","parsedData","batch","_callee4$","_context4","concatenateArrayBuffersAsync","mimeType","mimeTypes","shape","_parseChunkInBatches2","getAsyncIterableFromData","applyInputTransforms","transforms","_x14","_applyInputTransforms","_callee6","iteratorChain","_iteratorAbruptCompletion","_didIteratorError","_iteratorError","_iterator","_step","transformBatches","_args6","_callee6$","_context6","t0","finish"],"sources":["../../../../src/lib/api/parse-in-batches.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport type {Batch} from '@loaders.gl/schema';\nimport type {Loader, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport type {LoaderContext, BatchableDataType} from '@loaders.gl/loader-utils';\nimport type {LoaderBatchType, LoaderOptionsType} from '@loaders.gl/loader-utils';\nimport {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 {getResourceUrl} 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` synchronously using a specified loader\n */\nexport async function parseInBatches<\n  LoaderT extends Loader,\n  OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>\n>(\n  data: BatchableDataType,\n  loader: LoaderT,\n  options?: OptionsT,\n  context?: LoaderContext\n): Promise<AsyncIterable<LoaderBatchType<LoaderT>>>;\n\n/**\n * Parses `data` using one of the supplied loaders\n */\nexport async function parseInBatches(\n  data: BatchableDataType,\n  loaders: Loader[],\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<AsyncIterable<unknown>>;\n\n/**\n * Parses `data` in batches by selecting a pre-registered loader\n */\nexport async function parseInBatches(\n  data: BatchableDataType,\n  options?: LoaderOptions\n): Promise<AsyncIterable<unknown>>;\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<unknown>> {\n  const loaderArray = Array.isArray(loaders) ? loaders : undefined;\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 = getResourceUrl(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 | 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  options = normalizeOptions(options, loader, loaderArray, url);\n  context = getLoaderContext(\n    {url, _parseInBatches: parseInBatches, _parse: parse, loaders: loaderArray},\n    options,\n    context || null\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<unknown>> {\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(\n    iterator: Iterable<unknown> | AsyncIterable<unknown>\n  ): AsyncIterable<unknown> {\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<unknown>> {\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/es5/lib/api/parse-sync.js.map

@@ -1 +1 @@
-{"version":3,"file":"parse-sync.js","names":["_selectLoader","require","_normalizeLoader","_optionUtils","_getData","_loaderContext","_resourceUtils","parseSync","data","loaders","options","context","Array","isArray","isLoaderObject","undefined","typedLoaders","candidateLoaders","getLoadersFromContext","loader","selectLoaderSync","normalizeOptions","url","getResourceUrl","parse","Error","getLoaderContext","_parseSync","_parse","parseWithLoaderSync","getArrayBufferOrStringFromDataSync","parseTextSync","ArrayBuffer","concat","name"],"sources":["../../../../src/lib/api/parse-sync.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport type {Loader, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport type {LoaderContext, SyncDataType} from '@loaders.gl/loader-utils';\nimport type {LoaderOptionsType, LoaderReturnType} 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 {getResourceUrl} from '../utils/resource-utils';\n\n// OVERLOADS\n\n/**\n * Parses `data` synchronously using the specified loader\n */\nexport function parseSync<\n  LoaderT extends Loader,\n  OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>\n>(\n  data: SyncDataType,\n  loader: LoaderT,\n  options?: OptionsT,\n  context?: LoaderContext\n): LoaderReturnType<LoaderT>;\n\n/**\n * Parses `data` synchronously by matching one of the supplied loaders\n */\nexport function parseSync(\n  data: SyncDataType,\n  loaders: Loader[],\n  options?: LoaderOptions,\n  context?: LoaderContext\n): any;\n\n/**\n * Parses `data` synchronously by matching a pre=registered loader\n */\nexport function parseSync(data: SyncDataType, options?: LoaderOptions): any;\n\n/**\n * Parses `data` synchronously using a specified loader\n */\nexport function parseSync(\n  data: SyncDataType,\n  loaders?: Loader | Loader[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): unknown {\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 as Loader[] | undefined);\n\n  // Extract a url for auto detection\n  const url = getResourceUrl(data);\n\n  const parse = () => {\n    throw new Error('parseSync called parse (which is async');\n  };\n  context = getLoaderContext(\n    {url, _parseSync: parse, _parse: parse, loaders: loaders as Loader[]},\n    options,\n    context || null\n  );\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":";;;;;;AAKA,IAAAA,aAAA,GAAAC,OAAA;AACA,IAAAC,gBAAA,GAAAD,OAAA;AACA,IAAAE,YAAA,GAAAF,OAAA;AACA,IAAAG,QAAA,GAAAH,OAAA;AACA,IAAAI,cAAA,GAAAJ,OAAA;AACA,IAAAK,cAAA,GAAAL,OAAA;AAmCO,SAASM,SAASA,CACvBC,IAAkB,EAClBC,OAA2C,EAC3CC,OAAuB,EACvBC,OAAuB,EACd;EAGT,IAAI,CAACC,KAAK,CAACC,OAAO,CAACJ,OAAO,CAAC,IAAI,CAAC,IAAAK,+BAAc,EAACL,OAAO,CAAC,EAAE;IACvDE,OAAO,GAAGI,SAAS;IACnBL,OAAO,GAAGD,OAAwB;IAClCA,OAAO,GAAGM,SAAS;EACrB;EAEAL,OAAO,GAAGA,OAAO,IAAI,CAAC,CAAC;EAIvB,IAAMM,YAAY,GAAGP,OAAwC;EAC7D,IAAMQ,gBAAgB,GAAG,IAAAC,oCAAqB,EAACF,YAAY,EAAEL,OAAO,CAAC;EACrE,IAAMQ,MAAM,GAAG,IAAAC,8BAAgB,EAACZ,IAAI,EAAES,gBAAgB,EAAEP,OAAO,CAAC;EAEhE,IAAI,CAACS,MAAM,EAAE;IACX,OAAO,IAAI;EACb;EAGAT,OAAO,GAAG,IAAAW,6BAAgB,EAACX,OAAO,EAAES,MAAM,EAAEF,gBAAwC,CAAC;EAGrF,IAAMK,GAAG,GAAG,IAAAC,6BAAc,EAACf,IAAI,CAAC;EAEhC,IAAMgB,KAAK,GAAG,SAARA,KAAKA,CAAA,EAAS;IAClB,MAAM,IAAIC,KAAK,CAAC,wCAAwC,CAAC;EAC3D,CAAC;EACDd,OAAO,GAAG,IAAAe,+BAAgB,EACxB;IAACJ,GAAG,EAAHA,GAAG;IAAEK,UAAU,EAAEH,KAAK;IAAEI,MAAM,EAAEJ,KAAK;IAAEf,OAAO,EAAEA;EAAmB,CAAC,EACrEC,OAAO,EACPC,OAAO,IAAI,IACb,CAAC;EAED,OAAOkB,mBAAmB,CAACV,MAAM,EAAsBX,IAAI,EAAEE,OAAO,EAAEC,OAAO,CAAC;AAChF;AAGA,SAASkB,mBAAmBA,CAC1BV,MAAwB,EACxBX,IAAkB,EAClBE,OAAsB,EACtBC,OAAsB,EACtB;EACAH,IAAI,GAAG,IAAAsB,2CAAkC,EAACtB,IAAI,EAAEW,MAAM,EAAET,OAAO,CAAC;EAEhE,IAAIS,MAAM,CAACY,aAAa,IAAI,OAAOvB,IAAI,KAAK,QAAQ,EAAE;IACpD,OAAOW,MAAM,CAACY,aAAa,CAACvB,IAAI,EAAEE,OAAO,CAAC;EAC5C;EAEA,IAAIS,MAAM,CAACZ,SAAS,IAAIC,IAAI,YAAYwB,WAAW,EAAE;IACnD,OAAOb,MAAM,CAACZ,SAAS,CAACC,IAAI,EAAEE,OAAO,EAAEC,OAAO,CAAC;EACjD;EAGA,MAAM,IAAIc,KAAK,IAAAQ,MAAA,CACVd,MAAM,CAACe,IAAI,8EAAAD,MAAA,CACZtB,OAAO,CAACW,GAAG,IAAI,EAAE,CAErB,CAAC;AACH"}
+{"version":3,"file":"parse-sync.js","names":["_selectLoader","require","_normalizeLoader","_optionUtils","_getData","_loaderContext","_resourceUtils","parseSync","data","loaders","options","context","Array","isArray","isLoaderObject","undefined","typedLoaders","candidateLoaders","getLoadersFromContext","loader","selectLoaderSync","normalizeOptions","url","getResourceUrl","parse","Error","getLoaderContext","_parseSync","_parse","parseWithLoaderSync","getArrayBufferOrStringFromDataSync","parseTextSync","ArrayBuffer","concat","name"],"sources":["../../../../src/lib/api/parse-sync.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport type {Loader, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';\nimport type {LoaderContext, SyncDataType} from '@loaders.gl/loader-utils';\nimport type {LoaderOptionsType, LoaderReturnType} 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 {getResourceUrl} from '../utils/resource-utils';\n\n// OVERLOADS\n\n/**\n * Parses `data` synchronously using the specified loader\n */\nexport function parseSync<\n  LoaderT extends Loader,\n  OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>\n>(\n  data: SyncDataType,\n  loader: LoaderT,\n  options?: OptionsT,\n  context?: LoaderContext\n): LoaderReturnType<LoaderT>;\n\n/**\n * Parses `data` synchronously by matching one of the supplied loaders\n */\nexport function parseSync(\n  data: SyncDataType,\n  loaders: Loader[],\n  options?: LoaderOptions,\n  context?: LoaderContext\n): unknown;\n\n/**\n * Parses `data` synchronously by matching a pre=registered loader\n */\nexport function parseSync(data: SyncDataType, options?: LoaderOptions): unknown;\n\n/**\n * Parses `data` synchronously using a specified loader\n */\nexport function parseSync(\n  data: SyncDataType,\n  loaders?: Loader | Loader[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): unknown {\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 as Loader[] | undefined);\n\n  // Extract a url for auto detection\n  const url = getResourceUrl(data);\n\n  const parse = () => {\n    throw new Error('parseSync called parse (which is async');\n  };\n  context = getLoaderContext(\n    {url, _parseSync: parse, _parse: parse, loaders: loaders as Loader[]},\n    options,\n    context || null\n  );\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":";;;;;;AAKA,IAAAA,aAAA,GAAAC,OAAA;AACA,IAAAC,gBAAA,GAAAD,OAAA;AACA,IAAAE,YAAA,GAAAF,OAAA;AACA,IAAAG,QAAA,GAAAH,OAAA;AACA,IAAAI,cAAA,GAAAJ,OAAA;AACA,IAAAK,cAAA,GAAAL,OAAA;AAmCO,SAASM,SAASA,CACvBC,IAAkB,EAClBC,OAA2C,EAC3CC,OAAuB,EACvBC,OAAuB,EACd;EAGT,IAAI,CAACC,KAAK,CAACC,OAAO,CAACJ,OAAO,CAAC,IAAI,CAAC,IAAAK,+BAAc,EAACL,OAAO,CAAC,EAAE;IACvDE,OAAO,GAAGI,SAAS;IACnBL,OAAO,GAAGD,OAAwB;IAClCA,OAAO,GAAGM,SAAS;EACrB;EAEAL,OAAO,GAAGA,OAAO,IAAI,CAAC,CAAC;EAIvB,IAAMM,YAAY,GAAGP,OAAwC;EAC7D,IAAMQ,gBAAgB,GAAG,IAAAC,oCAAqB,EAACF,YAAY,EAAEL,OAAO,CAAC;EACrE,IAAMQ,MAAM,GAAG,IAAAC,8BAAgB,EAACZ,IAAI,EAAES,gBAAgB,EAAEP,OAAO,CAAC;EAEhE,IAAI,CAACS,MAAM,EAAE;IACX,OAAO,IAAI;EACb;EAGAT,OAAO,GAAG,IAAAW,6BAAgB,EAACX,OAAO,EAAES,MAAM,EAAEF,gBAAwC,CAAC;EAGrF,IAAMK,GAAG,GAAG,IAAAC,6BAAc,EAACf,IAAI,CAAC;EAEhC,IAAMgB,KAAK,GAAG,SAARA,KAAKA,CAAA,EAAS;IAClB,MAAM,IAAIC,KAAK,CAAC,wCAAwC,CAAC;EAC3D,CAAC;EACDd,OAAO,GAAG,IAAAe,+BAAgB,EACxB;IAACJ,GAAG,EAAHA,GAAG;IAAEK,UAAU,EAAEH,KAAK;IAAEI,MAAM,EAAEJ,KAAK;IAAEf,OAAO,EAAEA;EAAmB,CAAC,EACrEC,OAAO,EACPC,OAAO,IAAI,IACb,CAAC;EAED,OAAOkB,mBAAmB,CAACV,MAAM,EAAsBX,IAAI,EAAEE,OAAO,EAAEC,OAAO,CAAC;AAChF;AAGA,SAASkB,mBAAmBA,CAC1BV,MAAwB,EACxBX,IAAkB,EAClBE,OAAsB,EACtBC,OAAsB,EACtB;EACAH,IAAI,GAAG,IAAAsB,2CAAkC,EAACtB,IAAI,EAAEW,MAAM,EAAET,OAAO,CAAC;EAEhE,IAAIS,MAAM,CAACY,aAAa,IAAI,OAAOvB,IAAI,KAAK,QAAQ,EAAE;IACpD,OAAOW,MAAM,CAACY,aAAa,CAACvB,IAAI,EAAEE,OAAO,CAAC;EAC5C;EAEA,IAAIS,MAAM,CAACZ,SAAS,IAAIC,IAAI,YAAYwB,WAAW,EAAE;IACnD,OAAOb,MAAM,CAACZ,SAAS,CAACC,IAAI,EAAEE,OAAO,EAAEC,OAAO,CAAC;EACjD;EAGA,MAAM,IAAIc,KAAK,IAAAQ,MAAA,CACVd,MAAM,CAACe,IAAI,8EAAAD,MAAA,CACZtB,OAAO,CAACW,GAAG,IAAI,EAAE,CAErB,CAAC;AACH"}

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

@@ -1 +1 @@
-{"version":3,"file":"parse.js","names":["_loaderUtils","require","_workerUtils","_normalizeLoader","_isType","_optionUtils","_getData","_loaderContext","_resourceUtils","_selectLoader","parse","_x","_x2","_x3","_x4","_parse","apply","arguments","_asyncToGenerator2","default","_regenerator","mark","_callee","data","loaders","options","context","url","typedLoaders","candidateLoaders","loader","wrap","_callee$","_context","prev","next","Array","isArray","isLoaderObject","undefined","sent","getResourceUrl","getLoadersFromContext","selectLoader","abrupt","normalizeOptions","getLoaderContext","parseWithLoader","stop","_x5","_x6","_x7","_x8","_parseWithLoader","_callee2","response","ok","redirected","status","statusText","type","headers","loaderWithParser","_callee2$","_context2","validateWorkerVersion","isResponse","Object","fromEntries","entries","getArrayBufferOrStringFromData","parseTextSync","canParseWithWorker","parseWithWorker","parseText","assert","parseSync","Error","concat","id"],"sources":["../../../../src/lib/api/parse.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport type {Loader, LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';\nimport type {DataType, LoaderWithParser} from '@loaders.gl/loader-utils';\nimport type {LoaderOptionsType, LoaderReturnType} from '@loaders.gl/loader-utils';\nimport {parseWithWorker, canParseWithWorker} from '@loaders.gl/loader-utils';\nimport {assert, validateWorkerVersion} from '@loaders.gl/worker-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 {getResourceUrl} from '../utils/resource-utils';\nimport {selectLoader} from './select-loader';\n\n// type LoaderArrayType<T> = T extends (infer Loader)[] ? LoaderOptionsType<Loader> : T\n\n/**\n * Parses `data` asynchronously using the supplied loader\n */\nexport async function parse<\n  LoaderT extends Loader,\n  OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>\n>(\n  data: DataType | Promise<DataType>,\n  loader: LoaderT,\n  options?: OptionsT,\n  context?: LoaderContext\n): Promise<LoaderReturnType<LoaderT>>;\n\n/**\n * Parses `data` asynchronously by matching one of the supplied loader\n */\nexport async function parse(\n  data: DataType | Promise<DataType>,\n  loaders: Loader[],\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<any>;\n\n/**\n * Parses data asynchronously by matching a pre-registered loader\n */\nexport async function parse(\n  data: DataType | Promise<DataType>,\n  options?: LoaderOptions\n): Promise<any>;\n\n/**\n * Parses `data` using a specified loader\n * @param data\n * @param loaders\n * @param options\n * @param context\n */\n// implementation signature\nexport async function parse(\n  data: DataType | Promise<DataType>,\n  loaders?: Loader | Loader[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<unknown> {\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 || ({} as LoaderOptions); // Could be invalid...\n\n  // Extract a url for auto detection\n  const url = getResourceUrl(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  // @ts-expect-error\n  options = normalizeOptions(options, loader, candidateLoaders, url); // Could be invalid...\n\n  // Get a context (if already present, will be unchanged)\n  context = getLoaderContext(\n    // @ts-expect-error\n    {url, _parse: parse, loaders: candidateLoaders},\n    options,\n    context || null\n  );\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(\n  loader: Loader,\n  data,\n  options: LoaderOptions,\n  context: LoaderContext\n): Promise<unknown> {\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    // @ts-expect-error TODO - fix this\n    context.response = {headers, ok, redirected, status, statusText, type, url};\n  }\n\n  data = await getArrayBufferOrStringFromData(data, loader, options);\n\n  const loaderWithParser = loader as LoaderWithParser;\n\n  // First check for synchronous text parser, wrap results in promises\n  if (loaderWithParser.parseTextSync && typeof data === 'string') {\n    return loaderWithParser.parseTextSync(data, options, context);\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 (loaderWithParser.parseText && typeof data === 'string') {\n    return await loaderWithParser.parseText(data, options, context);\n  }\n\n  if (loaderWithParser.parse) {\n    return await loaderWithParser.parse(data, options, context);\n  }\n\n  // This should not happen, all sync loaders should also offer `parse` function\n  assert(!loaderWithParser.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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"}
+{"version":3,"file":"parse.js","names":["_loaderUtils","require","_workerUtils","_normalizeLoader","_isType","_optionUtils","_getData","_loaderContext","_resourceUtils","_selectLoader","parse","_x","_x2","_x3","_x4","_parse","apply","arguments","_asyncToGenerator2","default","_regenerator","mark","_callee","data","loaders","options","context","url","typedLoaders","candidateLoaders","loader","wrap","_callee$","_context","prev","next","Array","isArray","isLoaderObject","undefined","sent","getResourceUrl","getLoadersFromContext","selectLoader","abrupt","normalizeOptions","getLoaderContext","parseWithLoader","stop","_x5","_x6","_x7","_x8","_parseWithLoader","_callee2","response","ok","redirected","status","statusText","type","headers","loaderWithParser","_callee2$","_context2","validateWorkerVersion","isResponse","Object","fromEntries","entries","getArrayBufferOrStringFromData","parseTextSync","canParseWithWorker","parseWithWorker","parseText","assert","parseSync","Error","concat","id"],"sources":["../../../../src/lib/api/parse.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport type {Loader, LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';\nimport type {DataType, LoaderWithParser} from '@loaders.gl/loader-utils';\nimport type {LoaderOptionsType, LoaderReturnType} from '@loaders.gl/loader-utils';\nimport {parseWithWorker, canParseWithWorker} from '@loaders.gl/loader-utils';\nimport {assert, validateWorkerVersion} from '@loaders.gl/worker-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 {getResourceUrl} from '../utils/resource-utils';\nimport {selectLoader} from './select-loader';\n\n// type LoaderArrayType<T> = T extends (infer Loader)[] ? LoaderOptionsType<Loader> : T\n\n/**\n * Parses `data` asynchronously using the supplied loader\n */\nexport async function parse<\n  LoaderT extends Loader,\n  OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>\n>(\n  data: DataType | Promise<DataType>,\n  loader: LoaderT,\n  options?: OptionsT,\n  context?: LoaderContext\n): Promise<LoaderReturnType<LoaderT>>;\n\n/**\n * Parses `data` asynchronously by matching one of the supplied loader\n */\nexport async function parse(\n  data: DataType | Promise<DataType>,\n  loaders: Loader[],\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<unknown>;\n\n/**\n * Parses data asynchronously by matching a pre-registered loader\n */\nexport async function parse(\n  data: DataType | Promise<DataType>,\n  options?: LoaderOptions\n): Promise<unknown>;\n\n/**\n * Parses `data` using a specified loader\n * @param data\n * @param loaders\n * @param options\n * @param context\n */\n// implementation signature\nexport async function parse(\n  data: DataType | Promise<DataType>,\n  loaders?: Loader | Loader[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<unknown> {\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 || ({} as LoaderOptions); // Could be invalid...\n\n  // Extract a url for auto detection\n  const url = getResourceUrl(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  // @ts-expect-error\n  options = normalizeOptions(options, loader, candidateLoaders, url); // Could be invalid...\n\n  // Get a context (if already present, will be unchanged)\n  context = getLoaderContext(\n    // @ts-expect-error\n    {url, _parse: parse, loaders: candidateLoaders},\n    options,\n    context || null\n  );\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(\n  loader: Loader,\n  data,\n  options: LoaderOptions,\n  context: LoaderContext\n): Promise<unknown> {\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    // @ts-expect-error TODO - fix this\n    context.response = {headers, ok, redirected, status, statusText, type, url};\n  }\n\n  data = await getArrayBufferOrStringFromData(data, loader, options);\n\n  const loaderWithParser = loader as LoaderWithParser;\n\n  // First check for synchronous text parser, wrap results in promises\n  if (loaderWithParser.parseTextSync && typeof data === 'string') {\n    return loaderWithParser.parseTextSync(data, options, context);\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 (loaderWithParser.parseText && typeof data === 'string') {\n    return await loaderWithParser.parseText(data, options, context);\n  }\n\n  if (loaderWithParser.parse) {\n    return await loaderWithParser.parse(data, options, context);\n  }\n\n  // This should not happen, all sync loaders should also offer `parse` function\n  assert(!loaderWithParser.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/es5/lib/filesystems/browser-filesystem.js

@@ -4,7 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.BrowserFileSystem = void 0;
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
@@ -245,5 +245,5 @@ var BrowserFileSystem = function () {
   }]);
   return BrowserFileSystem;
 }();
-exports.default = BrowserFileSystem;
+exports.BrowserFileSystem = BrowserFileSystem;
 //# sourceMappingURL=browser-filesystem.js.map