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

package/dist/es5/bundle.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const moduleExports = require('./index');
+var moduleExports = require('./index');
 
 globalThis.loaders = globalThis.loaders || {};
 module.exports = Object.assign(globalThis.loaders, moduleExports);

package/dist/es5/bundle.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/bundle.ts"],"names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"mappings":";;AACA,MAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCH,aAAlC,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}
+{"version":3,"sources":["../../src/bundle.ts"],"names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"mappings":";;AACA,IAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCH,aAAlC,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}

package/dist/es5/index.js

@@ -7,337 +7,325 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "fetchFile", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _fetchFile.fetchFile;
   }
 });
 Object.defineProperty(exports, "readArrayBuffer", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _readArrayBuffer.readArrayBuffer;
   }
 });
 Object.defineProperty(exports, "readFileSync", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _readFile.readFileSync;
   }
 });
 Object.defineProperty(exports, "writeFile", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _writeFile.writeFile;
   }
 });
 Object.defineProperty(exports, "writeFileSync", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _writeFile.writeFileSync;
   }
 });
 Object.defineProperty(exports, "setLoaderOptions", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _setLoaderOptions.setLoaderOptions;
   }
 });
 Object.defineProperty(exports, "registerLoaders", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _registerLoaders.registerLoaders;
   }
 });
 Object.defineProperty(exports, "_unregisterLoaders", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _registerLoaders._unregisterLoaders;
   }
 });
 Object.defineProperty(exports, "selectLoader", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _selectLoader.selectLoader;
   }
 });
 Object.defineProperty(exports, "selectLoaderSync", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _selectLoader.selectLoaderSync;
   }
 });
 Object.defineProperty(exports, "parse", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _parse.parse;
   }
 });
 Object.defineProperty(exports, "parseSync", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _parseSync.parseSync;
   }
 });
 Object.defineProperty(exports, "parseInBatches", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _parseInBatches.parseInBatches;
   }
 });
 Object.defineProperty(exports, "load", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _load.load;
   }
 });
 Object.defineProperty(exports, "loadInBatches", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _loadInBatches.loadInBatches;
   }
 });
 Object.defineProperty(exports, "encode", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _encode.encode;
   }
 });
 Object.defineProperty(exports, "encodeSync", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _encode.encodeSync;
   }
 });
 Object.defineProperty(exports, "encodeInBatches", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _encode.encodeInBatches;
   }
 });
 Object.defineProperty(exports, "encodeText", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _encode.encodeText;
   }
 });
 Object.defineProperty(exports, "encodeURLtoURL", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _encode.encodeURLtoURL;
   }
 });
 Object.defineProperty(exports, "save", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _save.save;
   }
 });
 Object.defineProperty(exports, "saveSync", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _save.saveSync;
   }
 });
 Object.defineProperty(exports, "setPathPrefix", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _loaderUtils.setPathPrefix;
   }
 });
 Object.defineProperty(exports, "getPathPrefix", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _loaderUtils.getPathPrefix;
   }
 });
 Object.defineProperty(exports, "resolvePath", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _loaderUtils.resolvePath;
   }
 });
 Object.defineProperty(exports, "RequestScheduler", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _loaderUtils.RequestScheduler;
   }
 });
 Object.defineProperty(exports, "JSONLoader", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _loaderUtils.JSONLoader;
   }
 });
 Object.defineProperty(exports, "isBrowser", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _loaderUtils.isBrowser;
   }
 });
 Object.defineProperty(exports, "isWorker", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _loaderUtils.isWorker;
   }
 });
 Object.defineProperty(exports, "self", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _loaderUtils.self;
   }
 });
 Object.defineProperty(exports, "window", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _loaderUtils.window;
   }
 });
 Object.defineProperty(exports, "global", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _loaderUtils.global;
   }
 });
 Object.defineProperty(exports, "document", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _loaderUtils.document;
   }
 });
 Object.defineProperty(exports, "assert", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _loaderUtils.assert;
   }
 });
 Object.defineProperty(exports, "forEach", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _loaderUtils.forEach;
   }
 });
 Object.defineProperty(exports, "concatenateArrayBuffersAsync", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _loaderUtils.concatenateArrayBuffersAsync;
   }
 });
 Object.defineProperty(exports, "makeTextDecoderIterator", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _loaderUtils.makeTextDecoderIterator;
   }
 });
 Object.defineProperty(exports, "makeTextEncoderIterator", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _loaderUtils.makeTextEncoderIterator;
   }
 });
 Object.defineProperty(exports, "makeLineIterator", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _loaderUtils.makeLineIterator;
   }
 });
 Object.defineProperty(exports, "makeNumberedLineIterator", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _loaderUtils.makeNumberedLineIterator;
   }
 });
 Object.defineProperty(exports, "makeIterator", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _makeIterator.makeIterator;
   }
 });
 Object.defineProperty(exports, "makeStream", {
   enumerable: true,
-  get: function () {
-    return _makeStream.makeStream;
-  }
-});
-Object.defineProperty(exports, "makeDOMStream", {
-  enumerable: true,
-  get: function () {
-    return _makeDomStream.makeDOMStream;
-  }
-});
-Object.defineProperty(exports, "makeNodeStream", {
-  enumerable: true,
-  get: function () {
-    return _makeNodeStream.default;
+  get: function get() {
+    return _makeNodeStream.makeStream;
   }
 });
 Object.defineProperty(exports, "NullWorkerLoader", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _nullLoader.NullWorkerLoader;
   }
 });
 Object.defineProperty(exports, "NullLoader", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _nullLoader.NullLoader;
   }
 });
 Object.defineProperty(exports, "_fetchProgress", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _fetchProgress.default;
   }
 });
 Object.defineProperty(exports, "_BrowserFileSystem", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _browserFilesystem.default;
   }
 });
 Object.defineProperty(exports, "isPureObject", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _isType.isPureObject;
   }
 });
 Object.defineProperty(exports, "isPromise", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _isType.isPromise;
   }
 });
 Object.defineProperty(exports, "isIterable", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _isType.isIterable;
   }
 });
 Object.defineProperty(exports, "isAsyncIterable", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _isType.isAsyncIterable;
   }
 });
 Object.defineProperty(exports, "isIterator", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _isType.isIterator;
   }
 });
 Object.defineProperty(exports, "isResponse", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _isType.isResponse;
   }
 });
 Object.defineProperty(exports, "isReadableStream", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _isType.isReadableStream;
   }
 });
 Object.defineProperty(exports, "isWritableStream", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _isType.isWritableStream;
   }
 });
