@loaders.gl/core 4.0.0-alpha.4 → 4.0.0-alpha.6

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

@@ -1,30 +1,37 @@
-import { makeStringIterator } from './make-string-iterator';
-import { makeArrayBufferIterator } from './make-array-buffer-iterator';
-import { makeBlobIterator } from './make-blob-iterator';
-import { makeStreamIterator } from './make-stream-iterator';
-import { isBlob, isReadableStream, isResponse } from '../../javascript-utils/is-type';
-export function makeIterator(data, options) {
-  if (typeof data === 'string') {
-    return makeStringIterator(data, options);
-  }
-
-  if (data instanceof ArrayBuffer) {
-    return makeArrayBufferIterator(data, options);
-  }
-
-  if (isBlob(data)) {
-    return makeBlobIterator(data, options);
-  }
-
-  if (isReadableStream(data)) {
-    return makeStreamIterator(data, options);
-  }
-
-  if (isResponse(data)) {
-    const response = data;
-    return makeStreamIterator(response.body, options);
-  }
-
-  throw new Error('makeIterator');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeIterator = void 0;
+const make_string_iterator_1 = require("./make-string-iterator");
+const make_array_buffer_iterator_1 = require("./make-array-buffer-iterator");
+const make_blob_iterator_1 = require("./make-blob-iterator");
+const make_stream_iterator_1 = require("./make-stream-iterator");
+const is_type_1 = require("../../javascript-utils/is-type");
+/**
+ * Returns an iterator that breaks its input into chunks and yields them one-by-one.
+ * @param data
+ * @param options
+ * @returns
+ * This function can e.g. be used to enable data sources that can only be read atomically
+ * (such as `Blob` and `File` via `FileReader`) to still be parsed in batches.
+ */
+function makeIterator(data, options) {
+    if (typeof data === 'string') {
+        // Note: Converts string chunks to binary
+        return (0, make_string_iterator_1.makeStringIterator)(data, options);
+    }
+    if (data instanceof ArrayBuffer) {
+        return (0, make_array_buffer_iterator_1.makeArrayBufferIterator)(data, options);
+    }
+    if ((0, is_type_1.isBlob)(data)) {
+        return (0, make_blob_iterator_1.makeBlobIterator)(data, options);
+    }
+    if ((0, is_type_1.isReadableStream)(data)) {
+        return (0, make_stream_iterator_1.makeStreamIterator)(data, options);
+    }
+    if ((0, is_type_1.isResponse)(data)) {
+        const response = data;
+        return (0, make_stream_iterator_1.makeStreamIterator)(response.body, options);
+    }
+    throw new Error('makeIterator');
 }
-//# sourceMappingURL=make-iterator.js.map
+exports.makeIterator = makeIterator;

package/dist/iterators/make-iterator/make-stream-iterator.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import type { Readable } from 'stream';
+export type StreamIteratorOptions = {
+    _streamReadAhead?: boolean;
+};
+/**
+ * Returns an async iterable that reads from a stream (works in both Node.js and browsers)
+ * @param stream stream to iterator over
+ */
+export declare function makeStreamIterator(stream: ReadableStream | Readable, options?: StreamIteratorOptions): AsyncIterable<ArrayBuffer>;
+//# sourceMappingURL=make-stream-iterator.d.ts.map

package/dist/iterators/make-iterator/make-stream-iterator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-stream-iterator.d.ts","sourceRoot":"","sources":["../../../src/iterators/make-iterator/make-stream-iterator.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,QAAQ,CAAC;AAGrC,MAAM,MAAM,qBAAqB,GAAG;IAClC,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEF;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,cAAc,GAAG,QAAQ,EACjC,OAAO,CAAC,EAAE,qBAAqB,GAC9B,aAAa,CAAC,WAAW,CAAC,CAI5B"}

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

@@ -1,39 +1,96 @@
-import { isBrowser, toArrayBuffer } from '@loaders.gl/loader-utils';
-export function makeStreamIterator(stream, options) {
-  return isBrowser ? makeBrowserStreamIterator(stream, options) : makeNodeStreamIterator(stream, options);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStreamIterator = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+/**
+ * Returns an async iterable that reads from a stream (works in both Node.js and browsers)
+ * @param stream stream to iterator over
+ */
+function makeStreamIterator(stream, options) {
+    return loader_utils_1.isBrowser
+        ? makeBrowserStreamIterator(stream, options)
+        : makeNodeStreamIterator(stream, options);
 }
-
+exports.makeStreamIterator = makeStreamIterator;
+/**
+ * Returns an async iterable that reads from a DOM (browser) stream
+ * @param stream stream to iterate from
+ * @see https://jakearchibald.com/2017/async-iterators-and-generators/#making-streams-iterate
+ */
 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 toArrayBuffer(value);
+    // WhatWG: stream is supposed to have a `getIterator` method
+    // if (typeof stream.getIterator === 'function') {
+    //   return stream.getIterator();
+    // }
+    // if (typeof stream[Symbol.asyncIterator] === 'function') {
+    //   return makeToArrayBufferIterator(stream);
+    // }
+    // In the browser, we first need to get a lock on the stream
+    const reader = stream.getReader();
+    let nextBatchPromise;
+    try {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const currentBatchPromise = nextBatchPromise || reader.read();
+            // Issue a read for an additional batch, while we await the next batch
+            // Idea is to make fetching happen in parallel with processing / parsing
+            if (options?._streamReadAhead) {
+                nextBatchPromise = reader.read();
+            }
+            // Read from the stream
+            // value is a Uint8Array
+            const { done, value } = await currentBatchPromise;
+            // Exit if we're done
+            if (done) {
+                return;
+            }
+            // Else yield the chunk
+            yield (0, loader_utils_1.toArrayBuffer)(value);
+        }
+    }
+    catch (error) {
+        // TODO - examples makes it look like this should always be called,
+        // but that generates exceptions so only call it if we do not reach the end
+        reader.releaseLock();
     }
-  } catch (error) {
-    reader.releaseLock();
-  }
 }
