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

package/dist/parquet-loader-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parquet-loader-options.d.ts","sourceRoot":"","sources":["../src/parquet-loader-options.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAC,mBAAmB,EAAC,oCAAiC;AAElE,mEAAmE;AACnE,KAAK,0BAA0B,GAAG;IAChC,6CAA6C;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sEAAsE;IACtE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,uEAAuE;IACvE,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEF,sEAAsE;AACtE,KAAK,wBAAwB,GAAG,0BAA0B,GAAG;IAC3D,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gEAAgE;IAChE,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,uDAAuD;IACvD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2DAA2D;IAC3D,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,iFAAiF;AACjF,MAAM,MAAM,oBAAoB,GAAG,aAAa,GAAG;IACjD,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,kBAAkB,GAAG,aAAa,CAAC;KAC5C,GAAG;SACD,GAAG,IAAI,MAAM,wBAAwB,CAAC,CAAC,EAAE,wBAAwB,CAAC,GAAG,CAAC;KACxE,CAAC;CACH,CAAC;AAEF,8EAA8E;AAC9E,MAAM,MAAM,sBAAsB,GAAG,aAAa,GAAG;IACnD,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,kBAAkB,GAAG,aAAa,CAAC;QAC3C,0EAA0E;QAC1E,YAAY,CAAC,EAAE,mBAAmB,CAAC;QACnC,+EAA+E;QAC/E,SAAS,CAAC,EAAE,UAAU,CAAC;QACvB,2EAA2E;QAC3E,qBAAqB,CAAC,EAAE,OAAO,CAAC;KACjC,GAAG;SACD,GAAG,IAAI,MAAM,0BAA0B,CAAC,CAAC,EAAE,0BAA0B,CAAC,GAAG,CAAC;KAC5E,CAAC;CACH,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,8BAA8B;;;;CAIjC,CAAC"}

package/dist/parquet-loader-options.js

@@ -0,0 +1,10 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/** Shared default option bag for the wasm-backed Parquet loaders. */
+export const PARQUET_LOADER_DEFAULT_OPTIONS = {
+    columns: undefined,
+    preserveBinary: false,
+    shape: 'arrow-table'
+};
+//# sourceMappingURL=parquet-loader-options.js.map

package/dist/parquet-loader-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parquet-loader-options.js","sourceRoot":"","sources":["../src/parquet-loader-options.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAsDpC,qEAAqE;AACrE,MAAM,CAAC,MAAM,8BAA8B,GAAG;IAC5C,OAAO,EAAE,SAAS;IAClB,cAAc,EAAE,KAAK;IACrB,KAAK,EAAE,aAAa;CACZ,CAAC"}

package/dist/parquet-loader-types.d.ts

@@ -0,0 +1,61 @@
+import type { ObjectRowTable, ObjectRowTableBatch, ArrowTable, ArrowTableBatch } from '@loaders.gl/schema';
+import type { ParquetLoaderOptions as SharedParquetLoaderOptions } from "./parquet-loader-options.js";
+/** Options for the Parquet loader. */
+export type ParquetLoaderOptions = SharedParquetLoaderOptions;
+/** Preloads the parser-bearing WASM Parquet loader implementation. */
+declare function preloadParquetLoader(): Promise<{
+    readonly parse: (arrayBuffer: ArrayBuffer, options?: SharedParquetLoaderOptions) => Promise<ObjectRowTable | ArrowTable>;
+    readonly parseFile: (file: import("@loaders.gl/loader-utils").ReadableFile, options?: SharedParquetLoaderOptions) => Promise<ObjectRowTable | ArrowTable>;
+    readonly parseFileInBatches: (file: import("@loaders.gl/loader-utils").ReadableFile, options?: SharedParquetLoaderOptions) => AsyncIterable<ObjectRowTableBatch | ArrowTableBatch>;
+    readonly parseInBatches: (asyncIterator: AsyncIterable<ArrayBufferLike | ArrayBufferView> | Iterable<ArrayBufferLike | ArrayBufferView>, options?: SharedParquetLoaderOptions, _context?: unknown) => AsyncGenerator<ObjectRowTableBatch | ArrowTableBatch, void, any>;
+    readonly serializeWorkerResult: typeof import("./lib/parquet-worker-transport").serializeParquetWorkerResult;
+    readonly deserializeWorkerResult: typeof import("./lib/parquet-worker-transport").deserializeParquetWorkerResult;
+    readonly worker: string | true;
+    readonly dataType: ObjectRowTable | ArrowTable;
+    readonly batchType: ObjectRowTableBatch | ArrowTableBatch;
+    readonly id: "parquet";
+    readonly module: "parquet";
+    readonly version: any;
+    readonly options: {
+        readonly parquet: {
+            readonly columns: undefined;
+            readonly preserveBinary: false;
+            readonly shape: "arrow-table";
+        };
+    };
+    readonly name: "Apache Parquet";
+    readonly category: "table";
+    readonly encoding: "parquet";
+    readonly format: "parquet";
+    readonly extensions: ["parquet"];
+    readonly mimeTypes: ["application/octet-stream"];
+    readonly binary: true;
+    readonly tests: ["PAR1", "PARE"];
+}>;
+/** Metadata-only Parquet table loader supporting object-row and Arrow table output. */
+export declare const ParquetLoader: {
+    readonly worker: string | true;
+    readonly preload: typeof preloadParquetLoader;
+    readonly dataType: ObjectRowTable | ArrowTable;
+    readonly batchType: ObjectRowTableBatch | ArrowTableBatch;
+    readonly id: "parquet";
+    readonly module: "parquet";
+    readonly version: any;
+    readonly options: {
+        readonly parquet: {
+            readonly columns: undefined;
+            readonly preserveBinary: false;
+            readonly shape: "arrow-table";
+        };
+    };
+    readonly name: "Apache Parquet";
+    readonly category: "table";
+    readonly encoding: "parquet";
+    readonly format: "parquet";
+    readonly extensions: ["parquet"];
+    readonly mimeTypes: ["application/octet-stream"];
+    readonly binary: true;
+    readonly tests: ["PAR1", "PARE"];
+};
+export {};
+//# sourceMappingURL=parquet-loader-types.d.ts.map

