@loaders.gl/core 3.1.0-alpha.1 → 3.1.0-alpha.5

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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/iterators/make-iterator/make-stream-iterator.ts"],"names":["makeStreamIterator","stream","options","isBrowser","makeBrowserStreamIterator","makeNodeStreamIterator","reader","getReader","nextBatchPromise","currentBatchPromise","read","_streamReadAhead","done","value","error","releaseLock","chunk"],"mappings":";;;;;;;AACA;;AAUO,SAASA,kBAAT,CACLC,MADK,EAELC,OAFK,EAGuB;AAC5B,SAAOC,yBACHC,yBAAyB,CAACH,MAAD,EAA2BC,OAA3B,CADtB,GAEHG,sBAAsB,CAACJ,MAAD,EAAqBC,OAArB,CAF1B;AAGD;;AAOD,gBAAgBE,yBAAhB,CACEH,MADF,EAEEC,OAFF,EAG8B;AAU5B,QAAMI,MAAM,GAAGL,MAAM,CAACM,SAAP,EAAf;AAEA,MAAIC,gBAAJ;;AAEA,MAAI;AAEF,WAAO,IAAP,EAAa;AACX,YAAMC,mBAAmB,GAAGD,gBAAgB,IAAIF,MAAM,CAACI,IAAP,EAAhD;;AAGA,UAAIR,OAAJ,aAAIA,OAAJ,eAAIA,OAAO,CAAES,gBAAb,EAA+B;AAC7BH,QAAAA,gBAAgB,GAAGF,MAAM,CAACI,IAAP,EAAnB;AACD;;AAGD,YAAM;AAACE,QAAAA,IAAD;AAAOC,QAAAA;AAAP,UAAgB,MAAMJ,mBAA5B;;AAEA,UAAIG,IAAJ,EAAU;AACR;AACD;;AAED,YAAM,gCAAcC,KAAd,CAAN;AACD;AACF,GAnBD,CAmBE,OAAOC,KAAP,EAAc;AAGdR,IAAAA,MAAM,CAACS,WAAP;AACD;AACF;;AAOD,gBAAgBV,sBAAhB,CACEJ,MADF,EAEEC,OAFF,EAG8B;AAG5B,aAAW,MAAMc,KAAjB,IAA0Bf,MAA1B,EAAkC;AAChC,UAAM,gCAAce,KAAd,CAAN;AACD;AACF","sourcesContent":["import type {Readable} from 'stream';\nimport {isBrowser, toArrayBuffer} from '@loaders.gl/loader-utils';\n\nexport type StreamIteratorOptions = {\n  _streamReadAhead?: boolean;\n};\n\n/**\n * Returns an async iterable that reads from a stream (works in both Node.js and browsers)\n * @param stream stream to iterator over\n */\nexport function makeStreamIterator(\n  stream: ReadableStream | Readable,\n  options?: StreamIteratorOptions\n): AsyncIterable<ArrayBuffer> {\n  return isBrowser\n    ? makeBrowserStreamIterator(stream as ReadableStream, options)\n    : makeNodeStreamIterator(stream as Readable, options);\n}\n\n/**\n * Returns an async iterable that reads from a DOM (browser) stream\n * @param stream stream to iterate from\n * @see https://jakearchibald.com/2017/async-iterators-and-generators/#making-streams-iterate\n */\nasync function* makeBrowserStreamIterator(\n  stream: ReadableStream,\n  options?: StreamIteratorOptions\n): AsyncIterable<ArrayBuffer> {\n  // WhatWG: stream is supposed to have a `getIterator` method\n  // if (typeof stream.getIterator === 'function') {\n  //   return stream.getIterator();\n  // }\n  // if (typeof stream[Symbol.asyncIterator] === 'function') {\n  //   return makeToArrayBufferIterator(stream);\n  // }\n\n  // In the browser, we first need to get a lock on the stream\n  const reader = stream.getReader();\n\n  let nextBatchPromise: Promise<{done?: boolean; value?: Uint8Array}> | undefined;\n\n  try {\n    // eslint-disable-next-line no-constant-condition\n    while (true) {\n      const currentBatchPromise = nextBatchPromise || reader.read();\n      // Issue a read for an additional batch, while we await the next batch\n      // Idea is to make fetching happen in parallel with processing / parsing\n      if (options?._streamReadAhead) {\n        nextBatchPromise = reader.read();\n      }\n      // Read from the stream\n      // value is a Uint8Array\n      const {done, value} = await currentBatchPromise;\n      // Exit if we're done\n      if (done) {\n        return;\n      }\n      // Else yield the chunk\n      yield toArrayBuffer(value);\n    }\n  } catch (error) {\n    // TODO - examples makes it look like this should always be called,\n    // but that generates exceptions so only call it if we do not reach the end\n    reader.releaseLock();\n  }\n}\n\n/**\n * Returns an async iterable that reads from a DOM (browser) stream\n * @param stream stream to iterate from\n * @note Requires Node.js >= 10\n */\nasync function* makeNodeStreamIterator(\n  stream: Readable,\n  options?: StreamIteratorOptions\n): AsyncIterable<ArrayBuffer> {\n  // Hacky test for node version to ensure we don't call bad polyfills\n  // NODE 10+: stream is an asyncIterator\n  for await (const chunk of stream) {\n    yield toArrayBuffer(chunk); // Coerce each chunk to ArrayBuffer\n  }\n}\n/* TODO - remove NODE < 10\n * @see https://github.com/bustle/streaming-iterables, MIT license\n *\n  if (typeof stream[Symbol.asyncIterator] === 'function') {\n    return;\n  }\n\n  // TODO - check if is this ever used in Node 10+?\n  // eslint-disable-next-line no-constant-condition\n  while (true) {\n    const data = stream.read();\n    if (data !== null) {\n      yield toArrayBuffer(data);\n      // eslint-disable-next-line no-continue\n      continue;\n    }\n    if (stream._readableState?.ended) {\n      return;\n    }\n    await onceReadable(stream);\n  }\n\nasync function onceReadable(stream: Readable): Promise<any> {\n  return new Promise((resolve) => {\n    stream.once('readable', resolve);\n  });\n}\n  */\n"],"file":"make-stream-iterator.js"}

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

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeStringIterator = makeStringIterator;
+const DEFAULT_CHUNK_SIZE = 256 * 1024;
+
+function* makeStringIterator(string, options) {
+  const chunkSize = (options === null || options === void 0 ? void 0 : options.chunkSize) || DEFAULT_CHUNK_SIZE;
+  let offset = 0;
+  const textEncoder = new TextEncoder();
+
+  while (offset < string.length) {
+    const chunkLength = Math.min(string.length - offset, chunkSize);
+    const chunk = string.slice(offset, offset + chunkLength);
+    offset += chunkLength;
+    yield textEncoder.encode(chunk);
+  }
+}
+//# sourceMappingURL=make-string-iterator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/iterators/make-iterator/make-string-iterator.ts"],"names":["DEFAULT_CHUNK_SIZE","makeStringIterator","string","options","chunkSize","offset","textEncoder","TextEncoder","length","chunkLength","Math","min","chunk","slice","encode"],"mappings":";;;;;;AAEA,MAAMA,kBAAkB,GAAG,MAAM,IAAjC;;AAQO,UAAUC,kBAAV,CACLC,MADK,EAELC,OAFK,EAGkB;AACvB,QAAMC,SAAS,GAAG,CAAAD,OAAO,SAAP,IAAAA,OAAO,WAAP,YAAAA,OAAO,CAAEC,SAAT,KAAsBJ,kBAAxC;AAEA,MAAIK,MAAM,GAAG,CAAb;AACA,QAAMC,WAAW,GAAG,IAAIC,WAAJ,EAApB;;AACA,SAAOF,MAAM,GAAGH,MAAM,CAACM,MAAvB,EAA+B;AAE7B,UAAMC,WAAW,GAAGC,IAAI,CAACC,GAAL,CAAST,MAAM,CAACM,MAAP,GAAgBH,MAAzB,EAAiCD,SAAjC,CAApB;AACA,UAAMQ,KAAK,GAAGV,MAAM,CAACW,KAAP,CAAaR,MAAb,EAAqBA,MAAM,GAAGI,WAA9B,CAAd;AACAJ,IAAAA,MAAM,IAAII,WAAV;AAGA,UAAMH,WAAW,CAACQ,MAAZ,CAAmBF,KAAnB,CAAN;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 string into chunks and yields them one-by-one as ArrayBuffers\n * @param blob string to iterate over\n * @param options\n * @param options.chunkSize\n */\nexport function* makeStringIterator(\n  string: string,\n  options?: IteratorOptions\n): Iterable<ArrayBuffer> {\n  const chunkSize = options?.chunkSize || DEFAULT_CHUNK_SIZE;\n\n  let offset = 0;\n  const textEncoder = new TextEncoder();\n  while (offset < string.length) {\n    // Create a chunk of the right size\n    const chunkLength = Math.min(string.length - offset, chunkSize);\n    const chunk = string.slice(offset, offset + chunkLength);\n    offset += chunkLength;\n\n    // yield an ArrayBuffer chunk\n    yield textEncoder.encode(chunk);\n  }\n}\n"],"file":"make-string-iterator.js"}