@loaders.gl/parquet 4.4.5 → 5.0.0-alpha.2

package/src/parquetjs/utils/uint8-array-compact-protocol.ts

@@ -0,0 +1,322 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import * as thrift from './thrift-runtime';
+import {readDoubleLE} from './binary-utils';
+import {Uint8ArrayTransport} from './uint8-array-transport';
+
+const COMPACT_TYPE_STOP = 0x00;
+const COMPACT_TYPE_BOOLEAN_TRUE = 0x01;
+const COMPACT_TYPE_BOOLEAN_FALSE = 0x02;
+const COMPACT_TYPE_BYTE = 0x03;
+const COMPACT_TYPE_I16 = 0x04;
+const COMPACT_TYPE_I32 = 0x05;
+const COMPACT_TYPE_I64 = 0x06;
+const COMPACT_TYPE_DOUBLE = 0x07;
+const COMPACT_TYPE_BINARY = 0x08;
+const COMPACT_TYPE_LIST = 0x09;
+const COMPACT_TYPE_SET = 0x0a;
+const COMPACT_TYPE_MAP = 0x0b;
+const COMPACT_TYPE_STRUCT = 0x0c;
+
+/** Number-like replacement for node-int64 used by the compact protocol. */
+export class CompactInt64 {
+  /** Signed integer payload represented without precision loss. */
+  private readonly value: bigint;
+
+  /** Create a compact-protocol int64 wrapper from a bigint. */
+  constructor(value: bigint | number | string | {toString(): string}) {
+    this.value = typeof value === 'bigint' ? value : BigInt(value.toString());
+  }
+
+  /** Return the payload as a JavaScript number. */
+  toNumber(): number {
+    return Number(this.value);
+  }
+
+  /** Return the payload as a JavaScript number for generated thrift arithmetic. */
+  valueOf(): number {
+    return this.toNumber();
+  }
+
+  /** Format the payload as a string. */
+  toString(radix?: number): string {
+    return this.value.toString(radix);
+  }
+}
+
+/** Read-only Thrift compact protocol backed by Uint8Array. */
+export class Uint8ArrayCompactProtocol {
+  /** Byte transport that provides thrift-compatible read, borrow, and consume methods. */
+  private readonly transport: Uint8ArrayTransport;
+
+  /** Field id at the current nesting depth, used for compact field-id deltas. */
+  private lastFieldId = 0;
+
+  /** Parent struct field ids restored when nested structs end. */
+  private readonly lastFieldIds: number[] = [];
+
+  /** Boolean payload encoded in a compact field header. */
+  private boolValue: boolean | null = null;
+
+  /** Create a compact protocol reader over a Uint8Array-backed transport. */
+  constructor(transport: Uint8ArrayTransport) {
+    this.transport = transport;
+  }
+
+  /** Enter a struct and reset the delta-encoded field id state. */
+  readStructBegin(): thrift.TStruct {
+    this.lastFieldIds.push(this.lastFieldId);
+    this.lastFieldId = 0;
+    return {fname: ''};
+  }
+
+  readStructEnd(): void {
+    this.lastFieldId = this.lastFieldIds.pop() || 0;
+  }
+
+  /** Read a compact field header and expand it to a thrift field descriptor. */
+  readFieldBegin(): thrift.TField {
+    const fieldHeader = this.transport.readByte();
+    const compactType = fieldHeader & 0x0f;
+
+    if (compactType === COMPACT_TYPE_STOP) {
+      return {fname: null!, ftype: thrift.Thrift.Type.STOP, fid: 0};
+    }
+
+    const fieldIdDelta = (fieldHeader & 0xf0) >>> 4;
+    const fieldId = fieldIdDelta === 0 ? this.readI16() : this.lastFieldId + fieldIdDelta;
+    const fieldType = this.getThriftType(compactType);
+
+    if (compactType === COMPACT_TYPE_BOOLEAN_TRUE || compactType === COMPACT_TYPE_BOOLEAN_FALSE) {
+      this.boolValue = compactType === COMPACT_TYPE_BOOLEAN_TRUE;
+    }
+
+    this.lastFieldId = fieldId;
+    return {fname: null!, ftype: fieldType, fid: fieldId};
+  }
+
+  readFieldEnd(): void {}
+
+  /** Read a map header, including element compact types when the map is non-empty. */
+  readMapBegin(): thrift.TMap {
+    const size = this.readVarint32();
+    const keyAndValueType = size === 0 ? 0 : this.transport.readByte();
+    return {
+      ktype: this.getThriftType((keyAndValueType & 0xf0) >>> 4),
+      vtype: this.getThriftType(keyAndValueType & 0x0f),
+      size
+    };
+  }
+
+  readMapEnd(): void {}
+
+  /** Read a list header and expand the inline or varint element count. */
+  readListBegin(): thrift.TList {
+    const sizeAndType = this.transport.readByte();
+    let size = (sizeAndType >>> 4) & 0x0f;
+    if (size === 15) {
+      size = this.readVarint32();
+    }
+
+    return {
+      etype: this.getThriftType(sizeAndType & 0x0f),
+      size
+    };
+  }
+
+  readListEnd(): void {}
+
+  /** Read a set header; compact protocol encodes sets and lists the same way. */
+  readSetBegin(): thrift.TSet {
+    return this.readListBegin();
+  }
+
+  readSetEnd(): void {}
+
+  /** Read a boolean from the field header or from the next compact boolean byte. */
+  readBool(): boolean {
+    if (this.boolValue !== null) {
+      const value = this.boolValue;
+      this.boolValue = null;
+      return value;
+    }
+
+    return this.transport.readByte() === COMPACT_TYPE_BOOLEAN_TRUE;
+  }
+
+  /** Read a signed byte from the transport. */
+  readByte(): number {
+    return this.transport.readByte();
+  }
+
+  /** Read a signed 16-bit integer encoded as zig-zag varint. */
+  readI16(): number {
+    return this.readI32();
+  }
+
+  /** Read a signed 32-bit integer encoded as zig-zag varint. */
+  readI32(): number {
+    return this.decodeZigZag32(this.readVarint32());
+  }
+
+  /** Read a signed 64-bit integer encoded as zig-zag varint. */
+  readI64(): CompactInt64 {
+    return new CompactInt64(this.decodeZigZag64(this.readVarint64()));
+  }
+
+  /** Read a little-endian 64-bit float. */
+  readDouble(): number {
+    return readDoubleLE(this.transport.read(8), 0);
+  }
+
+  /** Read a length-prefixed binary payload as an exact Uint8Array. */
+  readBinary(): Uint8Array {
+    const size = this.readVarint32();
+    return size === 0 ? new Uint8Array(0) : this.transport.read(size);
+  }
+
+  /** Read a length-prefixed UTF-8 string. */
+  readString(): string {
+    const size = this.readVarint32();
+    return size === 0 ? '' : this.transport.readString(size);
+  }
+
+  /** Consume and discard a value with the supplied thrift type. */
+  skip(type: thrift.Thrift.Type): void {
+    switch (type) {
+      case thrift.Thrift.Type.STOP:
+        return;
+      case thrift.Thrift.Type.BOOL:
+        this.readBool();
+        return;
+      case thrift.Thrift.Type.BYTE:
+        this.readByte();
+        return;
+      case thrift.Thrift.Type.I16:
+        this.readI16();
+        return;
+      case thrift.Thrift.Type.I32:
+        this.readI32();
+        return;
+      case thrift.Thrift.Type.I64:
+        this.readI64();
+        return;
+      case thrift.Thrift.Type.DOUBLE:
+        this.readDouble();
+        return;
+      case thrift.Thrift.Type.STRING:
+        this.readBinary();
+        return;
+      case thrift.Thrift.Type.STRUCT:
+        this.skipStruct();
+        return;
+      case thrift.Thrift.Type.MAP:
+        this.skipMap();
+        return;
+      case thrift.Thrift.Type.SET:
+      case thrift.Thrift.Type.LIST:
+        this.skipList();
+        return;
+      default:
+        throw new Error(`Unsupported thrift type: ${type}`);
+    }
+  }
+
+  /** Read an unsigned 32-bit compact varint. */
+  private readVarint32(): number {
+    return Number(this.readVarint64());
+  }
+
+  /** Read an unsigned 64-bit compact varint. */
+  private readVarint64(): bigint {
+    let value = 0n;
+    let shift = 0n;
+
+    while (true) {
+      const byte = BigInt(this.transport.readByte() & 0xff);
+      value |= (byte & 0x7fn) << shift;
+      if ((byte & 0x80n) === 0n) {
+        return value;
+      }
+      shift += 7n;
+    }
+  }
+
+  /** Decode a zig-zag 32-bit integer to a signed integer. */
+  private decodeZigZag32(value: number): number {
+    return (value >>> 1) ^ -(value & 1);
+  }
+
+  /** Decode a zig-zag 64-bit integer to a signed integer. */
+  private decodeZigZag64(value: bigint): bigint {
+    return (value >> 1n) ^ -(value & 1n);
+  }
+
+  /** Convert a compact wire type to a generated-thrift type. */
+  private getThriftType(compactType: number): thrift.Thrift.Type {
+    switch (compactType) {
+      case COMPACT_TYPE_STOP:
+        return thrift.Thrift.Type.STOP;
+      case COMPACT_TYPE_BOOLEAN_TRUE:
+      case COMPACT_TYPE_BOOLEAN_FALSE:
+        return thrift.Thrift.Type.BOOL;
+      case COMPACT_TYPE_BYTE:
+        return thrift.Thrift.Type.BYTE;
+      case COMPACT_TYPE_I16:
+        return thrift.Thrift.Type.I16;
+      case COMPACT_TYPE_I32:
+        return thrift.Thrift.Type.I32;
+      case COMPACT_TYPE_I64:
+        return thrift.Thrift.Type.I64;
+      case COMPACT_TYPE_DOUBLE:
+        return thrift.Thrift.Type.DOUBLE;
+      case COMPACT_TYPE_BINARY:
+        return thrift.Thrift.Type.STRING;
+      case COMPACT_TYPE_LIST:
+        return thrift.Thrift.Type.LIST;
+      case COMPACT_TYPE_SET:
+        return thrift.Thrift.Type.SET;
+      case COMPACT_TYPE_MAP:
+        return thrift.Thrift.Type.MAP;
+      case COMPACT_TYPE_STRUCT:
+        return thrift.Thrift.Type.STRUCT;
+      default:
+        throw new Error(`Unknown compact thrift type: ${compactType}`);
+    }
+  }
+
+  /** Skip every field in the current struct. */
+  private skipStruct(): void {
+    this.readStructBegin();
+    while (true) {
+      const field = this.readFieldBegin();
+      if (field.ftype === thrift.Thrift.Type.STOP) {
+        break;
+      }
+      this.skip(field.ftype);
+      this.readFieldEnd();
+    }
+    this.readStructEnd();
+  }
+
+  /** Skip every key and value in the current map. */
+  private skipMap(): void {
+    const map = this.readMapBegin();
+    for (let index = 0; index < map.size; index++) {
+      this.skip(map.ktype);
+      this.skip(map.vtype);
+    }
+    this.readMapEnd();
+  }
+
+  /** Skip every element in the current list or set. */
+  private skipList(): void {
+    const list = this.readListBegin();
+    for (let index = 0; index < list.size; index++) {
+      this.skip(list.etype);
+    }
+    this.readListEnd();
+  }
+}

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,33 @@
+// 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 ParquetColumnChunkMetadata,
+  type ParquetBatchMetadata,
+  type ParquetSourceBatch
+} from './parquet-source-loader';
+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"}