package/dist/parquet-loader-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parquet-loader-types.d.ts","sourceRoot":"","sources":["../src/parquet-loader-types.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,cAAc,EACd,mBAAmB,EACnB,UAAU,EACV,eAAe,EAChB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,KAAK,EAAC,oBAAoB,IAAI,0BAA0B,EAAC,oCAAiC;AAGjG,sCAAsC;AACtC,MAAM,MAAM,oBAAoB,GAAG,0BAA0B,CAAC;AAE9D,sEAAsE;AACtE,iBAAe,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGlC;AAED,uFAAuF;AACvF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;CAQzB,CAAC"}

package/dist/parquet-loader-types.js

@@ -0,0 +1,17 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { PARQUET_LOADER_BASE } from "./parquet-loader-base.js";
+import { PARQUET_WORKER_URL } from "./parquet-worker-url.js";
+/** Preloads the parser-bearing WASM Parquet loader implementation. */
+async function preloadParquetLoader() {
+    const { ParquetLoaderWithParser } = await import('@loaders.gl/parquet/parquet-loader');
+    return ParquetLoaderWithParser;
+}
+/** Metadata-only Parquet table loader supporting object-row and Arrow table output. */
+export const ParquetLoader = {
+    ...PARQUET_LOADER_BASE,
+    worker: PARQUET_WORKER_URL,
+    preload: preloadParquetLoader
+};
+//# sourceMappingURL=parquet-loader-types.js.map

package/dist/parquet-loader-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parquet-loader-types.js","sourceRoot":"","sources":["../src/parquet-loader-types.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAUpC,OAAO,EAAC,mBAAmB,EAAC,iCAA8B;AAE1D,OAAO,EAAC,kBAAkB,EAAC,gCAA6B;AAKxD,sEAAsE;AACtE,KAAK,UAAU,oBAAoB;IACjC,MAAM,EAAC,uBAAuB,EAAC,GAAG,MAAM,MAAM,CAAC,oCAAoC,CAAC,CAAC;IACrF,OAAO,uBAAuB,CAAC;AACjC,CAAC;AAED,uFAAuF;AACvF,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,GAAG,mBAAmB;IACtB,MAAM,EAAE,kBAAkB;IAC1B,OAAO,EAAE,oBAAoB;CAK9B,CAAC"}

package/dist/parquet-loader.d.ts

