@loaders.gl/parquet 4.3.2 → 4.4.0-alpha.2

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 export { Buffer } from "./polyfills/buffer/install-buffer-polyfill.js";
-export { ParquetWorkerLoader, ParquetLoader, GeoParquetWorkerLoader, GeoParquetLoader, ParquetColumnarWorkerLoader, ParquetColumnarLoader } from "./parquet-loader.js";
-export { ParquetWriter as _ParquetWriter } from "./parquet-writer.js";
-export type { ParquetWasmLoaderOptions } from "./parquet-wasm-loader.js";
-export { ParquetWasmLoader, ParquetWasmWorkerLoader } from "./parquet-wasm-loader.js";
-export { ParquetWasmWriter } from "./parquet-wasm-writer.js";
+export { ParquetFormat } from "./parquet-format.js";
+export { ParquetJSONWorkerLoader, ParquetJSONLoader, GeoParquetWorkerLoader, GeoParquetLoader, ParquetJSONWorkerLoader as ParquetWorkerLoader, ParquetJSONLoader as ParquetLoader } from "./parquet-json-loader.js";
+export { ParquetJSONWriter as _ParquetJSONWriter, ParquetJSONWriter as ParquetWriter } from "./parquet-json-writer.js";
+export type { ParquetArrowLoaderOptions } from "./parquet-arrow-loader.js";
+export { ParquetArrowLoader, ParquetArrowWorkerLoader } from "./parquet-arrow-loader.js";
+export { ParquetArrowWriter } from "./parquet-arrow-writer.js";
 export { preloadCompressions } from "./parquetjs/compression.js";
 export { ParquetSchema } from "./parquetjs/schema/schema.js";
 export { ParquetReader } from "./parquetjs/parser/parquet-reader.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,MAAM,EAAC,sDAAmD;AAIlE,OAAO,EACL,mBAAmB,EACnB,aAAa,EACb,sBAAsB,EACtB,gBAAgB,EAChB,2BAA2B,EAC3B,qBAAqB,EACtB,4BAAyB;AAE1B,OAAO,EAAC,aAAa,IAAI,cAAc,EAAC,4BAAyB;AAIjE,YAAY,EAAC,wBAAwB,EAAC,iCAA8B;AACpE,OAAO,EAAC,iBAAiB,EAAE,uBAAuB,EAAC,iCAA8B;AACjF,OAAO,EAAC,iBAAiB,EAAC,iCAA8B;AAIxD,OAAO,EAAC,mBAAmB,EAAC,mCAAgC;AAE5D,OAAO,EAAC,aAAa,EAAC,qCAAkC;AACxD,OAAO,EAAC,aAAa,EAAC,6CAA0C;AAChE,OAAO,EAAC,cAAc,EAAC,+CAA4C;AAEnE,OAAO,EACL,oBAAoB,EACpB,oBAAoB,IAAI,2BAA2B,EACpD,mDAAgD;AAGjD,OAAO,EAAC,cAAc,EAAE,qBAAqB,EAAC,oCAAiC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,MAAM,EAAC,sDAAmD;AAIlE,OAAO,EAAC,aAAa,EAAC,4BAAyB;AAE/C,OAAO,EACL,uBAAuB,EACvB,iBAAiB,EACjB,sBAAsB,EACtB,gBAAgB,EAEhB,uBAAuB,IAAI,mBAAmB,EAC9C,iBAAiB,IAAI,aAAa,EACnC,iCAA8B;AAE/B,OAAO,EACL,iBAAiB,IAAI,kBAAkB,EAEvC,iBAAiB,IAAI,aAAa,EACnC,iCAA8B;AAI/B,YAAY,EAAC,yBAAyB,EAAC,kCAA+B;AACtE,OAAO,EAAC,kBAAkB,EAAE,wBAAwB,EAAC,kCAA+B;AACpF,OAAO,EAAC,kBAAkB,EAAC,kCAA+B;AAI1D,OAAO,EAAC,mBAAmB,EAAC,mCAAgC;AAE5D,OAAO,EAAC,aAAa,EAAC,qCAAkC;AACxD,OAAO,EAAC,aAAa,EAAC,6CAA0C;AAChE,OAAO,EAAC,cAAc,EAAC,+CAA4C;AAEnE,OAAO,EACL,oBAAoB,EACpB,oBAAoB,IAAI,2BAA2B,EACpD,mDAAgD;AAGjD,OAAO,EAAC,cAAc,EAAE,qBAAqB,EAAC,oCAAiC"}