@@ -374,11 +362,7 @@ var _loaderUtils = require("@loaders.gl/loader-utils");
 
 var _makeIterator = require("./iterators/make-iterator/make-iterator");
 
-var _makeStream = require("./iterators/make-stream/make-stream");
-
-var _makeDomStream = require("./iterators/make-stream/make-dom-stream");
-
-var _makeNodeStream = _interopRequireDefault(require("./iterators/make-stream/make-node-stream"));
+var _makeNodeStream = require("./iterators/make-stream/make-node-stream");
 
 var _nullLoader = require("./null-loader");
 

package/dist/es5/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA;;AAEA;;AACA;;AACA;;AAGA;;AACA;;AACA;;AAGA;;AACA;;AACA;;AAEA;;AACA;;AAGA;;AACA;;AAGA;;AAIA;;AACA;;AACA;;AACA;;AAGA;;AAIA;;AACA;;AAqBA","sourcesContent":["// 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} from './lib/api/set-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 {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-stream';\nexport {makeDOMStream} from './iterators/make-stream/make-dom-stream';\nexport {default as makeNodeStream} 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';\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"],"file":"index.js"}
+{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA;;AAEA;;AACA;;AACA;;AAGA;;AACA;;AACA;;AAGA;;AACA;;AACA;;AAEA;;AACA;;AAGA;;AACA;;AAGA;;AAIA;;AACA;;AAGA;;AAIA;;AACA;;AAqBA","sourcesContent":["// 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} from './lib/api/set-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 {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';\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"],"file":"index.js"}

package/dist/es5/iterators/batch-iterators/timed-batch-iterator.js

@@ -1,26 +1,131 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.timedBatchIterator = timedBatchIterator;
 
-async function* timedBatchIterator(batchIterator, timeout) {
-  let start = Date.now();
-  let batches = [];
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _awaitAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/awaitAsyncGenerator"));
+
+var _wrapAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapAsyncGenerator"));
+
+var _asyncIterator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncIterator"));
+
+function timedBatchIterator(_x, _x2) {
+  return _timedBatchIterator.apply(this, arguments);
+}
+
+function _timedBatchIterator() {
+  _timedBatchIterator = (0, _wrapAsyncGenerator2.default)(_regenerator.default.mark(function _callee(batchIterator, timeout) {
+    var start, batches, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, batch;
+
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            start = Date.now();
+            batches = [];
+            _iteratorNormalCompletion = true;
+            _didIteratorError = false;
+            _context.prev = 4;
+            _iterator = (0, _asyncIterator2.default)(batchIterator);
+
+          case 6:
+            _context.next = 8;
+            return (0, _awaitAsyncGenerator2.default)(_iterator.next());
+
+          case 8:
+            _step = _context.sent;
+            _iteratorNormalCompletion = _step.done;
+            _context.next = 12;
+            return (0, _awaitAsyncGenerator2.default)(_step.value);
+
+          case 12:
+            _value = _context.sent;
+
+            if (_iteratorNormalCompletion) {
+              _context.next = 24;
+              break;
+            }
+
+            batch = _value;
+            batches.push(batch);
+
+            if (!(Date.now() - start > timeout)) {
+              _context.next = 21;
+              break;
+            }
+
+            _context.next = 19;
+            return batches;
+
+          case 19:
+            start = Date.now();
+            batches = [];
+
+          case 21:
+            _iteratorNormalCompletion = true;
+            _context.next = 6;
+            break;
+
+          case 24:
+            _context.next = 30;
+            break;
+
+          case 26:
+            _context.prev = 26;
+            _context.t0 = _context["catch"](4);
+            _didIteratorError = true;
+            _iteratorError = _context.t0;
+
+          case 30:
+            _context.prev = 30;
+            _context.prev = 31;
+
+            if (!(!_iteratorNormalCompletion && _iterator.return != null)) {
+              _context.next = 35;
+              break;
+            }
+
+            _context.next = 35;
+            return (0, _awaitAsyncGenerator2.default)(_iterator.return());
+
+          case 35:
+            _context.prev = 35;
+
+            if (!_didIteratorError) {
+              _context.next = 38;
+              break;
+            }
+
+            throw _iteratorError;
+
+          case 38:
+            return _context.finish(35);
+
+          case 39:
+            return _context.finish(30);
 
-  for await (const batch of batchIterator) {
-    batches.push(batch);
+          case 40:
+            if (!batches) {
+              _context.next = 43;
+              break;
+            }
 
-    if (Date.now() - start > timeout) {
-      yield batches;
-      start = Date.now();
-      batches = [];
-    }
-  }
+            _context.next = 43;
+            return batches;
 
-  if (batches) {
-    yield batches;
-  }
+          case 43:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[4, 26, 30, 40], [31,, 35, 39]]);
+  }));
+  return _timedBatchIterator.apply(this, arguments);
 }
 //# sourceMappingURL=timed-batch-iterator.js.map