@@ -0,0 +1,42 @@
+import type { ObjectRowTable, ObjectRowTableBatch, ArrowTable, ArrowTableBatch } from '@loaders.gl/schema';
+import type { ReadableFile } from '@loaders.gl/loader-utils';
+import { deserializeParquetWorkerResult, serializeParquetWorkerResult } from "./lib/parquet-worker-transport.js";
+import type { ParquetLoaderOptions } from "./parquet-loader-options.js";
+export type { ParquetLoaderOptions } from "./parquet-loader-options.js";
+/** WASM-backed Parquet table loader supporting object-row and Arrow table output. */
+export declare const ParquetLoaderWithParser: {
+    readonly parse: (arrayBuffer: ArrayBuffer, options?: ParquetLoaderOptions) => Promise<ObjectRowTable | ArrowTable>;
+    readonly parseFile: (file: ReadableFile, options?: ParquetLoaderOptions) => Promise<ObjectRowTable | ArrowTable>;
+    readonly parseFileInBatches: (file: ReadableFile, options?: ParquetLoaderOptions) => AsyncIterable<ObjectRowTableBatch | ArrowTableBatch>;
+    readonly parseInBatches: (asyncIterator: AsyncIterable<ArrayBufferLike | ArrayBufferView> | Iterable<ArrayBufferLike | ArrayBufferView>, options?: ParquetLoaderOptions, _context?: unknown) => AsyncGenerator<ObjectRowTableBatch | ArrowTableBatch, void, any>;
+    readonly serializeWorkerResult: typeof serializeParquetWorkerResult;
+    readonly deserializeWorkerResult: typeof deserializeParquetWorkerResult;
+    readonly worker: string | true;
+    readonly dataType: ObjectRowTable | ArrowTable;
+    readonly batchType: ObjectRowTableBatch | ArrowTableBatch;
+    readonly id: "parquet";
+    readonly module: "parquet";
+    readonly version: any;
+    readonly options: {
+        readonly parquet: {
+            readonly columns: undefined;
+            readonly preserveBinary: false;
+            readonly shape: "arrow-table";
+        };
+    };
+    readonly name: "Apache Parquet";
+    readonly category: "table";
+    readonly encoding: "parquet";
+    readonly format: "parquet";
+    readonly extensions: ["parquet"];
+    readonly mimeTypes: ["application/octet-stream"];
+    readonly binary: true;
+    readonly tests: ["PAR1", "PARE"];
+};
+/**
+ * Normalizes caller options for the canonical WASM-backed Parquet loaders.
+ * @param options caller-supplied loader options
+ * @returns normalized loader options
+ */
+export declare function getParquetOptions(options?: ParquetLoaderOptions): ParquetLoaderOptions;
+//# sourceMappingURL=parquet-loader.d.ts.map

package/dist/parquet-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parquet-loader.d.ts","sourceRoot":"","sources":["../src/parquet-loader.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,cAAc,EACd,mBAAmB,EACnB,UAAU,EACV,eAAe,EAChB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,0BAA0B,CAAC;AAW3D,OAAO,EACL,8BAA8B,EAC9B,4BAA4B,EAC7B,0CAAuC;AAExC,OAAO,KAAK,EAAC,oBAAoB,EAAC,oCAAiC;AAEnE,YAAY,EAAC,oBAAoB,EAAC,oCAAiC;AAKnE,qFAAqF;AACrF,eAAO,MAAM,uBAAuB;kCAEf,WAAW,YAAY,oBAAoB;uDAGpC,oBAAoB;gEAGX,oBAAoB;6CAKjD,aAAa,CAAC,eAAe,GAAG,eAAe,CAAC,GAChD,QAAQ,CAAC,eAAe,GAAG,eAAe,CAAC,YACrC,oBAAoB,aACnB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;CAWrB,CAAC;AA4CF;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,oBAAoB,CAEtF"}

package/dist/parquet-loader.js

@@ -0,0 +1,68 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { BlobFile, concatenateArrayBuffersAsync } from '@loaders.gl/loader-utils';
+import { convertArrowBatchToObjectRows, convertArrowTableToObjectRows } from "./lib/parsers/convert-parquet-tables.js";
+import { parseParquetFileToArrow, parseParquetFileToArrowInBatches } from "./lib/parsers/parse-parquet-to-arrow.js";
+import { normalizeParquetOptions } from "./lib/utils/normalize-parquet-options.js";
+import { deserializeParquetWorkerResult, serializeParquetWorkerResult } from "./lib/parquet-worker-transport.js";
+import { ParquetLoader as ParquetLoaderMetadata } from "./parquet-loader-types.js";
+const { preload: _ParquetLoaderPreload, ...ParquetLoaderMetadataWithoutPreload } = ParquetLoaderMetadata;
+/** WASM-backed Parquet table loader supporting object-row and Arrow table output. */
+export const ParquetLoaderWithParser = {
+    ...ParquetLoaderMetadataWithoutPreload,
+    parse(arrayBuffer, options) {
+        return parseParquetTable(new BlobFile(arrayBuffer), options);
+    },
+    parseFile(file, options) {
+        return parseParquetTable(file, options);
+    },
+    parseFileInBatches(file, options) {
+        return parseParquetTableInBatches(file, options);
+    },
+    async *parseInBatches(asyncIterator, options, _context) {
+        const arrayBuffer = await concatenateArrayBuffersAsync(asyncIterator);
+        yield* parseParquetTableInBatches(new BlobFile(arrayBuffer), options);
+    },
+    serializeWorkerResult: serializeParquetWorkerResult,
+    deserializeWorkerResult: deserializeParquetWorkerResult
+};
+/**
+ * Parses a Parquet file using the canonical WASM-backed table loader.
+ * @param file readable file abstraction
+ * @param options optional loader options
+ * @returns object-row or Arrow table output depending on `parquet.shape`
+ */
+async function parseParquetTable(file, options) {
+    const parquetOptions = getParquetOptions(options);
+    if (parquetOptions.parquet?.shape === 'arrow-table') {
+        return await parseParquetFileToArrow(file, parquetOptions.parquet);
+    }
+    const arrowTable = await parseParquetFileToArrow(file, parquetOptions.parquet);
+    return convertArrowTableToObjectRows(arrowTable);
+}
+/**
+ * Parses a Parquet file into streamed table batches using the canonical WASM-backed loader.
+ * @param file readable file abstraction
+ * @param options optional loader options
+ * @returns async iterable of object-row or Arrow batches
+ */
+async function* parseParquetTableInBatches(file, options) {
+    const parquetOptions = getParquetOptions(options);
+    if (parquetOptions.parquet?.shape === 'arrow-table') {
+        yield* parseParquetFileToArrowInBatches(file, parquetOptions.parquet);
+        return;
+    }
+    for await (const batch of parseParquetFileToArrowInBatches(file, parquetOptions.parquet)) {
+        yield convertArrowBatchToObjectRows(batch);
+    }
+}
+/**
+ * Normalizes caller options for the canonical WASM-backed Parquet loaders.
+ * @param options caller-supplied loader options
+ * @returns normalized loader options
+ */
+export function getParquetOptions(options) {
+    return normalizeParquetOptions(options, ParquetLoaderWithParser.options.parquet);
+}
+//# sourceMappingURL=parquet-loader.js.map

