@loaders.gl/core 3.1.0-alpha.2 → 3.1.0-beta.1

package/dist/core-addons/write-file-browser.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=write-file-browser.d.ts.map

package/dist/core-addons/write-file-browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-file-browser.d.ts","sourceRoot":"","sources":["../../src/core-addons/write-file-browser.ts"],"names":[],"mappings":""}

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

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

package/dist/es5/bundle.js

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

package/dist/es5/bundle.js.map

@@ -0,0 +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"}

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

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

package/dist/es5/index.js

@@ -0,0 +1,390 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "fetchFile", {
+  enumerable: true,
+  get: function () {
+    return _fetchFile.fetchFile;
+  }
+});
+Object.defineProperty(exports, "readArrayBuffer", {
+  enumerable: true,
+  get: function () {
+    return _readArrayBuffer.readArrayBuffer;
+  }
+});
+Object.defineProperty(exports, "readFileSync", {
+  enumerable: true,
+  get: function () {
+    return _readFile.readFileSync;
+  }
+});
+Object.defineProperty(exports, "writeFile", {
+  enumerable: true,
+  get: function () {
+    return _writeFile.writeFile;
+  }
+});
+Object.defineProperty(exports, "writeFileSync", {
+  enumerable: true,
+  get: function () {
+    return _writeFile.writeFileSync;
+  }
+});
+Object.defineProperty(exports, "setLoaderOptions", {
+  enumerable: true,
+  get: function () {
+    return _setLoaderOptions.setLoaderOptions;
+  }
+});
+Object.defineProperty(exports, "registerLoaders", {
+  enumerable: true,
+  get: function () {
+    return _registerLoaders.registerLoaders;
+  }
+});
+Object.defineProperty(exports, "_unregisterLoaders", {
+  enumerable: true,
+  get: function () {
+    return _registerLoaders._unregisterLoaders;
+  }
+});
+Object.defineProperty(exports, "selectLoader", {
+  enumerable: true,
+  get: function () {
+    return _selectLoader.selectLoader;
+  }
+});
+Object.defineProperty(exports, "selectLoaderSync", {
+  enumerable: true,
+  get: function () {
+    return _selectLoader.selectLoaderSync;
+  }
+});
+Object.defineProperty(exports, "parse", {
+  enumerable: true,
+  get: function () {
+    return _parse.parse;
+  }
+});
+Object.defineProperty(exports, "parseSync", {
+  enumerable: true,
+  get: function () {
+    return _parseSync.parseSync;
+  }
+});
+Object.defineProperty(exports, "parseInBatches", {
+  enumerable: true,
+  get: function () {
+    return _parseInBatches.parseInBatches;
+  }
+});
+Object.defineProperty(exports, "load", {
+  enumerable: true,
+  get: function () {
+    return _load.load;
+  }
+});
+Object.defineProperty(exports, "loadInBatches", {
+  enumerable: true,
+  get: function () {
+    return _loadInBatches.loadInBatches;
+  }
+});
+Object.defineProperty(exports, "encode", {
+  enumerable: true,
+  get: function () {
+    return _encode.encode;
+  }
+});
+Object.defineProperty(exports, "encodeSync", {
+  enumerable: true,
+  get: function () {
+    return _encode.encodeSync;
+  }
+});
+Object.defineProperty(exports, "encodeInBatches", {
+  enumerable: true,
+  get: function () {
+    return _encode.encodeInBatches;
+  }
+});
+Object.defineProperty(exports, "encodeText", {
+  enumerable: true,
+  get: function () {
+    return _encode.encodeText;
+  }
+});
+Object.defineProperty(exports, "encodeURLtoURL", {
+  enumerable: true,
+  get: function () {
+    return _encode.encodeURLtoURL;
+  }
+});
+Object.defineProperty(exports, "save", {
+  enumerable: true,
+  get: function () {
+    return _save.save;
+  }
+});
+Object.defineProperty(exports, "saveSync", {
+  enumerable: true,
+  get: function () {
+    return _save.saveSync;
+  }
+});
+Object.defineProperty(exports, "setPathPrefix", {
+  enumerable: true,
+  get: function () {
+    return _loaderUtils.setPathPrefix;
+  }
+});
+Object.defineProperty(exports, "getPathPrefix", {
+  enumerable: true,
+  get: function () {
+    return _loaderUtils.getPathPrefix;
+  }
+});
+Object.defineProperty(exports, "resolvePath", {
+  enumerable: true,
+  get: function () {
+    return _loaderUtils.resolvePath;
+  }
+});
+Object.defineProperty(exports, "RequestScheduler", {
+  enumerable: true,
+  get: function () {
+    return _loaderUtils.RequestScheduler;
+  }
+});
+Object.defineProperty(exports, "JSONLoader", {
+  enumerable: true,
+  get: function () {
+    return _loaderUtils.JSONLoader;
+  }
+});
+Object.defineProperty(exports, "isBrowser", {
+  enumerable: true,
+  get: function () {
+    return _loaderUtils.isBrowser;
+  }
+});
+Object.defineProperty(exports, "isWorker", {
+  enumerable: true,
+  get: function () {
+    return _loaderUtils.isWorker;
+  }
+});
+Object.defineProperty(exports, "self", {
+  enumerable: true,
+  get: function () {
+    return _loaderUtils.self;
+  }
+});
+Object.defineProperty(exports, "window", {
+  enumerable: true,
+  get: function () {
+    return _loaderUtils.window;
+  }
+});
+Object.defineProperty(exports, "global", {
+  enumerable: true,
+  get: function () {
+    return _loaderUtils.global;
+  }
+});
+Object.defineProperty(exports, "document", {
+  enumerable: true,
+  get: function () {
+    return _loaderUtils.document;
+  }
+});
+Object.defineProperty(exports, "assert", {
+  enumerable: true,
+  get: function () {
+    return _loaderUtils.assert;
+  }
+});
+Object.defineProperty(exports, "forEach", {
+  enumerable: true,
+  get: function () {
+    return _loaderUtils.forEach;
+  }
+});
+Object.defineProperty(exports, "concatenateArrayBuffersAsync", {
+  enumerable: true,
+  get: function () {
+    return _loaderUtils.concatenateArrayBuffersAsync;
+  }
+});
+Object.defineProperty(exports, "makeTextDecoderIterator", {
+  enumerable: true,
+  get: function () {
+    return _loaderUtils.makeTextDecoderIterator;
+  }
+});
+Object.defineProperty(exports, "makeTextEncoderIterator", {
+  enumerable: true,
+  get: function () {
+    return _loaderUtils.makeTextEncoderIterator;
+  }
+});
+Object.defineProperty(exports, "makeLineIterator", {
+  enumerable: true,
+  get: function () {
+    return _loaderUtils.makeLineIterator;
+  }
+});
+Object.defineProperty(exports, "makeNumberedLineIterator", {
+  enumerable: true,
+  get: function () {
+    return _loaderUtils.makeNumberedLineIterator;
+  }
+});
+Object.defineProperty(exports, "makeIterator", {
+  enumerable: true,
+  get: function () {
+    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;
+  }
+});
+Object.defineProperty(exports, "NullWorkerLoader", {
+  enumerable: true,
+  get: function () {
+    return _nullLoader.NullWorkerLoader;
+  }
+});
+Object.defineProperty(exports, "NullLoader", {
+  enumerable: true,
+  get: function () {
+    return _nullLoader.NullLoader;
+  }
+});
+Object.defineProperty(exports, "_fetchProgress", {
+  enumerable: true,
+  get: function () {
+    return _fetchProgress.default;
+  }
+});
+Object.defineProperty(exports, "_BrowserFileSystem", {
+  enumerable: true,
+  get: function () {
+    return _browserFilesystem.default;
+  }
+});
+Object.defineProperty(exports, "isPureObject", {
+  enumerable: true,
+  get: function () {
+    return _isType.isPureObject;
+  }
+});
+Object.defineProperty(exports, "isPromise", {
+  enumerable: true,
+  get: function () {
+    return _isType.isPromise;
+  }
+});
+Object.defineProperty(exports, "isIterable", {
+  enumerable: true,
+  get: function () {
+    return _isType.isIterable;
+  }
+});
+Object.defineProperty(exports, "isAsyncIterable", {
+  enumerable: true,
+  get: function () {
+    return _isType.isAsyncIterable;
+  }
+});
+Object.defineProperty(exports, "isIterator", {
+  enumerable: true,
+  get: function () {
+    return _isType.isIterator;
+  }
+});
+Object.defineProperty(exports, "isResponse", {
+  enumerable: true,
+  get: function () {
+    return _isType.isResponse;
+  }
+});
+Object.defineProperty(exports, "isReadableStream", {
+  enumerable: true,
+  get: function () {
+    return _isType.isReadableStream;
+  }
+});
+Object.defineProperty(exports, "isWritableStream", {
+  enumerable: true,
+  get: function () {
+    return _isType.isWritableStream;
+  }
+});
+
+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 _setLoaderOptions = require("./lib/api/set-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 _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 _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 _nullLoader = require("./null-loader");
+
+var _fetchProgress = _interopRequireDefault(require("./lib/progress/fetch-progress"));
+
+var _browserFilesystem = _interopRequireDefault(require("./lib/filesystems/browser-filesystem"));
+
+var _isType = require("./javascript-utils/is-type");
+//# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -0,0 +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"}

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

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.timedBatchIterator = timedBatchIterator;
+
+async function* timedBatchIterator(batchIterator, timeout) {
+  let start = Date.now();
+  let batches = [];
+
+  for await (const batch of batchIterator) {
+    batches.push(batch);
+
+    if (Date.now() - start > timeout) {
+      yield batches;
+      start = Date.now();
+      batches = [];
+    }
+  }
+
+  if (batches) {
+    yield batches;
+  }
+}
+//# sourceMappingURL=timed-batch-iterator.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,25 @@
+"use strict";
+
+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;
+  }
+}
+//# sourceMappingURL=make-array-buffer-iterator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/iterators/make-iterator/make-array-buffer-iterator.ts"],"names":["DEFAULT_CHUNK_SIZE","makeArrayBufferIterator","arrayBuffer","options","chunkSize","byteOffset","byteLength","chunkByteLength","Math","min","chunk","ArrayBuffer","sourceArray","Uint8Array","chunkArray","set"],"mappings":";;;;;;AAEA,MAAMA,kBAAkB,GAAG,MAAM,IAAjC;;AAQO,UAAUC,uBAAV,CACLC,WADK,EAELC,OAAwB,GAAG,EAFtB,EAGkB;AACvB,QAAM;AAACC,IAAAA,SAAS,GAAGJ;AAAb,MAAmCG,OAAzC;AAEA,MAAIE,UAAU,GAAG,CAAjB;;AAEA,SAAOA,UAAU,GAAGH,WAAW,CAACI,UAAhC,EAA4C;AAE1C,UAAMC,eAAe,GAAGC,IAAI,CAACC,GAAL,CAASP,WAAW,CAACI,UAAZ,GAAyBD,UAAlC,EAA8CD,SAA9C,CAAxB;AACA,UAAMM,KAAK,GAAG,IAAIC,WAAJ,CAAgBJ,eAAhB,CAAd;AAGA,UAAMK,WAAW,GAAG,IAAIC,UAAJ,CAAeX,WAAf,EAA4BG,UAA5B,EAAwCE,eAAxC,CAApB;AACA,UAAMO,UAAU,GAAG,IAAID,UAAJ,CAAeH,KAAf,CAAnB;AACAI,IAAAA,UAAU,CAACC,GAAX,CAAeH,WAAf;AAGAP,IAAAA,UAAU,IAAIE,eAAd;AACA,UAAMG,KAAN;AACD;AACF","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"],"file":"make-array-buffer-iterator.js"}

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

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeBlobIterator = makeBlobIterator;
+const DEFAULT_CHUNK_SIZE = 1024 * 1024;
+
+async function* makeBlobIterator(blob, options) {
+  const chunkSize = (options === null || options === void 0 ? void 0 : options.chunkSize) || DEFAULT_CHUNK_SIZE;
+  let offset = 0;
+
+  while (offset < blob.size) {
+    const end = offset + chunkSize;
+    const chunk = await blob.slice(offset, end).arrayBuffer();
+    offset = end;
+    yield chunk;
+  }
+}
+//# sourceMappingURL=make-blob-iterator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/iterators/make-iterator/make-blob-iterator.ts"],"names":["DEFAULT_CHUNK_SIZE","makeBlobIterator","blob","options","chunkSize","offset","size","end","chunk","slice","arrayBuffer"],"mappings":";;;;;;AAEA,MAAMA,kBAAkB,GAAG,OAAO,IAAlC;;AAQO,gBAAgBC,gBAAhB,CACLC,IADK,EAELC,OAFK,EAGuB;AAC5B,QAAMC,SAAS,GAAG,CAAAD,OAAO,SAAP,IAAAA,OAAO,WAAP,YAAAA,OAAO,CAAEC,SAAT,KAAsBJ,kBAAxC;AAEA,MAAIK,MAAM,GAAG,CAAb;;AACA,SAAOA,MAAM,GAAGH,IAAI,CAACI,IAArB,EAA2B;AACzB,UAAMC,GAAG,GAAGF,MAAM,GAAGD,SAArB;AAEA,UAAMI,KAAK,GAAG,MAAMN,IAAI,CAACO,KAAL,CAAWJ,MAAX,EAAmBE,GAAnB,EAAwBG,WAAxB,EAApB;AAEAL,IAAAA,MAAM,GAAGE,GAAT;AACA,UAAMC,KAAN;AACD;AACF","sourcesContent":["import type {IteratorOptions} from './make-iterator';\n\nconst DEFAULT_CHUNK_SIZE = 1024 * 1024; // 1MB — biggest value that keeps UI responsive\n\n/**\n * Returns an iterator that breaks a big Blob into chunks and yields them one-by-one\n * @param blob Blob or File object\n * @param options\n * @param options.chunkSize\n */\nexport async function* makeBlobIterator(\n  blob: Blob,\n  options?: IteratorOptions\n): AsyncIterable<ArrayBuffer> {\n  const chunkSize = options?.chunkSize || DEFAULT_CHUNK_SIZE;\n\n  let offset = 0;\n  while (offset < blob.size) {\n    const end = offset + chunkSize;\n\n    const chunk = await blob.slice(offset, end).arrayBuffer();\n\n    offset = end;\n    yield chunk;\n  }\n}\n"],"file":"make-blob-iterator.js"}

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

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeIterator = makeIterator;
+
+var _makeStringIterator = require("./make-string-iterator");
+
+var _makeArrayBufferIterator = require("./make-array-buffer-iterator");
+
+var _makeBlobIterator = require("./make-blob-iterator");
+
+var _makeStreamIterator = require("./make-stream-iterator");
+
+var _isType = require("../../javascript-utils/is-type");
+
+function makeIterator(data, options) {
+  if (typeof data === 'string') {
+    return (0, _makeStringIterator.makeStringIterator)(data, options);
+  }
+
+  if (data instanceof ArrayBuffer) {
+    return (0, _makeArrayBufferIterator.makeArrayBufferIterator)(data, options);
+  }
+
+  if ((0, _isType.isBlob)(data)) {
+    return (0, _makeBlobIterator.makeBlobIterator)(data, options);
+  }
+
+  if ((0, _isType.isReadableStream)(data)) {
+    return (0, _makeStreamIterator.makeStreamIterator)(data, options);
+  }
+
+  if ((0, _isType.isResponse)(data)) {
+    const response = data;
+    return (0, _makeStreamIterator.makeStreamIterator)(response.body, options);
+  }
+
+  throw new Error('makeIterator');
+}
+//# sourceMappingURL=make-iterator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/iterators/make-iterator/make-iterator.ts"],"names":["makeIterator","data","options","ArrayBuffer","response","body","Error"],"mappings":";;;;;;;AAEA;;AACA;;AACA;;AAEA;;AACA;;AAiBO,SAASA,YAAT,CACLC,IADK,EAELC,OAFK,EAG+C;AACpD,MAAI,OAAOD,IAAP,KAAgB,QAApB,EAA8B;AAE5B,WAAO,4CAAmBA,IAAnB,EAAyBC,OAAzB,CAAP;AACD;;AACD,MAAID,IAAI,YAAYE,WAApB,EAAiC;AAC/B,WAAO,sDAAwBF,IAAxB,EAA8BC,OAA9B,CAAP;AACD;;AACD,MAAI,oBAAOD,IAAP,CAAJ,EAAkB;AAChB,WAAO,wCAAiBA,IAAjB,EAA+BC,OAA/B,CAAP;AACD;;AACD,MAAI,8BAAiBD,IAAjB,CAAJ,EAA4B;AAC1B,WAAO,4CAAmBA,IAAnB,EAA2CC,OAA3C,CAAP;AACD;;AACD,MAAI,wBAAWD,IAAX,CAAJ,EAAsB;AACpB,UAAMG,QAAQ,GAAGH,IAAjB;AACA,WAAO,4CAAmBG,QAAQ,CAACC,IAA5B,EAAoDH,OAApD,CAAP;AACD;;AACD,QAAM,IAAII,KAAJ,CAAU,cAAV,CAAN;AACD","sourcesContent":["import type {ReadStream} from 'fs';\n\nimport {makeStringIterator} from './make-string-iterator';\nimport {makeArrayBufferIterator} from './make-array-buffer-iterator';\nimport {makeBlobIterator} from './make-blob-iterator';\nimport type {StreamIteratorOptions} from './make-stream-iterator';\nimport {makeStreamIterator} from './make-stream-iterator';\nimport {isBlob, isReadableStream, isResponse} from '../../javascript-utils/is-type';\n\n/**\n * @param [options.chunkSize]\n */\nexport type IteratorOptions = StreamIteratorOptions & {\n  chunkSize?: number;\n};\n\n/**\n * Returns an iterator that breaks its input into chunks and yields them one-by-one.\n * @param data\n * @param options\n * @returns\n * This function can e.g. be used to enable data sources that can only be read atomically\n * (such as `Blob` and `File` via `FileReader`) to still be parsed in batches.\n */\nexport function makeIterator(\n  data: ArrayBuffer | string | Blob | Response | ReadableStream | ReadStream,\n  options?: IteratorOptions\n): AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer> {\n  if (typeof data === 'string') {\n    // Note: Converts string chunks to binary\n    return makeStringIterator(data, options);\n  }\n  if (data instanceof ArrayBuffer) {\n    return makeArrayBufferIterator(data, options);\n  }\n  if (isBlob(data)) {\n    return makeBlobIterator(data as Blob, options);\n  }\n  if (isReadableStream(data)) {\n    return makeStreamIterator(data as ReadableStream, options);\n  }\n  if (isResponse(data)) {\n    const response = data as Response;\n    return makeStreamIterator(response.body as ReadableStream, options);\n  }\n  throw new Error('makeIterator');\n}\n"],"file":"make-iterator.js"}

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

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeStreamIterator = makeStreamIterator;
+
+var _loaderUtils = require("@loaders.gl/loader-utils");
+
+function makeStreamIterator(stream, options) {
+  return _loaderUtils.isBrowser ? makeBrowserStreamIterator(stream, options) : makeNodeStreamIterator(stream, options);
+}
+
+async function* makeBrowserStreamIterator(stream, options) {
+  const reader = stream.getReader();
+  let nextBatchPromise;
+
+  try {
+    while (true) {
+      const currentBatchPromise = nextBatchPromise || reader.read();
+
+      if (options !== null && options !== void 0 && options._streamReadAhead) {
+        nextBatchPromise = reader.read();
+      }
+
+      const {
+        done,
+        value
+      } = await currentBatchPromise;
+
+      if (done) {
+        return;
+      }
+
+      yield (0, _loaderUtils.toArrayBuffer)(value);
+    }
+  } catch (error) {
+    reader.releaseLock();
+  }
+}
+
+async function* makeNodeStreamIterator(stream, options) {
+  for await (const chunk of stream) {
+    yield (0, _loaderUtils.toArrayBuffer)(chunk);
+  }
+}
+//# sourceMappingURL=make-stream-iterator.js.map