-
+/**
+ * Returns an async iterable that reads from a DOM (browser) stream
+ * @param stream stream to iterate from
+ * @note Requires Node.js >= 10
+ */
 async function* makeNodeStreamIterator(stream, options) {
-  for await (const chunk of stream) {
-    yield toArrayBuffer(chunk);
+    // Hacky test for node version to ensure we don't call bad polyfills
+    // NODE 10+: stream is an asyncIterator
+    for await (const chunk of stream) {
+        yield (0, loader_utils_1.toArrayBuffer)(chunk); // Coerce each chunk to ArrayBuffer
+    }
+}
+/* TODO - remove NODE < 10
+ * @see https://github.com/bustle/streaming-iterables, MIT license
+ *
+  if (typeof stream[Symbol.asyncIterator] === 'function') {
+    return;
+  }
+
+  // TODO - check if is this ever used in Node 10+?
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    const data = stream.read();
+    if (data !== null) {
+      yield toArrayBuffer(data);
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+    if (stream._readableState?.ended) {
+      return;
+    }
+    await onceReadable(stream);
   }
+
+async function onceReadable(stream: Readable): Promise<any> {
+  return new Promise((resolve) => {
+    stream.once('readable', resolve);
+  });
 }
-//# sourceMappingURL=make-stream-iterator.js.map
+  */

package/dist/iterators/make-iterator/make-string-iterator.d.ts

@@ -0,0 +1,9 @@
+import type { IteratorOptions } from './make-iterator';
+/**
+ * Returns an iterator that breaks a big string into chunks and yields them one-by-one as ArrayBuffers
+ * @param blob string to iterate over
+ * @param options
+ * @param options.chunkSize
+ */
+export declare function makeStringIterator(string: string, options?: IteratorOptions): Iterable<ArrayBuffer>;
+//# sourceMappingURL=make-string-iterator.d.ts.map

package/dist/iterators/make-iterator/make-string-iterator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-string-iterator.d.ts","sourceRoot":"","sources":["../../../src/iterators/make-iterator/make-string-iterator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,iBAAiB,CAAC;AAIrD;;;;;GAKG;AACH,wBAAiB,kBAAkB,CACjC,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,eAAe,GACxB,QAAQ,CAAC,WAAW,CAAC,CAcvB"}

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

@@ -1,14 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStringIterator = void 0;
 const DEFAULT_CHUNK_SIZE = 256 * 1024;
-export 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);
-  }
+/**
+ * Returns an iterator that breaks a big string into chunks and yields them one-by-one as ArrayBuffers
+ * @param blob string to iterate over
+ * @param options
+ * @param options.chunkSize
+ */
+function* makeStringIterator(string, options) {
+    const chunkSize = options?.chunkSize || DEFAULT_CHUNK_SIZE;
+    let offset = 0;
+    const textEncoder = new TextEncoder();
+    while (offset < string.length) {
+        // Create a chunk of the right size
+        const chunkLength = Math.min(string.length - offset, chunkSize);
+        const chunk = string.slice(offset, offset + chunkLength);
+        offset += chunkLength;
+        // yield an ArrayBuffer chunk
+        yield textEncoder.encode(chunk);
+    }
 }