package/dist/parquet-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parquet-loader.js","sourceRoot":"","sources":["../src/parquet-loader.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAGpC,OAAO,EAAC,QAAQ,EAAE,4BAA4B,EAAC,MAAM,0BAA0B,CAAC;AAShF,OAAO,EACL,6BAA6B,EAC7B,6BAA6B,EAC9B,gDAA6C;AAC9C,OAAO,EACL,uBAAuB,EACvB,gCAAgC,EACjC,gDAA6C;AAC9C,OAAO,EAAC,uBAAuB,EAAC,iDAA8C;AAC9E,OAAO,EACL,8BAA8B,EAC9B,4BAA4B,EAC7B,0CAAuC;AACxC,OAAO,EAAC,aAAa,IAAI,qBAAqB,EAAC,kCAA+B;AAK9E,MAAM,EAAC,OAAO,EAAE,qBAAqB,EAAE,GAAG,mCAAmC,EAAC,GAC5E,qBAAqB,CAAC;AAExB,qFAAqF;AACrF,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,GAAG,mCAAmC;IACtC,KAAK,CAAC,WAAwB,EAAE,OAA8B;QAC5D,OAAO,iBAAiB,CAAC,IAAI,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC,CAAC;IAC/D,CAAC;IACD,SAAS,CAAC,IAAI,EAAE,OAA8B;QAC5C,OAAO,iBAAiB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAC1C,CAAC;IACD,kBAAkB,CAAC,IAAI,EAAE,OAA8B;QACrD,OAAO,0BAA0B,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACnD,CAAC;IACD,KAAK,CAAC,CAAC,cAAc,CACnB,aAE+C,EAC/C,OAA8B,EAC9B,QAAkB;QAElB,MAAM,WAAW,GAAG,MAAM,4BAA4B,CAAC,aAAa,CAAC,CAAC;QACtE,KAAK,CAAC,CAAC,0BAA0B,CAAC,IAAI,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC,CAAC;IACxE,CAAC;IACD,qBAAqB,EAAE,4BAA4B;IACnD,uBAAuB,EAAE,8BAA8B;CAKxD,CAAC;AAEF;;;;;GAKG;AACH,KAAK,UAAU,iBAAiB,CAC9B,IAA6B,EAC7B,OAA8B;IAE9B,MAAM,cAAc,GAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC;IAElD,IAAI,cAAc,CAAC,OAAO,EAAE,KAAK,KAAK,aAAa,EAAE,CAAC;QACpD,OAAO,MAAM,uBAAuB,CAAC,IAAI,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;IACrE,CAAC;IAED,MAAM,UAAU,GAAG,MAAM,uBAAuB,CAAC,IAAI,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;IAC/E,OAAO,6BAA6B,CAAC,UAAU,CAAC,CAAC;AACnD,CAAC;AAED;;;;;GAKG;AACH,KAAK,SAAS,CAAC,CAAC,0BAA0B,CACxC,IAA6B,EAC7B,OAA8B;IAE9B,MAAM,cAAc,GAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC;IAElD,IAAI,cAAc,CAAC,OAAO,EAAE,KAAK,KAAK,aAAa,EAAE,CAAC;QACpD,KAAK,CAAC,CAAC,gCAAgC,CAAC,IAAI,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;QACtE,OAAO;IACT,CAAC;IAED,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,gCAAgC,CAAC,IAAI,EAAE,cAAc,CAAC,OAAO,CAAC,EAAE,CAAC;QACzF,MAAM,6BAA6B,CAAC,KAAK,CAAC,CAAC;IAC7C,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,OAA8B;IAC9D,OAAO,uBAAuB,CAAC,OAAO,EAAE,uBAAuB,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;AACnF,CAAC"}

