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

package/src/parquetjs/utils/uint8-array-transport.ts

@@ -0,0 +1,79 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {decodeString, toUint8Array} from './binary-utils';
+
+/** Thrift compact-protocol read transport backed by Uint8Array. */
+export class Uint8ArrayTransport {
+  public readPos = 0;
+
+  private readonly buffer: Uint8Array;
+
+  constructor(buffer: Uint8Array) {
+    this.buffer = toUint8Array(buffer);
+  }
+
+  commitPosition(): void {}
+
+  rollbackPosition(): void {}
+
+  isOpen(): boolean {
+    return true;
+  }
+
+  open(): boolean {
+    return true;
+  }
+
+  close(): boolean {
+    return true;
+  }
+
+  setCurrSeqId(_sequenceId: number): void {}
+
+  ensureAvailable(byteLength: number): void {
+    if (this.readPos + byteLength > this.buffer.length) {
+      throw new Error('Input buffer underrun');
+    }
+  }
+
+  read(byteLength: number): Uint8Array {
+    this.ensureAvailable(byteLength);
+    const end = this.readPos + byteLength;
+    const value = this.buffer.subarray(this.readPos, end);
+    this.readPos = end;
+    return value;
+  }
+
+  readByte(): number {
+    this.ensureAvailable(1);
+    const value = this.buffer[this.readPos++];
+    return value > 127 ? value - 256 : value;
+  }
+
+  readString(byteLength: number): string {
+    this.ensureAvailable(byteLength);
+    const value = decodeString(this.buffer, this.readPos, this.readPos + byteLength);
+    this.readPos += byteLength;
+    return value;
+  }
+
+  borrow(): {buf: Uint8Array; readIndex: number; writeIndex: number} {
+    return {
+      buf: this.buffer,
+      readIndex: this.readPos,
+      writeIndex: this.buffer.length
+    };
+  }
+
+  consume(bytesConsumed: number): void {
+    this.readPos += bytesConsumed;
+  }
+
+  write(): never {
+    throw new Error('Uint8ArrayTransport is read-only');
+  }
+
+  flush(): void {}
+}

package/src/polyfills/process.ts

@@ -0,0 +1,17 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/** Minimal browser process shim required by transitive Parquet dependencies in a worker. */
+export const process = {
+  /** Empty environment exposed to dependencies that only probe for process.env. */
+  env: {} as Record<string, string | undefined>,
+  /** Empty version map exposed to dependencies that only probe for process.versions. */
+  versions: {} as Record<string, string | undefined>,
+  /** Browser workers do not have a process identifier. */
+  pid: 0,
+  /** Schedules a Node-style next-tick callback with its arguments. */
+  nextTick(callback: (...arguments_: unknown[]) => void, ...arguments_: unknown[]): void {
+    queueMicrotask(() => callback(...arguments_));
+  }
+};

package/src/unbundled.ts

@@ -0,0 +1,47 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export type {ParquetLoaderOptions} from './parquet-loader-types';
+export type {GeoParquetLoaderOptions} from './geoparquet-loader';
+export {ParquetLoader} from './parquet-loader-types';
+export {GeoParquetLoader} from './geoparquet-loader';
+export {ParquetJSLoader} from './parquet-js-loader-types';
+export {
+  ParquetSourceLoader,
+  ParquetSource,
+  type ParquetSourceLoaderOptions,
+  type ParquetSourceReadOptions,
+  type ParquetSourceMetadata,
+  type ParquetRowGroupMetadata,
+  type ParquetSortingColumn,
+  type ParquetColumnChunkMetadata,
+  type ParquetColumnChunkSizeStatistics,
+  type ParquetGeospatialBoundingBox,
+  type ParquetGeospatialStatistics,
+  type ParquetBatchMetadata,
+  type ParquetSourceBatch
+} from './parquet-source-loader';
+export {
+  createParquetModuleAad,
+  decryptParquetModule,
+  encryptParquetModule,
+  createParquetFooterSignature,
+  type ParquetDecryptModuleOptions,
+  type ParquetEncryptionAlgorithm,
+  type ParquetKeyRetriever,
+  type ParquetWriterFooterSignatureOptions
+} from './lib/parquet-encryption';
+export {
+  ParquetDatasetSource,
+  type ParquetDatasetBatch,
+  type ParquetDatasetFile,
+  type ParquetDatasetFileProvider,
+  type ParquetDatasetReadOptions,
+  type ParquetDatasetSourceOptions,
+  type ParquetDatasetTelemetry
+} from './parquet-dataset-source';
+export {
+  PARQUET_SOURCE_CAPABILITIES,
+  type ParquetSourceCapabilities
+} from './parquet-source-capabilities';