-//# sourceMappingURL=make-string-iterator.js.map
+exports.makeStringIterator = makeStringIterator;

package/dist/iterators/make-stream/make-dom-stream.d.ts

@@ -0,0 +1,14 @@
+export type MakeStreamOptions = {
+    /** Stream allocates an arrayBuffer. Enables use of a default reader. */
+    autoAllocateChunkSize?: number;
+    /** Total number of chunks in queue before back pressure is applied */
+    highWaterMark?: number;
+};
+/**
+ * Builds a DOM stream from an iterator
+ * This stream is currently used in browsers only,
+ * but note that Web stream support is present in Node from Node 16
+ * https://nodejs.org/api/webstreams.html#webstreams_web_streams_api
+ */
+export declare function makeStream<ArrayBuffer>(source: Iterable<ArrayBuffer> | AsyncIterable<ArrayBuffer>, options?: MakeStreamOptions): ReadableStream;
+//# sourceMappingURL=make-dom-stream.d.ts.map

package/dist/iterators/make-stream/make-dom-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-dom-stream.d.ts","sourceRoot":"","sources":["../../../src/iterators/make-stream/make-dom-stream.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,wEAAwE;IACxE,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,sEAAsE;IACtE,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,WAAW,EACpC,MAAM,EAAE,QAAQ,CAAC,WAAW,CAAC,GAAG,aAAa,CAAC,WAAW,CAAC,EAC1D,OAAO,CAAC,EAAE,iBAAiB,GAC1B,cAAc,CAsChB"}

package/dist/iterators/make-stream/make-dom-stream.js