package/dist/parquet-source-capabilities.d.ts

@@ -0,0 +1,43 @@
+import type { TableQueryCapabilities } from '@loaders.gl/loader-utils';
+/** Portable table-query capabilities of Parquet-backed scans. */
+export declare const PARQUET_TABLE_QUERY_CAPABILITIES: TableQueryCapabilities;
+/** Feature support advertised by a {@link ParquetSource}. */
+export type ParquetSourceCapabilities = Readonly<{
+    /** Common portable query contract supported by this source. */
+    tableQuery: TableQueryCapabilities;
+    /** Schema and footer metadata are cached for the lifetime of the source. */
+    supportsCachedMetadata: boolean;
+    /** Reads can select explicit Parquet row groups. */
+    supportsRowGroupSelection: boolean;
+    /** Reads can project explicit Parquet column paths. */
+    supportsColumnProjection: boolean;
+    /** Every emitted batch identifies its source row group and row offsets. */
+    supportsBatchProvenance: boolean;
+    /** Read cancellation is propagated cooperatively through the active stream. */
+    supportsCooperativeReadCancellation: boolean;
+    /** The package includes a local parquet-wasm binary for self-hosted delivery. */
+    supportsLocalWasmAsset: boolean;
+    /** Column min/max/null statistics are exposed in public metadata. */
+    supportsColumnStatistics: boolean;
+    /** Serializable predicates can prune impossible row groups using column statistics. */
+    supportsPredicatePushdown: boolean;
+    /** Column and offset indexes can avoid irrelevant data-page reads for non-repeated columns. */
+    supportsPageIndexPruning: boolean;
+    /** Native geospatial statistics and GeoParquet 1.1 coverings drive spatial pruning. */
+    supportsGeoParquetSpatialPruning: boolean;
+    /** Surviving decoded rows are filtered exactly on the caller thread or worker. */
+    supportsExactPredicateFiltering: boolean;
+    /** Callers can supply the random-access transport used by the source. */
+    supportsCustomRangeTransport: boolean;
+    /** Range requests validate that the source object version remains unchanged. */
+    supportsObjectVersionValidation: boolean;
+    /** Requested bytes, downloaded bytes, request counts, and network time are reported. */
+    supportsNetworkTelemetry: boolean;
+    /** Decoder time is reported separately from network and Arrow conversion time. */
+    supportsDecodeTelemetry: boolean;
+    /** Parquet decoding can run in a worker and transfer Arrow output. */
+    supportsWorkerDecoding: boolean;
+}>;
+/** Capabilities of the current range-backed TypeScript {@link ParquetSource}. */
+export declare const PARQUET_SOURCE_CAPABILITIES: ParquetSourceCapabilities;
+//# sourceMappingURL=parquet-source-capabilities.d.ts.map

package/dist/parquet-source-capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parquet-source-capabilities.d.ts","sourceRoot":"","sources":["../src/parquet-source-capabilities.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,sBAAsB,EAAC,MAAM,0BAA0B,CAAC;AAErE,iEAAiE;AACjE,eAAO,MAAM,gCAAgC,EAAE,sBAM7C,CAAC;AAEH,6DAA6D;AAC7D,MAAM,MAAM,yBAAyB,GAAG,QAAQ,CAAC;IAC/C,+DAA+D;IAC/D,UAAU,EAAE,sBAAsB,CAAC;IACnC,4EAA4E;IAC5E,sBAAsB,EAAE,OAAO,CAAC;IAChC,oDAAoD;IACpD,yBAAyB,EAAE,OAAO,CAAC;IACnC,uDAAuD;IACvD,wBAAwB,EAAE,OAAO,CAAC;IAClC,2EAA2E;IAC3E,uBAAuB,EAAE,OAAO,CAAC;IACjC,+EAA+E;IAC/E,mCAAmC,EAAE,OAAO,CAAC;IAC7C,iFAAiF;IACjF,sBAAsB,EAAE,OAAO,CAAC;IAChC,qEAAqE;IACrE,wBAAwB,EAAE,OAAO,CAAC;IAClC,uFAAuF;IACvF,yBAAyB,EAAE,OAAO,CAAC;IACnC,+FAA+F;IAC/F,wBAAwB,EAAE,OAAO,CAAC;IAClC,uFAAuF;IACvF,gCAAgC,EAAE,OAAO,CAAC;IAC1C,kFAAkF;IAClF,+BAA+B,EAAE,OAAO,CAAC;IACzC,yEAAyE;IACzE,4BAA4B,EAAE,OAAO,CAAC;IACtC,gFAAgF;IAChF,+BAA+B,EAAE,OAAO,CAAC;IACzC,wFAAwF;IACxF,wBAAwB,EAAE,OAAO,CAAC;IAClC,kFAAkF;IAClF,uBAAuB,EAAE,OAAO,CAAC;IACjC,sEAAsE;IACtE,sBAAsB,EAAE,OAAO,CAAC;CACjC,CAAC,CAAC;AAEH,iFAAiF;AACjF,eAAO,MAAM,2BAA2B,EAAE,yBAkBxC,CAAC"}