package/src/wasm.ts

@@ -0,0 +1,6 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/** Package-local parquet-wasm binary URL for ESM applications and bundlers. */
+export const PARQUET_WASM_URL = new URL('./parquet_wasm_bg.wasm', import.meta.url);

package/src/workers/parquet-source-worker.ts

@@ -0,0 +1,21 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {createLoaderWorker} from '@loaders.gl/loader-utils';
+
+import {decodeParquetSourceWorkerInput} from '../lib/parquet-source-worker-decoder';
+import type {ParquetSourceWorkerInput} from '../lib/parquet-source-worker-types';
+import {PARQUET_LOADER_BASE} from '../parquet-loader-base';
+
+/** Worker-local parser for one selective Parquet source row-group job. */
+const ParquetSourceWorkerLoader = {
+  ...PARQUET_LOADER_BASE,
+  id: 'parquet-source',
+  name: 'ParquetSource',
+  parse(input: unknown) {
+    return decodeParquetSourceWorkerInput(input as ParquetSourceWorkerInput);
+  }
+};
+
+createLoaderWorker(ParquetSourceWorkerLoader);

package/src/workers/parquet-worker-node.ts

@@ -0,0 +1,5 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import './parquet-worker';

package/src/workers/parquet-worker.ts

@@ -0,0 +1,31 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {createLoaderWorker} from '@loaders.gl/loader-utils';
+import type {ParquetLoaderOptions} from '../parquet-loader-options';
+import {ParquetLoaderWithParser} from '../parquet-loader';
+
+/** Worker-local Parquet loader with a package-relative default WASM URL. */
+const ParquetWorkerLoader = {
+  ...ParquetLoaderWithParser,
+  parse(arrayBuffer: ArrayBuffer, options?: ParquetLoaderOptions) {
+    return ParquetLoaderWithParser.parse(arrayBuffer, addWorkerWasmUrl(options));
+  }
+};
+
+/** Adds the package-local WASM asset URL when the caller did not provide one. */
+function addWorkerWasmUrl(options?: ParquetLoaderOptions): ParquetLoaderOptions | undefined {
+  if (options?.parquet?.wasmUrl || typeof globalThis.location?.href !== 'string') {
+    return options;
+  }
+  return {
+    ...options,
+    parquet: {
+      ...options?.parquet,
+      wasmUrl: new URL('parquet_wasm_bg.wasm', globalThis.location.href).toString()
+    }
+  };
+}
+
+createLoaderWorker(ParquetWorkerLoader);

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

@@ -1,43 +0,0 @@
-import type { ArrowTable, ArrowTableBatch } from '@loaders.gl/schema';
-import type { LoaderOptions } from '@loaders.gl/loader-utils';
-/** Parquet WASM loader options */
-export type ParquetArrowLoaderOptions = LoaderOptions & {
-    parquet?: {
-        limit?: number;
-        offset?: number;
-        batchSize?: number;
-        columns?: string[];
-        rowGroups?: number[];
-        concurrency?: number;
-        wasmUrl?: string;
-    };
-};
-/** Parquet WASM table loader */
-export declare const ParquetArrowWorkerLoader: {
-    readonly dataType: ArrowTable;
-    readonly batchType: ArrowTableBatch;
-    readonly name: "Apache Parquet";
-    readonly id: "parquet-wasm";
-    readonly module: "parquet";
-    readonly version: any;
-    readonly worker: false;
-    readonly category: "table";
-    readonly extensions: ["parquet"];
-    readonly mimeTypes: ["application/octet-stream"];
-    readonly binary: true;
-    readonly tests: ["PAR1", "PARE"];
-    readonly options: {
-        readonly parquet: {
-            readonly limit: undefined;
-            readonly offset: 0;
-            readonly batchSize: undefined;
-            readonly columns: undefined;
-            readonly rowGroups: undefined;
-            readonly concurrency: undefined;
-            readonly wasmUrl: "https://unpkg.com/parquet-wasm@0.6.1/esm/parquet_wasm_bg.wasm";
-        };
-    };
-};
-/** Parquet WASM table loader */
-export declare const ParquetArrowLoader: any;
-//# sourceMappingURL=parquet-arrow-loader.d.ts.map

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

