@loaders.gl/parquet 4.2.0-alpha.5 → 4.2.0-beta.1

package/dist/parquetjs/parquet-thrift/PageEncodingStats.js

@@ -6,6 +6,9 @@
  */
 import * as thrift from 'thrift';
 export class PageEncodingStats {
+    page_type;
+    encoding;
+    count;
     constructor(args) {
         if (args != null && args.page_type != null) {
             this.page_type = args.page_type;

package/dist/parquetjs/parquet-thrift/PageHeader.js

@@ -10,6 +10,14 @@ import * as DataPageHeaderV2 from "./DataPageHeaderV2.js";
 import * as DictionaryPageHeader from "./DictionaryPageHeader.js";
 import * as IndexPageHeader from "./IndexPageHeader.js";
 export class PageHeader {
+    type;
+    uncompressed_page_size;
+    compressed_page_size;
+    crc;
+    data_page_header;
+    index_page_header;
+    dictionary_page_header;
+    data_page_header_v2;
     constructor(args) {
         if (args != null && args.type != null) {
             this.type = args.type;

package/dist/parquetjs/parquet-thrift/PageLocation.js

@@ -7,6 +7,9 @@
 import Int64 from 'node-int64';
 import * as thrift from 'thrift';
 export class PageLocation {
+    offset;
+    compressed_page_size;
+    first_row_index;
     constructor(args) {
         if (args != null && args.offset != null) {
             if (typeof args.offset === 'number') {

package/dist/parquetjs/parquet-thrift/RowGroup.js

@@ -9,6 +9,10 @@ import * as thrift from 'thrift';
 import * as ColumnChunk from "./ColumnChunk.js";
 import * as SortingColumn from "./SortingColumn.js";
 export class RowGroup {
+    columns;
+    total_byte_size;
+    num_rows;
+    sorting_columns;
     constructor(args) {
         if (args != null && args.columns != null) {
             this.columns = args.columns;

package/dist/parquetjs/parquet-thrift/SchemaElement.js

@@ -7,6 +7,16 @@
 import * as thrift from 'thrift';
 import * as LogicalType from "./LogicalType.js";
 export class SchemaElement {
+    type;
+    type_length;
+    repetition_type;
+    name;
+    num_children;
+    converted_type;
+    scale;
+    precision;
+    field_id;
+    logicalType;
     constructor(args) {
         if (args != null && args.type != null) {
             this.type = args.type;

package/dist/parquetjs/parquet-thrift/SortingColumn.js

@@ -6,6 +6,9 @@
  */
 import * as thrift from 'thrift';
 export class SortingColumn {
+    column_idx;
+    descending;
+    nulls_first;
     constructor(args) {
         if (args != null && args.column_idx != null) {
             this.column_idx = args.column_idx;

package/dist/parquetjs/parquet-thrift/Statistics.js

@@ -7,6 +7,12 @@
 import Int64 from 'node-int64';
 import * as thrift from 'thrift';
 export class Statistics {
+    max;
+    min;
+    null_count;
+    distinct_count;
+    max_value;
+    min_value;
     constructor(args) {
         if (args != null && args.max != null) {
             this.max = args.max;

package/dist/parquetjs/parquet-thrift/TimeType.js

@@ -7,6 +7,8 @@
 import * as thrift from 'thrift';
 import * as TimeUnit from "./TimeUnit.js";
 export class TimeType {
+    isAdjustedToUTC;
+    unit;
     constructor(args) {
         if (args != null && args.isAdjustedToUTC != null) {
             this.isAdjustedToUTC = args.isAdjustedToUTC;

package/dist/parquetjs/parquet-thrift/TimeUnit.js

@@ -8,6 +8,8 @@ import * as thrift from 'thrift';
 import * as MicroSeconds from "./MicroSeconds.js";
 import * as MilliSeconds from "./MilliSeconds.js";
 export class TimeUnit {
+    MILLIS;
+    MICROS;
     constructor(args) {
         let _fieldsSet = 0;
         if (args != null) {

package/dist/parquetjs/parquet-thrift/TimestampType.js

@@ -7,6 +7,8 @@
 import * as thrift from 'thrift';
 import * as TimeUnit from "./TimeUnit.js";
 export class TimestampType {
+    isAdjustedToUTC;
+    unit;
     constructor(args) {
         if (args != null && args.isAdjustedToUTC != null) {
             this.isAdjustedToUTC = args.isAdjustedToUTC;

package/dist/parquetjs/parser/parquet-reader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parquet-reader.d.ts","sourceRoot":"","sources":["../../../src/parquetjs/parser/parquet-reader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,0BAA0B,CAAC;AAE3D,OAAO,EAAC,aAAa,EAAC,4BAAyB;AAK/C,OAAO,EAAC,WAAW,EAAoB,YAAY,EAAE,QAAQ,EAAO,mCAAgC;AACpG,OAAO,EACL,eAAe,EAEf,kBAAkB,EAElB,oBAAoB,EACrB,6BAA0B;AAI3B,MAAM,MAAM,kBAAkB,GAAG;IAC/B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,0DAA0D;AAC1D,MAAM,MAAM,qBAAqB,GAAG;IAClC,iDAAiD;IACjD,UAAU,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,EAAE,CAAC;CACpC,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,aAAa;IACxB,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,kBAAkB,CAAC,CAG/C;IAEF,KAAK,EAAE,QAAQ,CAAC,kBAAkB,CAAC,CAAC;IACpC,IAAI,EAAE,YAAY,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI,CAAQ;gBAElC,IAAI,EAAE,YAAY,EAAE,KAAK,CAAC,EAAE,kBAAkB;IAK1D,KAAK,IAAI,IAAI;IAOb,8BAA8B;IACvB,WAAW,CAAC,KAAK,CAAC,EAAE,qBAAqB;IAShD,wCAAwC;IACjC,gBAAgB,CAAC,KAAK,CAAC,EAAE,qBAAqB;IAOrD,sCAAsC;IAC/B,gBAAgB,CAAC,KAAK,CAAC,EAAE,qBAAqB;IAqB/C,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC;IAK9B,SAAS,IAAI,OAAO,CAAC,aAAa,CAAC;IAQzC;;;OAGG;IACG,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IASpD,eAAe,IAAI,OAAO,CAAC,YAAY,CAAC;IAU9C,uCAAuC;IACjC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAcjC,uCAAuC;IACjC,UAAU,IAAI,OAAO,CAAC,YAAY,CAAC;IAyBzC,4EAA4E;IACtE,YAAY,CAChB,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,QAAQ,EAClB,UAAU,EAAE,MAAM,EAAE,EAAE,GACrB,OAAO,CAAC,eAAe,CAAC;IAgB3B;;OAEG;IACG,eAAe,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,WAAW,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAuDhG;;;;;;OAMG;IACG,aAAa,CACjB,oBAAoB,EAAE,MAAM,EAC5B,OAAO,EAAE,oBAAoB,EAC7B,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,EAAE,CAAC;CAwBrB"}
+{"version":3,"file":"parquet-reader.d.ts","sourceRoot":"","sources":["../../../src/parquetjs/parser/parquet-reader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,0BAA0B,CAAC;AAE3D,OAAO,EAAC,aAAa,EAAC,4BAAyB;AAK/C,OAAO,EAAC,WAAW,EAAoB,YAAY,EAAE,QAAQ,EAAO,mCAAgC;AACpG,OAAO,EACL,eAAe,EAEf,kBAAkB,EAElB,oBAAoB,EACrB,6BAA0B;AAI3B,MAAM,MAAM,kBAAkB,GAAG;IAC/B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,0DAA0D;AAC1D,MAAM,MAAM,qBAAqB,GAAG;IAClC,iDAAiD;IACjD,UAAU,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,EAAE,CAAC;CACpC,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,aAAa;IACxB,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,kBAAkB,CAAC,CAI/C;IAEF,KAAK,EAAE,QAAQ,CAAC,kBAAkB,CAAC,CAAC;IACpC,IAAI,EAAE,YAAY,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI,CAAQ;gBAElC,IAAI,EAAE,YAAY,EAAE,KAAK,CAAC,EAAE,kBAAkB;IAK1D,KAAK,IAAI,IAAI;IAOb,8BAA8B;IACvB,WAAW,CAAC,KAAK,CAAC,EAAE,qBAAqB;IAShD,wCAAwC;IACjC,gBAAgB,CAAC,KAAK,CAAC,EAAE,qBAAqB;IAOrD,sCAAsC;IAC/B,gBAAgB,CAAC,KAAK,CAAC,EAAE,qBAAqB;IAqB/C,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC;IAK9B,SAAS,IAAI,OAAO,CAAC,aAAa,CAAC;IAQzC;;;OAGG;IACG,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IASpD,eAAe,IAAI,OAAO,CAAC,YAAY,CAAC;IAU9C,uCAAuC;IACjC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAcjC,uCAAuC;IACjC,UAAU,IAAI,OAAO,CAAC,YAAY,CAAC;IAyBzC,4EAA4E;IACtE,YAAY,CAChB,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,QAAQ,EAClB,UAAU,EAAE,MAAM,EAAE,EAAE,GACrB,OAAO,CAAC,eAAe,CAAC;IAgB3B;;OAEG;IACG,eAAe,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,WAAW,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAuDhG;;;;;;OAMG;IACG,aAAa,CACjB,oBAAoB,EAAE,MAAM,EAC5B,OAAO,EAAE,oBAAoB,EAC7B,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,EAAE,CAAC;CAwBrB"}

package/dist/parquetjs/parser/parquet-reader.js

@@ -12,8 +12,15 @@ import { decodeDataPages, decodePage } from "./decoders.js";
  * rows from a parquet file use the ParquetReader instead
  */
 export class ParquetReader {
+    static defaultProps = {
+        // max ArrayBuffer size in js is 2Gb
+        defaultDictionarySize: 2147483648,
+        preserveBinary: false
+    };
+    props;
+    file;
+    metadata = null;
     constructor(file, props) {
-        this.metadata = null;
         this.file = file;
         this.props = { ...ParquetReader.defaultProps, ...props };
     }
@@ -198,7 +205,3 @@ export class ParquetReader {
         return decodedPage.dictionary;
     }
 }
-ParquetReader.defaultProps = {
-    defaultDictionarySize: 1e6,
-    preserveBinary: false
-};

package/dist/parquetjs/schema/declare.js

@@ -1,6 +1,10 @@
 /** @
  * Holds data for one row group (column chunks) */
 export class ParquetRowGroup {
+    /** Number of rows in this page */
+    rowCount;
+    /** Map of Column chunks */
+    columnData;
     constructor(rowCount = 0, columnData = {}) {
         this.rowCount = rowCount;
         this.columnData = columnData;

package/dist/parquetjs/schema/schema.js

@@ -7,6 +7,9 @@ import { PARQUET_LOGICAL_TYPES } from "./types.js";
  * A parquet file schema
  */
 export class ParquetSchema {
+    schema;
+    fields;
+    fieldList;
     /**
      * Create a new schema from a JSON schema definition
      */

package/dist/parquetjs/schema/types.js

@@ -296,6 +296,7 @@ function fromPrimitive_JSON(value) {
     return JSON.parse(value);
 }
 function toPrimitive_BSON(value) {
+    // @ts-ignore
     const arrayBuffer = BSONWriter.encodeSync?.(value);
     return Buffer.from(arrayBuffer);
 }
@@ -304,6 +305,7 @@ function fromPrimitive_BSON(value) {
 }
 function toPrimitive_TIME_MILLIS(value) {
     const v = parseInt(value, 10);
+    // eslint-disable-next-line @typescript-eslint/no-loss-of-precision
     if (v < 0 || v > 0xffffffffffffffff || isNaN(v)) {
         throw new Error(`invalid value for TIME_MILLIS: ${value}`);
     }

package/dist/parquetjs/utils/read-utils.js

@@ -1,10 +1,7 @@
 import { TBufferedTransport, TCompactProtocol, TFramedTransport } from "../parquet-thrift/index.js";
 import { FileMetaData, PageHeader } from "../parquet-thrift/index.js";
 class UFramedTransport extends TFramedTransport {
-    constructor() {
-        super(...arguments);
-        this.readPos = 0;
-    }
+    readPos = 0;
 }
 /**
  * Helper function that serializes a thrift object into a buffer

package/dist/polyfills/buffer/buffer.js

@@ -41,6 +41,7 @@ export const INSPECT_MAX_BYTES = 50;
  * The `Uint8Array` prototype remains unmodified.
  */
 export class Buffer extends Uint8Array {
+    static poolSize = 8192; // not used by this implementation
     // length: number; inherited
     get parent() {
         if (!Buffer.isBuffer(this))
@@ -52,6 +53,14 @@ export class Buffer extends Uint8Array {
             return undefined;
         return this.byteOffset;
     }
+    /** This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
+     * to detect a Buffer instance. It's not possible to use `instanceof Buffer`
+     * reliably in a browserify context because there could be multiple different
+     * copies of the 'buffer' package in use. This method works even for Buffer
+     * instances that were created from another copy of the `buffer` package.
+     * @see: https://github.com/feross/buffer/issues/154
+     */
+    _isBuffer = true;
     constructor(arg, encodingOrOffset, length) {
         if (typeof arg !== 'number') {
             return Buffer.from(arg, encodingOrOffset, length);
@@ -65,14 +74,6 @@ export class Buffer extends Uint8Array {
             throw new TypeError('The "string" argument must be of type string. Received type number');
         }
         super(size < 0 ? 0 : checked(size) | 0);
-        /** This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
-         * to detect a Buffer instance. It's not possible to use `instanceof Buffer`
-         * reliably in a browserify context because there could be multiple different
-         * copies of the 'buffer' package in use. This method works even for Buffer
-         * instances that were created from another copy of the `buffer` package.
-         * @see: https://github.com/feross/buffer/issues/154
-         */
-        this._isBuffer = true;
         return;
     }
     static from(value, encodingOrOffset, length) {
@@ -1064,7 +1065,6 @@ export class Buffer extends Uint8Array {
         }
     }
 }
-Buffer.poolSize = 8192; // not used by this implementation
 function checkInt(buf, value, offset, ext, max, min) {
     if (!Buffer.isBuffer(buf))
         throw new TypeError('"buffer" argument must be a Buffer instance');
@@ -1603,7 +1603,6 @@ function writeDouble(buf, value, offset, littleEndian, noAssert) {
     return offset + 8;
 }
 // CUSTOM ERRORS
-// =============
 // Simplified versions from Node, changed for Buffer-only usage
 const errors = {};
 function E(sym, getMessage, Base) {
@@ -1674,7 +1673,6 @@ function addNumericalSeparator(val) {
     return `${val.slice(0, i)}${res}`;
 }
 // CHECK FUNCTIONS
-// ===============
 function checkBounds(buf, offset, byteLength) {
     validateNumber(offset, 'offset');
     if (buf[offset] === undefined || buf[offset + byteLength] === undefined) {
@@ -1718,7 +1716,6 @@ function boundsError(value, length, type) {
     throw new errors.ERR_OUT_OF_RANGE(type || 'offset', `>= ${type ? 1 : 0} and <= ${length}`, value);
 }
 // HELPER FUNCTIONS
-// ================
 const INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
 function base64clean(str) {
     // Node takes equal signs as end of the Base64 encoding

package/dist/polyfills/buffer/install-buffer-polyfill.d.ts

@@ -1,3 +1,30 @@
 /// <reference types="node" />
-export declare const Buffer: BufferConstructor;
+export declare const Buffer: {
+    new (str: string, encoding?: string | undefined): Buffer;
+    new (size: number): Buffer;
+    new (array: Uint8Array): Buffer;
+    new (arrayBuffer: ArrayBuffer | SharedArrayBuffer): Buffer;
+    new (array: readonly any[]): Buffer;
+    new (buffer: Buffer): Buffer;
+    prototype: Buffer;
+    from(arrayBuffer: ArrayBuffer | SharedArrayBuffer, byteOffset?: number | undefined, length?: number | undefined): Buffer;
+    from(data: readonly any[]): Buffer;
+    from(data: Uint8Array): Buffer;
+    from(obj: {
+        valueOf(): string | object;
+    } | {
+        [Symbol.toPrimitive](hint: "string"): string;
+    }, byteOffset?: number | undefined, length?: number | undefined): Buffer;
+    from(str: string, encoding?: string | undefined): Buffer;
+    of(...items: number[]): Buffer;
+    isBuffer(obj: any): obj is Buffer;
+    isEncoding(encoding: string): boolean | undefined;
+    byteLength(string: string | ArrayBuffer | SharedArrayBuffer | NodeJS.TypedArray | DataView, encoding?: string | undefined): number;
+    concat(list: readonly Uint8Array[], totalLength?: number | undefined): Buffer;
+    compare(buf1: Uint8Array, buf2: Uint8Array): number;
+    alloc(size: number, fill?: string | number | Buffer | undefined, encoding?: string | undefined): Buffer;
+    allocUnsafe(size: number): Buffer;
+    allocUnsafeSlow(size: number): Buffer;
+    poolSize: number;
+};
 //# sourceMappingURL=install-buffer-polyfill.d.ts.map

package/dist/polyfills/buffer/install-buffer-polyfill.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"install-buffer-polyfill.d.ts","sourceRoot":"","sources":["../../../src/polyfills/buffer/install-buffer-polyfill.ts"],"names":[],"mappings":";AAOA,eAAO,MAAM,MAAM,mBAA0B,CAAC"}
+{"version":3,"file":"install-buffer-polyfill.d.ts","sourceRoot":"","sources":["../../../src/polyfills/buffer/install-buffer-polyfill.ts"],"names":[],"mappings":";AAOA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA0B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/parquet",
-  "version": "4.2.0-alpha.5",
+  "version": "4.2.0-beta.1",
   "description": "Framework-independent loader for Apache Parquet files",
   "license": "MIT",
   "type": "module",
@@ -46,27 +46,27 @@
     "copy-wasm": "cp ../../node_modules/parquet-wasm/esm2/arrow1_bg.wasm dist/arrow1_bg.wasm"
   },
   "browser": {
+    "./dist/polyfills/buffer/buffer-polyfill.node.js": "./dist/polyfills/buffer/buffer-polyfill.browser.js",
+    "./src/polyfills/buffer/buffer-polyfill.node.ts": "./src/polyfills/buffer/buffer-polyfill.browser.ts",
     "child_process": false,
+    "events": false,
+    "fs": false,
     "net": false,
-    "tls": false,
     "stream": false,
-    "fs": false,
-    "util": false,
-    "events": false,
-    "./src/polyfills/buffer/buffer-polyfill.node.ts": "./src/polyfills/buffer/buffer-polyfill.browser.ts",
-    "./dist/polyfills/buffer/buffer-polyfill.node.js": "./dist/polyfills/buffer/buffer-polyfill.browser.js"
+    "tls": false,
+    "util": false
   },
   "comments": [
     "base64-js and ieee754 are used by buffer polyfill"
   ],
   "dependencies": {
-    "@loaders.gl/arrow": "4.2.0-alpha.5",
-    "@loaders.gl/bson": "4.2.0-alpha.5",
-    "@loaders.gl/compression": "4.2.0-alpha.5",
-    "@loaders.gl/gis": "4.2.0-alpha.5",
-    "@loaders.gl/loader-utils": "4.2.0-alpha.5",
-    "@loaders.gl/schema": "4.2.0-alpha.5",
-    "@loaders.gl/wkt": "4.2.0-alpha.5",
+    "@loaders.gl/arrow": "4.2.0-beta.1",
+    "@loaders.gl/bson": "4.2.0-beta.1",
+    "@loaders.gl/compression": "4.2.0-beta.1",
+    "@loaders.gl/gis": "4.2.0-beta.1",
+    "@loaders.gl/loader-utils": "4.2.0-beta.1",
+    "@loaders.gl/schema": "4.2.0-beta.1",
+    "@loaders.gl/wkt": "4.2.0-beta.1",
     "async-mutex": "^0.2.2",
     "base64-js": "^1.3.1",
     "brotli": "^1.3.2",
@@ -93,5 +93,5 @@
     "@loaders.gl/core": "^4.0.0",
     "apache-arrow": ">= 15.0.0"
   },
-  "gitHead": "32d95a81971f104e4dfeb88ab57065f05321a76a"
+  "gitHead": "c386a9196516fe3ff24847b40e6c77be039cf905"
 }

package/src/lib/parsers/parse-parquet-to-columns.ts

@@ -11,6 +11,7 @@ import {ParquetSchema} from '../../parquetjs/schema/schema';
 import {materializeColumns} from '../../parquetjs/schema/shred';
 import {getSchemaFromParquetReader} from './get-parquet-schema';
 import {installBufferPolyfill} from '../../polyfills/buffer/index';
+import {preloadCompressions} from '../../parquetjs/compression';
 
 /**
  * @deprecated
@@ -20,6 +21,8 @@ export async function parseParquetFileInColumns(
   options?: ParquetLoaderOptions
 ): Promise<ColumnarTable> {
   installBufferPolyfill();
+  await preloadCompressions(options);
+
   for await (const batch of parseParquetFileInColumnarBatches(file, options)) {
     return {
       shape: 'columnar-table',
@@ -37,6 +40,9 @@ export async function* parseParquetFileInColumnarBatches(
   file: ReadableFile,
   options?: ParquetLoaderOptions
 ): AsyncIterable<ColumnarTableBatch> {
+  installBufferPolyfill();
+  await preloadCompressions(options);
+
   const reader = new ParquetReader(file);
 
   // Extract schema and geo metadata

package/src/lib/parsers/parse-parquet.ts

@@ -10,6 +10,7 @@ import type {ParquetRow} from '../../parquetjs/schema/declare';
 import {ParquetReader} from '../../parquetjs/parser/parquet-reader';
 import {getSchemaFromParquetReader} from './get-parquet-schema';
 import {installBufferPolyfill} from '../../polyfills/buffer/index';
+import {preloadCompressions} from '../../parquetjs/compression';
 
 /**
  *  * Parse a parquet file using parquetjs
@@ -22,6 +23,7 @@ export async function parseParquetFile(
   options?: ParquetLoaderOptions
 ): Promise<ObjectRowTable> {
   installBufferPolyfill();
+  await preloadCompressions(options);
 
   const reader = new ParquetReader(file, {
     preserveBinary: options?.parquet?.preserveBinary
@@ -57,6 +59,9 @@ export async function* parseParquetFileInBatches(
   file: ReadableFile,
   options?: ParquetLoaderOptions
 ): AsyncIterable<ObjectRowTableBatch> {
+  installBufferPolyfill();
+  await preloadCompressions(options);
+
   const reader = new ParquetReader(file, {
     preserveBinary: options?.parquet?.preserveBinary
   });

package/src/parquet-loader.ts

@@ -46,11 +46,10 @@ export type ParquetLoaderOptions = LoaderOptions & {
 /**
  * ParquetJS table loader
  */
-export const ParquetWorkerLoader: Loader<
-  ObjectRowTable,
-  ObjectRowTableBatch,
-  ParquetLoaderOptions
-> = {
+export const ParquetWorkerLoader = {
+  dataType: null as unknown as ObjectRowTable,
+  batchType: null as unknown as ObjectRowTableBatch,
+
   name: 'Apache Parquet',
   id: 'parquet',
   module: 'parquet',
@@ -70,69 +69,75 @@ export const ParquetWorkerLoader: Loader<
       preserveBinary: false
     }
   }
-};
+} as const satisfies Loader<ObjectRowTable, ObjectRowTableBatch, ParquetLoaderOptions>;
 
 /** ParquetJS table loader */
-export const ParquetLoader: LoaderWithParser<
-  ObjectRowTable | GeoJSONTable,
-  ObjectRowTableBatch | GeoJSONTableBatch,
-  ParquetLoaderOptions
-> = {
+export const ParquetLoader = {
   ...ParquetWorkerLoader,
+
+  dataType: null as unknown as ObjectRowTable | GeoJSONTable,
+  batchType: null as unknown as ObjectRowTableBatch | GeoJSONTableBatch,
+
   parse: (arrayBuffer: ArrayBuffer, options?: ParquetLoaderOptions) =>
     parseParquetFile(new BlobFile(arrayBuffer), options),
 
   parseFile: parseParquetFile,
   parseFileInBatches: parseParquetFileInBatches
-};
+} as const satisfies LoaderWithParser<
+  ObjectRowTable | GeoJSONTable,
+  ObjectRowTableBatch | GeoJSONTableBatch,
+  ParquetLoaderOptions
+>;
 
 // Defeat tree shaking
 // @ts-ignore
 ParquetLoader.Buffer = Buffer;
 
-export const GeoParquetWorkerLoader: Loader<GeoJSONTable, GeoJSONTableBatch, ParquetLoaderOptions> =
-  {
-    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: {
-      parquet: {
-        shape: 'geojson-table',
-        columnList: [],
-        geoparquet: true,
-        url: undefined,
-        preserveBinary: false
-      }
+export const GeoParquetWorkerLoader = {
+  dataType: null as unknown as GeoJSONTable,
+  batchType: null as unknown as GeoJSONTableBatch,
+
+  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: {
+    parquet: {
+      shape: 'geojson-table',
+      columnList: [],
+      geoparquet: true,
+      url: undefined,
+      preserveBinary: false
     }
-  };
+  }
+} as const satisfies Loader<GeoJSONTable, GeoJSONTableBatch, ParquetLoaderOptions>;
 
 /** ParquetJS table loader */
-export const GeoParquetLoader: LoaderWithParser<
-  ObjectRowTable | GeoJSONTable,
-  ObjectRowTableBatch | GeoJSONTableBatch,
-  ParquetLoaderOptions
-> = {
+export const GeoParquetLoader = {
   ...GeoParquetWorkerLoader,
+
   parse(arrayBuffer: ArrayBuffer, options?: ParquetLoaderOptions) {
     return parseGeoParquetFile(new BlobFile(arrayBuffer), options);
   },
   parseFile: parseGeoParquetFile,
   parseFileInBatches: parseGeoParquetFileInBatches
-};
+} as const satisfies LoaderWithParser<
+  ObjectRowTable | GeoJSONTable,
+  ObjectRowTableBatch | GeoJSONTableBatch,
+  ParquetLoaderOptions
+>;
 
 /** @deprecated Test to see if we can improve perf of parquetjs loader */
-export const ParquetColumnarWorkerLoader: Loader<
-  ColumnarTable,
-  ColumnarTableBatch,
-  ParquetLoaderOptions
-> = {
+export const ParquetColumnarWorkerLoader = {
+  dataType: null as any as ColumnarTable,
+  batchType: null as any as ColumnarTableBatch,
+
   name: 'Apache Parquet',
   id: 'parquet',
   module: 'parquet',
@@ -144,18 +149,14 @@ export const ParquetColumnarWorkerLoader: Loader<
   binary: true,
   tests: ['PAR1', 'PARE'],
   options: ParquetLoader.options
-};
+} as const satisfies Loader<ColumnarTable, ColumnarTableBatch, ParquetLoaderOptions>;
 
 /** @deprecated Test to see if we can improve perf of parquetjs loader */
-export const ParquetColumnarLoader: LoaderWithParser<
-  ColumnarTable,
-  ColumnarTableBatch,
-  ParquetLoaderOptions
-> = {
+export const ParquetColumnarLoader = {
   ...ParquetColumnarWorkerLoader,
   parse(arrayBuffer: ArrayBuffer, options?: ParquetLoaderOptions) {
     return parseParquetFileInColumns(new BlobFile(arrayBuffer), options);
   },
   parseFile: parseParquetFileInColumns,
   parseFileInBatches: parseParquetFileInColumnarBatches
-};
+} as const satisfies LoaderWithParser<ColumnarTable, ColumnarTableBatch, ParquetLoaderOptions>;

package/src/parquet-wasm-loader.ts

@@ -17,7 +17,10 @@ export type ParquetWasmLoaderOptions = LoaderOptions & {
 };
 
 /** Parquet WASM table loader */
-export const ParquetWasmWorkerLoader: Loader<ArrowTable, never, ParquetWasmLoaderOptions> = {
+export const ParquetWasmWorkerLoader = {
+  dataType: null as unknown as ArrowTable,
+  batchType: null as never,
+
   name: 'Apache Parquet',
   id: 'parquet-wasm',
   module: 'parquet',
@@ -34,13 +37,13 @@ export const ParquetWasmWorkerLoader: Loader<ArrowTable, never, ParquetWasmLoade
       wasmUrl: PARQUET_WASM_URL
     }
   }
-};
+} as const satisfies Loader<ArrowTable, never, ParquetWasmLoaderOptions>;
 
 /** Parquet WASM table loader */
-export const ParquetWasmLoader: LoaderWithParser<ArrowTable, never, ParquetWasmLoaderOptions> = {
+export const ParquetWasmLoader = {
   ...ParquetWasmWorkerLoader,
   parse(arrayBuffer: ArrayBuffer, options?: ParquetWasmLoaderOptions) {
     options = {parquet: {...ParquetWasmLoader.options.parquet, ...options?.parquet}, ...options};
     return parseParquetWasm(arrayBuffer, options);
   }
-};
+} as const satisfies LoaderWithParser<ArrowTable, never, ParquetWasmLoaderOptions>;

package/src/parquet-wasm-writer.ts

@@ -16,7 +16,7 @@ export type ParquetWriterOptions = WriterOptions & {
 };
 
 /** Parquet WASM writer */
-export const ParquetWasmWriter: WriterWithEncoder<ArrowTable, never, ParquetWriterOptions> = {
+export const ParquetWasmWriter = {
   name: 'Apache Parquet',
   id: 'parquet-wasm',
   module: 'parquet',
@@ -33,4 +33,4 @@ export const ParquetWasmWriter: WriterWithEncoder<ArrowTable, never, ParquetWrit
     options = {parquet: {...ParquetWasmWriter.options.parquet, ...options?.parquet}, ...options};
     return encode(arrowTable, options);
   }
-};
+} as const satisfies WriterWithEncoder<ArrowTable, never, ParquetWriterOptions>;

package/src/parquet-writer.ts

@@ -11,7 +11,7 @@ const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
 
 export type ParquetWriterOptions = {};
 
-export const ParquetWriter: WriterWithEncoder<Table, TableBatch, ParquetWriterOptions> = {
+export const ParquetWriter = {
   name: 'Apache Parquet',
   id: 'parquet',
   module: 'parquet',
@@ -22,7 +22,7 @@ export const ParquetWriter: WriterWithEncoder<Table, TableBatch, ParquetWriterOp
   options: {},
   encode: async (data, options) => encodeSync(data, options),
   encodeSync
-};
+} as const satisfies WriterWithEncoder<Table, TableBatch, ParquetWriterOptions>;
 
 function encodeSync(data, options?: ParquetWriterOptions) {
   return new ArrayBuffer(0);