package/dist/parquet-source-capabilities.js

@@ -0,0 +1,32 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/** Portable table-query capabilities of Parquet-backed scans. */
+export const PARQUET_TABLE_QUERY_CAPABILITIES = Object.freeze({
+    projection: 'pushdown',
+    predicate: 'pushdown+residual',
+    limit: 'pushdown',
+    streaming: true,
+    cancellation: true
+});
+/** Capabilities of the current range-backed TypeScript {@link ParquetSource}. */
+export const PARQUET_SOURCE_CAPABILITIES = Object.freeze({
+    tableQuery: PARQUET_TABLE_QUERY_CAPABILITIES,
+    supportsCachedMetadata: true,
+    supportsRowGroupSelection: true,
+    supportsColumnProjection: true,
+    supportsBatchProvenance: true,
+    supportsCooperativeReadCancellation: true,
+    supportsLocalWasmAsset: true,
+    supportsColumnStatistics: true,
+    supportsPredicatePushdown: true,
+    supportsPageIndexPruning: true,
+    supportsGeoParquetSpatialPruning: true,
+    supportsExactPredicateFiltering: true,
+    supportsCustomRangeTransport: true,
+    supportsObjectVersionValidation: true,
+    supportsNetworkTelemetry: true,
+    supportsDecodeTelemetry: true,
+    supportsWorkerDecoding: true
+});
+//# sourceMappingURL=parquet-source-capabilities.js.map

package/dist/parquet-source-capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parquet-source-capabilities.js","sourceRoot":"","sources":["../src/parquet-source-capabilities.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAIpC,iEAAiE;AACjE,MAAM,CAAC,MAAM,gCAAgC,GAA2B,MAAM,CAAC,MAAM,CAAC;IACpF,UAAU,EAAE,UAAU;IACtB,SAAS,EAAE,mBAAmB;IAC9B,KAAK,EAAE,UAAU;IACjB,SAAS,EAAE,IAAI;IACf,YAAY,EAAE,IAAI;CACnB,CAAC,CAAC;AAwCH,iFAAiF;AACjF,MAAM,CAAC,MAAM,2BAA2B,GAA8B,MAAM,CAAC,MAAM,CAAC;IAClF,UAAU,EAAE,gCAAgC;IAC5C,sBAAsB,EAAE,IAAI;IAC5B,yBAAyB,EAAE,IAAI;IAC/B,wBAAwB,EAAE,IAAI;IAC9B,uBAAuB,EAAE,IAAI;IAC7B,mCAAmC,EAAE,IAAI;IACzC,sBAAsB,EAAE,IAAI;IAC5B,wBAAwB,EAAE,IAAI;IAC9B,yBAAyB,EAAE,IAAI;IAC/B,wBAAwB,EAAE,IAAI;IAC9B,gCAAgC,EAAE,IAAI;IACtC,+BAA+B,EAAE,IAAI;IACrC,4BAA4B,EAAE,IAAI;IAClC,+BAA+B,EAAE,IAAI;IACrC,wBAAwB,EAAE,IAAI;IAC9B,uBAAuB,EAAE,IAAI;IAC7B,sBAAsB,EAAE,IAAI;CAC7B,CAAC,CAAC"}

package/dist/parquet-source-loader-types.d.ts

