@loaders.gl/parquet 3.1.0-beta.3 → 3.1.1

package/dist/es5/bundle.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const moduleExports = require('./index');
+var moduleExports = require('./index');
 
 globalThis.loaders = globalThis.loaders || {};
 module.exports = Object.assign(globalThis.loaders, moduleExports);

package/dist/es5/bundle.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/bundle.ts"],"names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"mappings":";;AACA,MAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCH,aAAlC,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}
+{"version":3,"sources":["../../src/bundle.ts"],"names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"mappings":";;AACA,IAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCH,aAAlC,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}

package/dist/es5/constants.js

@@ -4,14 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.PARQUET_RDLVL_ENCODING = exports.PARQUET_RDLVL_TYPE = exports.PARQUET_VERSION = exports.PARQUET_MAGIC_ENCRYPTED = exports.PARQUET_MAGIC = void 0;
-const PARQUET_MAGIC = 'PAR1';
+var PARQUET_MAGIC = 'PAR1';
 exports.PARQUET_MAGIC = PARQUET_MAGIC;
-const PARQUET_MAGIC_ENCRYPTED = 'PARE';
+var PARQUET_MAGIC_ENCRYPTED = 'PARE';
 exports.PARQUET_MAGIC_ENCRYPTED = PARQUET_MAGIC_ENCRYPTED;
-const PARQUET_VERSION = 1;
+var PARQUET_VERSION = 1;
 exports.PARQUET_VERSION = PARQUET_VERSION;
-const PARQUET_RDLVL_TYPE = 'INT32';
+var PARQUET_RDLVL_TYPE = 'INT32';
 exports.PARQUET_RDLVL_TYPE = PARQUET_RDLVL_TYPE;
-const PARQUET_RDLVL_ENCODING = 'RLE';
+var PARQUET_RDLVL_ENCODING = 'RLE';
 exports.PARQUET_RDLVL_ENCODING = PARQUET_RDLVL_ENCODING;
 //# sourceMappingURL=constants.js.map

package/dist/es5/constants.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/constants.ts"],"names":["PARQUET_MAGIC","PARQUET_MAGIC_ENCRYPTED","PARQUET_VERSION","PARQUET_RDLVL_TYPE","PARQUET_RDLVL_ENCODING"],"mappings":";;;;;;AAIO,MAAMA,aAAa,GAAG,MAAtB;;AACA,MAAMC,uBAAuB,GAAG,MAAhC;;AAKA,MAAMC,eAAe,GAAG,CAAxB;;AAKA,MAAMC,kBAAkB,GAAG,OAA3B;;AACA,MAAMC,sBAAsB,GAAG,KAA/B","sourcesContent":["// Forked from https://github.com/kbajalc/parquets under MIT license (Copyright (c) 2017 ironSource Ltd.)\n/**\n * Parquet File Magic String\n */\nexport const PARQUET_MAGIC = 'PAR1';\nexport const PARQUET_MAGIC_ENCRYPTED = 'PARE';\n\n/**\n * Parquet File Format Version\n */\nexport const PARQUET_VERSION = 1;\n\n/**\n * Internal type used for repetition/definition levels\n */\nexport const PARQUET_RDLVL_TYPE = 'INT32';\nexport const PARQUET_RDLVL_ENCODING = 'RLE';\n"],"file":"constants.js"}
+{"version":3,"sources":["../../src/constants.ts"],"names":["PARQUET_MAGIC","PARQUET_MAGIC_ENCRYPTED","PARQUET_VERSION","PARQUET_RDLVL_TYPE","PARQUET_RDLVL_ENCODING"],"mappings":";;;;;;AAIO,IAAMA,aAAa,GAAG,MAAtB;;AACA,IAAMC,uBAAuB,GAAG,MAAhC;;AAKA,IAAMC,eAAe,GAAG,CAAxB;;AAKA,IAAMC,kBAAkB,GAAG,OAA3B;;AACA,IAAMC,sBAAsB,GAAG,KAA/B","sourcesContent":["// Forked from https://github.com/kbajalc/parquets under MIT license (Copyright (c) 2017 ironSource Ltd.)\n/**\n * Parquet File Magic String\n */\nexport const PARQUET_MAGIC = 'PAR1';\nexport const PARQUET_MAGIC_ENCRYPTED = 'PARE';\n\n/**\n * Parquet File Format Version\n */\nexport const PARQUET_VERSION = 1;\n\n/**\n * Internal type used for repetition/definition levels\n */\nexport const PARQUET_RDLVL_TYPE = 'INT32';\nexport const PARQUET_RDLVL_ENCODING = 'RLE';\n"],"file":"constants.js"}

package/dist/es5/index.js