@@ -1,34 +1,46 @@
-export function makeDOMStream(source, options) {
-  const iterator = source[Symbol.asyncIterator] ? source[Symbol.asyncIterator]() : source[Symbol.iterator]();
-  return new ReadableStream({
-    type: 'bytes',
-
-    async pull(controller) {
-      try {
-        const {
-          done,
-          value
-        } = await iterator.next();
-
-        if (done) {
-          controller.close();
-        } else {
-          controller.enqueue(new Uint8Array(value));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStream = void 0;
+/**
+ * Builds a DOM stream from an iterator
+ * This stream is currently used in browsers only,
+ * but note that Web stream support is present in Node from Node 16
+ * https://nodejs.org/api/webstreams.html#webstreams_web_streams_api
+ */
+function makeStream(source, options) {
+    const iterator = source[Symbol.asyncIterator]
+        ? source[Symbol.asyncIterator]()
+        : source[Symbol.iterator]();
+    return new ReadableStream({
+        // Create a byte stream (enables `Response(stream).arrayBuffer()`)
+        // Only supported on Chrome
+        // See: https://developer.mozilla.org/en-US/docs/Web/API/ReadableByteStreamController
+        type: 'bytes',
+        async pull(controller) {
+            try {
+                const { done, value } = await iterator.next();
+                if (done) {
+                    controller.close();
+                }
+                else {
+                    // TODO - ignores controller.desiredSize
+                    // @ts-expect-error Unclear why value is not correctly typed
+                    controller.enqueue(new Uint8Array(value));
+                }
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+        async cancel() {
+            await iterator?.return?.();
         }
-      } catch (error) {
-        controller.error(error);
-      }
-    },
-
-    async cancel() {
-      var _iterator$return;
-
-      await (iterator === null || iterator === void 0 ? void 0 : (_iterator$return = iterator.return) === null || _iterator$return === void 0 ? void 0 : _iterator$return.call(iterator));
-    }
-
-  }, {
-    highWaterMark: 2 ** 24,
-    ...options
-  });
+    }, 
+    // options: QueingStrategy<Uint8Array>
+    {
+        // This is bytes, not chunks
+        highWaterMark: 2 ** 24,
+        ...options
+    });
 }
-//# sourceMappingURL=make-dom-stream.js.map
+exports.makeStream = makeStream;

package/dist/iterators/make-stream/make-node-stream.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import type { ReadableOptions } from 'stream';
+import * as Stream from 'stream';
+declare class _Readable {
+}
+type ReadableType = Stream.Readable | _Readable;
+export type MakeStreamOptions = ReadableOptions;
+/** Builds a node stream from an iterator */
+export declare function makeStream<ArrayBuffer>(source: Iterable<ArrayBuffer> | AsyncIterable<ArrayBuffer>, options?: ReadableOptions): ReadableType;
+export {};
+//# sourceMappingURL=make-node-stream.d.ts.map

package/dist/iterators/make-stream/make-node-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-node-stream.d.ts","sourceRoot":"","sources":["../../../src/iterators/make-stream/make-node-stream.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,QAAQ,CAAC;AAC5C,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEjC,cAAM,SAAS;CAAG;AAElB,KAAK,YAAY,GAAG,MAAM,CAAC,QAAQ,GAAG,SAAS,CAAC;AAGhD,MAAM,MAAM,iBAAiB,GAAG,eAAe,CAAC;AAEhD,4CAA4C;AAC5C,wBAAgB,UAAU,CAAC,WAAW,EACpC,MAAM,EAAE,QAAQ,CAAC,WAAW,CAAC,GAAG,aAAa,CAAC,WAAW,CAAC,EAC1D,OAAO,CAAC,EAAE,eAAe,GACxB,YAAY,CAKd"}

package/dist/iterators/make-stream/make-node-stream.js

@@ -1,77 +1,82 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { Readable } from 'stream';
-
-function makeNodeStream(source, options) {
-  const iterator = source[Symbol.asyncIterator] ? source[Symbol.asyncIterator]() : source[Symbol.iterator]();
-  return new AsyncIterableReadable(iterator, options);
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStream = void 0;
+const Stream = __importStar(require("stream"));
+class _Readable {
+}
+const Readable = Stream.Readable || _Readable;
+/** Builds a node stream from an iterator */
+function makeStream(source, options) {
+    const iterator = source[Symbol.asyncIterator]
+        ? source[Symbol.asyncIterator]()
+        : source[Symbol.iterator]();
+    return new AsyncIterableReadable(iterator, options);
 }
-
+exports.makeStream = makeStream;
 class AsyncIterableReadable extends Readable {
-  constructor(it, options) {
-    super(options);
-
-    _defineProperty(this, "_pulling", void 0);
-
-    _defineProperty(this, "_bytesMode", void 0);
-
-    _defineProperty(this, "_iterator", void 0);
-
-    this._iterator = it;
-    this._pulling = false;
-    this._bytesMode = !options || !options.objectMode;
-  }
-
-  async _read(size) {
-    if (!this._pulling) {
-      this._pulling = true;
-      this._pulling = await this._pull(size, this._iterator);
-    }
-  }
-
-  async _destroy(error, cb) {
-    if (!this._iterator) {
-      return;
+    constructor(it, options) {
+        super(options);
+        this._iterator = it;
+        this._pulling = false;
+        this._bytesMode = !options || !options.objectMode;
     }
-
-    if (error) {
-      var _this$_iterator, _this$_iterator$throw;
-
-      await ((_this$_iterator = this._iterator) === null || _this$_iterator === void 0 ? void 0 : (_this$_iterator$throw = _this$_iterator.throw) === null || _this$_iterator$throw === void 0 ? void 0 : _this$_iterator$throw.call(_this$_iterator, error));
-    } else {
-      var _this$_iterator2, _this$_iterator2$retu;
-
-      await ((_this$_iterator2 = this._iterator) === null || _this$_iterator2 === void 0 ? void 0 : (_this$_iterator2$retu = _this$_iterator2.return) === null || _this$_iterator2$retu === void 0 ? void 0 : _this$_iterator2$retu.call(_this$_iterator2, error));
+    async _read(size) {
+        if (!this._pulling) {
+            this._pulling = true;
+            this._pulling = await this._pull(size, this._iterator);
+        }
     }
-
-    cb === null || cb === void 0 ? void 0 : cb(null);
-  }
-
-  async _pull(size, it) {
-    var _r;
-
-    const bm = this._bytesMode;
-    let r = null;
-
-    while (this.readable && !(r = await it.next()).done) {
-      if (size !== null) {
-        size -= bm && ArrayBuffer.isView(r.value) ? r.value.byteLength : 1;
-      }
-
-      if (!this.push(new Uint8Array(r.value)) || size <= 0) {
-        break;
-      }
+    async _destroy(error, cb) {
+        if (!this._iterator) {
+            return;
+        }
+        if (error) {
+            await this._iterator?.throw?.(error);
+        }
+        else {
+            await this._iterator?.return?.(error);
+        }
+        cb?.(null);
     }
-
-    if (((_r = r) !== null && _r !== void 0 && _r.done || !this.readable) && (this.push(null) || true)) {
-      var _it$return;
-
-      it === null || it === void 0 ? void 0 : (_it$return = it.return) === null || _it$return === void 0 ? void 0 : _it$return.call(it);
+    // eslint-disable-next-line complexity
+    async _pull(size, it) {
+        const bm = this._bytesMode;
+        let r = null;
+        // while (this.readable && !(r = await it.next(bm ? size : null)).done) {
+        while (this.readable && !(r = await it.next()).done) {
+            if (size !== null) {
+                size -= bm && ArrayBuffer.isView(r.value) ? r.value.byteLength : 1;
+            }
+            if (!this.push(new Uint8Array(r.value)) || size <= 0) {
+                break;
+            }
+        }
+        if ((r?.done || !this.readable) && (this.push(null) || true)) {
+            it?.return?.();
+        }
+        return !this.readable;
     }
-
-    return !this.readable;
-  }
-
 }
-
-export default makeNodeStream;
-//# sourceMappingURL=make-node-stream.js.map

package/dist/javascript-utils/is-type.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import type { Readable } from 'stream';
+/** A DOM or Node readable stream */
+export type ReadableStreamType = ReadableStream | Readable;
+export declare const isObject: (x: any) => boolean;
+export declare const isPureObject: (x: any) => boolean;
+export declare const isPromise: (x: any) => boolean;
+export declare const isIterable: (x: any) => boolean;
+export declare const isAsyncIterable: (x: any) => boolean;
+export declare const isIterator: (x: any) => boolean;
+export declare const isResponse: (x: any) => boolean;
+export declare const isFile: (x: any) => boolean;
+export declare const isBlob: (x: any) => boolean;
+/** Check for Node.js `Buffer` without triggering bundler to include buffer polyfill */
+export declare const isBuffer: (x: any) => boolean;
+export declare const isWritableDOMStream: (x: any) => boolean;
+export declare const isReadableDOMStream: (x: any) => boolean;
+export declare const isWritableNodeStream: (x: any) => boolean;
+export declare const isReadableNodeStream: (x: any) => boolean;
+export declare const isReadableStream: (x: any) => boolean;
+export declare const isWritableStream: (x: any) => boolean;
+//# sourceMappingURL=is-type.d.ts.map

package/dist/javascript-utils/is-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-type.d.ts","sourceRoot":"","sources":["../../src/javascript-utils/is-type.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,QAAQ,CAAC;AAErC,oCAAoC;AACpC,MAAM,MAAM,kBAAkB,GAAG,cAAc,GAAG,QAAQ,CAAC;AAK3D,eAAO,MAAM,QAAQ,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OAAoD,CAAC;AACxF,eAAO,MAAM,YAAY,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OACU,CAAC;AAClD,eAAO,MAAM,SAAS,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OAAkD,CAAC;AAEvF,eAAO,MAAM,UAAU,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OAA8D,CAAC;AACpG,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OACU,CAAC;AACrD,eAAO,MAAM,UAAU,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OAAwC,CAAC;AAE9E,eAAO,MAAM,UAAU,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OAEK,CAAC;AAE3C,eAAO,MAAM,MAAM,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OAAiE,CAAC;AACnG,eAAO,MAAM,MAAM,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OAAiE,CAAC;AAEnG,uFAAuF;AACvF,eAAO,MAAM,QAAQ,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OAAyD,CAAC;AAE7F,eAAO,MAAM,mBAAmB,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OACiB,CAAC;AAEhE,eAAO,MAAM,mBAAmB,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OAEyC,CAAC;AAGxF,eAAO,MAAM,oBAAoB,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OACmC,CAAC;AACnF,eAAO,MAAM,oBAAoB,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OACmC,CAAC;AACnF,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OACQ,CAAC;AACpD,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,OACQ,CAAC"}

package/dist/javascript-utils/is-type.js

@@ -1,21 +1,41 @@
-const isBoolean = x => typeof x === 'boolean';
-
-const isFunction = x => typeof x === 'function';
-
-export const isObject = x => x !== null && typeof x === 'object';
-export const isPureObject = x => isObject(x) && x.constructor === {}.constructor;
-export const isPromise = x => isObject(x) && isFunction(x.then);
-export const isIterable = x => x && typeof x[Symbol.iterator] === 'function';
-export const isAsyncIterable = x => x && typeof x[Symbol.asyncIterator] === 'function';
-export const isIterator = x => x && isFunction(x.next);
-export const isResponse = x => typeof Response !== 'undefined' && x instanceof Response || x && x.arrayBuffer && x.text && x.json;
-export const isFile = x => typeof File !== 'undefined' && x instanceof File;
-export const isBlob = x => typeof Blob !== 'undefined' && x instanceof Blob;
-export const isBuffer = x => x && typeof x === 'object' && x.isBuffer;
-export const isWritableDOMStream = x => isObject(x) && isFunction(x.abort) && isFunction(x.getWriter);
-export const isReadableDOMStream = x => typeof ReadableStream !== 'undefined' && x instanceof ReadableStream || isObject(x) && isFunction(x.tee) && isFunction(x.cancel) && isFunction(x.getReader);
-export const isWritableNodeStream = x => isObject(x) && isFunction(x.end) && isFunction(x.write) && isBoolean(x.writable);
-export const isReadableNodeStream = x => isObject(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);
-export const isReadableStream = x => isReadableDOMStream(x) || isReadableNodeStream(x);
-export const isWritableStream = x => isWritableDOMStream(x) || isWritableNodeStream(x);
-//# sourceMappingURL=is-type.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWritableStream = exports.isReadableStream = exports.isReadableNodeStream = exports.isWritableNodeStream = exports.isReadableDOMStream = exports.isWritableDOMStream = exports.isBuffer = exports.isBlob = exports.isFile = exports.isResponse = exports.isIterator = exports.isAsyncIterable = exports.isIterable = exports.isPromise = exports.isPureObject = exports.isObject = void 0;
+const isBoolean = (x) => typeof x === 'boolean';
+const isFunction = (x) => typeof x === 'function';
+const isObject = (x) => x !== null && typeof x === 'object';
+exports.isObject = isObject;
+const isPureObject = (x) => (0, exports.isObject)(x) && x.constructor === {}.constructor;
+exports.isPureObject = isPureObject;
+const isPromise = (x) => (0, exports.isObject)(x) && isFunction(x.then);
+exports.isPromise = isPromise;
+const isIterable = (x) => x && typeof x[Symbol.iterator] === 'function';
+exports.isIterable = isIterable;
+const isAsyncIterable = (x) => x && typeof x[Symbol.asyncIterator] === 'function';
+exports.isAsyncIterable = isAsyncIterable;
+const isIterator = (x) => x && isFunction(x.next);
+exports.isIterator = isIterator;
+const isResponse = (x) => (typeof Response !== 'undefined' && x instanceof Response) ||
+    (x && x.arrayBuffer && x.text && x.json);
+exports.isResponse = isResponse;
+const isFile = (x) => typeof File !== 'undefined' && x instanceof File;
+exports.isFile = isFile;
+const isBlob = (x) => typeof Blob !== 'undefined' && x instanceof Blob;
+exports.isBlob = isBlob;
+/** Check for Node.js `Buffer` without triggering bundler to include buffer polyfill */
+const isBuffer = (x) => x && typeof x === 'object' && x.isBuffer;
+exports.isBuffer = isBuffer;
+const isWritableDOMStream = (x) => (0, exports.isObject)(x) && isFunction(x.abort) && isFunction(x.getWriter);
+exports.isWritableDOMStream = isWritableDOMStream;
+const isReadableDOMStream = (x) => (typeof ReadableStream !== 'undefined' && x instanceof ReadableStream) ||
+    ((0, exports.isObject)(x) && isFunction(x.tee) && isFunction(x.cancel) && isFunction(x.getReader));
+exports.isReadableDOMStream = isReadableDOMStream;
+// Not implemented in Firefox: && isFunction(x.pipeTo)
+const isWritableNodeStream = (x) => (0, exports.isObject)(x) && isFunction(x.end) && isFunction(x.write) && isBoolean(x.writable);
+exports.isWritableNodeStream = isWritableNodeStream;
+const isReadableNodeStream = (x) => (0, exports.isObject)(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);
+exports.isReadableNodeStream = isReadableNodeStream;
+const isReadableStream = (x) => (0, exports.isReadableDOMStream)(x) || (0, exports.isReadableNodeStream)(x);
+exports.isReadableStream = isReadableStream;
+const isWritableStream = (x) => (0, exports.isWritableDOMStream)(x) || (0, exports.isWritableNodeStream)(x);
+exports.isWritableStream = isWritableStream;

package/dist/lib/api/encode-table.d.ts

@@ -0,0 +1,6 @@
+import { Writer, WriterOptionsType } from '@loaders.gl/loader-utils';
+import { Table } from '@loaders.gl/schema';
+export declare function encodeTable<WriterT extends Writer = Writer>(data: Table, writer: WriterT, options?: WriterOptionsType<WriterT>): Promise<ArrayBuffer>;
+export declare function encodeTableAsText<WriterT extends Writer = Writer>(data: Table, writer: WriterT, options?: WriterOptionsType<WriterT>): Promise<string>;
+export declare function encodeTableInBatches<WriterT extends Writer = Writer>(data: Table, writer: WriterT, options?: WriterOptionsType<WriterT>): AsyncIterable<ArrayBuffer>;
+//# sourceMappingURL=encode-table.d.ts.map