@@ -0,0 +1,82 @@
+import type { CoreAPI, SourceLoader } from '@loaders.gl/loader-utils';
+import type { ParquetSource } from "./parquet-source-loader.js";
+import type { ParquetSourceLoaderOptions } from "./parquet-source-types.js";
+/** Loads the runtime Parquet source implementation from its explicit package subpath. */
+declare function preloadParquetSourceLoader(): Promise<SourceLoader<ParquetSource>>;
+/**
+ * Lightweight Parquet source metadata.
+ *
+ * Use with the async `load()` API, which preloads the implementation, or import the runtime source
+ * loader from `@loaders.gl/parquet/parquet-source-loader` for synchronous `createDataSource()`.
+ */
+export declare const ParquetSourceLoader: {
+    readonly dataType: ParquetSource;
+    readonly batchType: never;
+    readonly name: "ParquetSourceLoader";
+    readonly id: "parquet-source";
+    readonly module: "parquet";
+    readonly version: any;
+    readonly type: "parquet";
+    readonly fromUrl: true;
+    readonly fromBlob: true;
+    readonly options: {
+        readonly parquet: {
+            readonly rowGroups: undefined;
+            readonly columns: undefined;
+            readonly batchSize: undefined;
+            readonly concurrency: undefined;
+            readonly rowGroupFilter: undefined;
+            readonly predicate: undefined;
+            readonly bbox: undefined;
+            readonly geometryColumn: undefined;
+            readonly headers: undefined;
+            readonly preserveBinary: false;
+            readonly verifyPageChecksums: false;
+            readonly verifyFooterSignature: true;
+            readonly onTelemetry: undefined;
+            readonly workerUrl: undefined;
+            readonly wasmUrl: undefined;
+        };
+        readonly rangeRequests: {
+            readonly batchDelayMs: 0;
+            readonly maxGapBytes: 0;
+            readonly rangeExpansionBytes: 0;
+        };
+    };
+    readonly defaultOptions: {
+        readonly parquet: {
+            readonly rowGroups: never;
+            readonly columns: never;
+            readonly batchSize: never;
+            readonly concurrency: never;
+            readonly rowGroupFilter: never;
+            readonly predicate: never;
+            readonly bbox: never;
+            readonly geometryColumn: never;
+            readonly headers: never;
+            readonly preserveBinary: false;
+            readonly verifyPageChecksums: false;
+            readonly verifyFooterSignature: true;
+            readonly onTelemetry: never;
+            readonly workerUrl: never;
+            readonly wasmUrl: never;
+        };
+        readonly rangeRequests: {
+            readonly batchDelayMs: 0;
+            readonly maxGapBytes: 0;
+            readonly rangeExpansionBytes: 0;
+        };
+    };
+    readonly testURL: (url: string) => boolean;
+    readonly preload: typeof preloadParquetSourceLoader;
+    readonly createDataSource: (_data: string | Blob, _options: ParquetSourceLoaderOptions, _coreApi?: CoreAPI) => ParquetSource;
+    readonly category: "table";
+    readonly encoding: "parquet";
+    readonly format: "parquet";
+    readonly extensions: ["parquet"];
+    readonly mimeTypes: ["application/octet-stream"];
+    readonly binary: true;
+    readonly tests: ["PAR1", "PARE"];
+};
+export {};
+//# sourceMappingURL=parquet-source-loader-types.d.ts.map

package/dist/parquet-source-loader-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parquet-source-loader-types.d.ts","sourceRoot":"","sources":["../src/parquet-source-loader-types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,OAAO,EAAE,YAAY,EAAC,MAAM,0BAA0B,CAAC;AAGpE,OAAO,KAAK,EAAC,aAAa,EAAC,mCAAgC;AAC3D,OAAO,KAAK,EAAC,0BAA0B,EAAC,kCAA+B;AAMvE,yFAAyF;AACzF,iBAAe,0BAA0B,IAAI,OAAO,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC,CAGhF;AAED;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;uBAED,aAAa;wBACvB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAwDT,MAAM,KAAG,OAAO;;uCAGtB,MAAM,GAAG,IAAI,YACV,0BAA0B,aACzB,OAAO,KACjB,aAAa;;;;;;;;CAK8B,CAAC"}

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

