@loaders.gl/parquet 3.1.3 → 4.0.0-alpha.5

package/dist/index.js

@@ -1,30 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._typecheckParquetLoader = exports.convertParquetToArrowSchema = exports.ParquetEnvelopeReader = exports.ParquetReader = exports.ParquetSchema = exports.preloadCompressions = exports._ParquetWriter = exports.ParquetLoader = exports.ParquetWorkerLoader = void 0;
-// ParquetLoader
-const parquet_loader_1 = require("./parquet-loader");
-Object.defineProperty(exports, "ParquetWorkerLoader", { enumerable: true, get: function () { return parquet_loader_1.ParquetLoader; } });
-const parse_parquet_1 = require("./lib/parse-parquet");
-/** ParquetJS table loader */
-exports.ParquetLoader = {
-    ...parquet_loader_1.ParquetLoader,
-    parse: parse_parquet_1.parseParquet,
-    parseFileInBatches: parse_parquet_1.parseParquetFileInBatches
+import { ParquetLoader as ParquetWorkerLoader } from './parquet-loader';
+import { parseParquet, parseParquetFileInBatches } from './lib/parse-parquet';
+export { ParquetWorkerLoader };
+export const ParquetLoader = { ...ParquetWorkerLoader,
+  parse: parseParquet,
+  parseFileInBatches: parseParquetFileInBatches
 };
-// ParquetWriter
-var parquet_writer_1 = require("./parquet-writer");
-Object.defineProperty(exports, "_ParquetWriter", { enumerable: true, get: function () { return parquet_writer_1.ParquetWriter; } });
-// EXPERIMENTAL - expose the internal parquetjs API
-var compression_1 = require("./parquetjs/compression");
-Object.defineProperty(exports, "preloadCompressions", { enumerable: true, get: function () { return compression_1.preloadCompressions; } });
-var schema_1 = require("./parquetjs/schema/schema");
-Object.defineProperty(exports, "ParquetSchema", { enumerable: true, get: function () { return schema_1.ParquetSchema; } });
-var parquet_reader_1 = require("./parquetjs/parser/parquet-reader");
-Object.defineProperty(exports, "ParquetReader", { enumerable: true, get: function () { return parquet_reader_1.ParquetReader; } });
-var parquet_envelope_reader_1 = require("./parquetjs/parser/parquet-envelope-reader");
-Object.defineProperty(exports, "ParquetEnvelopeReader", { enumerable: true, get: function () { return parquet_envelope_reader_1.ParquetEnvelopeReader; } });
-// export {ParquetWriter, ParquetEnvelopeWriter, ParquetTransformer} from './parquetjs/encoder/writer.js';
-var convert_schema_1 = require("./lib/convert-schema");
-Object.defineProperty(exports, "convertParquetToArrowSchema", { enumerable: true, get: function () { return convert_schema_1.convertParquetToArrowSchema; } });
-// TESTS
-exports._typecheckParquetLoader = exports.ParquetLoader;
+export { ParquetWriter as _ParquetWriter } from './parquet-writer';
+export { preloadCompressions } from './parquetjs/compression';
+export { ParquetSchema } from './parquetjs/schema/schema';
+export { ParquetReader } from './parquetjs/parser/parquet-reader';
+export { ParquetEnvelopeReader } from './parquetjs/parser/parquet-envelope-reader';
+export { convertParquetToArrowSchema } from './lib/convert-schema';
+export const _typecheckParquetLoader = ParquetLoader;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"names":["ParquetLoader","ParquetWorkerLoader","parseParquet","parseParquetFileInBatches","parse","parseFileInBatches","ParquetWriter","_ParquetWriter","preloadCompressions","ParquetSchema","ParquetReader","ParquetEnvelopeReader","convertParquetToArrowSchema","_typecheckParquetLoader"],"mappings":"AAIA,SAAQA,aAAa,IAAIC,mBAAzB,QAAmD,kBAAnD;AACA,SAAQC,YAAR,EAAsBC,yBAAtB,QAAsD,qBAAtD;AAEA,SAAQF,mBAAR;AAGA,OAAO,MAAMD,aAAa,GAAG,EAC3B,GAAGC,mBADwB;AAE3BG,EAAAA,KAAK,EAAEF,YAFoB;AAG3BG,EAAAA,kBAAkB,EAAEF;AAHO,CAAtB;AAQP,SAAQG,aAAa,IAAIC,cAAzB,QAA8C,kBAA9C;AAIA,SAAQC,mBAAR,QAAkC,yBAAlC;AAEA,SAAQC,aAAR,QAA4B,2BAA5B;AACA,SAAQC,aAAR,QAA4B,mCAA5B;AACA,SAAQC,qBAAR,QAAoC,4CAApC;AAEA,SAAQC,2BAAR,QAA0C,sBAA1C;AAGA,OAAO,MAAMC,uBAAyC,GAAGb,aAAlD","sourcesContent":["import type {LoaderWithParser} from '@loaders.gl/loader-utils';\n\n// ParquetLoader\n\nimport {ParquetLoader as ParquetWorkerLoader} from './parquet-loader';\nimport {parseParquet, parseParquetFileInBatches} from './lib/parse-parquet';\n\nexport {ParquetWorkerLoader};\n\n/** ParquetJS table loader */\nexport const ParquetLoader = {\n  ...ParquetWorkerLoader,\n  parse: parseParquet,\n  parseFileInBatches: parseParquetFileInBatches\n};\n\n// ParquetWriter\n\nexport {ParquetWriter as _ParquetWriter} from './parquet-writer';\n\n// EXPERIMENTAL - expose the internal parquetjs API\n\nexport {preloadCompressions} from './parquetjs/compression';\n\nexport {ParquetSchema} from './parquetjs/schema/schema';\nexport {ParquetReader} from './parquetjs/parser/parquet-reader';\nexport {ParquetEnvelopeReader} from './parquetjs/parser/parquet-envelope-reader';\n// export {ParquetWriter, ParquetEnvelopeWriter, ParquetTransformer} from './parquetjs/encoder/writer';\nexport {convertParquetToArrowSchema} from './lib/convert-schema';\n\n// TESTS\nexport const _typecheckParquetLoader: LoaderWithParser = ParquetLoader;\n"],"file":"index.js"}

