@loaders.gl/core 4.0.0-beta.1 → 4.0.0-beta.3

package/src/lib/filesystems/browser-filesystem.ts

@@ -1,4 +1,5 @@
-import type {FileSystem} from '@loaders.gl/loader-utils';
+import type {FileSystem, ReadableFile} from '@loaders.gl/loader-utils';
+import {BlobFile} from '@loaders.gl/loader-utils';
 
 type BrowserFileSystemOptions = {
   fetch?: typeof fetch;
@@ -109,18 +110,30 @@ export class BrowserFileSystem implements FileSystem {
   // implements IRandomAccessFileSystem
 
   // RANDOM ACCESS
-  async open(pathname: string, flags: unknown, mode?: unknown): Promise<any> {
-    return this.files[pathname];
+  async openReadableFile(pathname: string, flags: unknown): Promise<ReadableFile> {
+    return new BlobFile(this.files[pathname]);
   }
 
-  /**
+  // PRIVATE
+
+  // Supports case independent paths, and file usage tracking
+  _getFile(path: string, used: boolean): File {
+    // Prefer case match, but fall back to case independent.
+    const file = this.files[path] || this.lowerCaseFiles[path];
+    if (file && used) {
+      this.usedFiles[path] = true;
+    }
+    return file;
+  }
+}
+/*
    * Read a range into a buffer
    * @todo - handle position memory
    * @param buffer is the buffer that the data (read from the fd) will be written to.
    * @param offset is the offset in the buffer to start writing at.
    * @param length is an integer specifying the number of bytes to read.
    * @param position is an argument specifying where to begin reading from in the file. If position is null, data will be read from the current file position, and the file position will be updated. If position is an integer, the file position will remain unchanged.
-   */
+   *
   async read(
     fd: any,
     buffer: ArrayBuffer,
@@ -140,16 +153,4 @@ export class BrowserFileSystem implements FileSystem {
   }
 
   // fstat(fd: number): Promise<object>; // Stat
-
-  // PRIVATE
-
-  // Supports case independent paths, and file usage tracking
-  _getFile(path: string, used: boolean): File {
-    // Prefer case match, but fall back to case independent.
-    const file = this.files[path] || this.lowerCaseFiles[path];
-    if (file && used) {
-      this.usedFiles[path] = true;
-    }
-    return file;
-  }
-}
+  */

package/dist/es5/bundle.js

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

package/dist/es5/bundle.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bundle.js","names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"sources":["../../src/bundle.ts"],"sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"mappings":";;AACA,IAAMA,aAAa,GAAGC,OAAO,CAAC,SAAS,CAAC;AACxCC,UAAU,CAACC,OAAO,GAAGD,UAAU,CAACC,OAAO,IAAI,CAAC,CAAC;AAC7CC,MAAM,CAACC,OAAO,GAAGC,MAAM,CAACC,MAAM,CAACL,UAAU,CAACC,OAAO,EAAEH,aAAa,CAAC"}

package/dist/es5/core-addons/write-file-browser.js

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=write-file-browser.js.map

package/dist/es5/core-addons/write-file-browser.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"write-file-browser.js","names":[],"sources":["../../../src/core-addons/write-file-browser.ts"],"sourcesContent":["// A browser implementation of the Node.js `fs` module's `fs.writeFile` method.\n// NOTE: WAS COMMENTED OUT TO GET NODE 8 TESTS RUNNING\n\n/*\n/* global global *\n/* global Blob *\nimport {isBrowser} from '@loaders.gl/core';\n\n// TODO hack - trick filesaver.js to skip loading under node\nconst savedNavigatorExists = 'navigator' in global;\nconst savedNavigator = global.navigator;\nif (!isBrowser) {\n  global.navigator = {userAgent: 'MSIE 9.'};\n}\n\n// Need to use `require` to ensure our modification of global code above happens first\nconst saveAs = require('filesaver.js');\n\nif (!isBrowser) {\n  if (savedNavigatorExists) {\n    global.navigator = savedNavigator;\n  } else {\n    delete global.navigator;\n  }\n}\n// END hack\n\n/**\n * File system write function for the browser, similar to Node's fs.writeFile\n *\n * Saves a file by downloading it with the given file name.\n *\n * @param {String} file - file name\n * @param {String|Blob} data - data to be written to file\n * @param {String|Object} options -\n * @param {Function} callback - Standard node (err, data) callback\n * @return {Promise} - promise, can be used instead of callback\n *\nasync export function writeFile(file, data, options, callback = () => {}) {\n  // options is optional\n  if (callback === undefined && typeof options === 'function') {\n    options = undefined;\n    callback = options;\n  }\n  if (typeof data === 'string') {\n    data = new Blob(data);\n  }\n  return new Promise((resolve, reject) => {\n    let result;\n    try {\n      result = saveAs(data, file, options);\n    } catch (error) {\n      reject(error);\n      return callback(error, null);\n    }\n    resolve();\n    return callback(null, result);\n  });\n}\n*/\n"],"mappings":""}

package/dist/es5/index.js

@@ -1,382 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "JSONLoader", {
-  enumerable: true,
-  get: function get() {
-    return _loaderUtils.JSONLoader;
-  }
-});
-Object.defineProperty(exports, "NullLoader", {
-  enumerable: true,
-  get: function get() {
-    return _nullLoader.NullLoader;
-  }
-});
-Object.defineProperty(exports, "NullWorkerLoader", {
-  enumerable: true,
-  get: function get() {
-    return _nullLoader.NullWorkerLoader;
-  }
-});
-Object.defineProperty(exports, "RequestScheduler", {
-  enumerable: true,
-  get: function get() {
-    return _loaderUtils.RequestScheduler;
-  }
-});
-Object.defineProperty(exports, "_BrowserFileSystem", {
-  enumerable: true,
-  get: function get() {
-    return _browserFilesystem.BrowserFileSystem;
-  }
-});
-Object.defineProperty(exports, "_fetchProgress", {
-  enumerable: true,
-  get: function get() {
-    return _fetchProgress.fetchProgress;
-  }
-});
-Object.defineProperty(exports, "_unregisterLoaders", {
-  enumerable: true,
-  get: function get() {
-    return _registerLoaders._unregisterLoaders;
-  }
-});
-Object.defineProperty(exports, "assert", {
-  enumerable: true,
-  get: function get() {
-    return _loaderUtils.assert;
-  }
-});
-Object.defineProperty(exports, "concatenateArrayBuffersAsync", {
-  enumerable: true,
-  get: function get() {
-    return _loaderUtils.concatenateArrayBuffersAsync;
-  }
-});
-Object.defineProperty(exports, "document", {
-  enumerable: true,
-  get: function get() {
-    return _loaderUtils.document;
-  }
-});
-Object.defineProperty(exports, "encode", {
-  enumerable: true,
-  get: function get() {
-    return _encode.encode;
-  }
-});
-Object.defineProperty(exports, "encodeInBatches", {
-  enumerable: true,
-  get: function get() {
-    return _encode.encodeInBatches;
-  }
-});
-Object.defineProperty(exports, "encodeSync", {
-  enumerable: true,
-  get: function get() {
-    return _encode.encodeSync;
-  }
-});
-Object.defineProperty(exports, "encodeTable", {
-  enumerable: true,
-  get: function get() {
-    return _encodeTable.encodeTable;
-  }
-});
-Object.defineProperty(exports, "encodeTableAsText", {
-  enumerable: true,
-  get: function get() {
-    return _encodeTable.encodeTableAsText;
-  }
-});
-Object.defineProperty(exports, "encodeTableInBatches", {
-  enumerable: true,
-  get: function get() {
-    return _encodeTable.encodeTableInBatches;
-  }
-});
-Object.defineProperty(exports, "encodeText", {
-  enumerable: true,
-  get: function get() {
-    return _encode.encodeText;
-  }
-});
-Object.defineProperty(exports, "encodeTextSync", {
-  enumerable: true,
-  get: function get() {
-    return _encode.encodeTextSync;
-  }
-});
-Object.defineProperty(exports, "encodeURLtoURL", {
-  enumerable: true,
-  get: function get() {
-    return _encode.encodeURLtoURL;
-  }
-});
-Object.defineProperty(exports, "fetchFile", {
-  enumerable: true,
-  get: function get() {
-    return _fetchFile.fetchFile;
-  }
-});
-Object.defineProperty(exports, "forEach", {
-  enumerable: true,
-  get: function get() {
-    return _loaderUtils.forEach;
-  }
-});
-Object.defineProperty(exports, "getLoaderOptions", {
-  enumerable: true,
-  get: function get() {
-    return _loaderOptions.getLoaderOptions;
-  }
-});
-Object.defineProperty(exports, "getPathPrefix", {
-  enumerable: true,
-  get: function get() {
-    return _loaderUtils.getPathPrefix;
-  }
-});
-Object.defineProperty(exports, "global", {
-  enumerable: true,
-  get: function get() {
-    return _loaderUtils.global;
-  }
-});
-Object.defineProperty(exports, "isAsyncIterable", {
-  enumerable: true,
-  get: function get() {
-    return _isType.isAsyncIterable;
-  }
-});
-Object.defineProperty(exports, "isBrowser", {
-  enumerable: true,
-  get: function get() {
-    return _loaderUtils.isBrowser;
-  }
-});
-Object.defineProperty(exports, "isIterable", {
-  enumerable: true,
-  get: function get() {
-    return _isType.isIterable;
-  }
-});
-Object.defineProperty(exports, "isIterator", {
-  enumerable: true,
-  get: function get() {
-    return _isType.isIterator;
-  }
-});
-Object.defineProperty(exports, "isPromise", {
-  enumerable: true,
-  get: function get() {
-    return _isType.isPromise;
-  }
-});
-Object.defineProperty(exports, "isPureObject", {
-  enumerable: true,
-  get: function get() {
-    return _isType.isPureObject;
-  }
-});
-Object.defineProperty(exports, "isReadableStream", {
-  enumerable: true,
-  get: function get() {
-    return _isType.isReadableStream;
-  }
-});
-Object.defineProperty(exports, "isResponse", {
-  enumerable: true,
-  get: function get() {
-    return _isType.isResponse;
-  }
-});
-Object.defineProperty(exports, "isWorker", {
-  enumerable: true,
-  get: function get() {
-    return _loaderUtils.isWorker;
-  }
-});
-Object.defineProperty(exports, "isWritableStream", {
-  enumerable: true,
-  get: function get() {
-    return _isType.isWritableStream;
-  }
-});
-Object.defineProperty(exports, "load", {
-  enumerable: true,
-  get: function get() {
-    return _load.load;
-  }
-});
-Object.defineProperty(exports, "loadInBatches", {
-  enumerable: true,
-  get: function get() {
-    return _loadInBatches.loadInBatches;
-  }
-});
-Object.defineProperty(exports, "makeIterator", {
-  enumerable: true,
-  get: function get() {
-    return _makeIterator.makeIterator;
-  }
-});
-Object.defineProperty(exports, "makeLineIterator", {
-  enumerable: true,
-  get: function get() {
-    return _loaderUtils.makeLineIterator;
-  }
-});
-Object.defineProperty(exports, "makeNumberedLineIterator", {
-  enumerable: true,
-  get: function get() {
-    return _loaderUtils.makeNumberedLineIterator;
-  }
-});
-Object.defineProperty(exports, "makeStream", {
-  enumerable: true,
-  get: function get() {
-    return _makeNodeStream.makeStream;
-  }
-});
-Object.defineProperty(exports, "makeTextDecoderIterator", {
-  enumerable: true,
-  get: function get() {
-    return _loaderUtils.makeTextDecoderIterator;
-  }
-});
-Object.defineProperty(exports, "makeTextEncoderIterator", {
-  enumerable: true,
-  get: function get() {
-    return _loaderUtils.makeTextEncoderIterator;
-  }
-});
-Object.defineProperty(exports, "parse", {
-  enumerable: true,
-  get: function get() {
-    return _parse.parse;
-  }
-});
-Object.defineProperty(exports, "parseInBatches", {
-  enumerable: true,
-  get: function get() {
-    return _parseInBatches.parseInBatches;
-  }
-});
-Object.defineProperty(exports, "parseSync", {
-  enumerable: true,
-  get: function get() {
-    return _parseSync.parseSync;
-  }
-});
-Object.defineProperty(exports, "readArrayBuffer", {
-  enumerable: true,
-  get: function get() {
-    return _readArrayBuffer.readArrayBuffer;
-  }
-});
-Object.defineProperty(exports, "readFileSync", {
-  enumerable: true,
-  get: function get() {
-    return _readFile.readFileSync;
-  }
-});
-Object.defineProperty(exports, "registerLoaders", {
-  enumerable: true,
-  get: function get() {
-    return _registerLoaders.registerLoaders;
-  }
-});
-Object.defineProperty(exports, "resolvePath", {
-  enumerable: true,
-  get: function get() {
-    return _loaderUtils.resolvePath;
-  }
-});
-Object.defineProperty(exports, "save", {
-  enumerable: true,
-  get: function get() {
-    return _save.save;
-  }
-});
-Object.defineProperty(exports, "saveSync", {
-  enumerable: true,
-  get: function get() {
-    return _save.saveSync;
-  }
-});
-Object.defineProperty(exports, "selectLoader", {
-  enumerable: true,
-  get: function get() {
-    return _selectLoader.selectLoader;
-  }
-});
-Object.defineProperty(exports, "selectLoaderSync", {
-  enumerable: true,
-  get: function get() {
-    return _selectLoader.selectLoaderSync;
-  }
-});
-Object.defineProperty(exports, "self", {
-  enumerable: true,
-  get: function get() {
-    return _loaderUtils.self;
-  }
-});
-Object.defineProperty(exports, "setLoaderOptions", {
-  enumerable: true,
-  get: function get() {
-    return _loaderOptions.setLoaderOptions;
-  }
-});
-Object.defineProperty(exports, "setPathPrefix", {
-  enumerable: true,
-  get: function get() {
-    return _loaderUtils.setPathPrefix;
-  }
-});
-Object.defineProperty(exports, "window", {
-  enumerable: true,
-  get: function get() {
-    return _loaderUtils.window;
-  }
-});
-Object.defineProperty(exports, "writeFile", {
-  enumerable: true,
-  get: function get() {
-    return _writeFile.writeFile;
-  }
-});
-Object.defineProperty(exports, "writeFileSync", {
-  enumerable: true,
-  get: function get() {
-    return _writeFile.writeFileSync;
-  }
-});
-var _fetchFile = require("./lib/fetch/fetch-file");
-var _readArrayBuffer = require("./lib/fetch/read-array-buffer");
-var _readFile = require("./lib/fetch/read-file");
-var _writeFile = require("./lib/fetch/write-file");
-var _loaderOptions = require("./lib/api/loader-options");
-var _registerLoaders = require("./lib/api/register-loaders");
-var _selectLoader = require("./lib/api/select-loader");
-var _parse = require("./lib/api/parse");
-var _parseSync = require("./lib/api/parse-sync");
-var _parseInBatches = require("./lib/api/parse-in-batches");
-var _load = require("./lib/api/load");
-var _loadInBatches = require("./lib/api/load-in-batches");
-var _encodeTable = require("./lib/api/encode-table");
-var _encode = require("./lib/api/encode");
-var _save = require("./lib/api/save");
-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 = 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 +0,0 @@
-{"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, encodeURLtoURL} from './lib/api/encode';\nexport {encodeText, encodeTextSync} 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;AAEA,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/iterators/batch-iterators/timed-batch-iterator.js

@@ -1,94 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.timedBatchIterator = timedBatchIterator;
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _awaitAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/awaitAsyncGenerator"));
-var _wrapAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapAsyncGenerator"));
-function _asyncIterator(iterable) { var method, async, sync, retry = 2; for ("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;) { if (async && null != (method = iterable[async])) return method.call(iterable); if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable)); async = "@@asyncIterator", sync = "@@iterator"; } throw new TypeError("Object is not async iterable"); }
-function AsyncFromSyncIterator(s) { function AsyncFromSyncIteratorContinuation(r) { if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object.")); var done = r.done; return Promise.resolve(r.value).then(function (value) { return { value: value, done: done }; }); } return AsyncFromSyncIterator = function AsyncFromSyncIterator(s) { this.s = s, this.n = s.next; }, AsyncFromSyncIterator.prototype = { s: null, n: null, next: function next() { return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments)); }, return: function _return(value) { var ret = this.s.return; return void 0 === ret ? Promise.resolve({ value: value, done: !0 }) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments)); }, throw: function _throw(value) { var thr = this.s.return; return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments)); } }, new AsyncFromSyncIterator(s); }
-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, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, batch;
-    return _regenerator.default.wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          start = Date.now();
-          batches = [];
-          _iteratorAbruptCompletion = false;
-          _didIteratorError = false;
-          _context.prev = 4;
-          _iterator = _asyncIterator(batchIterator);
-        case 6:
-          _context.next = 8;
-          return (0, _awaitAsyncGenerator2.default)(_iterator.next());
-        case 8:
-          if (!(_iteratorAbruptCompletion = !(_step = _context.sent).done)) {
-            _context.next = 19;
-            break;
-          }
-          batch = _step.value;
-          batches.push(batch);
-          if (!(Date.now() - start > timeout)) {
-            _context.next = 16;
-            break;
-          }
-          _context.next = 14;
-          return batches;
-        case 14:
-          start = Date.now();
-          batches = [];
-        case 16:
-          _iteratorAbruptCompletion = false;
-          _context.next = 6;
-          break;
-        case 19:
-          _context.next = 25;
-          break;
-        case 21:
-          _context.prev = 21;
-          _context.t0 = _context["catch"](4);
-          _didIteratorError = true;
-          _iteratorError = _context.t0;
-        case 25:
-          _context.prev = 25;
-          _context.prev = 26;
-          if (!(_iteratorAbruptCompletion && _iterator.return != null)) {
-            _context.next = 30;
-            break;
-          }
-          _context.next = 30;
-          return (0, _awaitAsyncGenerator2.default)(_iterator.return());
-        case 30:
-          _context.prev = 30;
-          if (!_didIteratorError) {
-            _context.next = 33;
-            break;
-          }
-          throw _iteratorError;
-        case 33:
-          return _context.finish(30);
-        case 34:
-          return _context.finish(25);
-        case 35:
-          if (!batches) {
-            _context.next = 38;
-            break;
-          }
-          _context.next = 38;
-          return batches;
-        case 38:
-        case "end":
-          return _context.stop();
-      }
-    }, _callee, null, [[4, 21, 25, 35], [26,, 30, 34]]);
-  }));
-  return _timedBatchIterator.apply(this, arguments);
-}
-//# sourceMappingURL=timed-batch-iterator.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"timed-batch-iterator.js","names":["timedBatchIterator","_x","_x2","_timedBatchIterator","apply","arguments","_wrapAsyncGenerator2","default","_regenerator","mark","_callee","batchIterator","timeout","start","batches","_iteratorAbruptCompletion","_didIteratorError","_iteratorError","_iterator","_step","batch","wrap","_callee$","_context","prev","next","Date","now","_asyncIterator","_awaitAsyncGenerator2","sent","done","value","push","t0","return","finish","stop"],"sources":["../../../../src/iterators/batch-iterators/timed-batch-iterator.ts"],"sourcesContent":["/**\n * \"Debounces\" batches and returns them in groups\n */\nexport async function* timedBatchIterator<Batch>(\n  batchIterator: AsyncIterable<Batch>,\n  timeout: number\n): AsyncIterable<Batch[]> {\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"],"mappings":";;;;;;;;;;;;SAGuBA,kBAAkBA,CAAAC,EAAA,EAAAC,GAAA;EAAA,OAAAC,mBAAA,CAAAC,KAAA,OAAAC,SAAA;AAAA;AAAA,SAAAF,oBAAA;EAAAA,mBAAA,OAAAG,oBAAA,CAAAC,OAAA,EAAAC,YAAA,CAAAD,OAAA,CAAAE,IAAA,CAAlC,SAAAC,QACLC,aAAmC,EACnCC,OAAe;IAAA,IAAAC,KAAA,EAAAC,OAAA,EAAAC,yBAAA,EAAAC,iBAAA,EAAAC,cAAA,EAAAC,SAAA,EAAAC,KAAA,EAAAC,KAAA;IAAA,OAAAZ,YAAA,CAAAD,OAAA,CAAAc,IAAA,UAAAC,SAAAC,QAAA;MAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;QAAA;UAEXZ,KAAK,GAAGa,IAAI,CAACC,GAAG,CAAC,CAAC;UAClBb,OAAgB,GAAG,EAAE;UAAAC,yBAAA;UAAAC,iBAAA;UAAAO,QAAA,CAAAC,IAAA;UAAAN,SAAA,GAAAU,cAAA,CACCjB,aAAa;QAAA;UAAAY,QAAA,CAAAE,IAAA;UAAA,WAAAI,qBAAA,CAAAtB,OAAA,EAAAW,SAAA,CAAAO,IAAA;QAAA;UAAA,MAAAV,yBAAA,KAAAI,KAAA,GAAAI,QAAA,CAAAO,IAAA,EAAAC,IAAA;YAAAR,QAAA,CAAAE,IAAA;YAAA;UAAA;UAAtBL,KAAK,GAAAD,KAAA,CAAAa,KAAA;UACpBlB,OAAO,CAACmB,IAAI,CAACb,KAAK,CAAC;UAAC,MAChBM,IAAI,CAACC,GAAG,CAAC,CAAC,GAAGd,KAAK,GAAGD,OAAO;YAAAW,QAAA,CAAAE,IAAA;YAAA;UAAA;UAAAF,QAAA,CAAAE,IAAA;UAC9B,OAAMX,OAAO;QAAA;UACbD,KAAK,GAAGa,IAAI,CAACC,GAAG,CAAC,CAAC;UAClBb,OAAO,GAAG,EAAE;QAAC;UAAAC,yBAAA;UAAAQ,QAAA,CAAAE,IAAA;UAAA;QAAA;UAAAF,QAAA,CAAAE,IAAA;UAAA;QAAA;UAAAF,QAAA,CAAAC,IAAA;UAAAD,QAAA,CAAAW,EAAA,GAAAX,QAAA;UAAAP,iBAAA;UAAAC,cAAA,GAAAM,QAAA,CAAAW,EAAA;QAAA;UAAAX,QAAA,CAAAC,IAAA;UAAAD,QAAA,CAAAC,IAAA;UAAA,MAAAT,yBAAA,IAAAG,SAAA,CAAAiB,MAAA;YAAAZ,QAAA,CAAAE,IAAA;YAAA;UAAA;UAAAF,QAAA,CAAAE,IAAA;UAAA,WAAAI,qBAAA,CAAAtB,OAAA,EAAAW,SAAA,CAAAiB,MAAA;QAAA;UAAAZ,QAAA,CAAAC,IAAA;UAAA,KAAAR,iBAAA;YAAAO,QAAA,CAAAE,IAAA;YAAA;UAAA;UAAA,MAAAR,cAAA;QAAA;UAAA,OAAAM,QAAA,CAAAa,MAAA;QAAA;UAAA,OAAAb,QAAA,CAAAa,MAAA;QAAA;UAAA,KAIbtB,OAAO;YAAAS,QAAA,CAAAE,IAAA;YAAA;UAAA;UAAAF,QAAA,CAAAE,IAAA;UACT,OAAMX,OAAO;QAAA;QAAA;UAAA,OAAAS,QAAA,CAAAc,IAAA;MAAA;IAAA,GAAA3B,OAAA;EAAA,CAEhB;EAAA,OAAAP,mBAAA,CAAAC,KAAA,OAAAC,SAAA;AAAA"}

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