package/dist/es5/iterators/batch-iterators/timed-batch-iterator.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/iterators/batch-iterators/timed-batch-iterator.ts"],"names":["timedBatchIterator","batchIterator","timeout","start","Date","now","batches","batch","push"],"mappings":";;;;;;;AAGO,gBAAgBA,kBAAhB,CAA0CC,aAA1C,EAA+EC,OAA/E,EAAwF;AAC7F,MAAIC,KAAK,GAAGC,IAAI,CAACC,GAAL,EAAZ;AACA,MAAIC,OAAgB,GAAG,EAAvB;;AACA,aAAW,MAAMC,KAAjB,IAA0BN,aAA1B,EAAyC;AACvCK,IAAAA,OAAO,CAACE,IAAR,CAAaD,KAAb;;AACA,QAAIH,IAAI,CAACC,GAAL,KAAaF,KAAb,GAAqBD,OAAzB,EAAkC;AAChC,YAAMI,OAAN;AACAH,MAAAA,KAAK,GAAGC,IAAI,CAACC,GAAL,EAAR;AACAC,MAAAA,OAAO,GAAG,EAAV;AACD;AACF;;AAED,MAAIA,OAAJ,EAAa;AACX,UAAMA,OAAN;AACD;AACF","sourcesContent":["/**\n * \"Debounces\" batches and returns them in groups\n */\nexport async function* timedBatchIterator<Batch>(batchIterator: AsyncIterable<Batch>, timeout) {\n  let start = Date.now();\n  let batches: Batch[] = [];\n  for await (const batch of batchIterator) {\n    batches.push(batch);\n    if (Date.now() - start > timeout) {\n      yield batches;\n      start = Date.now();\n      batches = [];\n    }\n  }\n\n  if (batches) {\n    yield batches;\n  }\n}\n"],"file":"timed-batch-iterator.js"}
+{"version":3,"sources":["../../../../src/iterators/batch-iterators/timed-batch-iterator.ts"],"names":["timedBatchIterator","batchIterator","timeout","start","Date","now","batches","batch","push"],"mappings":";;;;;;;;;;;;;;;;;SAGuBA,kB;;;;;oFAAhB,iBAA0CC,aAA1C,EAA+EC,OAA/E;AAAA;;AAAA;AAAA;AAAA;AAAA;AACDC,YAAAA,KADC,GACOC,IAAI,CAACC,GAAL,EADP;AAEDC,YAAAA,OAFC,GAEkB,EAFlB;AAAA;AAAA;AAAA;AAAA,qDAGqBL,aAHrB;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAGYM,YAAAA,KAHZ;AAIHD,YAAAA,OAAO,CAACE,IAAR,CAAaD,KAAb;;AAJG,kBAKCH,IAAI,CAACC,GAAL,KAAaF,KAAb,GAAqBD,OALtB;AAAA;AAAA;AAAA;;AAAA;AAMD,mBAAMI,OAAN;;AANC;AAODH,YAAAA,KAAK,GAAGC,IAAI,CAACC,GAAL,EAAR;AACAC,YAAAA,OAAO,GAAG,EAAV;;AARC;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA,iBAYDA,OAZC;AAAA;AAAA;AAAA;;AAAA;AAaH,mBAAMA,OAAN;;AAbG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G","sourcesContent":["/**\n * \"Debounces\" batches and returns them in groups\n */\nexport async function* timedBatchIterator<Batch>(batchIterator: AsyncIterable<Batch>, timeout) {\n  let start = Date.now();\n  let batches: Batch[] = [];\n  for await (const batch of batchIterator) {\n    batches.push(batch);\n    if (Date.now() - start > timeout) {\n      yield batches;\n      start = Date.now();\n      batches = [];\n    }\n  }\n\n  if (batches) {\n    yield batches;\n  }\n}\n"],"file":"timed-batch-iterator.js"}