@@ -1 +0,0 @@
-{"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-arrow-loader.js

@@ -1,49 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-import { BlobFile } from '@loaders.gl/loader-utils';
-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 ParquetArrowWorkerLoader = {
-    dataType: null,
-    batchType: null,
-    name: 'Apache Parquet',
-    id: 'parquet-wasm',
-    module: 'parquet',
-    version: VERSION,
-    worker: false,
-    category: 'table',
-    extensions: ['parquet'],
-    mimeTypes: ['application/octet-stream'],
-    binary: true,
-    tests: ['PAR1', 'PARE'],
-    options: {
-        parquet: {
-            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.
-            columns: undefined, // The column names from the file to read.
-            rowGroups: undefined, // Only read data from the provided row group indexes.
-            concurrency: undefined, // The number of concurrent requests to make
-            wasmUrl: PARQUET_WASM_URL
-        }
-    }
-};
-/** Parquet WASM table loader */
-export const ParquetArrowLoader = {
-    ...ParquetArrowWorkerLoader,
-    parse(arrayBuffer, options) {
-        const wasmOptions = { ...ParquetArrowLoader.options.parquet, ...options?.parquet };
-        return parseParquetFileToArrow(new BlobFile(arrayBuffer), wasmOptions);
-    },
-    parseFile(file, options) {
-        const wasmOptions = { ...ParquetArrowLoader.options.parquet, ...options?.parquet };
-        return parseParquetFileToArrow(file, wasmOptions);
-    },
-    parseFileInBatches(file, options) {
-        const wasmOptions = { ...ParquetArrowLoader.options.parquet, ...options?.parquet };
-        return parseParquetFileToArrowInBatches(file, wasmOptions);
-    }
-};
-//# sourceMappingURL=parquet-arrow-loader.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"parquet-arrow-loader.js","sourceRoot":"","sources":["../src/parquet-arrow-loader.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAIpC,OAAO,EAAe,QAAQ,EAAC,MAAM,0BAA0B,CAAC;AAEhE,OAAO,EACL,uBAAuB,EACvB,gCAAgC,EACjC,gDAA6C;AAC9C,OAAO,EAAC,OAAO,EAAE,gBAAgB,EAAC,2BAAwB;AAe1D,gCAAgC;AAChC,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,QAAQ,EAAE,IAA6B;IACvC,SAAS,EAAE,IAAkC;IAE7C,IAAI,EAAE,gBAAgB;IACtB,EAAE,EAAE,cAAc;IAClB,MAAM,EAAE,SAAS;IACjB,OAAO,EAAE,OAAO;IAChB,MAAM,EAAE,KAAK;IACb,QAAQ,EAAE,OAAO;IACjB,UAAU,EAAE,CAAC,SAAS,CAAC;IACvB,SAAS,EAAE,CAAC,0BAA0B,CAAC;IACvC,MAAM,EAAE,IAAI;IACZ,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE;QACP,OAAO,EAAE;YACP,KAAK,EAAE,SAAS,EAAE,oDAAoD;YACtE,MAAM,EAAE,CAAC,EAAE,2DAA2D;YACtE,SAAS,EAAE,SAAS,EAAE,2FAA2F;YACjH,OAAO,EAAE,SAAS,EAAE,0CAA0C;YAC9D,SAAS,EAAE,SAAS,EAAE,sDAAsD;YAC5E,WAAW,EAAE,SAAS,EAAE,4CAA4C;YACpE,OAAO,EAAE,gBAAgB;SAC1B;KACF;CACgF,CAAC;AAEpF,gCAAgC;AAChC,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,GAAG,wBAAwB;IAE3B,KAAK,CAAC,WAAwB,EAAE,OAAmC;QACjE,MAAM,WAAW,GAAG,EAAC,GAAG,kBAAkB,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,OAAO,EAAE,OAAO,EAAC,CAAC;QACjF,OAAO,uBAAuB,CAAC,IAAI,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC,CAAC;IACzE,CAAC;IAED,SAAS,CAAC,IAAkB,EAAE,OAAmC;QAC/D,MAAM,WAAW,GAAG,EAAC,GAAG,kBAAkB,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,OAAO,EAAE,OAAO,EAAC,CAAC;QACjF,OAAO,uBAAuB,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;IACpD,CAAC;IAED,kBAAkB,CAAC,IAAkB,EAAE,OAAmC;QACxE,MAAM,WAAW,GAAG,EAAC,GAAG,kBAAkB,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,OAAO,EAAE,OAAO,EAAC,CAAC;QACjF,OAAO,gCAAgC,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;IAC7D,CAAC;CAC0F,CAAC"}

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

@@ -1,9 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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-arrow-writer.js

@@ -1,23 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-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 ParquetArrowWriter = {
-    ...ParquetFormat,
-    id: 'parquet-wasm',
-    module: 'parquet',
-    version: VERSION,
-    options: {
-        parquet: {
-            wasmUrl: PARQUET_WASM_URL
-        }
-    },
-    encode(arrowTable, options) {
-        options = { parquet: { ...ParquetArrowWriter.options.parquet, ...options?.parquet }, ...options };
-        return encodeArrowToParquet(arrowTable, options);
-    }
-};
-//# sourceMappingURL=parquet-arrow-writer.js.map

package/dist/parquet-arrow-writer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parquet-arrow-writer.js","sourceRoot":"","sources":["../src/parquet-arrow-writer.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAIpC,OAAO,EAAC,oBAAoB,EAAC,kDAA+C;AAC5E,OAAO,EAAC,aAAa,EAAC,4BAAyB;AAE/C,OAAO,EAAC,OAAO,EAAE,gBAAgB,EAAC,2BAAwB;AAQ1D,0BAA0B;AAC1B,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,GAAG,aAAa;IAChB,EAAE,EAAE,cAAc;IAClB,MAAM,EAAE,SAAS;IACjB,OAAO,EAAE,OAAO;IAChB,OAAO,EAAE;QACP,OAAO,EAAE;YACP,OAAO,EAAE,gBAAgB;SAC1B;KACF;IACD,MAAM,CAAC,UAAsB,EAAE,OAAmC;QAChE,OAAO,GAAG,EAAC,OAAO,EAAE,EAAC,GAAG,kBAAkB,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,OAAO,EAAE,OAAO,EAAC,EAAE,GAAG,OAAO,EAAC,CAAC;QAC9F,OAAO,oBAAoB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IACnD,CAAC;CACiF,CAAC"}

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

@@ -1,148 +0,0 @@
-import type { LoaderOptions } from '@loaders.gl/loader-utils';
-import type { ObjectRowTable, ObjectRowTableBatch, GeoJSONTable, GeoJSONTableBatch } from '@loaders.gl/schema';
-import { parseParquetFile, parseParquetFileInBatches } from "./lib/parsers/parse-parquet-to-json.js";
-import { parseGeoParquetFile, parseGeoParquetFileInBatches } from "./lib/parsers/parse-geoparquet-to-geojson.js";
-import { Buffer } from "./polyfills/buffer/install-buffer-polyfill.js";
-export { Buffer };
-/** Options for the parquet loader */
-export type ParquetJSONLoaderOptions = LoaderOptions & {
-    /** Options for the parquet loader */
-    parquet?: {
-        /** Restrict which columns that are parsed from the table. Can save significant memory. */
-        columnList?: string[] | string[][];
-        /** If true, binary values are not converted to strings */
-        preserveBinary?: boolean;
-        /**  @deprecated not used? Set to true to indicate that this is a geoparquet file. */
-        geoparquet?: boolean;
-        /** @deprecated URL to override loaders.gl/core parser system */
-        url?: string;
-    };
-};
-/**
- * ParquetJS table loader
- */
-export declare const ParquetJSONWorkerLoader: {
-    readonly dataType: ObjectRowTable;
-    readonly batchType: ObjectRowTableBatch;
-    readonly id: "parquet";
-    readonly module: "parquet";
-    readonly version: any;
-    readonly worker: false;
-    readonly options: {
-        readonly parquet: {
-            readonly columnList: [];
-            readonly geoparquet: true;
-            readonly url: undefined;
-            readonly preserveBinary: false;
-        };
-    };
-    readonly name: "Apache Parquet";
-    readonly category: "table";
-    readonly extensions: ["parquet"];
-    readonly mimeTypes: ["application/octet-stream"];
-    readonly binary: true;
-    readonly tests: ["PAR1", "PARE"];
-};
-/** ParquetJS table loader */
-export declare const ParquetJSONLoader: {
-    readonly dataType: ObjectRowTable;
-    readonly batchType: ObjectRowTableBatch;
-    readonly parse: (arrayBuffer: ArrayBuffer, options?: ParquetJSONLoaderOptions) => Promise<ObjectRowTable>;
-    readonly parseFile: typeof parseParquetFile;
-    readonly parseFileInBatches: typeof parseParquetFileInBatches;
-    readonly id: "parquet";
-    readonly module: "parquet";
-    readonly version: any;
-    readonly worker: false;
-    readonly options: {
-        readonly parquet: {
-            readonly columnList: [];
-            readonly geoparquet: true;
-            readonly url: undefined;
-            readonly preserveBinary: false;
-        };
-    };
-    readonly name: "Apache Parquet";
-    readonly category: "table";
-    readonly extensions: ["parquet"];
-    readonly mimeTypes: ["application/octet-stream"];
-    readonly binary: true;
-    readonly tests: ["PAR1", "PARE"];
-};
-export declare const GeoParquetWorkerLoader: {
-    readonly dataType: GeoJSONTable;
-    readonly batchType: GeoJSONTableBatch;
-    readonly id: "parquet";
-    readonly module: "parquet";
-    readonly version: any;
-    readonly worker: true;
-    readonly options: {
-        readonly parquet: {
-            readonly columnList: [];
-            readonly geoparquet: true;
-            readonly url: undefined;
-            readonly preserveBinary: false;
-        };
-    };
-    readonly name: "Apache Parquet";
-    readonly category: "table";
-    readonly extensions: ["parquet"];
-    readonly mimeTypes: ["application/octet-stream"];
-    readonly binary: true;
-    readonly tests: ["PAR1", "PARE"];
-};
-/** ParquetJS table loader */
-export declare const GeoParquetLoader: {
-    readonly parse: (arrayBuffer: ArrayBuffer, options?: ParquetJSONLoaderOptions) => Promise<ObjectRowTable | GeoJSONTable>;
-    readonly parseFile: typeof parseGeoParquetFile;
-    readonly parseFileInBatches: typeof parseGeoParquetFileInBatches;
-    readonly dataType: GeoJSONTable;
-    readonly batchType: GeoJSONTableBatch;
-    readonly id: "parquet";
-    readonly module: "parquet";
-    readonly version: any;
-    readonly worker: true;
-    readonly options: {
-        readonly parquet: {
-            readonly columnList: [];
-            readonly geoparquet: true;
-            readonly url: undefined;
-            readonly preserveBinary: false;
-        };
-    };
-    readonly name: "Apache Parquet";
-    readonly category: "table";
-    readonly extensions: ["parquet"];
-    readonly mimeTypes: ["application/octet-stream"];
-    readonly binary: true;
-    readonly tests: ["PAR1", "PARE"];
-};
-/** @deprecated Test to see if we can improve perf of parquetjs loader *
-export const ParquetJSONColumnarWorkerLoader = {
-  dataType: null as any as ColumnarTable,
-  batchType: null as any as ColumnarTableBatch,
-
-  name: 'Apache Parquet',
-  id: 'parquet',
-  module: 'parquet',
-  version: VERSION,
-  worker: true,
-  category: 'table',
-  extensions: ['parquet'],
-  mimeTypes: ['application/octet-stream'],
-  binary: true,
-  tests: ['PAR1', 'PARE'],
-  options: ParquetJSONLoader.options
-} as const satisfies Loader<ColumnarTable, ColumnarTableBatch, ParquetJSONLoaderOptions>;
-
-/** @deprecated Test to see if we can improve perf of parquetjs loader *
-export const ParquetJSONColumnarLoader = {
-  ...ParquetJSONColumnarWorkerLoader,
-  parse(arrayBuffer: ArrayBuffer, options?: ParquetJSONLoaderOptions) {
-    return parseParquetFileInColumns(new BlobFile(arrayBuffer), options);
-  },
-  parseFile: parseParquetFileInColumns,
-  parseFileInBatches: parseParquetFileInColumnarBatches
-} as const satisfies LoaderWithParser<ColumnarTable, ColumnarTableBatch, ParquetJSONLoaderOptions>;
-*/
-//# sourceMappingURL=parquet-json-loader.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"parquet-json-loader.d.ts","sourceRoot":"","sources":["../src/parquet-json-loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAA2B,aAAa,EAAC,MAAM,0BAA0B,CAAC;AACtF,OAAO,KAAK,EACV,cAAc,EACd,mBAAmB,EACnB,YAAY,EACZ,iBAAiB,EAGlB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAAC,gBAAgB,EAAE,yBAAyB,EAAC,+CAA4C;AAChG,OAAO,EACL,mBAAmB,EACnB,4BAA4B,EAC7B,qDAAkD;AAUnD,OAAO,EAAC,MAAM,EAAC,sDAAmD;AAClE,OAAO,EAAC,MAAM,EAAC,CAAC;AAMhB,qCAAqC;AACrC,MAAM,MAAM,wBAAwB,GAAG,aAAa,GAAG;IACrD,qCAAqC;IACrC,OAAO,CAAC,EAAE;QACR,0FAA0F;QAC1F,UAAU,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,EAAE,CAAC;QACnC,0DAA0D;QAC1D,cAAc,CAAC,EAAE,OAAO,CAAC;QACzB,qFAAqF;QACrF,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,gEAAgE;QAChE,GAAG,CAAC,EAAE,MAAM,CAAC;KACd,CAAC;CACH,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB;uBAGL,cAAc;wBACb,mBAAmB;;;;;;;;;;;;;;;;;;;CAcuC,CAAC;AAE3F,6BAA6B;AAC7B,eAAO,MAAM,iBAAiB;uBAGC,cAAc;wBACb,mBAAmB;kCAE5B,WAAW,YAAY,wBAAwB;;;;;;;;;;;;;;;;;;;;;CASrE,CAAC;AAMF,eAAO,MAAM,sBAAsB;uBAGJ,YAAY;wBACX,iBAAiB;;;;;;;;;;;;;;;;;;;CAeqC,CAAC;AAEvF,6BAA6B;AAC7B,eAAO,MAAM,gBAAgB;kCAGR,WAAW,YAAY,wBAAwB;;;uBAtBrC,YAAY;wBACX,iBAAiB;;;;;;;;;;;;;;;;;;;CA8BhD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BE"}

package/dist/parquet-json-loader.js

@@ -1,106 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-import { BlobFile } from '@loaders.gl/loader-utils';
-import { parseParquetFile, parseParquetFileInBatches } from "./lib/parsers/parse-parquet-to-json.js";
-import { parseGeoParquetFile, parseGeoParquetFileInBatches } from "./lib/parsers/parse-geoparquet-to-geojson.js";
-// import {
-//   parseParquetFileInColumns,
-//   parseParquetFileInColumnarBatches
-// } from './lib/parsers/parse-parquet-to-columns';
-import { ParquetFormat } from "./parquet-format.js";
-// Note: The Buffer polyfill is quite fragile
-// For some reason, just exporting directly fails with some bundlers
-// export {Buffer} from './polyfills/buffer/install-buffer-polyfill';
-import { Buffer } from "./polyfills/buffer/install-buffer-polyfill.js";
-export { Buffer };
-// __VERSION__ is injected by babel-plugin-version-inline
-// @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof "4.5.3" !== 'undefined' ? "4.5.3" : 'latest';
-/**
- * ParquetJS table loader
- */
-export const ParquetJSONWorkerLoader = {
-    ...ParquetFormat,
-    dataType: null,
-    batchType: null,
-    id: 'parquet',
-    module: 'parquet',
-    version: VERSION,
-    worker: false,
-    options: {
-        parquet: {
-            columnList: [],
-            geoparquet: true,
-            url: undefined,
-            preserveBinary: false
-        }
-    }
-};
-/** ParquetJS table loader */
-export const ParquetJSONLoader = {
-    ...ParquetJSONWorkerLoader,
-    dataType: null,
-    batchType: null,
-    parse: (arrayBuffer, options) => parseParquetFile(new BlobFile(arrayBuffer), options),
-    parseFile: parseParquetFile,
-    parseFileInBatches: parseParquetFileInBatches
-};
-// Defeat tree shaking
-// @ts-ignore
-ParquetJSONLoader.Buffer = Buffer;
-export const GeoParquetWorkerLoader = {
-    ...ParquetFormat,
-    dataType: null,
-    batchType: null,
-    id: 'parquet',
-    module: 'parquet',
-    version: VERSION,
-    worker: true,
-    options: {
-        parquet: {
-            columnList: [],
-            geoparquet: true,
-            url: undefined,
-            preserveBinary: false
-        }
-    }
-};
-/** ParquetJS table loader */
-export const GeoParquetLoader = {
-    ...GeoParquetWorkerLoader,
-    parse(arrayBuffer, options) {
-        return parseGeoParquetFile(new BlobFile(arrayBuffer), options);
-    },
-    parseFile: parseGeoParquetFile,
-    parseFileInBatches: parseGeoParquetFileInBatches
-};
-/** @deprecated Test to see if we can improve perf of parquetjs loader *
-export const ParquetJSONColumnarWorkerLoader = {
-  dataType: null as any as ColumnarTable,
-  batchType: null as any as ColumnarTableBatch,
-
-  name: 'Apache Parquet',
-  id: 'parquet',
-  module: 'parquet',
-  version: VERSION,
-  worker: true,
-  category: 'table',
-  extensions: ['parquet'],
-  mimeTypes: ['application/octet-stream'],
-  binary: true,
-  tests: ['PAR1', 'PARE'],
-  options: ParquetJSONLoader.options
-} as const satisfies Loader<ColumnarTable, ColumnarTableBatch, ParquetJSONLoaderOptions>;
-
-/** @deprecated Test to see if we can improve perf of parquetjs loader *
-export const ParquetJSONColumnarLoader = {
-  ...ParquetJSONColumnarWorkerLoader,
-  parse(arrayBuffer: ArrayBuffer, options?: ParquetJSONLoaderOptions) {
-    return parseParquetFileInColumns(new BlobFile(arrayBuffer), options);
-  },
-  parseFile: parseParquetFileInColumns,
-  parseFileInBatches: parseParquetFileInColumnarBatches
-} as const satisfies LoaderWithParser<ColumnarTable, ColumnarTableBatch, ParquetJSONLoaderOptions>;
-*/
-//# sourceMappingURL=parquet-json-loader.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"parquet-json-loader.js","sourceRoot":"","sources":["../src/parquet-json-loader.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAWpC,OAAO,EAAC,QAAQ,EAAC,MAAM,0BAA0B,CAAC;AAElD,OAAO,EAAC,gBAAgB,EAAE,yBAAyB,EAAC,+CAA4C;AAChG,OAAO,EACL,mBAAmB,EACnB,4BAA4B,EAC7B,qDAAkD;AACnD,WAAW;AACX,+BAA+B;AAC/B,sCAAsC;AACtC,mDAAmD;AACnD,OAAO,EAAC,aAAa,EAAC,4BAAyB;AAE/C,6CAA6C;AAC7C,oEAAoE;AACpE,qEAAqE;AACrE,OAAO,EAAC,MAAM,EAAC,sDAAmD;AAClE,OAAO,EAAC,MAAM,EAAC,CAAC;AAEhB,yDAAyD;AACzD,qDAAqD;AACrD,MAAM,OAAO,GAAG,cAAkB,KAAK,WAAW,CAAC,CAAC,SAAa,CAAC,CAAC,QAAQ,CAAC;AAiB5E;;GAEG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,GAAG,aAAa;IAEhB,QAAQ,EAAE,IAAiC;IAC3C,SAAS,EAAE,IAAsC;IAEjD,EAAE,EAAE,SAAS;IACb,MAAM,EAAE,SAAS;IACjB,OAAO,EAAE,OAAO;IAChB,MAAM,EAAE,KAAK;IACb,OAAO,EAAE;QACP,OAAO,EAAE;YACP,UAAU,EAAE,EAAE;YACd,UAAU,EAAE,IAAI;YAChB,GAAG,EAAE,SAAS;YACd,cAAc,EAAE,KAAK;SACtB;KACF;CACuF,CAAC;AAE3F,6BAA6B;AAC7B,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,GAAG,uBAAuB;IAE1B,QAAQ,EAAE,IAAiC;IAC3C,SAAS,EAAE,IAAsC;IAEjD,KAAK,EAAE,CAAC,WAAwB,EAAE,OAAkC,EAAE,EAAE,CACtE,gBAAgB,CAAC,IAAI,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtD,SAAS,EAAE,gBAAgB;IAC3B,kBAAkB,EAAE,yBAAyB;CAK9C,CAAC;AAEF,sBAAsB;AACtB,aAAa;AACb,iBAAiB,CAAC,MAAM,GAAG,MAAM,CAAC;AAElC,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,GAAG,aAAa;IAEhB,QAAQ,EAAE,IAA+B;IACzC,SAAS,EAAE,IAAoC;IAE/C,EAAE,EAAE,SAAS;IACb,MAAM,EAAE,SAAS;IACjB,OAAO,EAAE,OAAO;IAChB,MAAM,EAAE,IAAI;IAEZ,OAAO,EAAE;QACP,OAAO,EAAE;YACP,UAAU,EAAE,EAAE;YACd,UAAU,EAAE,IAAI;YAChB,GAAG,EAAE,SAAS;YACd,cAAc,EAAE,KAAK;SACtB;KACF;CACmF,CAAC;AAEvF,6BAA6B;AAC7B,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,GAAG,sBAAsB;IAEzB,KAAK,CAAC,WAAwB,EAAE,OAAkC;QAChE,OAAO,mBAAmB,CAAC,IAAI,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC,CAAC;IACjE,CAAC;IACD,SAAS,EAAE,mBAAmB;IAC9B,kBAAkB,EAAE,4BAA4B;CAKjD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BE"}

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

@@ -1,19 +0,0 @@
-import { Table } from '@loaders.gl/schema';
-export type ParquetJSONWriterOptions = {};
-export declare const ParquetJSONWriter: {
-    readonly id: "parquet";
-    readonly module: "parquet";
-    readonly version: any;
-    readonly options: {};
-    readonly encode: (data: Table, options: ParquetJSONWriterOptions | undefined) => Promise<ArrayBuffer>;
-    readonly encodeSync: typeof encodeSync;
-    readonly name: "Apache Parquet";
-    readonly category: "table";
-    readonly extensions: ["parquet"];
-    readonly mimeTypes: ["application/octet-stream"];
-    readonly binary: true;
-    readonly tests: ["PAR1", "PARE"];
-};
-declare function encodeSync(data: any, options?: ParquetJSONWriterOptions): ArrayBuffer;
-export {};
-//# sourceMappingURL=parquet-json-writer.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"parquet-json-writer.d.ts","sourceRoot":"","sources":["../src/parquet-json-writer.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,KAAK,EAAa,MAAM,oBAAoB,CAAC;AAOrD,MAAM,MAAM,wBAAwB,GAAG,EAAE,CAAC;AAE1C,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;CAQqD,CAAC;AAEpF,iBAAS,UAAU,CAAC,IAAI,KAAA,EAAE,OAAO,CAAC,EAAE,wBAAwB,eAE3D"}