package/dist/index.js

@@ -3,10 +3,15 @@
 // Copyright (c) vis.gl contributors
 export { Buffer } from "./polyfills/buffer/install-buffer-polyfill.js";
 // import {ArrowTable, ArrowTableBatch} from '@loaders.gl/arrow';
-export { ParquetWorkerLoader, ParquetLoader, GeoParquetWorkerLoader, GeoParquetLoader, ParquetColumnarWorkerLoader, ParquetColumnarLoader } from "./parquet-loader.js";
-export { ParquetWriter as _ParquetWriter } from "./parquet-writer.js";
-export { ParquetWasmLoader, ParquetWasmWorkerLoader } from "./parquet-wasm-loader.js";
-export { ParquetWasmWriter } from "./parquet-wasm-writer.js";
+export { ParquetFormat } from "./parquet-format.js";
+export { ParquetJSONWorkerLoader, ParquetJSONLoader, GeoParquetWorkerLoader, GeoParquetLoader, 
+// deprecated
+ParquetJSONWorkerLoader as ParquetWorkerLoader, ParquetJSONLoader as ParquetLoader } from "./parquet-json-loader.js";
+export { ParquetJSONWriter as _ParquetJSONWriter, 
+// deprecated
+ParquetJSONWriter as ParquetWriter } from "./parquet-json-writer.js";
+export { ParquetArrowLoader, ParquetArrowWorkerLoader } from "./parquet-arrow-loader.js";
+export { ParquetArrowWriter } from "./parquet-arrow-writer.js";
 // EXPERIMENTAL - expose the internal parquetjs API
 export { preloadCompressions } from "./parquetjs/compression.js";
 export { ParquetSchema } from "./parquetjs/schema/schema.js";

package/dist/lib/constants.js

@@ -3,7 +3,7 @@
 // Copyright (c) vis.gl contributors
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
-export const VERSION = typeof "4.3.1" !== 'undefined' ? "4.3.1" : 'latest';
+export const VERSION = typeof "4.4.0-alpha.1" !== 'undefined' ? "4.4.0-alpha.1" : 'latest';
 export const PARQUET_WASM_URL = 'https://unpkg.com/parquet-wasm@0.6.1/esm/parquet_wasm_bg.wasm';
 /**
  * Parquet File Magic String

package/dist/lib/encoders/encode-arrow-to-parquet.d.ts

@@ -0,0 +1,7 @@
+import type { ArrowTable } from '@loaders.gl/schema';
+import type { ParquetArrowWriterOptions } from "../../parquet-arrow-writer.js";
+/**
+ * Encode Arrow arrow.Table to Parquet buffer
+ */
+export declare function encodeArrowToParquet(table: ArrowTable, options: ParquetArrowWriterOptions): Promise<ArrayBuffer>;
+//# sourceMappingURL=encode-arrow-to-parquet.d.ts.map

package/dist/lib/encoders/encode-arrow-to-parquet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode-arrow-to-parquet.d.ts","sourceRoot":"","sources":["../../../src/lib/encoders/encode-arrow-to-parquet.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAKnD,OAAO,KAAK,EAAC,yBAAyB,EAAC,sCAAmC;AAE1E;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,WAAW,CAAC,CAsBtB"}

