@loaders.gl/core 3.1.0-beta.7 → 3.1.3

package/dist/es5/lib/api/encode.js

@@ -1,5 +1,7 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -9,46 +11,178 @@ exports.encodeText = encodeText;
 exports.encodeInBatches = encodeInBatches;
 exports.encodeURLtoURL = encodeURLtoURL;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _asyncIterator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncIterator"));
+
 var _loaderUtils = require("@loaders.gl/loader-utils");
 
 var _writeFile = require("../fetch/write-file");
 
 var _fetchFile = require("../fetch/fetch-file");
 
-async function encode(data, writer, options) {
-  if (writer.encode) {
-    return await writer.encode(data, options);
-  }
+function encode(_x, _x2, _x3) {
+  return _encode.apply(this, arguments);
+}
 
-  if (writer.encodeSync) {
-    return writer.encodeSync(data, options);
-  }
+function _encode() {
+  _encode = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(data, writer, options) {
+    var batches, chunks, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, batch, tmpInputFilename, tmpOutputFilename, outputFilename, response;
 
-  if (writer.encodeText) {
-    return new TextEncoder().encode(await writer.encodeText(data, options));
-  }
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            if (!writer.encode) {
+              _context.next = 4;
+              break;
+            }
 
-  if (writer.encodeInBatches) {
-    const batches = encodeInBatches(data, writer, options);
-    const chunks = [];
+            _context.next = 3;
+            return writer.encode(data, options);
 
-    for await (const batch of batches) {
-      chunks.push(batch);
-    }
+          case 3:
+            return _context.abrupt("return", _context.sent);
 
-    return (0, _loaderUtils.concatenateArrayBuffers)(...chunks);
-  }
+          case 4:
+            if (!writer.encodeSync) {
+              _context.next = 6;
+              break;
+            }
 
-  if (!_loaderUtils.isBrowser && writer.encodeURLtoURL) {
-    const tmpInputFilename = getTemporaryFilename('input');
-    await (0, _writeFile.writeFile)(tmpInputFilename, data);
-    const tmpOutputFilename = getTemporaryFilename('output');
-    const outputFilename = await encodeURLtoURL(tmpInputFilename, tmpOutputFilename, writer, options);
-    const response = await (0, _fetchFile.fetchFile)(outputFilename);
-    return response.arrayBuffer();
-  }
+            return _context.abrupt("return", writer.encodeSync(data, options));
+
+          case 6:
+            if (!writer.encodeText) {
+              _context.next = 12;
+              break;
+            }
+
+            _context.t0 = new TextEncoder();
+            _context.next = 10;
+            return writer.encodeText(data, options);
+
+          case 10:
+            _context.t1 = _context.sent;
+            return _context.abrupt("return", _context.t0.encode.call(_context.t0, _context.t1));
+
+          case 12:
+            if (!writer.encodeInBatches) {
+              _context.next = 49;
+              break;
+            }
+
+            batches = encodeInBatches(data, writer, options);
+            chunks = [];
+            _iteratorNormalCompletion = true;
+            _didIteratorError = false;
+            _context.prev = 17;
+            _iterator = (0, _asyncIterator2.default)(batches);
+
+          case 19:
+            _context.next = 21;
+            return _iterator.next();
+
+          case 21:
+            _step = _context.sent;
+            _iteratorNormalCompletion = _step.done;
+            _context.next = 25;
+            return _step.value;
+
+          case 25:
+            _value = _context.sent;
+
+            if (_iteratorNormalCompletion) {
+              _context.next = 32;
+              break;
+            }
+
+            batch = _value;
+            chunks.push(batch);
+
+          case 29:
+            _iteratorNormalCompletion = true;
+            _context.next = 19;
+            break;
+
+          case 32:
+            _context.next = 38;
+            break;
+
+          case 34:
+            _context.prev = 34;
+            _context.t2 = _context["catch"](17);
+            _didIteratorError = true;
+            _iteratorError = _context.t2;
+
+          case 38:
+            _context.prev = 38;
+            _context.prev = 39;
+
+            if (!(!_iteratorNormalCompletion && _iterator.return != null)) {
+              _context.next = 43;
+              break;
+            }
 
-  throw new Error('Writer could not encode data');
+            _context.next = 43;
+            return _iterator.return();
+
+          case 43:
+            _context.prev = 43;
+
+            if (!_didIteratorError) {
+              _context.next = 46;
+              break;
+            }
+
+            throw _iteratorError;
+
+          case 46:
+            return _context.finish(43);
+
+          case 47:
+            return _context.finish(38);
+
+          case 48:
+            return _context.abrupt("return", _loaderUtils.concatenateArrayBuffers.apply(void 0, chunks));
+
+          case 49:
+            if (!(!_loaderUtils.isBrowser && writer.encodeURLtoURL)) {
+              _context.next = 61;
+              break;
+            }
+
+            tmpInputFilename = getTemporaryFilename('input');
+            _context.next = 53;
+            return (0, _writeFile.writeFile)(tmpInputFilename, data);
+
+          case 53:
+            tmpOutputFilename = getTemporaryFilename('output');
+            _context.next = 56;
+            return encodeURLtoURL(tmpInputFilename, tmpOutputFilename, writer, options);
+
+          case 56:
+            outputFilename = _context.sent;
+            _context.next = 59;
+            return (0, _fetchFile.fetchFile)(outputFilename);
+
+          case 59:
+            response = _context.sent;
+            return _context.abrupt("return", response.arrayBuffer());
+
+          case 61:
+            throw new Error('Writer could not encode data');
+
+          case 62:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[17, 34, 38, 48], [39,, 43, 47]]);
+  }));
+  return _encode.apply(this, arguments);
 }
 
 function encodeSync(data, writer, options) {
@@ -59,42 +193,104 @@ function encodeSync(data, writer, options) {
   throw new Error('Writer could not synchronously encode data');
 }
 
-async function encodeText(data, writer, options) {
-  if (writer.text && writer.encodeText) {
-    return await writer.encodeText(data, options);
-  }
+function encodeText(_x4, _x5, _x6) {
+  return _encodeText.apply(this, arguments);
+}
 
-  if (writer.text && (writer.encode || writer.encodeInBatches)) {
-    const arrayBuffer = await encode(data, writer, options);
-    return new TextDecoder().decode(arrayBuffer);
-  }
+function _encodeText() {
+  _encodeText = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(data, writer, options) {
+    var arrayBuffer;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            if (!(writer.text && writer.encodeText)) {
+              _context2.next = 4;
+              break;
+            }
+
+            _context2.next = 3;
+            return writer.encodeText(data, options);
+
+          case 3:
+            return _context2.abrupt("return", _context2.sent);
+
+          case 4:
+            if (!(writer.text && (writer.encode || writer.encodeInBatches))) {
+              _context2.next = 9;
+              break;
+            }
+
+            _context2.next = 7;
+            return encode(data, writer, options);
+
+          case 7:
+            arrayBuffer = _context2.sent;
+            return _context2.abrupt("return", new TextDecoder().decode(arrayBuffer));
 
-  throw new Error('Writer could not encode data as text');
+          case 9:
+            throw new Error('Writer could not encode data as text');
+
+          case 10:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _encodeText.apply(this, arguments);
 }
 
 function encodeInBatches(data, writer, options) {
   if (writer.encodeInBatches) {
-    const dataIterator = getIterator(data);
+    var dataIterator = getIterator(data);
     return writer.encodeInBatches(dataIterator, options);
   }
 
   throw new Error('Writer could not encode data in batches');
 }
 
-async function encodeURLtoURL(inputUrl, outputUrl, writer, options) {
-  inputUrl = (0, _loaderUtils.resolvePath)(inputUrl);
-  outputUrl = (0, _loaderUtils.resolvePath)(outputUrl);
+function encodeURLtoURL(_x7, _x8, _x9, _x10) {
+  return _encodeURLtoURL.apply(this, arguments);
+}
+
+function _encodeURLtoURL() {
+  _encodeURLtoURL = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee3(inputUrl, outputUrl, writer, options) {
+    var outputFilename;
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            inputUrl = (0, _loaderUtils.resolvePath)(inputUrl);
+            outputUrl = (0, _loaderUtils.resolvePath)(outputUrl);
 
-  if (_loaderUtils.isBrowser || !writer.encodeURLtoURL) {
-    throw new Error();
-  }
+            if (!(_loaderUtils.isBrowser || !writer.encodeURLtoURL)) {
+              _context3.next = 4;
+              break;
+            }
+
+            throw new Error();
+
+          case 4:
+            _context3.next = 6;
+            return writer.encodeURLtoURL(inputUrl, outputUrl, options);
+
+          case 6:
+            outputFilename = _context3.sent;
+            return _context3.abrupt("return", outputFilename);
 
-  const outputFilename = await writer.encodeURLtoURL(inputUrl, outputUrl, options);
-  return outputFilename;
+          case 8:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _encodeURLtoURL.apply(this, arguments);
 }
 
 function getIterator(data) {
-  const dataIterator = [{
+  var dataIterator = [{
     table: data,
     start: 0,
     end: data.length

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/api/encode.ts"],"names":["encode","data","writer","options","encodeSync","encodeText","TextEncoder","encodeInBatches","batches","chunks","batch","push","isBrowser","encodeURLtoURL","tmpInputFilename","getTemporaryFilename","tmpOutputFilename","outputFilename","response","arrayBuffer","Error","text","TextDecoder","decode","dataIterator","getIterator","inputUrl","outputUrl","table","start","end","length","filename"],"mappings":"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","sourcesContent":["import type {Writer, LoaderOptions} from '@loaders.gl/loader-utils';\nimport {concatenateArrayBuffers, resolvePath} from '@loaders.gl/loader-utils';\nimport {isBrowser} from '@loaders.gl/loader-utils';\nimport {writeFile} from '../fetch/write-file';\nimport {fetchFile} from '../fetch/fetch-file';\n\n/**\n * Encode loaded data into a binary ArrayBuffer using the specified Writer.\n */\nexport async function encode(\n  data: any,\n  writer: Writer,\n  options?: LoaderOptions\n): Promise<ArrayBuffer> {\n  // TODO Merge default writer options with options argument like it is done in load module.\n  if (writer.encode) {\n    return await writer.encode(data, options);\n  }\n\n  if (writer.encodeSync) {\n    return writer.encodeSync(data, options);\n  }\n\n  if (writer.encodeText) {\n    return new TextEncoder().encode(await writer.encodeText(data, options));\n  }\n\n  if (writer.encodeInBatches) {\n    // Create an iterator representing the data\n    // TODO - Assumes this is a table\n    const batches = encodeInBatches(data, writer, options);\n\n    // Concatenate the output\n    const chunks: any[] = [];\n    for await (const batch of batches) {\n      chunks.push(batch);\n    }\n    // @ts-ignore\n    return concatenateArrayBuffers(...chunks);\n  }\n\n  if (!isBrowser && writer.encodeURLtoURL) {\n    // TODO - how to generate filenames with correct extensions?\n    const tmpInputFilename = getTemporaryFilename('input');\n    await writeFile(tmpInputFilename, data);\n\n    const tmpOutputFilename = getTemporaryFilename('output');\n\n    const outputFilename = await encodeURLtoURL(\n      tmpInputFilename,\n      tmpOutputFilename,\n      writer,\n      options\n    );\n\n    const response = await fetchFile(outputFilename);\n    return response.arrayBuffer();\n  }\n\n  throw new Error('Writer could not encode data');\n}\n\n/**\n * Encode loaded data into a binary ArrayBuffer using the specified Writer.\n */\nexport function encodeSync(data: any, writer: Writer, options?: LoaderOptions): ArrayBuffer {\n  if (writer.encodeSync) {\n    return writer.encodeSync(data, options);\n  }\n  throw new Error('Writer could not synchronously encode data');\n}\n\n/**\n * Encode loaded data to text using the specified Writer\n * @note This is a convenience function not intended for production use on large input data.\n * It is not optimized for performance. Data maybe converted from text to binary and back.\n * @throws if the writer does not generate text output\n */\nexport async function encodeText(\n  data: any,\n  writer: Writer,\n  options?: LoaderOptions\n): Promise<string> {\n  if (writer.text && writer.encodeText) {\n    return await writer.encodeText(data, options);\n  }\n\n  if (writer.text && (writer.encode || writer.encodeInBatches)) {\n    const arrayBuffer = await encode(data, writer, options);\n    return new TextDecoder().decode(arrayBuffer);\n  }\n\n  throw new Error('Writer could not encode data as text');\n}\n\n/**\n * Encode loaded data into a sequence (iterator) of binary ArrayBuffers using the specified Writer.\n */\nexport function encodeInBatches(\n  data: any,\n  writer: Writer,\n  options?: LoaderOptions\n): AsyncIterable<ArrayBuffer> {\n  if (writer.encodeInBatches) {\n    const dataIterator = getIterator(data);\n    return writer.encodeInBatches(dataIterator, options);\n  }\n  // TODO -fall back to atomic encode?\n  throw new Error('Writer could not encode data in batches');\n}\n\n/**\n * Encode data stored in a file (on disk) to another file.\n * @note Node.js only. This function enables using command-line converters as \"writers\".\n */\nexport async function encodeURLtoURL(\n  inputUrl,\n  outputUrl,\n  writer: Writer,\n  options\n): Promise<string> {\n  inputUrl = resolvePath(inputUrl);\n  outputUrl = resolvePath(outputUrl);\n  if (isBrowser || !writer.encodeURLtoURL) {\n    throw new Error();\n  }\n  const outputFilename = await writer.encodeURLtoURL(inputUrl, outputUrl, options);\n  return outputFilename;\n}\n\n/**\n * @todo TODO - this is an unacceptable hack!!!\n */\nfunction getIterator(data) {\n  const dataIterator = [{table: data, start: 0, end: data.length}];\n  return dataIterator;\n}\n\n/**\n * @todo Move to utils\n */\nfunction getTemporaryFilename(filename: string): string {\n  return `/tmp/${filename}`;\n}\n"],"file":"encode.js"}
+{"version":3,"sources":["../../../../src/lib/api/encode.ts"],"names":["encode","data","writer","options","encodeSync","encodeText","TextEncoder","encodeInBatches","batches","chunks","batch","push","concatenateArrayBuffers","isBrowser","encodeURLtoURL","tmpInputFilename","getTemporaryFilename","tmpOutputFilename","outputFilename","response","arrayBuffer","Error","text","TextDecoder","decode","dataIterator","getIterator","inputUrl","outputUrl","table","start","end","length","filename"],"mappings":"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","sourcesContent":["import type {Writer, LoaderOptions} from '@loaders.gl/loader-utils';\nimport {concatenateArrayBuffers, resolvePath} from '@loaders.gl/loader-utils';\nimport {isBrowser} from '@loaders.gl/loader-utils';\nimport {writeFile} from '../fetch/write-file';\nimport {fetchFile} from '../fetch/fetch-file';\n\n/**\n * Encode loaded data into a binary ArrayBuffer using the specified Writer.\n */\nexport async function encode(\n  data: any,\n  writer: Writer,\n  options?: LoaderOptions\n): Promise<ArrayBuffer> {\n  // TODO Merge default writer options with options argument like it is done in load module.\n  if (writer.encode) {\n    return await writer.encode(data, options);\n  }\n\n  if (writer.encodeSync) {\n    return writer.encodeSync(data, options);\n  }\n\n  if (writer.encodeText) {\n    return new TextEncoder().encode(await writer.encodeText(data, options));\n  }\n\n  if (writer.encodeInBatches) {\n    // Create an iterator representing the data\n    // TODO - Assumes this is a table\n    const batches = encodeInBatches(data, writer, options);\n\n    // Concatenate the output\n    const chunks: any[] = [];\n    for await (const batch of batches) {\n      chunks.push(batch);\n    }\n    // @ts-ignore\n    return concatenateArrayBuffers(...chunks);\n  }\n\n  if (!isBrowser && writer.encodeURLtoURL) {\n    // TODO - how to generate filenames with correct extensions?\n    const tmpInputFilename = getTemporaryFilename('input');\n    await writeFile(tmpInputFilename, data);\n\n    const tmpOutputFilename = getTemporaryFilename('output');\n\n    const outputFilename = await encodeURLtoURL(\n      tmpInputFilename,\n      tmpOutputFilename,\n      writer,\n      options\n    );\n\n    const response = await fetchFile(outputFilename);\n    return response.arrayBuffer();\n  }\n\n  throw new Error('Writer could not encode data');\n}\n\n/**\n * Encode loaded data into a binary ArrayBuffer using the specified Writer.\n */\nexport function encodeSync(data: any, writer: Writer, options?: LoaderOptions): ArrayBuffer {\n  if (writer.encodeSync) {\n    return writer.encodeSync(data, options);\n  }\n  throw new Error('Writer could not synchronously encode data');\n}\n\n/**\n * Encode loaded data to text using the specified Writer\n * @note This is a convenience function not intended for production use on large input data.\n * It is not optimized for performance. Data maybe converted from text to binary and back.\n * @throws if the writer does not generate text output\n */\nexport async function encodeText(\n  data: any,\n  writer: Writer,\n  options?: LoaderOptions\n): Promise<string> {\n  if (writer.text && writer.encodeText) {\n    return await writer.encodeText(data, options);\n  }\n\n  if (writer.text && (writer.encode || writer.encodeInBatches)) {\n    const arrayBuffer = await encode(data, writer, options);\n    return new TextDecoder().decode(arrayBuffer);\n  }\n\n  throw new Error('Writer could not encode data as text');\n}\n\n/**\n * Encode loaded data into a sequence (iterator) of binary ArrayBuffers using the specified Writer.\n */\nexport function encodeInBatches(\n  data: any,\n  writer: Writer,\n  options?: LoaderOptions\n): AsyncIterable<ArrayBuffer> {\n  if (writer.encodeInBatches) {\n    const dataIterator = getIterator(data);\n    return writer.encodeInBatches(dataIterator, options);\n  }\n  // TODO -fall back to atomic encode?\n  throw new Error('Writer could not encode data in batches');\n}\n\n/**\n * Encode data stored in a file (on disk) to another file.\n * @note Node.js only. This function enables using command-line converters as \"writers\".\n */\nexport async function encodeURLtoURL(\n  inputUrl,\n  outputUrl,\n  writer: Writer,\n  options\n): Promise<string> {\n  inputUrl = resolvePath(inputUrl);\n  outputUrl = resolvePath(outputUrl);\n  if (isBrowser || !writer.encodeURLtoURL) {\n    throw new Error();\n  }\n  const outputFilename = await writer.encodeURLtoURL(inputUrl, outputUrl, options);\n  return outputFilename;\n}\n\n/**\n * @todo TODO - this is an unacceptable hack!!!\n */\nfunction getIterator(data) {\n  const dataIterator = [{table: data, start: 0, end: data.length}];\n  return dataIterator;\n}\n\n/**\n * @todo Move to utils\n */\nfunction getTemporaryFilename(filename: string): string {\n  return `/tmp/${filename}`;\n}\n"],"file":"encode.js"}

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

@@ -1,10 +1,16 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.loadInBatches = loadInBatches;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _normalizeLoader = require("../loader-utils/normalize-loader");
 
 var _optionUtils = require("../loader-utils/option-utils");
@@ -18,23 +24,60 @@ function loadInBatches(files, loaders, options, context) {
     loaders = null;
   }
 
-  const fetch = (0, _optionUtils.getFetchFunction)(options || {});
+  var fetch = (0, _optionUtils.getFetchFunction)(options || {});
 
   if (!Array.isArray(files)) {
     return loadOneFileInBatches(files, loaders, options, fetch);
   }
 
-  const promises = files.map(file => loadOneFileInBatches(file, loaders, options, fetch));
+  var promises = files.map(function (file) {
+    return loadOneFileInBatches(file, loaders, options, fetch);
+  });
   return promises;
 }
 
-async function loadOneFileInBatches(file, loaders, options, fetch) {
-  if (typeof file === 'string') {
-    const url = file;
-    const response = await fetch(url);
-    return await (0, _parseInBatches.parseInBatches)(response, loaders, options);
-  }
+function loadOneFileInBatches(_x, _x2, _x3, _x4) {
+  return _loadOneFileInBatches.apply(this, arguments);
+}
+
+function _loadOneFileInBatches() {
+  _loadOneFileInBatches = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(file, loaders, options, fetch) {
+    var url, response;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            if (!(typeof file === 'string')) {
+              _context.next = 8;
+              break;
+            }
+
+            url = file;
+            _context.next = 4;
+            return fetch(url);
+
+          case 4:
+            response = _context.sent;
+            _context.next = 7;
+            return (0, _parseInBatches.parseInBatches)(response, loaders, options);
+
+          case 7:
+            return _context.abrupt("return", _context.sent);
+
+          case 8:
+            _context.next = 10;
+            return (0, _parseInBatches.parseInBatches)(file, loaders, options);
+
+          case 10:
+            return _context.abrupt("return", _context.sent);
 
-  return await (0, _parseInBatches.parseInBatches)(file, loaders, options);
+          case 11:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _loadOneFileInBatches.apply(this, arguments);
 }
 //# sourceMappingURL=load-in-batches.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/api/load-in-batches.ts"],"names":["loadInBatches","files","loaders","options","context","Array","isArray","undefined","fetch","loadOneFileInBatches","promises","map","file","url","response"],"mappings":";;;;;;;AACA;;AACA;;AAEA;;AAyBO,SAASA,aAAT,CAAuBC,KAAvB,EAA8BC,OAA9B,EAAuCC,OAAvC,EAAgDC,OAAhD,EAAyD;AAE9D,MAAI,CAACC,KAAK,CAACC,OAAN,CAAcJ,OAAd,CAAD,IAA2B,CAAC,qCAAeA,OAAf,CAAhC,EAAyD;AACvDE,IAAAA,OAAO,GAAGG,SAAV;AACAJ,IAAAA,OAAO,GAAGD,OAAV;AACAA,IAAAA,OAAO,GAAG,IAAV;AACD;;AAGD,QAAMM,KAAK,GAAG,mCAAiBL,OAAO,IAAI,EAA5B,CAAd;;AAGA,MAAI,CAACE,KAAK,CAACC,OAAN,CAAcL,KAAd,CAAL,EAA2B;AACzB,WAAOQ,oBAAoB,CAACR,KAAD,EAAQC,OAAR,EAAiBC,OAAjB,EAA0BK,KAA1B,CAA3B;AACD;;AAGD,QAAME,QAAQ,GAAGT,KAAK,CAACU,GAAN,CAAWC,IAAD,IAAUH,oBAAoB,CAACG,IAAD,EAAOV,OAAP,EAAgBC,OAAhB,EAAyBK,KAAzB,CAAxC,CAAjB;AAGA,SAAOE,QAAP;AACD;;AAED,eAAeD,oBAAf,CAAoCG,IAApC,EAA0CV,OAA1C,EAAmDC,OAAnD,EAA4DK,KAA5D,EAAmE;AACjE,MAAI,OAAOI,IAAP,KAAgB,QAApB,EAA8B;AAC5B,UAAMC,GAAG,GAAGD,IAAZ;AACA,UAAME,QAAQ,GAAG,MAAMN,KAAK,CAACK,GAAD,CAA5B;AACA,WAAO,MAAM,oCAAeC,QAAf,EAAyBZ,OAAzB,EAAkCC,OAAlC,CAAb;AACD;;AACD,SAAO,MAAM,oCAAeS,IAAf,EAAqBV,OAArB,EAA8BC,OAA9B,CAAb;AACD","sourcesContent":["import type {LoaderWithParser, LoaderOptions, LoaderContext} from '@loaders.gl/loader-utils';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {getFetchFunction} from '../loader-utils/option-utils';\n\nimport {parseInBatches} from './parse-in-batches';\n\ntype FileType = string | File | Blob | Response | (string | File | Blob | Response)[] | FileList;\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(files, loaders, options, context) {\n  // Signature: load(url, options)\n  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {\n    context = undefined; // context not supported in short signature\n    options = loaders;\n    loaders = null;\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, loaders, options, fetch);\n  }\n\n  // Multiple URLs / files\n  const promises = files.map((file) => loadOneFileInBatches(file, loaders, options, fetch));\n\n  // No point in waiting here for all responses before starting to stream individual streams?\n  return promises;\n}\n\nasync function loadOneFileInBatches(file, loaders, options, fetch) {\n  if (typeof file === 'string') {\n    const url = file;\n    const response = await fetch(url);\n    return await parseInBatches(response, loaders, options);\n  }\n  return await parseInBatches(file, loaders, options);\n}\n"],"file":"load-in-batches.js"}
+{"version":3,"sources":["../../../../src/lib/api/load-in-batches.ts"],"names":["loadInBatches","files","loaders","options","context","Array","isArray","undefined","fetch","loadOneFileInBatches","promises","map","file","url","response"],"mappings":";;;;;;;;;;;;;AACA;;AACA;;AAEA;;AAyBO,SAASA,aAAT,CAAuBC,KAAvB,EAA8BC,OAA9B,EAAuCC,OAAvC,EAAgDC,OAAhD,EAAyD;AAE9D,MAAI,CAACC,KAAK,CAACC,OAAN,CAAcJ,OAAd,CAAD,IAA2B,CAAC,qCAAeA,OAAf,CAAhC,EAAyD;AACvDE,IAAAA,OAAO,GAAGG,SAAV;AACAJ,IAAAA,OAAO,GAAGD,OAAV;AACAA,IAAAA,OAAO,GAAG,IAAV;AACD;;AAGD,MAAMM,KAAK,GAAG,mCAAiBL,OAAO,IAAI,EAA5B,CAAd;;AAGA,MAAI,CAACE,KAAK,CAACC,OAAN,CAAcL,KAAd,CAAL,EAA2B;AACzB,WAAOQ,oBAAoB,CAACR,KAAD,EAAQC,OAAR,EAAiBC,OAAjB,EAA0BK,KAA1B,CAA3B;AACD;;AAGD,MAAME,QAAQ,GAAGT,KAAK,CAACU,GAAN,CAAU,UAACC,IAAD;AAAA,WAAUH,oBAAoB,CAACG,IAAD,EAAOV,OAAP,EAAgBC,OAAhB,EAAyBK,KAAzB,CAA9B;AAAA,GAAV,CAAjB;AAGA,SAAOE,QAAP;AACD;;SAEcD,oB;;;;;oFAAf,iBAAoCG,IAApC,EAA0CV,OAA1C,EAAmDC,OAAnD,EAA4DK,KAA5D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBACM,OAAOI,IAAP,KAAgB,QADtB;AAAA;AAAA;AAAA;;AAEUC,YAAAA,GAFV,GAEgBD,IAFhB;AAAA;AAAA,mBAG2BJ,KAAK,CAACK,GAAD,CAHhC;;AAAA;AAGUC,YAAAA,QAHV;AAAA;AAAA,mBAIiB,oCAAeA,QAAf,EAAyBZ,OAAzB,EAAkCC,OAAlC,CAJjB;;AAAA;AAAA;;AAAA;AAAA;AAAA,mBAMe,oCAAeS,IAAf,EAAqBV,OAArB,EAA8BC,OAA9B,CANf;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G","sourcesContent":["import type {LoaderWithParser, LoaderOptions, LoaderContext} from '@loaders.gl/loader-utils';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {getFetchFunction} from '../loader-utils/option-utils';\n\nimport {parseInBatches} from './parse-in-batches';\n\ntype FileType = string | File | Blob | Response | (string | File | Blob | Response)[] | FileList;\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(files, loaders, options, context) {\n  // Signature: load(url, options)\n  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {\n    context = undefined; // context not supported in short signature\n    options = loaders;\n    loaders = null;\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, loaders, options, fetch);\n  }\n\n  // Multiple URLs / files\n  const promises = files.map((file) => loadOneFileInBatches(file, loaders, options, fetch));\n\n  // No point in waiting here for all responses before starting to stream individual streams?\n  return promises;\n}\n\nasync function loadOneFileInBatches(file, loaders, options, fetch) {\n  if (typeof file === 'string') {\n    const url = file;\n    const response = await fetch(url);\n    return await parseInBatches(response, loaders, options);\n  }\n  return await parseInBatches(file, loaders, options);\n}\n"],"file":"load-in-batches.js"}

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

@@ -1,10 +1,16 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.load = load;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _isType = require("../../javascript-utils/is-type");
 
 var _normalizeLoader = require("../loader-utils/normalize-loader");
@@ -13,24 +19,63 @@ var _optionUtils = require("../loader-utils/option-utils");
 
 var _parse = require("./parse");
 
-async function load(url, loaders, options, context) {
-  if (!Array.isArray(loaders) && !(0, _normalizeLoader.isLoaderObject)(loaders)) {
-    context = undefined;
-    options = loaders;
-    loaders = undefined;
-  }
+function load(_x, _x2, _x3, _x4) {
+  return _load.apply(this, arguments);
+}
+
+function _load() {
+  _load = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(url, loaders, options, context) {
+    var fetch, data;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            if (!Array.isArray(loaders) && !(0, _normalizeLoader.isLoaderObject)(loaders)) {
+              context = undefined;
+              options = loaders;
+              loaders = undefined;
+            }
+
+            fetch = (0, _optionUtils.getFetchFunction)(options);
+            data = url;
+
+            if (!(typeof url === 'string')) {
+              _context.next = 7;
+              break;
+            }
+
+            _context.next = 6;
+            return fetch(url);
+
+          case 6:
+            data = _context.sent;
+
+          case 7:
+            if (!(0, _isType.isBlob)(url)) {
+              _context.next = 11;
+              break;
+            }
+
+            _context.next = 10;
+            return fetch(url);
 
-  const fetch = (0, _optionUtils.getFetchFunction)(options);
-  let data = url;
+          case 10:
+            data = _context.sent;
 
-  if (typeof url === 'string') {
-    data = await fetch(url);
-  }
+          case 11:
+            _context.next = 13;
+            return (0, _parse.parse)(data, loaders, options);
 
-  if ((0, _isType.isBlob)(url)) {
-    data = await fetch(url);
-  }
+          case 13:
+            return _context.abrupt("return", _context.sent);
 
-  return await (0, _parse.parse)(data, loaders, options);
+          case 14:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _load.apply(this, arguments);
 }
 //# sourceMappingURL=load.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/api/load.ts"],"names":["load","url","loaders","options","context","Array","isArray","undefined","fetch","data"],"mappings":";;;;;;;AACA;;AACA;;AACA;;AAEA;;AAYO,eAAeA,IAAf,CACLC,GADK,EAELC,OAFK,EAGLC,OAHK,EAILC,OAJK,EAKS;AAEd,MAAI,CAACC,KAAK,CAACC,OAAN,CAAcJ,OAAd,CAAD,IAA2B,CAAC,qCAAeA,OAAf,CAAhC,EAAyD;AACvDE,IAAAA,OAAO,GAAGG,SAAV;AACAJ,IAAAA,OAAO,GAAGD,OAAV;AACAA,IAAAA,OAAO,GAAGK,SAAV;AACD;;AAGD,QAAMC,KAAK,GAAG,mCAAiBL,OAAjB,CAAd;AAGA,MAAIM,IAAI,GAAGR,GAAX;;AAEA,MAAI,OAAOA,GAAP,KAAe,QAAnB,EAA6B;AAC3BQ,IAAAA,IAAI,GAAG,MAAMD,KAAK,CAACP,GAAD,CAAlB;AAED;;AAED,MAAI,oBAAOA,GAAP,CAAJ,EAAiB;AAEfQ,IAAAA,IAAI,GAAG,MAAMD,KAAK,CAACP,GAAD,CAAlB;AACD;;AAGD,SAAO,MAAM,kBAAMQ,IAAN,EAAYP,OAAZ,EAAqBC,OAArB,CAAb;AACD","sourcesContent":["import type {DataType, Loader, LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';\nimport {isBlob} from '../../javascript-utils/is-type';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {getFetchFunction} from '../loader-utils/option-utils';\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// implementation signature\nexport async function load(\n  url: string | DataType,\n  loaders?: Loader | Loader[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<any> {\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    loaders = undefined;\n  }\n\n  // Select fetch function\n  const fetch = getFetchFunction(options);\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    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, options);\n}\n"],"file":"load.js"}
+{"version":3,"sources":["../../../../src/lib/api/load.ts"],"names":["load","url","loaders","options","context","Array","isArray","undefined","fetch","data"],"mappings":";;;;;;;;;;;;;AACA;;AACA;;AACA;;AAEA;;SAYsBA,I;;;;;oEAAf,iBACLC,GADK,EAELC,OAFK,EAGLC,OAHK,EAILC,OAJK;AAAA;AAAA;AAAA;AAAA;AAAA;AAOL,gBAAI,CAACC,KAAK,CAACC,OAAN,CAAcJ,OAAd,CAAD,IAA2B,CAAC,qCAAeA,OAAf,CAAhC,EAAyD;AACvDE,cAAAA,OAAO,GAAGG,SAAV;AACAJ,cAAAA,OAAO,GAAGD,OAAV;AACAA,cAAAA,OAAO,GAAGK,SAAV;AACD;;AAGKC,YAAAA,KAdD,GAcS,mCAAiBL,OAAjB,CAdT;AAiBDM,YAAAA,IAjBC,GAiBMR,GAjBN;;AAAA,kBAmBD,OAAOA,GAAP,KAAe,QAnBd;AAAA;AAAA;AAAA;;AAAA;AAAA,mBAoBUO,KAAK,CAACP,GAAD,CApBf;;AAAA;AAoBHQ,YAAAA,IApBG;;AAAA;AAAA,iBAwBD,oBAAOR,GAAP,CAxBC;AAAA;AAAA;AAAA;;AAAA;AAAA,mBA0BUO,KAAK,CAACP,GAAD,CA1Bf;;AAAA;AA0BHQ,YAAAA,IA1BG;;AAAA;AAAA;AAAA,mBA8BQ,kBAAMA,IAAN,EAAYP,OAAZ,EAAqBC,OAArB,CA9BR;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G","sourcesContent":["import type {DataType, Loader, LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';\nimport {isBlob} from '../../javascript-utils/is-type';\nimport {isLoaderObject} from '../loader-utils/normalize-loader';\nimport {getFetchFunction} from '../loader-utils/option-utils';\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// implementation signature\nexport async function load(\n  url: string | DataType,\n  loaders?: Loader | Loader[] | LoaderOptions,\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<any> {\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    loaders = undefined;\n  }\n\n  // Select fetch function\n  const fetch = getFetchFunction(options);\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    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, options);\n}\n"],"file":"load.js"}