@@ -1,52 +1,56 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 Object.defineProperty(exports, "ParquetWorkerLoader", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _parquetLoader.ParquetLoader;
   }
 });
 Object.defineProperty(exports, "_ParquetWriter", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _parquetWriter.ParquetWriter;
   }
 });
 Object.defineProperty(exports, "preloadCompressions", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _compression.preloadCompressions;
   }
 });
 Object.defineProperty(exports, "ParquetSchema", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _schema.ParquetSchema;
   }
 });
 Object.defineProperty(exports, "ParquetReader", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _parquetReader.ParquetReader;
   }
 });
 Object.defineProperty(exports, "ParquetEnvelopeReader", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _parquetEnvelopeReader.ParquetEnvelopeReader;
   }
 });
 Object.defineProperty(exports, "convertParquetToArrowSchema", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _convertSchema.convertParquetToArrowSchema;
   }
 });
 exports._typecheckParquetLoader = exports.ParquetLoader = void 0;
 
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
 var _parquetLoader = require("./parquet-loader");
 
 var _parseParquet = require("./lib/parse-parquet");
@@ -63,11 +67,16 @@ var _parquetEnvelopeReader = require("./parquetjs/parser/parquet-envelope-reader
 
 var _convertSchema = require("./lib/convert-schema");
 
-const ParquetLoader = { ..._parquetLoader.ParquetLoader,
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var ParquetLoader = _objectSpread(_objectSpread({}, _parquetLoader.ParquetLoader), {}, {
   parse: _parseParquet.parseParquet,
   parseFileInBatches: _parseParquet.parseParquetFileInBatches
-};
+});
+
 exports.ParquetLoader = ParquetLoader;
-const _typecheckParquetLoader = ParquetLoader;
+var _typecheckParquetLoader = ParquetLoader;
 exports._typecheckParquetLoader = _typecheckParquetLoader;
 //# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"names":["ParquetLoader","ParquetWorkerLoader","parse","parseParquet","parseFileInBatches","parseParquetFileInBatches","_typecheckParquetLoader"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA;;AACA;;AAaA;;AAIA;;AAEA;;AACA;;AACA;;AAEA;;AAlBO,MAAMA,aAAa,GAAG,EAC3B,GAAGC,4BADwB;AAE3BC,EAAAA,KAAK,EAAEC,0BAFoB;AAG3BC,EAAAA,kBAAkB,EAAEC;AAHO,CAAtB;;AAqBA,MAAMC,uBAAyC,GAAGN,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"}
+{"version":3,"sources":["../../src/index.ts"],"names":["ParquetLoader","ParquetWorkerLoader","parse","parseParquet","parseFileInBatches","parseParquetFileInBatches","_typecheckParquetLoader"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA;;AACA;;AAaA;;AAIA;;AAEA;;AACA;;AACA;;AAEA;;;;;;AAlBO,IAAMA,aAAa,mCACrBC,4BADqB;AAExBC,EAAAA,KAAK,EAAEC,0BAFiB;AAGxBC,EAAAA,kBAAkB,EAAEC;AAHI,EAAnB;;;AAqBA,IAAMC,uBAAyC,GAAGN,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/es5/lib/convert-schema.js

@@ -8,7 +8,7 @@ exports.PARQUET_TYPE_MAPPING = void 0;
 
 var _schema = require("@loaders.gl/schema");
 
-const PARQUET_TYPE_MAPPING = {
+var PARQUET_TYPE_MAPPING = {
   BOOLEAN: _schema.Bool,
   INT32: _schema.Int32,
   INT64: _schema.Float64,
@@ -42,16 +42,16 @@ const PARQUET_TYPE_MAPPING = {
 exports.PARQUET_TYPE_MAPPING = PARQUET_TYPE_MAPPING;
 
 function convertParquetToArrowSchema(parquetSchema) {
-  const fields = getFields(parquetSchema.schema);
+  var fields = getFields(parquetSchema.schema);
   return new _schema.Schema(fields);
 }
 
 function getFieldMetadata(field) {
-  const metadata = new Map();
+  var metadata = new Map();
 
-  for (const key in field) {
+  for (var key in field) {
     if (key !== 'name') {
-      const value = typeof field[key] !== 'string' ? JSON.stringify(field[key]) : field[key];
+      var value = typeof field[key] !== 'string' ? JSON.stringify(field[key]) : field[key];
       metadata.set(key, value);
     }
   }
@@ -60,19 +60,19 @@ function getFieldMetadata(field) {
 }
 
 function getFields(schema) {
-  const fields = [];
+  var fields = [];
 
-  for (const name in schema) {
-    const field = schema[name];
+  for (var name in schema) {
+    var field = schema[name];
 
     if (field.fields) {
-      const childField = getFields(field.fields);
-      const nestedField = new _schema.Field(name, new _schema.Struct(childField), field.optional);
+      var childField = getFields(field.fields);
+      var nestedField = new _schema.Field(name, new _schema.Struct(childField), field.optional);
       fields.push(nestedField);
     } else {
-      const FieldType = PARQUET_TYPE_MAPPING[field.type];
-      const metadata = getFieldMetadata(field);
-      const arrowField = new _schema.Field(name, new FieldType(), field.optional, metadata);
+      var FieldType = PARQUET_TYPE_MAPPING[field.type];
+      var metadata = getFieldMetadata(field);
+      var arrowField = new _schema.Field(name, new FieldType(), field.optional, metadata);
       fields.push(arrowField);
     }
   }

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/convert-schema.ts"],"names":["PARQUET_TYPE_MAPPING","BOOLEAN","Bool","INT32","Int32","INT64","Float64","INT96","FLOAT","Float32","DOUBLE","BYTE_ARRAY","Binary","FIXED_LEN_BYTE_ARRAY","UTF8","Utf8","DATE","TIME_MILLIS","Int64","TIME_MICROS","TIMESTAMP_MILLIS","TIMESTAMP_MICROS","UINT_8","UINT_16","Uint16","UINT_32","Uint32","UINT_64","Uint64","INT_8","Int8","INT_16","Int16","INT_32","INT_64","JSON","BSON","INTERVAL","DECIMAL_INT32","DECIMAL_INT64","DECIMAL_BYTE_ARRAY","DECIMAL_FIXED_LEN_BYTE_ARRAY","convertParquetToArrowSchema","parquetSchema","fields","getFields","schema","Schema","getFieldMetadata","field","metadata","Map","key","value","stringify","set","name","childField","nestedField","Field","Struct","optional","push","FieldType","type","arrowField"],"mappings":";;;;;;;;AAGA;;AAmBO,MAAMA,oBAA8D,GAAG;AAC5EC,EAAAA,OAAO,EAAEC,YADmE;AAE5EC,EAAAA,KAAK,EAAEC,aAFqE;AAG5EC,EAAAA,KAAK,EAAEC,eAHqE;AAI5EC,EAAAA,KAAK,EAAED,eAJqE;AAK5EE,EAAAA,KAAK,EAAEC,eALqE;AAM5EC,EAAAA,MAAM,EAAEJ,eANoE;AAO5EK,EAAAA,UAAU,EAAEC,cAPgE;AAQ5EC,EAAAA,oBAAoB,EAAED,cARsD;AAS5EE,EAAAA,IAAI,EAAEC,YATsE;AAU5EC,EAAAA,IAAI,EAAEZ,aAVsE;AAW5Ea,EAAAA,WAAW,EAAEC,aAX+D;AAY5EC,EAAAA,WAAW,EAAED,aAZ+D;AAa5EE,EAAAA,gBAAgB,EAAEF,aAb0D;AAc5EG,EAAAA,gBAAgB,EAAEH,aAd0D;AAe5EI,EAAAA,MAAM,EAAElB,aAfoE;AAgB5EmB,EAAAA,OAAO,EAAEC,cAhBmE;AAiB5EC,EAAAA,OAAO,EAAEC,cAjBmE;AAkB5EC,EAAAA,OAAO,EAAEC,cAlBmE;AAmB5EC,EAAAA,KAAK,EAAEC,YAnBqE;AAoB5EC,EAAAA,MAAM,EAAEC,aApBoE;AAqB5EC,EAAAA,MAAM,EAAE7B,aArBoE;AAsB5E8B,EAAAA,MAAM,EAAEhB,aAtBoE;AAuB5EiB,EAAAA,IAAI,EAAEvB,cAvBsE;AAwB5EwB,EAAAA,IAAI,EAAExB,cAxBsE;AA0B5EyB,EAAAA,QAAQ,EAAEzB,cA1BkE;AA2B5E0B,EAAAA,aAAa,EAAE7B,eA3B6D;AA4B5E8B,EAAAA,aAAa,EAAEjC,eA5B6D;AA6B5EkC,EAAAA,kBAAkB,EAAElC,eA7BwD;AA8B5EmC,EAAAA,4BAA4B,EAAEnC;AA9B8C,CAAvE;;;AAiCA,SAASoC,2BAAT,CAAqCC,aAArC,EAA2E;AAChF,QAAMC,MAAM,GAAGC,SAAS,CAACF,aAAa,CAACG,MAAf,CAAxB;AAGA,SAAO,IAAIC,cAAJ,CAAWH,MAAX,CAAP;AACD;;AAED,SAASI,gBAAT,CAA0BC,KAA1B,EAAoE;AAClE,QAAMC,QAAQ,GAAG,IAAIC,GAAJ,EAAjB;;AAEA,OAAK,MAAMC,GAAX,IAAkBH,KAAlB,EAAyB;AACvB,QAAIG,GAAG,KAAK,MAAZ,EAAoB;AAClB,YAAMC,KAAK,GAAG,OAAOJ,KAAK,CAACG,GAAD,CAAZ,KAAsB,QAAtB,GAAiCjB,IAAI,CAACmB,SAAL,CAAeL,KAAK,CAACG,GAAD,CAApB,CAAjC,GAA8DH,KAAK,CAACG,GAAD,CAAjF;AACAF,MAAAA,QAAQ,CAACK,GAAT,CAAaH,GAAb,EAAkBC,KAAlB;AACD;AACF;;AAED,SAAOH,QAAP;AACD;;AAED,SAASL,SAAT,CAAmBC,MAAnB,EAAqD;AACnD,QAAMF,MAAe,GAAG,EAAxB;;AAEA,OAAK,MAAMY,IAAX,IAAmBV,MAAnB,EAA2B;AACzB,UAAMG,KAAK,GAAGH,MAAM,CAACU,IAAD,CAApB;;AAEA,QAAIP,KAAK,CAACL,MAAV,EAAkB;AAChB,YAAMa,UAAU,GAAGZ,SAAS,CAACI,KAAK,CAACL,MAAP,CAA5B;AACA,YAAMc,WAAW,GAAG,IAAIC,aAAJ,CAAUH,IAAV,EAAgB,IAAII,cAAJ,CAAWH,UAAX,CAAhB,EAAwCR,KAAK,CAACY,QAA9C,CAApB;AACAjB,MAAAA,MAAM,CAACkB,IAAP,CAAYJ,WAAZ;AACD,KAJD,MAIO;AACL,YAAMK,SAAS,GAAG/D,oBAAoB,CAACiD,KAAK,CAACe,IAAP,CAAtC;AACA,YAAMd,QAAQ,GAAGF,gBAAgB,CAACC,KAAD,CAAjC;AACA,YAAMgB,UAAU,GAAG,IAAIN,aAAJ,CAAUH,IAAV,EAAgB,IAAIO,SAAJ,EAAhB,EAAiCd,KAAK,CAACY,QAAvC,EAAiDX,QAAjD,CAAnB;AACAN,MAAAA,MAAM,CAACkB,IAAP,CAAYG,UAAZ;AACD;AACF;;AAED,SAAOrB,MAAP;AACD","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"}
+{"version":3,"sources":["../../../src/lib/convert-schema.ts"],"names":["PARQUET_TYPE_MAPPING","BOOLEAN","Bool","INT32","Int32","INT64","Float64","INT96","FLOAT","Float32","DOUBLE","BYTE_ARRAY","Binary","FIXED_LEN_BYTE_ARRAY","UTF8","Utf8","DATE","TIME_MILLIS","Int64","TIME_MICROS","TIMESTAMP_MILLIS","TIMESTAMP_MICROS","UINT_8","UINT_16","Uint16","UINT_32","Uint32","UINT_64","Uint64","INT_8","Int8","INT_16","Int16","INT_32","INT_64","JSON","BSON","INTERVAL","DECIMAL_INT32","DECIMAL_INT64","DECIMAL_BYTE_ARRAY","DECIMAL_FIXED_LEN_BYTE_ARRAY","convertParquetToArrowSchema","parquetSchema","fields","getFields","schema","Schema","getFieldMetadata","field","metadata","Map","key","value","stringify","set","name","childField","nestedField","Field","Struct","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/es5/lib/parse-parquet.js

@@ -1,38 +1,173 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.parseParquet = parseParquet;
 exports.parseParquetFileInBatches = parseParquetFileInBatches;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _awaitAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/awaitAsyncGenerator"));
+
+var _wrapAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapAsyncGenerator"));
+
+var _asyncIterator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncIterator"));
+
 var _parquetReader = require("../parquetjs/parser/parquet-reader");
 
-async function parseParquet(arrayBuffer, options) {
-  const blob = new Blob([arrayBuffer]);
+function parseParquet(_x3, _x4) {
+  return _parseParquet.apply(this, arguments);
+}
+
+function _parseParquet() {
+  _parseParquet = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(arrayBuffer, options) {
+    var blob, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, batch;
+
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            blob = new Blob([arrayBuffer]);
+            _iteratorNormalCompletion = true;
+            _didIteratorError = false;
+            _context2.prev = 3;
+            _iterator = (0, _asyncIterator2.default)(parseParquetFileInBatches(blob, options));
+
+          case 5:
+            _context2.next = 7;
+            return _iterator.next();
+
+          case 7:
+            _step = _context2.sent;
+            _iteratorNormalCompletion = _step.done;
+            _context2.next = 11;
+            return _step.value;
+
+          case 11:
+            _value = _context2.sent;
+
+            if (_iteratorNormalCompletion) {
+              _context2.next = 18;
+              break;
+            }
+
+            batch = _value;
+            return _context2.abrupt("return", batch);
+
+          case 15:
+            _iteratorNormalCompletion = true;
+            _context2.next = 5;
+            break;
+
+          case 18:
+            _context2.next = 24;
+            break;
 
-  for await (const batch of parseParquetFileInBatches(blob, options)) {
-    return batch;
-  }
+          case 20:
+            _context2.prev = 20;
+            _context2.t0 = _context2["catch"](3);
+            _didIteratorError = true;
+            _iteratorError = _context2.t0;
 
-  return null;
+          case 24:
+            _context2.prev = 24;
+            _context2.prev = 25;
+
+            if (!(!_iteratorNormalCompletion && _iterator.return != null)) {
+              _context2.next = 29;
+              break;
+            }
+
+            _context2.next = 29;
+            return _iterator.return();
+
+          case 29:
+            _context2.prev = 29;
+
+            if (!_didIteratorError) {
+              _context2.next = 32;
+              break;
+            }
+
+            throw _iteratorError;
+
+          case 32:
+            return _context2.finish(29);
+
+          case 33:
+            return _context2.finish(24);
+
+          case 34:
+            return _context2.abrupt("return", null);
+
+          case 35:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2, null, [[3, 20, 24, 34], [25,, 29, 33]]);
+  }));
+  return _parseParquet.apply(this, arguments);
+}
+
+function parseParquetFileInBatches(_x, _x2) {
+  return _parseParquetFileInBatches.apply(this, arguments);
 }
 
-async function* parseParquetFileInBatches(blob, options) {
-  const reader = await _parquetReader.ParquetReader.openBlob(blob);
-  const rows = [];
+function _parseParquetFileInBatches() {
+  _parseParquetFileInBatches = (0, _wrapAsyncGenerator2.default)(_regenerator.default.mark(function _callee(blob, options) {
+    var reader, rows, cursor, record;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return (0, _awaitAsyncGenerator2.default)(_parquetReader.ParquetReader.openBlob(blob));
+
+          case 2:
+            reader = _context.sent;
+            rows = [];
+            _context.prev = 4;
+            cursor = reader.getCursor();
+
+          case 6:
+            _context.next = 8;
+            return (0, _awaitAsyncGenerator2.default)(cursor.next());
+
+          case 8:
+            if (!(record = _context.sent)) {
+              _context.next = 12;
+              break;
+            }
+
+            rows.push(record);
+            _context.next = 6;
+            break;
+
+          case 12:
+            _context.prev = 12;
+            _context.next = 15;
+            return (0, _awaitAsyncGenerator2.default)(reader.close());
 
-  try {
-    const cursor = reader.getCursor();
-    let record;
+          case 15:
+            return _context.finish(12);
 
-    while (record = await cursor.next()) {
-      rows.push(record);
-    }
-  } finally {
-    await reader.close();
-  }
+          case 16:
+            _context.next = 18;
+            return rows;
 
-  yield rows;
+          case 18:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[4,, 12, 16]]);
+  }));
+  return _parseParquetFileInBatches.apply(this, arguments);
 }
 //# sourceMappingURL=parse-parquet.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/parse-parquet.ts"],"names":["parseParquet","arrayBuffer","options","blob","Blob","batch","parseParquetFileInBatches","reader","ParquetReader","openBlob","rows","cursor","getCursor","record","next","push","close"],"mappings":";;;;;;;;AAGA;;AAEO,eAAeA,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;;AAEM,gBAAgBC,yBAAhB,CAA0CH,IAA1C,EAAsDD,OAAtD,EAAsF;AAC3F,QAAMK,MAAM,GAAG,MAAMC,6BAAcC,QAAd,CAAuBN,IAAvB,CAArB;AACA,QAAMO,IAAa,GAAG,EAAtB;;AACA,MAAI;AACF,UAAMC,MAAM,GAAGJ,MAAM,CAACK,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,UAAMN,MAAM,CAACS,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"}
+{"version":3,"sources":["../../../src/lib/parse-parquet.ts"],"names":["parseParquet","arrayBuffer","options","blob","Blob","parseParquetFileInBatches","batch","ParquetReader","openBlob","reader","rows","cursor","getCursor","next","record","push","close"],"mappings":";;;;;;;;;;;;;;;;;;;;AAGA;;SAEsBA,Y;;;;;4EAAf,kBAA4BC,WAA5B,EAAsDC,OAAtD;AAAA;;AAAA;AAAA;AAAA;AAAA;AACCC,YAAAA,IADD,GACQ,IAAIC,IAAJ,CAAS,CAACH,WAAD,CAAT,CADR;AAAA;AAAA;AAAA;AAAA,qDAEqBI,yBAAyB,CAACF,IAAD,EAAOD,OAAP,CAF9C;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAEYI,YAAAA,KAFZ;AAAA,8CAGIA,KAHJ;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA,8CAKE,IALF;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;SAQgBD,yB;;;;;2FAAhB,iBAA0CF,IAA1C,EAAsDD,OAAtD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,sDACgBK,6BAAcC,QAAd,CAAuBL,IAAvB,CADhB;;AAAA;AACCM,YAAAA,MADD;AAECC,YAAAA,IAFD,GAEiB,EAFjB;AAAA;AAIGC,YAAAA,MAJH,GAIYF,MAAM,CAACG,SAAP,EAJZ;;AAAA;AAAA;AAAA,sDAMoBD,MAAM,CAACE,IAAP,EANpB;;AAAA;AAAA,kBAMKC,MANL;AAAA;AAAA;AAAA;;AAODJ,YAAAA,IAAI,CAACK,IAAL,CAAUD,MAAV;AAPC;AAAA;;AAAA;AAAA;AAAA;AAAA,sDAUGL,MAAM,CAACO,KAAP,EAVH;;AAAA;AAAA;;AAAA;AAAA;AAYL,mBAAMN,IAAN;;AAZK;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G","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/es5/lib/read-array-buffer.js

@@ -1,16 +1,53 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.readArrayBuffer = readArrayBuffer;
 
-async function readArrayBuffer(file, start, length) {
-  if (file instanceof Blob) {
-    const slice = file.slice(start, start + length);
-    return await slice.arrayBuffer();
-  }
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+function readArrayBuffer(_x, _x2, _x3) {
+  return _readArrayBuffer.apply(this, arguments);
+}
+
+function _readArrayBuffer() {
+  _readArrayBuffer = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(file, start, length) {
+    var slice;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            if (!(file instanceof Blob)) {
+              _context.next = 5;
+              break;
+            }
+
+            slice = file.slice(start, start + length);
+            _context.next = 4;
+            return slice.arrayBuffer();
+
+          case 4:
+            return _context.abrupt("return", _context.sent);
+
+          case 5:
+            _context.next = 7;
+            return file.read(start, start + length);
+
+          case 7:
+            return _context.abrupt("return", _context.sent);
 
-  return await file.read(start, start + length);
+          case 8:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _readArrayBuffer.apply(this, arguments);
 }
 //# sourceMappingURL=read-array-buffer.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/read-array-buffer.ts"],"names":["readArrayBuffer","file","start","length","Blob","slice","arrayBuffer","read"],"mappings":";;;;;;;AAEO,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"}
+{"version":3,"sources":["../../../src/lib/read-array-buffer.ts"],"names":["readArrayBuffer","file","start","length","Blob","slice","arrayBuffer","read"],"mappings":";;;;;;;;;;;;;SAEsBA,e;;;;;+EAAf,iBACLC,IADK,EAELC,KAFK,EAGLC,MAHK;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAKDF,IAAI,YAAYG,IALf;AAAA;AAAA;AAAA;;AAMGC,YAAAA,KANH,GAMWJ,IAAI,CAACI,KAAL,CAAWH,KAAX,EAAkBA,KAAK,GAAGC,MAA1B,CANX;AAAA;AAAA,mBAOUE,KAAK,CAACC,WAAN,EAPV;;AAAA;AAAA;;AAAA;AAAA;AAAA,mBASQL,IAAI,CAACM,IAAL,CAAUL,KAAV,EAAiBA,KAAK,GAAGC,MAAzB,CATR;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G","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/es5/parquet-loader.js

@@ -4,14 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports._typecheckParquetLoader = exports.ParquetLoader = void 0;
-const VERSION = typeof "3.1.0-beta.3" !== 'undefined' ? "3.1.0-beta.3" : 'latest';
-const DEFAULT_PARQUET_LOADER_OPTIONS = {
+var VERSION = typeof "3.1.1" !== 'undefined' ? "3.1.1" : 'latest';
+var DEFAULT_PARQUET_LOADER_OPTIONS = {
   parquet: {
     type: 'object-row-table',
     url: undefined
   }
 };
-const ParquetLoader = {
+var ParquetLoader = {
   name: 'Apache Parquet',
   id: 'parquet',
   module: 'parquet',
@@ -25,6 +25,6 @@ const ParquetLoader = {
   options: DEFAULT_PARQUET_LOADER_OPTIONS
 };
 exports.ParquetLoader = ParquetLoader;
-const _typecheckParquetLoader = ParquetLoader;
+var _typecheckParquetLoader = ParquetLoader;
 exports._typecheckParquetLoader = _typecheckParquetLoader;
 //# sourceMappingURL=parquet-loader.js.map

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

@@ -1 +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,0BAAuB,WAAvB,oBAAmD,QAAnE;AASA,MAAMC,8BAAoD,GAAG;AAC3DC,EAAAA,OAAO,EAAE;AACPC,IAAAA,IAAI,EAAE,kBADC;AAEPC,IAAAA,GAAG,EAAEC;AAFE;AADkD,CAA7D;AAQO,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;;AAcA,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"}
+{"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,IAAMA,OAAO,GAAG,mBAAuB,WAAvB,aAAmD,QAAnE;AASA,IAAMC,8BAAoD,GAAG;AAC3DC,EAAAA,OAAO,EAAE;AACPC,IAAAA,IAAI,EAAE,kBADC;AAEPC,IAAAA,GAAG,EAAEC;AAFE;AADkD,CAA7D;AAQO,IAAMC,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;;AAcA,IAAMiB,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"}

package/dist/es5/parquet-writer.js

@@ -4,16 +4,16 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.ParquetWriter = void 0;
-const VERSION = typeof "3.1.0-beta.3" !== 'undefined' ? "3.1.0-beta.3" : 'latest';
-const DEFAULT_PARQUET_LOADER_OPTIONS = {};
-const ParquetWriter = {
+var VERSION = typeof "3.1.1" !== 'undefined' ? "3.1.1" : 'latest';
+var DEFAULT_PARQUET_LOADER_OPTIONS = {};
+var ParquetWriter = {
   name: 'Apache Parquet',
   id: 'parquet',
   module: 'parquet',
   version: VERSION,
   extensions: ['parquet'],
   mimeTypes: ['application/octet-stream'],
-  encodeSync,
+  encodeSync: encodeSync,
   binary: true,
   options: DEFAULT_PARQUET_LOADER_OPTIONS
 };

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

@@ -1 +1 @@
-{"version":3,"sources":["../../src/parquet-writer.ts"],"names":["VERSION","DEFAULT_PARQUET_LOADER_OPTIONS","ParquetWriter","name","id","module","version","extensions","mimeTypes","encodeSync","binary","options","data","ArrayBuffer"],"mappings":";;;;;;AAIA,MAAMA,OAAO,GAAG,0BAAuB,WAAvB,oBAAmD,QAAnE;AAIA,MAAMC,8BAA8B,GAAG,EAAvC;AAEO,MAAMC,aAAqB,GAAG;AACnCC,EAAAA,IAAI,EAAE,gBAD6B;AAEnCC,EAAAA,EAAE,EAAE,SAF+B;AAGnCC,EAAAA,MAAM,EAAE,SAH2B;AAInCC,EAAAA,OAAO,EAAEN,OAJ0B;AAKnCO,EAAAA,UAAU,EAAE,CAAC,SAAD,CALuB;AAMnCC,EAAAA,SAAS,EAAE,CAAC,0BAAD,CANwB;AAOnCC,EAAAA,UAPmC;AAQnCC,EAAAA,MAAM,EAAE,IAR2B;AASnCC,EAAAA,OAAO,EAAEV;AAT0B,CAA9B;;;AAYP,SAASQ,UAAT,CAAoBG,IAApB,EAA0BD,OAA1B,EAA0D;AACxD,SAAO,IAAIE,WAAJ,CAAgB,CAAhB,CAAP;AACD","sourcesContent":["import type {Writer} 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 ParquetWriterOptions = {};\n\nconst DEFAULT_PARQUET_LOADER_OPTIONS = {};\n\nexport const ParquetWriter: Writer = {\n  name: 'Apache Parquet',\n  id: 'parquet',\n  module: 'parquet',\n  version: VERSION,\n  extensions: ['parquet'],\n  mimeTypes: ['application/octet-stream'],\n  encodeSync,\n  binary: true,\n  options: DEFAULT_PARQUET_LOADER_OPTIONS\n};\n\nfunction encodeSync(data, options?: ParquetWriterOptions) {\n  return new ArrayBuffer(0);\n}\n"],"file":"parquet-writer.js"}
+{"version":3,"sources":["../../src/parquet-writer.ts"],"names":["VERSION","DEFAULT_PARQUET_LOADER_OPTIONS","ParquetWriter","name","id","module","version","extensions","mimeTypes","encodeSync","binary","options","data","ArrayBuffer"],"mappings":";;;;;;AAIA,IAAMA,OAAO,GAAG,mBAAuB,WAAvB,aAAmD,QAAnE;AAIA,IAAMC,8BAA8B,GAAG,EAAvC;AAEO,IAAMC,aAAqB,GAAG;AACnCC,EAAAA,IAAI,EAAE,gBAD6B;AAEnCC,EAAAA,EAAE,EAAE,SAF+B;AAGnCC,EAAAA,MAAM,EAAE,SAH2B;AAInCC,EAAAA,OAAO,EAAEN,OAJ0B;AAKnCO,EAAAA,UAAU,EAAE,CAAC,SAAD,CALuB;AAMnCC,EAAAA,SAAS,EAAE,CAAC,0BAAD,CANwB;AAOnCC,EAAAA,UAAU,EAAVA,UAPmC;AAQnCC,EAAAA,MAAM,EAAE,IAR2B;AASnCC,EAAAA,OAAO,EAAEV;AAT0B,CAA9B;;;AAYP,SAASQ,UAAT,CAAoBG,IAApB,EAA0BD,OAA1B,EAA0D;AACxD,SAAO,IAAIE,WAAJ,CAAgB,CAAhB,CAAP;AACD","sourcesContent":["import type {Writer} 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 ParquetWriterOptions = {};\n\nconst DEFAULT_PARQUET_LOADER_OPTIONS = {};\n\nexport const ParquetWriter: Writer = {\n  name: 'Apache Parquet',\n  id: 'parquet',\n  module: 'parquet',\n  version: VERSION,\n  extensions: ['parquet'],\n  mimeTypes: ['application/octet-stream'],\n  encodeSync,\n  binary: true,\n  options: DEFAULT_PARQUET_LOADER_OPTIONS\n};\n\nfunction encodeSync(data, options?: ParquetWriterOptions) {\n  return new ArrayBuffer(0);\n}\n"],"file":"parquet-writer.js"}

package/dist/es5/parquetjs/codecs/dictionary.js

@@ -1,19 +1,27 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.decodeValues = decodeValues;
 exports.encodeValues = encodeValues;
 
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
 var _rle = require("./rle");
 
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
 function decodeValues(type, cursor, count, opts) {
   opts.bitWidth = cursor.buffer.slice(cursor.offset, cursor.offset + 1).readInt8(0);
   cursor.offset += 1;
-  return (0, _rle.decodeValues)(type, cursor, count, { ...opts,
+  return (0, _rle.decodeValues)(type, cursor, count, _objectSpread(_objectSpread({}, opts), {}, {
     disableEnvelope: true
-  });
+  }));
 }
 
 function encodeValues(type, cursor, count, opts) {

package/dist/es5/parquetjs/codecs/dictionary.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/parquetjs/codecs/dictionary.ts"],"names":["decodeValues","type","cursor","count","opts","bitWidth","buffer","slice","offset","readInt8","disableEnvelope","encodeValues","Error"],"mappings":";;;;;;;;AAAA;;AAEO,SAASA,YAAT,CAAsBC,IAAtB,EAA4BC,MAA5B,EAAoCC,KAApC,EAA2CC,IAA3C,EAAiD;AACtDA,EAAAA,IAAI,CAACC,QAAL,GAAgBH,MAAM,CAACI,MAAP,CAAcC,KAAd,CAAoBL,MAAM,CAACM,MAA3B,EAAmCN,MAAM,CAACM,MAAP,GAAgB,CAAnD,EAAsDC,QAAtD,CAA+D,CAA/D,CAAhB;AACAP,EAAAA,MAAM,CAACM,MAAP,IAAiB,CAAjB;AACA,SAAO,uBAAgBP,IAAhB,EAAsBC,MAAtB,EAA8BC,KAA9B,EAAqC,EAAC,GAAGC,IAAJ;AAAUM,IAAAA,eAAe,EAAE;AAA3B,GAArC,CAAP;AACD;;AAEM,SAASC,YAAT,CAAsBV,IAAtB,EAA4BC,MAA5B,EAAoCC,KAApC,EAA2CC,IAA3C,EAAiD;AACtD,QAAM,IAAIQ,KAAJ,CAAU,kDAAV,CAAN;AACD","sourcesContent":["import {decodeValues as decodeRleValues} from './rle';\n\nexport function decodeValues(type, cursor, count, opts) {\n  opts.bitWidth = cursor.buffer.slice(cursor.offset, cursor.offset + 1).readInt8(0);\n  cursor.offset += 1;\n  return decodeRleValues(type, cursor, count, {...opts, disableEnvelope: true});\n}\n\nexport function encodeValues(type, cursor, count, opts) {\n  throw new Error('Encode dictionary functionality is not supported');\n}\n"],"file":"dictionary.js"}
+{"version":3,"sources":["../../../../src/parquetjs/codecs/dictionary.ts"],"names":["decodeValues","type","cursor","count","opts","bitWidth","buffer","slice","offset","readInt8","disableEnvelope","encodeValues","Error"],"mappings":";;;;;;;;;;;;AAAA;;;;;;AAEO,SAASA,YAAT,CAAsBC,IAAtB,EAA4BC,MAA5B,EAAoCC,KAApC,EAA2CC,IAA3C,EAAiD;AACtDA,EAAAA,IAAI,CAACC,QAAL,GAAgBH,MAAM,CAACI,MAAP,CAAcC,KAAd,CAAoBL,MAAM,CAACM,MAA3B,EAAmCN,MAAM,CAACM,MAAP,GAAgB,CAAnD,EAAsDC,QAAtD,CAA+D,CAA/D,CAAhB;AACAP,EAAAA,MAAM,CAACM,MAAP,IAAiB,CAAjB;AACA,SAAO,uBAAgBP,IAAhB,EAAsBC,MAAtB,EAA8BC,KAA9B,kCAAyCC,IAAzC;AAA+CM,IAAAA,eAAe,EAAE;AAAhE,KAAP;AACD;;AAEM,SAASC,YAAT,CAAsBV,IAAtB,EAA4BC,MAA5B,EAAoCC,KAApC,EAA2CC,IAA3C,EAAiD;AACtD,QAAM,IAAIQ,KAAJ,CAAU,kDAAV,CAAN;AACD","sourcesContent":["import {decodeValues as decodeRleValues} from './rle';\n\nexport function decodeValues(type, cursor, count, opts) {\n  opts.bitWidth = cursor.buffer.slice(cursor.offset, cursor.offset + 1).readInt8(0);\n  cursor.offset += 1;\n  return decodeRleValues(type, cursor, count, {...opts, disableEnvelope: true});\n}\n\nexport function encodeValues(type, cursor, count, opts) {\n  throw new Error('Encode dictionary functionality is not supported');\n}\n"],"file":"dictionary.js"}