package/dist/lib/convert-schema.js

@@ -1,70 +1,71 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertParquetToArrowSchema = exports.PARQUET_TYPE_MAPPING = void 0;
-const schema_1 = require("@loaders.gl/schema");
-exports.PARQUET_TYPE_MAPPING = {
-    BOOLEAN: schema_1.Bool,
-    INT32: schema_1.Int32,
-    INT64: schema_1.Float64,
-    INT96: schema_1.Float64,
-    FLOAT: schema_1.Float32,
-    DOUBLE: schema_1.Float64,
-    BYTE_ARRAY: schema_1.Binary,
-    FIXED_LEN_BYTE_ARRAY: schema_1.Binary,
-    UTF8: schema_1.Utf8,
-    DATE: schema_1.Int32,
-    TIME_MILLIS: schema_1.Int64,
-    TIME_MICROS: schema_1.Int64,
-    TIMESTAMP_MILLIS: schema_1.Int64,
-    TIMESTAMP_MICROS: schema_1.Int64,
-    UINT_8: schema_1.Int32,
-    UINT_16: schema_1.Uint16,
-    UINT_32: schema_1.Uint32,
-    UINT_64: schema_1.Uint64,
-    INT_8: schema_1.Int8,
-    INT_16: schema_1.Int16,
-    INT_32: schema_1.Int32,
-    INT_64: schema_1.Int64,
-    JSON: schema_1.Binary,
-    BSON: schema_1.Binary,
-    // TODO check interal type
-    INTERVAL: schema_1.Binary,
-    DECIMAL_INT32: schema_1.Float32,
-    DECIMAL_INT64: schema_1.Float64,
-    DECIMAL_BYTE_ARRAY: schema_1.Float64,
-    DECIMAL_FIXED_LEN_BYTE_ARRAY: schema_1.Float64
+import { Schema, Struct, Field, Bool, Float64, Int32, Float32, Binary, Utf8, Int64, Uint16, Uint32, Uint64, Int8, Int16 } from '@loaders.gl/schema';
+export const PARQUET_TYPE_MAPPING = {
+  BOOLEAN: Bool,
+  INT32: Int32,
+  INT64: Float64,
+  INT96: Float64,
+  FLOAT: Float32,
+  DOUBLE: Float64,
+  BYTE_ARRAY: Binary,
+  FIXED_LEN_BYTE_ARRAY: Binary,
+  UTF8: Utf8,
+  DATE: Int32,
+  TIME_MILLIS: Int64,
+  TIME_MICROS: Int64,
+  TIMESTAMP_MILLIS: Int64,
+  TIMESTAMP_MICROS: Int64,
+  UINT_8: Int32,
+  UINT_16: Uint16,
+  UINT_32: Uint32,
+  UINT_64: Uint64,
+  INT_8: Int8,
+  INT_16: Int16,
+  INT_32: Int32,
+  INT_64: Int64,
+  JSON: Binary,
+  BSON: Binary,
+  INTERVAL: Binary,
+  DECIMAL_INT32: Float32,
+  DECIMAL_INT64: Float64,
+  DECIMAL_BYTE_ARRAY: Float64,
+  DECIMAL_FIXED_LEN_BYTE_ARRAY: Float64
 };
-function convertParquetToArrowSchema(parquetSchema) {
-    const fields = getFields(parquetSchema.schema);
-    // TODO add metadata if needed.
-    return new schema_1.Schema(fields);
+export function convertParquetToArrowSchema(parquetSchema) {
+  const fields = getFields(parquetSchema.schema);
+  return new Schema(fields);
 }
-exports.convertParquetToArrowSchema = convertParquetToArrowSchema;
+
 function getFieldMetadata(field) {
-    const metadata = new Map();
-    for (const key in field) {
-        if (key !== 'name') {
-            const value = typeof field[key] !== 'string' ? JSON.stringify(field[key]) : field[key];
-            metadata.set(key, value);
-        }
+  const metadata = new Map();
+
+  for (const key in field) {
+    if (key !== 'name') {
+      const value = typeof field[key] !== 'string' ? JSON.stringify(field[key]) : field[key];
+      metadata.set(key, value);
     }
-    return metadata;
+  }
+
+  return metadata;
 }
+
 function getFields(schema) {
-    const fields = [];
-    for (const name in schema) {
-        const field = schema[name];
-        if (field.fields) {
-            const childField = getFields(field.fields);
-            const nestedField = new schema_1.Field(name, new schema_1.Struct(childField), field.optional);
-            fields.push(nestedField);
-        }
-        else {
-            const FieldType = exports.PARQUET_TYPE_MAPPING[field.type];
-            const metadata = getFieldMetadata(field);
-            const arrowField = new schema_1.Field(name, new FieldType(), field.optional, metadata);
-            fields.push(arrowField);
-        }
+  const fields = [];
+
+  for (const name in schema) {
+    const field = schema[name];
+
+    if (field.fields) {
+      const childField = getFields(field.fields);
+      const nestedField = new Field(name, new Struct(childField), field.optional);
+      fields.push(nestedField);
+    } else {
+      const FieldType = PARQUET_TYPE_MAPPING[field.type];
+      const metadata = getFieldMetadata(field);
+      const arrowField = new Field(name, new FieldType(), field.optional, metadata);
+      fields.push(arrowField);
     }
-    return fields;
+  }
+
+  return fields;
 }
+//# sourceMappingURL=convert-schema.js.map

package/dist/lib/convert-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/convert-schema.ts"],"names":["Schema","Struct","Field","Bool","Float64","Int32","Float32","Binary","Utf8","Int64","Uint16","Uint32","Uint64","Int8","Int16","PARQUET_TYPE_MAPPING","BOOLEAN","INT32","INT64","INT96","FLOAT","DOUBLE","BYTE_ARRAY","FIXED_LEN_BYTE_ARRAY","UTF8","DATE","TIME_MILLIS","TIME_MICROS","TIMESTAMP_MILLIS","TIMESTAMP_MICROS","UINT_8","UINT_16","UINT_32","UINT_64","INT_8","INT_16","INT_32","INT_64","JSON","BSON","INTERVAL","DECIMAL_INT32","DECIMAL_INT64","DECIMAL_BYTE_ARRAY","DECIMAL_FIXED_LEN_BYTE_ARRAY","convertParquetToArrowSchema","parquetSchema","fields","getFields","schema","getFieldMetadata","field","metadata","Map","key","value","stringify","set","name","childField","nestedField","optional","push","FieldType","type","arrowField"],"mappings":"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","sourcesContent":["import type {ParquetSchema} from '../parquetjs/schema/schema';\nimport type {FieldDefinition, ParquetField, ParquetType} from '../parquetjs/schema/declare';\n\nimport {\n  Schema,\n  Struct,\n  Field,\n  DataType,\n  Bool,\n  Float64,\n  Int32,\n  Float32,\n  Binary,\n  Utf8,\n  Int64,\n  Uint16,\n  Uint32,\n  Uint64,\n  Int8,\n  Int16\n} from '@loaders.gl/schema';\n\nexport const PARQUET_TYPE_MAPPING: {[type in ParquetType]: typeof DataType} = {\n  BOOLEAN: Bool,\n  INT32: Int32,\n  INT64: Float64,\n  INT96: Float64,\n  FLOAT: Float32,\n  DOUBLE: Float64,\n  BYTE_ARRAY: Binary,\n  FIXED_LEN_BYTE_ARRAY: Binary,\n  UTF8: Utf8,\n  DATE: Int32,\n  TIME_MILLIS: Int64,\n  TIME_MICROS: Int64,\n  TIMESTAMP_MILLIS: Int64,\n  TIMESTAMP_MICROS: Int64,\n  UINT_8: Int32,\n  UINT_16: Uint16,\n  UINT_32: Uint32,\n  UINT_64: Uint64,\n  INT_8: Int8,\n  INT_16: Int16,\n  INT_32: Int32,\n  INT_64: Int64,\n  JSON: Binary,\n  BSON: Binary,\n  // TODO check interal type\n  INTERVAL: Binary,\n  DECIMAL_INT32: Float32,\n  DECIMAL_INT64: Float64,\n  DECIMAL_BYTE_ARRAY: Float64,\n  DECIMAL_FIXED_LEN_BYTE_ARRAY: Float64\n};\n\nexport function convertParquetToArrowSchema(parquetSchema: ParquetSchema): Schema {\n  const fields = getFields(parquetSchema.schema);\n\n  // TODO add metadata if needed.\n  return new Schema(fields);\n}\n\nfunction getFieldMetadata(field: ParquetField): Map<string, string> {\n  const metadata = new Map();\n\n  for (const key in field) {\n    if (key !== 'name') {\n      const value = typeof field[key] !== 'string' ? JSON.stringify(field[key]) : field[key];\n      metadata.set(key, value);\n    }\n  }\n\n  return metadata;\n}\n\nfunction getFields(schema: FieldDefinition): Field[] {\n  const fields: Field[] = [];\n\n  for (const name in schema) {\n    const field = schema[name];\n\n    if (field.fields) {\n      const childField = getFields(field.fields);\n      const nestedField = new Field(name, new Struct(childField), field.optional);\n      fields.push(nestedField);\n    } else {\n      const FieldType = PARQUET_TYPE_MAPPING[field.type];\n      const metadata = getFieldMetadata(field);\n      const arrowField = new Field(name, new FieldType(), field.optional, metadata);\n      fields.push(arrowField);\n    }\n  }\n\n  return fields;\n}\n"],"file":"convert-schema.js"}

package/dist/lib/parse-parquet.js

@@ -1,28 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseParquetFileInBatches = exports.parseParquet = void 0;
-const parquet_reader_1 = require("../parquetjs/parser/parquet-reader");
-async function parseParquet(arrayBuffer, options) {
-    const blob = new Blob([arrayBuffer]);
-    for await (const batch of parseParquetFileInBatches(blob, options)) {
-        return batch;
-    }
-    return null;
+import { ParquetReader } from '../parquetjs/parser/parquet-reader';
+export async function parseParquet(arrayBuffer, options) {
+  const blob = new Blob([arrayBuffer]);
+
+  for await (const batch of parseParquetFileInBatches(blob, options)) {
+    return batch;
+  }
+
+  return null;
 }
-exports.parseParquet = parseParquet;
-async function* parseParquetFileInBatches(blob, options) {
-    const reader = await parquet_reader_1.ParquetReader.openBlob(blob);
-    const rows = [];
-    try {
-        const cursor = reader.getCursor();
-        let record;
-        while ((record = await cursor.next())) {
-            rows.push(record);
-        }
-    }
-    finally {
-        await reader.close();
+export async function* parseParquetFileInBatches(blob, options) {
+  const reader = await ParquetReader.openBlob(blob);
+  const rows = [];
+
+  try {
+    const cursor = reader.getCursor();
+    let record;
+
+    while (record = await cursor.next()) {
+      rows.push(record);
     }
-    yield rows;
+  } finally {
+    await reader.close();
+  }
+
+  yield rows;
 }
-exports.parseParquetFileInBatches = parseParquetFileInBatches;
+//# sourceMappingURL=parse-parquet.js.map

package/dist/lib/parse-parquet.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/parse-parquet.ts"],"names":["ParquetReader","parseParquet","arrayBuffer","options","blob","Blob","batch","parseParquetFileInBatches","reader","openBlob","rows","cursor","getCursor","record","next","push","close"],"mappings":"AAGA,SAAQA,aAAR,QAA4B,oCAA5B;AAEA,OAAO,eAAeC,YAAf,CAA4BC,WAA5B,EAAsDC,OAAtD,EAAsF;AAC3F,QAAMC,IAAI,GAAG,IAAIC,IAAJ,CAAS,CAACH,WAAD,CAAT,CAAb;;AACA,aAAW,MAAMI,KAAjB,IAA0BC,yBAAyB,CAACH,IAAD,EAAOD,OAAP,CAAnD,EAAoE;AAClE,WAAOG,KAAP;AACD;;AACD,SAAO,IAAP;AACD;AAED,OAAO,gBAAgBC,yBAAhB,CAA0CH,IAA1C,EAAsDD,OAAtD,EAAsF;AAC3F,QAAMK,MAAM,GAAG,MAAMR,aAAa,CAACS,QAAd,CAAuBL,IAAvB,CAArB;AACA,QAAMM,IAAa,GAAG,EAAtB;;AACA,MAAI;AACF,UAAMC,MAAM,GAAGH,MAAM,CAACI,SAAP,EAAf;AACA,QAAIC,MAAJ;;AACA,WAAQA,MAAM,GAAG,MAAMF,MAAM,CAACG,IAAP,EAAvB,EAAuC;AACrCJ,MAAAA,IAAI,CAACK,IAAL,CAAUF,MAAV;AACD;AACF,GAND,SAMU;AACR,UAAML,MAAM,CAACQ,KAAP,EAAN;AACD;;AACD,QAAMN,IAAN;AACD","sourcesContent":["// import type {LoaderWithParser, Loader, LoaderOptions} from '@loaders.gl/loader-utils';\nimport type {ParquetLoaderOptions} from '../parquet-loader';\n\nimport {ParquetReader} from '../parquetjs/parser/parquet-reader';\n\nexport async function parseParquet(arrayBuffer: ArrayBuffer, options?: ParquetLoaderOptions) {\n  const blob = new Blob([arrayBuffer]);\n  for await (const batch of parseParquetFileInBatches(blob, options)) {\n    return batch;\n  }\n  return null;\n}\n\nexport async function* parseParquetFileInBatches(blob: Blob, options?: ParquetLoaderOptions) {\n  const reader = await ParquetReader.openBlob(blob);\n  const rows: any[][] = [];\n  try {\n    const cursor = reader.getCursor();\n    let record: any[] | null;\n    while ((record = await cursor.next())) {\n      rows.push(record);\n    }\n  } finally {\n    await reader.close();\n  }\n  yield rows;\n}\n"],"file":"parse-parquet.js"}

package/dist/lib/read-array-buffer.js

@@ -1,29 +1,9 @@
-"use strict";
-// Random-Access read
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readArrayBuffer = void 0;
-async function readArrayBuffer(file, start, length) {
-    if (file instanceof Blob) {
-        const slice = file.slice(start, start + length);
-        return await slice.arrayBuffer();
-    }
-    return await file.read(start, start + length);
+export async function readArrayBuffer(file, start, length) {
+  if (file instanceof Blob) {
+    const slice = file.slice(start, start + length);
+    return await slice.arrayBuffer();
+  }
+
+  return await file.read(start, start + length);
 }
-exports.readArrayBuffer = readArrayBuffer;
-/**
- * Read a slice of a Blob or File, without loading the entire file into memory
- * The trick when reading File objects is to read successive "slices" of the File
- * Per spec https://w3c.github.io/FileAPI/, slicing a File only updates the start and end fields
- * Actually reading from file happens in `readAsArrayBuffer`
- * @param blob to read
- export async function readBlob(blob: Blob): Promise<ArrayBuffer> {
-  return await new Promise((resolve, reject) => {
-    const fileReader = new FileReader();
-    fileReader.onload = (event: ProgressEvent<FileReader>) =>
-      resolve(event?.target?.result as ArrayBuffer);
-    // TODO - reject with a proper Error
-    fileReader.onerror = (error: ProgressEvent<FileReader>) => reject(error);
-    fileReader.readAsArrayBuffer(blob);
-  });
-}
-*/
+//# sourceMappingURL=read-array-buffer.js.map

package/dist/lib/read-array-buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/read-array-buffer.ts"],"names":["readArrayBuffer","file","start","length","Blob","slice","arrayBuffer","read"],"mappings":"AAEA,OAAO,eAAeA,eAAf,CACLC,IADK,EAELC,KAFK,EAGLC,MAHK,EAIiB;AACtB,MAAIF,IAAI,YAAYG,IAApB,EAA0B;AACxB,UAAMC,KAAK,GAAGJ,IAAI,CAACI,KAAL,CAAWH,KAAX,EAAkBA,KAAK,GAAGC,MAA1B,CAAd;AACA,WAAO,MAAME,KAAK,CAACC,WAAN,EAAb;AACD;;AACD,SAAO,MAAML,IAAI,CAACM,IAAL,CAAUL,KAAV,EAAiBA,KAAK,GAAGC,MAAzB,CAAb;AACD","sourcesContent":["// Random-Access read\n\nexport async function readArrayBuffer(\n  file: Blob | ArrayBuffer | any,\n  start: number,\n  length: number\n): Promise<ArrayBuffer> {\n  if (file instanceof Blob) {\n    const slice = file.slice(start, start + length);\n    return await slice.arrayBuffer();\n  }\n  return await file.read(start, start + length);\n}\n\n/**\n * Read a slice of a Blob or File, without loading the entire file into memory\n * The trick when reading File objects is to read successive \"slices\" of the File\n * Per spec https://w3c.github.io/FileAPI/, slicing a File only updates the start and end fields\n * Actually reading from file happens in `readAsArrayBuffer`\n * @param blob to read\n export async function readBlob(blob: Blob): Promise<ArrayBuffer> {\n  return await new Promise((resolve, reject) => {\n    const fileReader = new FileReader();\n    fileReader.onload = (event: ProgressEvent<FileReader>) =>\n      resolve(event?.target?.result as ArrayBuffer);\n    // TODO - reject with a proper Error\n    fileReader.onerror = (error: ProgressEvent<FileReader>) => reject(error);\n    fileReader.readAsArrayBuffer(blob);\n  });\n}\n*/\n"],"file":"read-array-buffer.js"}

package/dist/parquet-loader.js

@@ -1,27 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._typecheckParquetLoader = exports.ParquetLoader = void 0;
-// __VERSION__ is injected by babel-plugin-version-inline
-// @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+const VERSION = typeof "4.0.0-alpha.5" !== 'undefined' ? "4.0.0-alpha.5" : 'latest';
 const DEFAULT_PARQUET_LOADER_OPTIONS = {
-    parquet: {
-        type: 'object-row-table',
-        url: undefined
-    }
+  parquet: {
+    type: 'object-row-table',
+    url: undefined
+  }
 };
-/** ParquetJS table loader */
-exports.ParquetLoader = {
-    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: DEFAULT_PARQUET_LOADER_OPTIONS
+export const ParquetLoader = {
+  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: DEFAULT_PARQUET_LOADER_OPTIONS
 };
-exports._typecheckParquetLoader = exports.ParquetLoader;
+export const _typecheckParquetLoader = ParquetLoader;
+//# sourceMappingURL=parquet-loader.js.map

package/dist/parquet-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/parquet-loader.ts"],"names":["VERSION","DEFAULT_PARQUET_LOADER_OPTIONS","parquet","type","url","undefined","ParquetLoader","name","id","module","version","worker","category","extensions","mimeTypes","binary","tests","options","_typecheckParquetLoader"],"mappings":"AAIA,MAAMA,OAAO,GAAG,2BAAuB,WAAvB,qBAAmD,QAAnE;AASA,MAAMC,8BAAoD,GAAG;AAC3DC,EAAAA,OAAO,EAAE;AACPC,IAAAA,IAAI,EAAE,kBADC;AAEPC,IAAAA,GAAG,EAAEC;AAFE;AADkD,CAA7D;AAQA,OAAO,MAAMC,aAAa,GAAG;AAC3BC,EAAAA,IAAI,EAAE,gBADqB;AAE3BC,EAAAA,EAAE,EAAE,SAFuB;AAG3BC,EAAAA,MAAM,EAAE,SAHmB;AAI3BC,EAAAA,OAAO,EAAEV,OAJkB;AAK3BW,EAAAA,MAAM,EAAE,IALmB;AAM3BC,EAAAA,QAAQ,EAAE,OANiB;AAO3BC,EAAAA,UAAU,EAAE,CAAC,SAAD,CAPe;AAQ3BC,EAAAA,SAAS,EAAE,CAAC,0BAAD,CARgB;AAS3BC,EAAAA,MAAM,EAAE,IATmB;AAU3BC,EAAAA,KAAK,EAAE,CAAC,MAAD,EAAS,MAAT,CAVoB;AAW3BC,EAAAA,OAAO,EAAEhB;AAXkB,CAAtB;AAcP,OAAO,MAAMiB,uBAA+B,GAAGZ,aAAxC","sourcesContent":["import type {Loader, LoaderOptions} from '@loaders.gl/loader-utils';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nexport type ParquetLoaderOptions = LoaderOptions & {\n  parquet?: {\n    type?: 'object-row-table';\n    url?: string;\n  };\n};\n\nconst DEFAULT_PARQUET_LOADER_OPTIONS: ParquetLoaderOptions = {\n  parquet: {\n    type: 'object-row-table',\n    url: undefined\n  }\n};\n\n/** ParquetJS table loader */\nexport const ParquetLoader = {\n  name: 'Apache Parquet',\n  id: 'parquet',\n  module: 'parquet',\n  version: VERSION,\n  worker: true,\n  category: 'table',\n  extensions: ['parquet'],\n  mimeTypes: ['application/octet-stream'],\n  binary: true,\n  tests: ['PAR1', 'PARE'],\n  options: DEFAULT_PARQUET_LOADER_OPTIONS\n};\n\nexport const _typecheckParquetLoader: Loader = ParquetLoader;\n"],"file":"parquet-loader.js"}