@@ -0,0 +1,84 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { ParquetFormat } from "./parquet-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';
+/** Loads the runtime Parquet source implementation from its explicit package subpath. */
+async function preloadParquetSourceLoader() {
+    const { ParquetSourceLoaderWithParser } = await import('@loaders.gl/parquet/parquet-source-loader');
+    return ParquetSourceLoaderWithParser;
+}
+/**
+ * Lightweight Parquet source metadata.
+ *
+ * Use with the async `load()` API, which preloads the implementation, or import the runtime source
+ * loader from `@loaders.gl/parquet/parquet-source-loader` for synchronous `createDataSource()`.
+ */
+export const ParquetSourceLoader = {
+    ...ParquetFormat,
+    dataType: null,
+    batchType: null,
+    name: 'ParquetSourceLoader',
+    id: 'parquet-source',
+    module: 'parquet',
+    version: VERSION,
+    type: 'parquet',
+    fromUrl: true,
+    fromBlob: true,
+    options: {
+        parquet: {
+            rowGroups: undefined,
+            columns: undefined,
+            batchSize: undefined,
+            concurrency: undefined,
+            rowGroupFilter: undefined,
+            predicate: undefined,
+            bbox: undefined,
+            geometryColumn: undefined,
+            headers: undefined,
+            preserveBinary: false,
+            verifyPageChecksums: false,
+            verifyFooterSignature: true,
+            onTelemetry: undefined,
+            workerUrl: undefined,
+            wasmUrl: undefined
+        },
+        rangeRequests: {
+            batchDelayMs: 0,
+            maxGapBytes: 0,
+            rangeExpansionBytes: 0
+        }
+    },
+    defaultOptions: {
+        parquet: {
+            rowGroups: undefined,
+            columns: undefined,
+            batchSize: undefined,
+            concurrency: undefined,
+            rowGroupFilter: undefined,
+            predicate: undefined,
+            bbox: undefined,
+            geometryColumn: undefined,
+            headers: undefined,
+            preserveBinary: false,
+            verifyPageChecksums: false,
+            verifyFooterSignature: true,
+            onTelemetry: undefined,
+            workerUrl: undefined,
+            wasmUrl: undefined
+        },
+        rangeRequests: {
+            batchDelayMs: 0,
+            maxGapBytes: 0,
+            rangeExpansionBytes: 0
+        }
+    },
+    testURL: (url) => /\.parquet(?:$|[?#])/i.test(url),
+    preload: preloadParquetSourceLoader,
+    createDataSource(_data, _options, _coreApi) {
+        throw new Error('ParquetSourceLoader requires async load() or an explicit @loaders.gl/parquet/parquet-source-loader import');
+    }
+};
+//# sourceMappingURL=parquet-source-loader-types.js.map

package/dist/parquet-source-loader-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parquet-source-loader-types.js","sourceRoot":"","sources":["../src/parquet-source-loader-types.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAIpC,OAAO,EAAC,aAAa,EAAC,4BAAyB;AAI/C,yDAAyD;AACzD,qDAAqD;AACrD,MAAM,OAAO,GAAG,uBAAkB,KAAK,WAAW,CAAC,CAAC,kBAAa,CAAC,CAAC,QAAQ,CAAC;AAE5E,yFAAyF;AACzF,KAAK,UAAU,0BAA0B;IACvC,MAAM,EAAC,6BAA6B,EAAC,GAAG,MAAM,MAAM,CAAC,2CAA2C,CAAC,CAAC;IAClG,OAAO,6BAA6B,CAAC;AACvC,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,GAAG,aAAa;IAChB,QAAQ,EAAE,IAAgC;IAC1C,SAAS,EAAE,IAAa;IACxB,IAAI,EAAE,qBAAqB;IAC3B,EAAE,EAAE,gBAAgB;IACpB,MAAM,EAAE,SAAS;IACjB,OAAO,EAAE,OAAO;IAChB,IAAI,EAAE,SAAS;IACf,OAAO,EAAE,IAAI;IACb,QAAQ,EAAE,IAAI;IACd,OAAO,EAAE;QACP,OAAO,EAAE;YACP,SAAS,EAAE,SAAS;YACpB,OAAO,EAAE,SAAS;YAClB,SAAS,EAAE,SAAS;YACpB,WAAW,EAAE,SAAS;YACtB,cAAc,EAAE,SAAS;YACzB,SAAS,EAAE,SAAS;YACpB,IAAI,EAAE,SAAS;YACf,cAAc,EAAE,SAAS;YACzB,OAAO,EAAE,SAAS;YAClB,cAAc,EAAE,KAAK;YACrB,mBAAmB,EAAE,KAAK;YAC1B,qBAAqB,EAAE,IAAI;YAC3B,WAAW,EAAE,SAAS;YACtB,SAAS,EAAE,SAAS;YACpB,OAAO,EAAE,SAAS;SACnB;QACD,aAAa,EAAE;YACb,YAAY,EAAE,CAAC;YACf,WAAW,EAAE,CAAC;YACd,mBAAmB,EAAE,CAAC;SACvB;KACF;IACD,cAAc,EAAE;QACd,OAAO,EAAE;YACP,SAAS,EAAE,SAAU;YACrB,OAAO,EAAE,SAAU;YACnB,SAAS,EAAE,SAAU;YACrB,WAAW,EAAE,SAAU;YACvB,cAAc,EAAE,SAAU;YAC1B,SAAS,EAAE,SAAU;YACrB,IAAI,EAAE,SAAU;YAChB,cAAc,EAAE,SAAU;YAC1B,OAAO,EAAE,SAAU;YACnB,cAAc,EAAE,KAAK;YACrB,mBAAmB,EAAE,KAAK;YAC1B,qBAAqB,EAAE,IAAI;YAC3B,WAAW,EAAE,SAAU;YACvB,SAAS,EAAE,SAAU;YACrB,OAAO,EAAE,SAAU;SACpB;QACD,aAAa,EAAE;YACb,YAAY,EAAE,CAAC;YACf,WAAW,EAAE,CAAC;YACd,mBAAmB,EAAE,CAAC;SACvB;KACF;IACD,OAAO,EAAE,CAAC,GAAW,EAAW,EAAE,CAAC,sBAAsB,CAAC,IAAI,CAAC,GAAG,CAAC;IACnE,OAAO,EAAE,0BAA0B;IACnC,gBAAgB,CACd,KAAoB,EACpB,QAAoC,EACpC,QAAkB;QAElB,MAAM,IAAI,KAAK,CACb,2GAA2G,CAC5G,CAAC;IACJ,CAAC;CAC6C,CAAC"}