@@ -1,42 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.makeArrayBufferIterator = makeArrayBufferIterator;
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var DEFAULT_CHUNK_SIZE = 256 * 1024;
-function makeArrayBufferIterator(arrayBuffer) {
-  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  return _regenerator.default.mark(function _callee() {
-    var _options$chunkSize, chunkSize, byteOffset, chunkByteLength, chunk, sourceArray, chunkArray;
-    return _regenerator.default.wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          _options$chunkSize = options.chunkSize, chunkSize = _options$chunkSize === void 0 ? DEFAULT_CHUNK_SIZE : _options$chunkSize;
-          byteOffset = 0;
-        case 2:
-          if (!(byteOffset < arrayBuffer.byteLength)) {
-            _context.next = 13;
-            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 = 11;
-          return chunk;
-        case 11:
-          _context.next = 2;
-          break;
-        case 13:
-        case "end":
-          return _context.stop();
-      }
-    }, _callee);
-  })();
-}
-//# sourceMappingURL=make-array-buffer-iterator.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"make-array-buffer-iterator.js","names":["DEFAULT_CHUNK_SIZE","makeArrayBufferIterator","arrayBuffer","options","arguments","length","undefined","_regenerator","default","mark","_callee","_options$chunkSize","chunkSize","byteOffset","chunkByteLength","chunk","sourceArray","chunkArray","wrap","_callee$","_context","prev","next","byteLength","Math","min","ArrayBuffer","Uint8Array","set","stop"],"sources":["../../../../src/iterators/make-iterator/make-array-buffer-iterator.ts"],"sourcesContent":["import type {IteratorOptions} from './make-iterator';\n\nconst DEFAULT_CHUNK_SIZE = 256 * 1024;\n\n/**\n * Returns an iterator that breaks a big ArrayBuffer into chunks and yields them one-by-one\n * @param blob ArrayBuffer to iterate over\n * @param options\n * @param options.chunkSize\n */\nexport function* makeArrayBufferIterator(\n  arrayBuffer: ArrayBuffer,\n  options: IteratorOptions = {}\n): Iterable<ArrayBuffer> {\n  const {chunkSize = DEFAULT_CHUNK_SIZE} = options;\n\n  let byteOffset = 0;\n\n  while (byteOffset < arrayBuffer.byteLength) {\n    // Create a chunk of the right size\n    const chunkByteLength = Math.min(arrayBuffer.byteLength - byteOffset, chunkSize);\n    const chunk = new ArrayBuffer(chunkByteLength);\n\n    // Copy data from the big chunk\n    const sourceArray = new Uint8Array(arrayBuffer, byteOffset, chunkByteLength);\n    const chunkArray = new Uint8Array(chunk);\n    chunkArray.set(sourceArray);\n\n    // yield the chunk\n    byteOffset += chunkByteLength;\n    yield chunk;\n  }\n}\n"],"mappings":";;;;;;;;AAEA,IAAMA,kBAAkB,GAAG,GAAG,GAAG,IAAI;AAQ9B,SAAUC,uBAAuBA,CACtCC,WAAwB;EAAA,IACxBC,OAAwB,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;EAAA,OAAAG,YAAA,CAAAC,OAAA,CAAAC,IAAA,UAAAC,QAAA;IAAA,IAAAC,kBAAA,EAAAC,SAAA,EAAAC,UAAA,EAAAC,eAAA,EAAAC,KAAA,EAAAC,WAAA,EAAAC,UAAA;IAAA,OAAAV,YAAA,CAAAC,OAAA,CAAAU,IAAA,UAAAC,SAAAC,QAAA;MAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;QAAA;UAAAX,kBAAA,GAEYR,OAAO,CAAzCS,SAAS,EAATA,SAAS,GAAAD,kBAAA,cAAGX,kBAAkB,GAAAW,kBAAA;UAEjCE,UAAU,GAAG,CAAC;QAAA;UAAA,MAEXA,UAAU,GAAGX,WAAW,CAACqB,UAAU;YAAAH,QAAA,CAAAE,IAAA;YAAA;UAAA;UAElCR,eAAe,GAAGU,IAAI,CAACC,GAAG,CAACvB,WAAW,CAACqB,UAAU,GAAGV,UAAU,EAAED,SAAS,CAAC;UAC1EG,KAAK,GAAG,IAAIW,WAAW,CAACZ,eAAe,CAAC;UAGxCE,WAAW,GAAG,IAAIW,UAAU,CAACzB,WAAW,EAAEW,UAAU,EAAEC,eAAe,CAAC;UACtEG,UAAU,GAAG,IAAIU,UAAU,CAACZ,KAAK,CAAC;UACxCE,UAAU,CAACW,GAAG,CAACZ,WAAW,CAAC;UAG3BH,UAAU,IAAIC,eAAe;UAACM,QAAA,CAAAE,IAAA;UAC9B,OAAMP,KAAK;QAAA;UAAAK,QAAA,CAAAE,IAAA;UAAA;QAAA;QAAA;UAAA,OAAAF,QAAA,CAAAS,IAAA;MAAA;IAAA,GAAAnB,OAAA;EAAA;AAAA"}