package/dist/lib/encoders/{encode-parquet-wasm.js → encode-arrow-to-parquet.js}

@@ -6,7 +6,7 @@ import { loadWasm } from "../utils/load-wasm.js";
 /**
  * Encode Arrow arrow.Table to Parquet buffer
  */
-export async function encode(table, options) {
+export async function encodeArrowToParquet(table, options) {
     const wasmUrl = options.parquet?.wasmUrl;
     const wasm = await loadWasm(wasmUrl);
     // Serialize the table to the IPC format.

package/dist/lib/parsers/get-parquet-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-parquet-schema.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/get-parquet-schema.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,MAAM,EAAC,MAAM,oBAAoB,CAAC;AAC1C,OAAO,EAAC,aAAa,EAAC,iDAA8C;AAIpE,wBAAsB,0BAA0B,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAOvF"}
+{"version":3,"file":"get-parquet-schema.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/get-parquet-schema.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,MAAM,EAAC,MAAM,oBAAoB,CAAC;AAE1C,OAAO,EAAC,aAAa,EAAC,iDAA8C;AAGpE,wBAAsB,0BAA0B,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAOvF"}

package/dist/lib/parsers/get-parquet-schema.js

@@ -1,13 +1,13 @@
 // loaders.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
+import { unpackGeoMetadata, unpackJSONStringMetadata } from '@loaders.gl/geoarrow';
 import { convertParquetSchema } from "../arrow/convert-schema-from-parquet.js";
-import { unpackGeoMetadata, unpackJSONStringMetadata } from '@loaders.gl/gis';
 export async function getSchemaFromParquetReader(reader) {
     const parquetSchema = await reader.getSchema();
     const parquetMetadata = await reader.getFileMetadata();
     const schema = convertParquetSchema(parquetSchema, parquetMetadata);
-    unpackGeoMetadata(schema);
-    unpackJSONStringMetadata(schema, 'pandas');
+    unpackGeoMetadata(schema.metadata);
+    unpackJSONStringMetadata(schema.metadata, 'pandas');
     return schema;
 }

package/dist/lib/parsers/parse-geoparquet-to-geojson.d.ts

@@ -0,0 +1,6 @@
+import type { ReadableFile } from '@loaders.gl/loader-utils';
+import type { GeoJSONTable, GeoJSONTableBatch, ObjectRowTable, ObjectRowTableBatch } from '@loaders.gl/schema';
+import type { ParquetJSONLoaderOptions } from "../../parquet-json-loader.js";
+export declare function parseGeoParquetFile(file: ReadableFile, options?: ParquetJSONLoaderOptions): Promise<ObjectRowTable | GeoJSONTable>;
+export declare function parseGeoParquetFileInBatches(file: ReadableFile, options?: ParquetJSONLoaderOptions): AsyncIterable<ObjectRowTableBatch | GeoJSONTableBatch>;
+//# sourceMappingURL=parse-geoparquet-to-geojson.d.ts.map

package/dist/lib/parsers/parse-geoparquet-to-geojson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-geoparquet-to-geojson.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-geoparquet-to-geojson.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,0BAA0B,CAAC;AAC3D,OAAO,KAAK,EACV,YAAY,EACZ,iBAAiB,EACjB,cAAc,EACd,mBAAmB,EACpB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,KAAK,EAAC,wBAAwB,EAAC,qCAAkC;AAIxE,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,YAAY,EAClB,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,cAAc,GAAG,YAAY,CAAC,CAIxC;AAED,wBAAuB,4BAA4B,CACjD,IAAI,EAAE,YAAY,EAClB,OAAO,CAAC,EAAE,wBAAwB,GACjC,aAAa,CAAC,mBAAmB,GAAG,iBAAiB,CAAC,CAMxD"}

package/dist/lib/parsers/parse-geoparquet-to-geojson.js

@@ -0,0 +1,15 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { parseParquetFile, parseParquetFileInBatches } from "./parse-parquet-to-json.js";
+export async function parseGeoParquetFile(file, options) {
+    const table = await parseParquetFile(file, { ...options, shape: 'object-row-table' });
+    // return convertGeoArrowToTable(table, 'geojson-table');
+    return table;
+}
+export async function* parseGeoParquetFileInBatches(file, options) {
+    const tableBatches = parseParquetFileInBatches(file, { ...options, shape: 'object-row-table' });
+    for await (const batch of tableBatches) {
+        yield batch; // convertGeoArrowToTable(batch, 'geojson-table');
+    }
+}

package/dist/lib/parsers/{parse-parquet-wasm.d.ts → parse-parquet-to-arrow.d.ts}

@@ -1,10 +1,10 @@
 import type { ReadableFile } from '@loaders.gl/loader-utils';
 import type { ArrowTable, ArrowTableBatch } from '@loaders.gl/schema';
 import type * as parquetWasm from 'parquet-wasm';
-export declare function parseParquetFileWasm(file: ReadableFile, options?: parquetWasm.ReaderOptions & {
+export declare function parseParquetFileToArrow(file: ReadableFile, options?: parquetWasm.ReaderOptions & {
     wasmUrl: string;
 }): Promise<ArrowTable>;
-export declare function parseParquetFileInBatchesWasm(file: ReadableFile, options: parquetWasm.ReaderOptions & {
+export declare function parseParquetFileToArrowInBatches(file: ReadableFile, options: parquetWasm.ReaderOptions & {
     wasmUrl: string;
 }): AsyncIterable<ArrowTableBatch>;
-//# sourceMappingURL=parse-parquet-wasm.d.ts.map
+//# sourceMappingURL=parse-parquet-to-arrow.d.ts.map

package/dist/lib/parsers/parse-parquet-to-arrow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-parquet-to-arrow.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-parquet-to-arrow.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,0BAA0B,CAAC;AAC3D,OAAO,KAAK,EAAC,UAAU,EAAE,eAAe,EAAS,MAAM,oBAAoB,CAAC;AAG5E,OAAO,KAAK,KAAK,WAAW,MAAM,cAAc,CAAC;AAMjD,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,YAAY,EAClB,OAAO,CAAC,EAAE,WAAW,CAAC,aAAa,GAAG;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,GACtD,OAAO,CAAC,UAAU,CAAC,CAsBrB;AAED,wBAAuB,gCAAgC,CACrD,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE,WAAW,CAAC,aAAa,GAAG;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,GACrD,aAAa,CAAC,eAAe,CAAC,CA0BhC"}

package/dist/lib/parsers/{parse-parquet-wasm.js → parse-parquet-to-arrow.js}

@@ -1,11 +1,11 @@
 // loaders.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { serializeArrowSchema } from '@loaders.gl/arrow';
+import { convertArrowToSchema } from '@loaders.gl/schema-utils';
 import * as arrow from 'apache-arrow';
 import { loadWasm } from "../utils/load-wasm.js";
 import { makeStreamIterator } from "../utils/make-stream-iterator.js";
-export async function parseParquetFileWasm(file, options) {
+export async function parseParquetFileToArrow(file, options) {
     const wasmUrl = options?.wasmUrl;
     const wasm = await loadWasm(wasmUrl);
     let parquetFile;
@@ -21,11 +21,11 @@ export async function parseParquetFileWasm(file, options) {
     const arrowTable = arrow.tableFromIPC(ipcStream);
     return {
         shape: 'arrow-table',
-        schema: serializeArrowSchema(arrowTable.schema),
+        schema: convertArrowToSchema(arrowTable.schema),
         data: arrowTable
     };
 }
-export async function* parseParquetFileInBatchesWasm(file, options) {
+export async function* parseParquetFileToArrowInBatches(file, options) {
     const wasmUrl = options?.wasmUrl;
     const wasm = await loadWasm(wasmUrl);
     let parquetFile;
@@ -38,14 +38,14 @@ export async function* parseParquetFileInBatchesWasm(file, options) {
     }
     const stream = await parquetFile.stream(options);
     let schema;
-    for await (const table of makeStreamIterator(stream)) {
-        schema ||= serializeArrowSchema(table.schema);
+    for await (const recordBatch of makeStreamIterator(stream)) {
+        schema ||= convertArrowToSchema(recordBatch.schema);
         yield {
             batchType: 'data',
             shape: 'arrow-table',
             schema,
-            data: table.batches[0],
-            length: table.numRows
+            data: new arrow.Table(recordBatch),
+            length: recordBatch.numRows
         };
     }
 }

package/dist/lib/parsers/parse-parquet-to-columns.d.ts

@@ -1,12 +1,12 @@
 import type { ColumnarTable, ColumnarTableBatch } from '@loaders.gl/schema';
 import type { ReadableFile } from '@loaders.gl/loader-utils';
-import type { ParquetLoaderOptions } from "../../parquet-loader.js";
+import type { ParquetJSONLoaderOptions } from "../../parquet-json-loader.js";
 /**
- * @deprecated
+ * @deprecated - Use parseParquetToArrow
  */
-export declare function parseParquetFileInColumns(file: ReadableFile, options?: ParquetLoaderOptions): Promise<ColumnarTable>;
+export declare function parseParquetFileInColumns(file: ReadableFile, options?: ParquetJSONLoaderOptions): Promise<ColumnarTable>;
 /**
  * @deprecated
  */
-export declare function parseParquetFileInColumnarBatches(file: ReadableFile, options?: ParquetLoaderOptions): AsyncIterable<ColumnarTableBatch>;
+export declare function parseParquetFileInColumnarBatches(file: ReadableFile, options?: ParquetJSONLoaderOptions): AsyncIterable<ColumnarTableBatch>;
 //# sourceMappingURL=parse-parquet-to-columns.d.ts.map

package/dist/lib/parsers/parse-parquet-to-columns.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-parquet-to-columns.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-parquet-to-columns.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,aAAa,EAAE,kBAAkB,EAAS,MAAM,oBAAoB,CAAC;AAClF,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,0BAA0B,CAAC;AAC3D,OAAO,KAAK,EAAC,oBAAoB,EAAC,gCAA6B;AAS/D;;GAEG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,YAAY,EAClB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CAAC,aAAa,CAAC,CAYxB;AAED;;GAEG;AACH,wBAAuB,iCAAiC,CACtD,IAAI,EAAE,YAAY,EAClB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,aAAa,CAAC,kBAAkB,CAAC,CAgBnC"}
+{"version":3,"file":"parse-parquet-to-columns.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-parquet-to-columns.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,aAAa,EAAE,kBAAkB,EAAS,MAAM,oBAAoB,CAAC;AAClF,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,0BAA0B,CAAC;AAC3D,OAAO,KAAK,EAAC,wBAAwB,EAAC,qCAAkC;AASxE;;GAEG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,YAAY,EAClB,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,aAAa,CAAC,CAYxB;AAED;;GAEG;AACH,wBAAuB,iCAAiC,CACtD,IAAI,EAAE,YAAY,EAClB,OAAO,CAAC,EAAE,wBAAwB,GACjC,aAAa,CAAC,kBAAkB,CAAC,CAgBnC"}

package/dist/lib/parsers/parse-parquet-to-columns.js

@@ -7,7 +7,7 @@ import { getSchemaFromParquetReader } from "./get-parquet-schema.js";
 import { installBufferPolyfill } from "../../polyfills/buffer/index.js";
 import { preloadCompressions } from "../../parquetjs/compression.js";
 /**
- * @deprecated
+ * @deprecated - Use parseParquetToArrow
  */
 export async function parseParquetFileInColumns(file, options) {
     installBufferPolyfill();

package/dist/lib/parsers/{parse-parquet.d.ts → parse-parquet-to-json.d.ts}

@@ -1,17 +1,17 @@
 import type { ReadableFile } from '@loaders.gl/loader-utils';
 import type { ObjectRowTable, ObjectRowTableBatch } from '@loaders.gl/schema';
-import type { ParquetLoaderOptions } from "../../parquet-loader.js";
+import type { ParquetJSONLoaderOptions } from "../../parquet-json-loader.js";
 /**
  *  * Parse a parquet file using parquetjs
  * @param file
  * @param options
  * @returns
  */
-export declare function parseParquetFile(file: ReadableFile, options?: ParquetLoaderOptions): Promise<ObjectRowTable>;
+export declare function parseParquetFile(file: ReadableFile, options?: ParquetJSONLoaderOptions): Promise<ObjectRowTable>;
 /**
  * Parse a parquet file in batches using parquetjs
  * @param file
  * @param options
  */
-export declare function parseParquetFileInBatches(file: ReadableFile, options?: ParquetLoaderOptions): AsyncIterable<ObjectRowTableBatch>;
-//# sourceMappingURL=parse-parquet.d.ts.map
+export declare function parseParquetFileInBatches(file: ReadableFile, options?: ParquetJSONLoaderOptions): AsyncIterable<ObjectRowTableBatch>;
+//# sourceMappingURL=parse-parquet-to-json.d.ts.map

package/dist/lib/parsers/parse-parquet-to-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-parquet-to-json.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-parquet-to-json.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,0BAA0B,CAAC;AAC3D,OAAO,KAAK,EAAC,cAAc,EAAE,mBAAmB,EAAC,MAAM,oBAAoB,CAAC;AAE5E,OAAO,KAAK,EAAC,wBAAwB,EAAC,qCAAkC;AAOxE;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,YAAY,EAClB,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,cAAc,CAAC,CAmCzB;AAED;;;;GAIG;AACH,wBAAuB,yBAAyB,CAC9C,IAAI,EAAE,YAAY,EAClB,OAAO,CAAC,EAAE,wBAAwB,GACjC,aAAa,CAAC,mBAAmB,CAAC,CAwBpC"}

package/dist/lib/parsers/{parse-parquet.js → parse-parquet-to-json.js}

@@ -41,8 +41,7 @@ export async function parseParquetFile(file, options) {
         schema,
         data: rows
     };
-    const shape = options?.parquet?.shape;
-    return convertTable(objectRowTable, shape);
+    return objectRowTable;
 }
 /**
  * Parse a parquet file in batches using parquetjs
@@ -63,24 +62,11 @@ export async function* parseParquetFileInBatches(file, options) {
             schema,
             data: rows
         };
-        const shape = options?.parquet?.shape;
-        const table = convertTable(objectRowTable, shape);
         yield {
             batchType: 'data',
             schema,
-            ...table,
+            ...objectRowTable,
             length: rows.length
         };
     }
 }
-function convertTable(objectRowTable, shape) {
-    switch (shape) {
-        case 'object-row-table':
-            return objectRowTable;
-        // Hack until geoparquet fixes up forwarded shape
-        case 'geojson-table':
-            return objectRowTable;
-        default:
-            throw new Error(shape);
-    }
-}

package/dist/{parquet-wasm-loader.d.ts → parquet-arrow-loader.d.ts}

@@ -1,9 +1,8 @@
 import type { ArrowTable, ArrowTableBatch } from '@loaders.gl/schema';
 import type { LoaderOptions } from '@loaders.gl/loader-utils';
 /** Parquet WASM loader options */
-export type ParquetWasmLoaderOptions = LoaderOptions & {
+export type ParquetArrowLoaderOptions = LoaderOptions & {
     parquet?: {
-        shape?: 'arrow-table';
         limit?: number;
         offset?: number;
         batchSize?: number;
@@ -14,7 +13,7 @@ export type ParquetWasmLoaderOptions = LoaderOptions & {
     };
 };
 /** Parquet WASM table loader */
-export declare const ParquetWasmWorkerLoader: {
+export declare const ParquetArrowWorkerLoader: {
     readonly dataType: ArrowTable;
     readonly batchType: ArrowTableBatch;
     readonly name: "Apache Parquet";
@@ -29,7 +28,6 @@ export declare const ParquetWasmWorkerLoader: {
     readonly tests: ["PAR1", "PARE"];
     readonly options: {
         readonly parquet: {
-            readonly shape: "arrow-table";
             readonly limit: undefined;
             readonly offset: 0;
             readonly batchSize: undefined;
@@ -41,5 +39,5 @@ export declare const ParquetWasmWorkerLoader: {
     };
 };
 /** Parquet WASM table loader */
-export declare const ParquetWasmLoader: any;
-//# sourceMappingURL=parquet-wasm-loader.d.ts.map
+export declare const ParquetArrowLoader: any;
+//# sourceMappingURL=parquet-arrow-loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parquet-arrow-loader.d.ts","sourceRoot":"","sources":["../src/parquet-arrow-loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,UAAU,EAAE,eAAe,EAAC,MAAM,oBAAoB,CAAC;AACpE,OAAO,KAAK,EAA2B,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAStF,kCAAkC;AAClC,MAAM,MAAM,yBAAyB,GAAG,aAAa,GAAG;IACtD,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;QACrB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACH,CAAC;AAEF,gCAAgC;AAChC,eAAO,MAAM,wBAAwB;uBACN,UAAU;wBACT,eAAe;;;;;;;;;;;;;;;;;;;;;;CAuBoC,CAAC;AAEpF,gCAAgC;AAChC,eAAO,MAAM,kBAAkB,KAiB8D,CAAC"}

package/dist/{parquet-wasm-loader.js → parquet-arrow-loader.js}

@@ -2,10 +2,10 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 import { BlobFile } from '@loaders.gl/loader-utils';
-import { parseParquetFileWasm, parseParquetFileInBatchesWasm } from "./lib/parsers/parse-parquet-wasm.js";
+import { parseParquetFileToArrow, parseParquetFileToArrowInBatches } from "./lib/parsers/parse-parquet-to-arrow.js";
 import { VERSION, PARQUET_WASM_URL } from "./lib/constants.js";
 /** Parquet WASM table loader */
-export const ParquetWasmWorkerLoader = {
+export const ParquetArrowWorkerLoader = {
     dataType: null,
     batchType: null,
     name: 'Apache Parquet',
@@ -20,7 +20,6 @@ export const ParquetWasmWorkerLoader = {
     tests: ['PAR1', 'PARE'],
     options: {
         parquet: {
-            shape: 'arrow-table',
             limit: undefined, // Provide a limit to the number of rows to be read.
             offset: 0, // Provide an offset to skip over the given number of rows.
             batchSize: undefined, // The number of rows in each batch. If not provided, the upstream parquet default is 1024.
@@ -32,18 +31,18 @@ export const ParquetWasmWorkerLoader = {
     }
 };
 /** Parquet WASM table loader */
-export const ParquetWasmLoader = {
-    ...ParquetWasmWorkerLoader,
+export const ParquetArrowLoader = {
+    ...ParquetArrowWorkerLoader,
     parse(arrayBuffer, options) {
-        const wasmOptions = { ...ParquetWasmLoader.options.parquet, ...options?.parquet };
-        return parseParquetFileWasm(new BlobFile(arrayBuffer), wasmOptions);
+        const wasmOptions = { ...ParquetArrowLoader.options.parquet, ...options?.parquet };
+        return parseParquetFileToArrow(new BlobFile(arrayBuffer), wasmOptions);
     },
     parseFile(file, options) {
-        const wasmOptions = { ...ParquetWasmLoader.options.parquet, ...options?.parquet };
-        return parseParquetFileWasm(file, wasmOptions);
+        const wasmOptions = { ...ParquetArrowLoader.options.parquet, ...options?.parquet };
+        return parseParquetFileToArrow(file, wasmOptions);
     },
     parseFileInBatches(file, options) {
-        const wasmOptions = { ...ParquetWasmLoader.options.parquet, ...options?.parquet };
-        return parseParquetFileInBatchesWasm(file, wasmOptions);
+        const wasmOptions = { ...ParquetArrowLoader.options.parquet, ...options?.parquet };
+        return parseParquetFileToArrowInBatches(file, wasmOptions);
     }
 };

package/dist/parquet-arrow-writer.d.ts

@@ -0,0 +1,9 @@
+import type { WriterOptions } from '@loaders.gl/loader-utils';
+export type ParquetArrowWriterOptions = WriterOptions & {
+    parquet?: {
+        wasmUrl?: string;
+    };
+};
+/** Parquet WASM writer */
+export declare const ParquetArrowWriter: any;
+//# sourceMappingURL=parquet-arrow-writer.d.ts.map

package/dist/parquet-arrow-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parquet-arrow-writer.d.ts","sourceRoot":"","sources":["../src/parquet-arrow-writer.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAoB,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAO/E,MAAM,MAAM,yBAAyB,GAAG,aAAa,GAAG;IACtD,OAAO,CAAC,EAAE;QACR,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACH,CAAC;AAEF,0BAA0B;AAC1B,eAAO,MAAM,kBAAkB,KAcqD,CAAC"}

package/dist/{parquet-wasm-writer.js → parquet-arrow-writer.js}

@@ -1,24 +1,22 @@
 // loaders.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { encode } from "./lib/encoders/encode-parquet-wasm.js";
+import { encodeArrowToParquet } from "./lib/encoders/encode-arrow-to-parquet.js";
+import { ParquetFormat } from "./parquet-format.js";
 import { VERSION, PARQUET_WASM_URL } from "./lib/constants.js";
 /** Parquet WASM writer */
-export const ParquetWasmWriter = {
-    name: 'Apache Parquet',
+export const ParquetArrowWriter = {
+    ...ParquetFormat,
     id: 'parquet-wasm',
     module: 'parquet',
     version: VERSION,
-    extensions: ['parquet'],
-    mimeTypes: ['application/octet-stream'],
-    binary: true,
     options: {
         parquet: {
             wasmUrl: PARQUET_WASM_URL
         }
     },
     encode(arrowTable, options) {
-        options = { parquet: { ...ParquetWasmWriter.options.parquet, ...options?.parquet }, ...options };
-        return encode(arrowTable, options);
+        options = { parquet: { ...ParquetArrowWriter.options.parquet, ...options?.parquet }, ...options };
+        return encodeArrowToParquet(arrowTable, options);
     }
 };

package/dist/parquet-format.d.ts

@@ -0,0 +1,9 @@
+export declare const ParquetFormat: {
+    readonly name: "Apache Parquet";
+    readonly category: "table";
+    readonly extensions: ["parquet"];
+    readonly mimeTypes: ["application/octet-stream"];
+    readonly binary: true;
+    readonly tests: ["PAR1", "PARE"];
+};
+//# sourceMappingURL=parquet-format.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parquet-format.d.ts","sourceRoot":"","sources":["../src/parquet-format.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,aAAa;;;;;;;CAOU,CAAC"}

package/dist/parquet-format.js

@@ -0,0 +1,11 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+export const ParquetFormat = {
+    name: 'Apache Parquet',
+    category: 'table',
+    extensions: ['parquet'],
+    mimeTypes: ['application/octet-stream'],
+    binary: true,
+    tests: ['PAR1', 'PARE']
+};