package/dist/es5/iterators/make-iterator/make-array-buffer-iterator.js

@@ -1,25 +1,61 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.makeArrayBufferIterator = makeArrayBufferIterator;
-const DEFAULT_CHUNK_SIZE = 256 * 1024;
-
-function* makeArrayBufferIterator(arrayBuffer, options = {}) {
-  const {
-    chunkSize = DEFAULT_CHUNK_SIZE
-  } = options;
-  let byteOffset = 0;
-
-  while (byteOffset < arrayBuffer.byteLength) {
-    const chunkByteLength = Math.min(arrayBuffer.byteLength - byteOffset, chunkSize);
-    const chunk = new ArrayBuffer(chunkByteLength);
-    const sourceArray = new Uint8Array(arrayBuffer, byteOffset, chunkByteLength);
-    const chunkArray = new Uint8Array(chunk);
-    chunkArray.set(sourceArray);
-    byteOffset += chunkByteLength;
-    yield chunk;
-  }
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _marked = _regenerator.default.mark(makeArrayBufferIterator);
+
+var DEFAULT_CHUNK_SIZE = 256 * 1024;
+
+function makeArrayBufferIterator(arrayBuffer) {
+  var options,
+      _options$chunkSize,
+      chunkSize,
+      byteOffset,
+      chunkByteLength,
+      chunk,
+      sourceArray,
+      chunkArray,
+      _args = arguments;
+
+  return _regenerator.default.wrap(function makeArrayBufferIterator$(_context) {
+    while (1) {
+      switch (_context.prev = _context.next) {
+        case 0:
+          options = _args.length > 1 && _args[1] !== undefined ? _args[1] : {};
+          _options$chunkSize = options.chunkSize, chunkSize = _options$chunkSize === void 0 ? DEFAULT_CHUNK_SIZE : _options$chunkSize;
+          byteOffset = 0;
+
+        case 3:
+          if (!(byteOffset < arrayBuffer.byteLength)) {
+            _context.next = 14;
+            break;
+          }
+
+          chunkByteLength = Math.min(arrayBuffer.byteLength - byteOffset, chunkSize);
+          chunk = new ArrayBuffer(chunkByteLength);
+          sourceArray = new Uint8Array(arrayBuffer, byteOffset, chunkByteLength);
+          chunkArray = new Uint8Array(chunk);
+          chunkArray.set(sourceArray);
+          byteOffset += chunkByteLength;
+          _context.next = 12;
+          return chunk;
+
+        case 12:
+          _context.next = 3;
+          break;
+
+        case 14:
+        case "end":
+          return _context.stop();
+      }
+    }
+  }, _marked);
 }
 //# sourceMappingURL=make-array-buffer-iterator.js.map