@loaders.gl/parquet 5.0.0-alpha.10 → 5.0.0-alpha.11

package/dist/delta-source-loader-types.js

@@ -4,7 +4,7 @@
 import { DeltaFormat } from "./delta-format.js";
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof "5.0.0-alpha.10" !== 'undefined' ? "5.0.0-alpha.10" : 'latest';
+const VERSION = typeof "5.0.0-alpha.11" !== 'undefined' ? "5.0.0-alpha.11" : 'latest';
 /** Loads the parser-bearing Delta source implementation on demand. */
 async function preloadDeltaSourceLoader() {
     const { DeltaSourceLoaderWithParser } = await import('@loaders.gl/parquet/delta-source');

package/dist/delta-source.js

@@ -7,7 +7,7 @@ import { PARQUET_TABLE_QUERY_CAPABILITIES } from "./parquet-source-capabilities.
 import { DeltaFormat } from "./delta-format.js";
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof "5.0.0-alpha.10" !== 'undefined' ? "5.0.0-alpha.10" : 'latest';
+const VERSION = typeof "5.0.0-alpha.11" !== 'undefined' ? "5.0.0-alpha.11" : 'latest';
 /** Lightweight Delta Lake snapshot source backed by a newline-delimited commit log. */
 export class DeltaTableSource extends DataSource {
     actionsPromises = new Map();

package/dist/geoparquet-loader.js

@@ -5,7 +5,7 @@ import { ParquetFormat } from "./parquet-format.js";
 import { PARQUET_LOADER_DEFAULT_OPTIONS } from "./parquet-loader-options.js";
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof "5.0.0-alpha.10" !== 'undefined' ? "5.0.0-alpha.10" : 'latest';
+const VERSION = typeof "5.0.0-alpha.11" !== 'undefined' ? "5.0.0-alpha.11" : 'latest';
 /** Preloads the parser-bearing GeoParquet loader implementation. */
 async function preloadGeoParquetLoader() {
     const { GeoParquetLoaderWithParser } = await import("./geoparquet-loader-with-parser.js");

package/dist/index.cjs

@@ -73,7 +73,7 @@ var init_parquet_loader_base = __esm({
     "use strict";
     init_parquet_format();
     init_parquet_loader_options();
-    VERSION = true ? "5.0.0-alpha.10" : "latest";
+    VERSION = true ? "5.0.0-alpha.11" : "latest";
     PARQUET_LOADER_BASE = {
       ...ParquetFormat,
       dataType: null,
@@ -7587,7 +7587,7 @@ var init_geoparquet_loader = __esm({
     "use strict";
     init_parquet_format();
     init_parquet_loader_options();
-    VERSION5 = true ? "5.0.0-alpha.10" : "latest";
+    VERSION5 = true ? "5.0.0-alpha.11" : "latest";
     GeoParquetLoader = {
       ...ParquetFormat,
       dataType: null,
@@ -9845,6 +9845,234 @@ var init_codecs = __esm({
   }
 });
 
+// ../compression/src/lib/native-compressor.ts
+var native_compressor_exports = {};
+__export(native_compressor_exports, {
+  NativeCompressor: () => NativeCompressor
+});
+var NativeCompressor;
+var init_native_compressor = __esm({
+  "../compression/src/lib/native-compressor.ts"() {
+    "use strict";
+    init_compression();
+    init_compression_stream();
+    NativeCompressor = class extends Compressor {
+      name;
+      extensions;
+      contentEncodings;
+      isSupported = true;
+      /** Runtime stream format used for every operation. */
+      format;
+      constructor(metadata, format, options = {}) {
+        super(options);
+        this.name = metadata.name;
+        this.extensions = [...metadata.extensions];
+        this.contentEncodings = [...metadata.contentEncodings];
+        this.format = format;
+      }
+      /** Compresses one buffer with the runtime-provided stream. */
+      async compress(input) {
+        const output = await compressWithNativeCompressionStream(input, this.format);
+        if (!output) throw new Error(`${this.name}: built-in compression is no longer available`);
+        return output;
+      }
+      /** Compresses batches incrementally with the runtime-provided stream. */
+      async *compressBatches(inputBatches) {
+        const output = compressBatchesWithNativeCompressionStream(inputBatches, this.format);
+        if (!output) throw new Error(`${this.name}: built-in compression is no longer available`);
+        yield* output;
+      }
+    };
+  }
+});
+
+// ../compression/src/lib/native-decompressor.ts
+var native_decompressor_exports = {};
+__export(native_decompressor_exports, {
+  NativeDecompressor: () => NativeDecompressor
+});
+var NativeDecompressor;
+var init_native_decompressor = __esm({
+  "../compression/src/lib/native-decompressor.ts"() {
+    "use strict";
+    init_compression();
+    init_decompression_stream();
+    NativeDecompressor = class extends Decompressor {
+      name;
+      extensions;
+      contentEncodings;
+      isSupported = true;
+      /** Runtime stream format used for every operation. */
+      format;
+      constructor(metadata, format, options = {}) {
+        super(options);
+        this.name = metadata.name;
+        this.extensions = [...metadata.extensions];
+        this.contentEncodings = [...metadata.contentEncodings];
+        this.format = format;
+      }
+      /** Decompresses one buffer with the runtime-provided stream. */
+      async decompress(input) {
+        const output = await decompressWithNativeDecompressionStream(input, this.format);
+        if (!output) throw new Error(`${this.name}: built-in decompression is no longer available`);
+        return output;
+      }
+      /** Decompresses batches incrementally with the runtime-provided stream. */
+      async *decompressBatches(inputBatches) {
+        const output = decompressBatchesWithNativeDecompressionStream(inputBatches, this.format);
+        if (!output) throw new Error(`${this.name}: built-in decompression is no longer available`);
+        yield* output;
+      }
+    };
+  }
+});
+
+// ../compression/src/lib/lazy-compression.ts
+function mergeModules(options, modules) {
+  return { ...options, modules: { ...options.modules, ...modules } };
+}
+var LazyCompressor, LazyDecompressor;
+var init_lazy_compression = __esm({
+  "../compression/src/lib/lazy-compression.ts"() {
+    "use strict";
+    init_compression();
+    init_compression_stream();
+    init_decompression_stream();
+    LazyCompressor = class extends Compressor {
+      name;
+      extensions;
+      contentEncodings;
+      isSupported = true;
+      /** Constructor options retained until a concrete implementation is selected. */
+      options;
+      /** Built-in stream format to probe, or null when the format has no built-in path. */
+      nativeFormat;
+      /** Returns whether built-in selection remains eligible for the merged preload options. */
+      shouldUseNative;
+      /** Dynamically imports the balanced fallback constructor. */
+      loadFallback;
+      /** Selected concrete implementation after preload completes. */
+      implementation = null;
+      /** Shared in-flight selection used by concurrent asynchronous calls. */
+      implementationPromise = null;
+      constructor(metadata, loadFallback, options = {}, nativeFormat = null, shouldUseNative = () => true) {
+        super(options);
+        this.name = metadata.name;
+        this.extensions = [...metadata.extensions];
+        this.contentEncodings = [...metadata.contentEncodings];
+        this.options = options;
+        this.nativeFormat = nativeFormat;
+        this.shouldUseNative = shouldUseNative;
+        this.loadFallback = loadFallback;
+      }
+      /** Selects and returns the built-in or dynamically imported fallback compressor. */
+      async preload(modules = {}) {
+        if (this.implementation) return this.implementation;
+        const options = mergeModules(this.options, modules);
+        this.implementationPromise ||= this.loadImplementation(options);
+        try {
+          this.implementation = await this.implementationPromise;
+          return this.implementation;
+        } catch (error) {
+          this.implementationPromise = null;
+          throw error;
+        }
+      }
+      /** Loads the selected concrete compressor. */
+      async loadImplementation(options) {
+        if (options.useNative !== false && this.nativeFormat && this.shouldUseNative(options) && isNativeCompressionSupported(this.nativeFormat)) {
+          const { NativeCompressor: NativeCompressor2 } = await Promise.resolve().then(() => (init_native_compressor(), native_compressor_exports));
+          return new NativeCompressor2(this, this.nativeFormat, options);
+        }
+        const Compressor2 = await this.loadFallback();
+        const implementation = new Compressor2({ ...options, useNative: false });
+        await implementation.preload(options.modules);
+        return implementation;
+      }
+      /** Compresses after lazily selecting the default implementation. */
+      async compress(input) {
+        return (await this.preload()).compress(input);
+      }
+      /** Compresses synchronously after an implementation has been preloaded. */
+      compressSync(input) {
+        if (!this.implementation) throw new Error(`${this.name}: call preload() before compressSync()`);
+        return this.implementation.compressSync(input);
+      }
+      /** Compresses batches after lazily selecting the default implementation. */
+      async *compressBatches(inputBatches) {
+        yield* (await this.preload()).compressBatches(inputBatches);
+      }
+    };
+    LazyDecompressor = class extends Decompressor {
+      name;
+      extensions;
+      contentEncodings;
+      isSupported = true;
+      /** Constructor options retained until a concrete implementation is selected. */
+      options;
+      /** Built-in stream format to probe, or null when the format has no built-in path. */
+      nativeFormat;
+      /** Returns whether built-in selection remains eligible for the merged preload options. */
+      shouldUseNative;
+      /** Dynamically imports the balanced fallback constructor. */
+      loadFallback;
+      /** Selected concrete implementation after preload completes. */
+      implementation = null;
+      /** Shared in-flight selection used by concurrent asynchronous calls. */
+      implementationPromise = null;
+      constructor(metadata, loadFallback, options = {}, nativeFormat = null, shouldUseNative = () => true) {
+        super(options);
+        this.name = metadata.name;
+        this.extensions = [...metadata.extensions];
+        this.contentEncodings = [...metadata.contentEncodings];
+        this.options = options;
+        this.nativeFormat = nativeFormat;
+        this.shouldUseNative = shouldUseNative;
+        this.loadFallback = loadFallback;
+      }
+      /** Selects and returns the built-in or dynamically imported fallback decompressor. */
+      async preload(modules = {}) {
+        if (this.implementation) return this.implementation;
+        const options = mergeModules(this.options, modules);
+        this.implementationPromise ||= this.loadImplementation(options);
+        try {
+          this.implementation = await this.implementationPromise;
+          return this.implementation;
+        } catch (error) {
+          this.implementationPromise = null;
+          throw error;
+        }
+      }
+      /** Loads the selected concrete decompressor. */
+      async loadImplementation(options) {
+        if (options.useNative !== false && this.nativeFormat && this.shouldUseNative(options) && isNativeDecompressionSupported(this.nativeFormat)) {
+          const { NativeDecompressor: NativeDecompressor2 } = await Promise.resolve().then(() => (init_native_decompressor(), native_decompressor_exports));
+          return new NativeDecompressor2(this, this.nativeFormat, options);
+        }
+        const Decompressor2 = await this.loadFallback();
+        const implementation = new Decompressor2({ ...options, useNative: false });
+        await implementation.preload(options.modules);
+        return implementation;
+      }
+      /** Decompresses after lazily selecting the default implementation. */
+      async decompress(input, size) {
+        return (await this.preload()).decompress(input, size);
+      }
+      /** Decompresses synchronously after an implementation has been preloaded. */
+      decompressSync(input, size) {
+        if (!this.implementation) {
+          throw new Error(`${this.name}: call preload() before decompressSync()`);
+        }
+        return this.implementation.decompressSync(input, size);
+      }
+      /** Decompresses batches after lazily selecting the default implementation. */
+      async *decompressBatches(inputBatches) {
+        yield* (await this.preload()).decompressBatches(inputBatches);
+      }
+    };
+  }
+});
+
 // ../compression/src/lib/fflate/index.ts
 function gzipSync(data, opts) {
   if (!opts) opts = {};
@@ -10634,234 +10862,6 @@ var init_fflate = __esm({
   }
 });
 
-// ../compression/src/lib/native-compressor.ts
-var native_compressor_exports = {};
-__export(native_compressor_exports, {
-  NativeCompressor: () => NativeCompressor
-});
-var NativeCompressor;
-var init_native_compressor = __esm({
-  "../compression/src/lib/native-compressor.ts"() {
-    "use strict";
-    init_compression();
-    init_compression_stream();
-    NativeCompressor = class extends Compressor {
-      name;
-      extensions;
-      contentEncodings;
-      isSupported = true;
-      /** Runtime stream format used for every operation. */
-      format;
-      constructor(metadata, format, options = {}) {
-        super(options);
-        this.name = metadata.name;
-        this.extensions = [...metadata.extensions];
-        this.contentEncodings = [...metadata.contentEncodings];
-        this.format = format;
-      }
-      /** Compresses one buffer with the runtime-provided stream. */
-      async compress(input) {
-        const output = await compressWithNativeCompressionStream(input, this.format);
-        if (!output) throw new Error(`${this.name}: built-in compression is no longer available`);
-        return output;
-      }
-      /** Compresses batches incrementally with the runtime-provided stream. */
-      async *compressBatches(inputBatches) {
-        const output = compressBatchesWithNativeCompressionStream(inputBatches, this.format);
-        if (!output) throw new Error(`${this.name}: built-in compression is no longer available`);
-        yield* output;
-      }
-    };
-  }
-});
-
-// ../compression/src/lib/native-decompressor.ts
-var native_decompressor_exports = {};
-__export(native_decompressor_exports, {
-  NativeDecompressor: () => NativeDecompressor
-});
-var NativeDecompressor;
-var init_native_decompressor = __esm({
-  "../compression/src/lib/native-decompressor.ts"() {
-    "use strict";
-    init_compression();
-    init_decompression_stream();
-    NativeDecompressor = class extends Decompressor {
-      name;
-      extensions;
-      contentEncodings;
-      isSupported = true;
-      /** Runtime stream format used for every operation. */
-      format;
-      constructor(metadata, format, options = {}) {
-        super(options);
-        this.name = metadata.name;
-        this.extensions = [...metadata.extensions];
-        this.contentEncodings = [...metadata.contentEncodings];
-        this.format = format;
-      }
-      /** Decompresses one buffer with the runtime-provided stream. */
-      async decompress(input) {
-        const output = await decompressWithNativeDecompressionStream(input, this.format);
-        if (!output) throw new Error(`${this.name}: built-in decompression is no longer available`);
-        return output;
-      }
-      /** Decompresses batches incrementally with the runtime-provided stream. */
-      async *decompressBatches(inputBatches) {
-        const output = decompressBatchesWithNativeDecompressionStream(inputBatches, this.format);
-        if (!output) throw new Error(`${this.name}: built-in decompression is no longer available`);
-        yield* output;
-      }
-    };
-  }
-});
-
-// ../compression/src/lib/lazy-compression.ts
-function mergeModules(options, modules) {
-  return { ...options, modules: { ...options.modules, ...modules } };
-}
-var LazyCompressor, LazyDecompressor;
-var init_lazy_compression = __esm({
-  "../compression/src/lib/lazy-compression.ts"() {
-    "use strict";
-    init_compression();
-    init_compression_stream();
-    init_decompression_stream();
-    LazyCompressor = class extends Compressor {
-      name;
-      extensions;
-      contentEncodings;
-      isSupported = true;
-      /** Constructor options retained until a concrete implementation is selected. */
-      options;
-      /** Built-in stream format to probe, or null when the format has no built-in path. */
-      nativeFormat;
-      /** Returns whether built-in selection remains eligible for the merged preload options. */
-      shouldUseNative;
-      /** Dynamically imports the balanced fallback constructor. */
-      loadFallback;
-      /** Selected concrete implementation after preload completes. */
-      implementation = null;
-      /** Shared in-flight selection used by concurrent asynchronous calls. */
-      implementationPromise = null;
-      constructor(metadata, loadFallback, options = {}, nativeFormat = null, shouldUseNative = () => true) {
-        super(options);
-        this.name = metadata.name;
-        this.extensions = [...metadata.extensions];
-        this.contentEncodings = [...metadata.contentEncodings];
-        this.options = options;
-        this.nativeFormat = nativeFormat;
-        this.shouldUseNative = shouldUseNative;
-        this.loadFallback = loadFallback;
-      }
-      /** Selects and returns the built-in or dynamically imported fallback compressor. */
-      async preload(modules = {}) {
-        if (this.implementation) return this.implementation;
-        const options = mergeModules(this.options, modules);
-        this.implementationPromise ||= this.loadImplementation(options);
-        try {
-          this.implementation = await this.implementationPromise;
-          return this.implementation;
-        } catch (error) {
-          this.implementationPromise = null;
-          throw error;
-        }
-      }
-      /** Loads the selected concrete compressor. */
-      async loadImplementation(options) {
-        if (options.useNative !== false && this.nativeFormat && this.shouldUseNative(options) && isNativeCompressionSupported(this.nativeFormat)) {
-          const { NativeCompressor: NativeCompressor2 } = await Promise.resolve().then(() => (init_native_compressor(), native_compressor_exports));
-          return new NativeCompressor2(this, this.nativeFormat, options);
-        }
-        const Compressor2 = await this.loadFallback();
-        const implementation = new Compressor2({ ...options, useNative: false });
-        await implementation.preload(options.modules);
-        return implementation;
-      }
-      /** Compresses after lazily selecting the default implementation. */
-      async compress(input) {
-        return (await this.preload()).compress(input);
-      }
-      /** Compresses synchronously after an implementation has been preloaded. */
-      compressSync(input) {
-        if (!this.implementation) throw new Error(`${this.name}: call preload() before compressSync()`);
-        return this.implementation.compressSync(input);
-      }
-      /** Compresses batches after lazily selecting the default implementation. */
-      async *compressBatches(inputBatches) {
-        yield* (await this.preload()).compressBatches(inputBatches);
-      }
-    };
-    LazyDecompressor = class extends Decompressor {
-      name;
-      extensions;
-      contentEncodings;
-      isSupported = true;
-      /** Constructor options retained until a concrete implementation is selected. */
-      options;
-      /** Built-in stream format to probe, or null when the format has no built-in path. */
-      nativeFormat;
-      /** Returns whether built-in selection remains eligible for the merged preload options. */
-      shouldUseNative;
-      /** Dynamically imports the balanced fallback constructor. */
-      loadFallback;
-      /** Selected concrete implementation after preload completes. */
-      implementation = null;
-      /** Shared in-flight selection used by concurrent asynchronous calls. */
-      implementationPromise = null;
-      constructor(metadata, loadFallback, options = {}, nativeFormat = null, shouldUseNative = () => true) {
-        super(options);
-        this.name = metadata.name;
-        this.extensions = [...metadata.extensions];
-        this.contentEncodings = [...metadata.contentEncodings];
-        this.options = options;
-        this.nativeFormat = nativeFormat;
-        this.shouldUseNative = shouldUseNative;
-        this.loadFallback = loadFallback;
-      }
-      /** Selects and returns the built-in or dynamically imported fallback decompressor. */
-      async preload(modules = {}) {
-        if (this.implementation) return this.implementation;
-        const options = mergeModules(this.options, modules);
-        this.implementationPromise ||= this.loadImplementation(options);
-        try {
-          this.implementation = await this.implementationPromise;
-          return this.implementation;
-        } catch (error) {
-          this.implementationPromise = null;
-          throw error;
-        }
-      }
-      /** Loads the selected concrete decompressor. */
-      async loadImplementation(options) {
-        if (options.useNative !== false && this.nativeFormat && this.shouldUseNative(options) && isNativeDecompressionSupported(this.nativeFormat)) {
-          const { NativeDecompressor: NativeDecompressor2 } = await Promise.resolve().then(() => (init_native_decompressor(), native_decompressor_exports));
-          return new NativeDecompressor2(this, this.nativeFormat, options);
-        }
-        const Decompressor2 = await this.loadFallback();
-        const implementation = new Decompressor2({ ...options, useNative: false });
-        await implementation.preload(options.modules);
-        return implementation;
-      }
-      /** Decompresses after lazily selecting the default implementation. */
-      async decompress(input, size) {
-        return (await this.preload()).decompress(input, size);
-      }
-      /** Decompresses synchronously after an implementation has been preloaded. */
-      decompressSync(input, size) {
-        if (!this.implementation) {
-          throw new Error(`${this.name}: call preload() before decompressSync()`);
-        }
-        return this.implementation.decompressSync(input, size);
-      }
-      /** Decompresses batches after lazily selecting the default implementation. */
-      async *decompressBatches(inputBatches) {
-        yield* (await this.preload()).decompressBatches(inputBatches);
-      }
-    };
-  }
-});
-
 // ../compression/src/lib/fflate-stream.ts
 async function* transformFflateBatches(processor, inputBatches) {
   const chunks = [];
@@ -29234,7 +29234,7 @@ init_geoparquet_loader();
 
 // dist/parquet-js-loader-types.js
 init_parquet_format();
-var VERSION8 = true ? "5.0.0-alpha.10" : "latest";
+var VERSION8 = true ? "5.0.0-alpha.11" : "latest";
 var DEFAULT_PARQUET_JS_OPTIONS3 = {
   columns: void 0,
   preserveBinary: false,
@@ -29261,7 +29261,7 @@ var ParquetJSLoader2 = {
 
 // dist/parquet-source-loader-types.js
 init_parquet_format();
-var VERSION10 = true ? "5.0.0-alpha.10" : "latest";
+var VERSION10 = true ? "5.0.0-alpha.11" : "latest";
 async function preloadParquetSourceLoader2() {
   const { ParquetSourceLoaderWithParser: ParquetSourceLoaderWithParser2 } = await Promise.resolve().then(() => (init_parquet_source_loader(), parquet_source_loader_exports));
   return ParquetSourceLoaderWithParser2;
@@ -29385,7 +29385,7 @@ init_normalize_parquet_options2();
 init_parquet_format();
 
 // dist/lib/constants.js
-var VERSION11 = true ? "5.0.0-alpha.10" : "latest";
+var VERSION11 = true ? "5.0.0-alpha.11" : "latest";
 var PARQUET_MAGIC2 = "PAR1";
 var PARQUET_MAGIC_ENCRYPTED2 = "PARE";
 var PARQUET_RDLVL_TYPE2 = "INT32";
@@ -40258,7 +40258,7 @@ function formatDataType(dataType) {
 
 // dist/parquet-js-writer.js
 init_parquet_format();
-var VERSION12 = true ? "5.0.0-alpha.10" : "latest";
+var VERSION12 = true ? "5.0.0-alpha.11" : "latest";
 var DEFAULT_PARQUET_JS_OPTIONS4 = {};
 var ParquetJSWriter = {
   ...ParquetFormat,