package/dist/es5/iterators/make-iterator/make-blob-iterator.js

@@ -1,47 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.makeBlobIterator = makeBlobIterator;
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _awaitAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/awaitAsyncGenerator"));
-var _wrapAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapAsyncGenerator"));
-var DEFAULT_CHUNK_SIZE = 1024 * 1024;
-function makeBlobIterator(_x, _x2) {
-  return _makeBlobIterator.apply(this, arguments);
-}
-function _makeBlobIterator() {
-  _makeBlobIterator = (0, _wrapAsyncGenerator2.default)(_regenerator.default.mark(function _callee(blob, options) {
-    var chunkSize, offset, end, chunk;
-    return _regenerator.default.wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          chunkSize = (options === null || options === void 0 ? void 0 : options.chunkSize) || DEFAULT_CHUNK_SIZE;
-          offset = 0;
-        case 2:
-          if (!(offset < blob.size)) {
-            _context.next = 12;
-            break;
-          }
-          end = offset + chunkSize;
-          _context.next = 6;
-          return (0, _awaitAsyncGenerator2.default)(blob.slice(offset, end).arrayBuffer());
-        case 6:
-          chunk = _context.sent;
-          offset = end;
-          _context.next = 10;
-          return chunk;
-        case 10:
-          _context.next = 2;
-          break;
-        case 12:
-        case "end":
-          return _context.stop();
-      }
-    }, _callee);
-  }));
-  return _makeBlobIterator.apply(this, arguments);
-}
-//# sourceMappingURL=make-blob-iterator.js.map