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

package/dist/es5/bundle.js

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

package/dist/es5/bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.js","names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"sources":["../../src/bundle.ts"],"sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"mappings":";;AACA,IAAMA,aAAa,GAAGC,OAAO,CAAC,SAAS,CAAC;AACxCC,UAAU,CAACC,OAAO,GAAGD,UAAU,CAACC,OAAO,IAAI,CAAC,CAAC;AAC7CC,MAAM,CAACC,OAAO,GAAGC,MAAM,CAACC,MAAM,CAACL,UAAU,CAACC,OAAO,EAAEH,aAAa,CAAC"}

package/dist/es5/constants.js

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

package/dist/es5/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","names":["PARQUET_MAGIC","exports","PARQUET_MAGIC_ENCRYPTED","PARQUET_VERSION","PARQUET_RDLVL_TYPE","PARQUET_RDLVL_ENCODING"],"sources":["../../src/constants.ts"],"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"],"mappings":";;;;;;AAIO,IAAMA,aAAa,GAAG,MAAM;AAACC,OAAA,CAAAD,aAAA,GAAAA,aAAA;AAC7B,IAAME,uBAAuB,GAAG,MAAM;AAACD,OAAA,CAAAC,uBAAA,GAAAA,uBAAA;AAKvC,IAAMC,eAAe,GAAG,CAAC;AAACF,OAAA,CAAAE,eAAA,GAAAA,eAAA;AAK1B,IAAMC,kBAAkB,GAAG,OAAO;AAACH,OAAA,CAAAG,kBAAA,GAAAA,kBAAA;AACnC,IAAMC,sBAAsB,GAAG,KAAK;AAACJ,OAAA,CAAAI,sBAAA,GAAAA,sBAAA"}

package/dist/es5/index.js

@@ -0,0 +1,128 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ParquetColumnarLoader = void 0;
+Object.defineProperty(exports, "ParquetEncoder", {
+  enumerable: true,
+  get: function get() {
+    return _parquetEncoder.ParquetEncoder;
+  }
+});
+exports.ParquetLoader = void 0;
+Object.defineProperty(exports, "ParquetReader", {
+  enumerable: true,
+  get: function get() {
+    return _parquetReader.ParquetReader;
+  }
+});
+Object.defineProperty(exports, "ParquetSchema", {
+  enumerable: true,
+  get: function get() {
+    return _schema.ParquetSchema;
+  }
+});
+exports.ParquetWasmLoader = void 0;
+Object.defineProperty(exports, "ParquetWasmWorkerLoader", {
+  enumerable: true,
+  get: function get() {
+    return _parquetWasmLoader.ParquetWasmLoader;
+  }
+});
+Object.defineProperty(exports, "ParquetWasmWriter", {
+  enumerable: true,
+  get: function get() {
+    return _parquetWasmWriter.ParquetWasmWriter;
+  }
+});
+Object.defineProperty(exports, "ParquetWorkerLoader", {
+  enumerable: true,
+  get: function get() {
+    return _parquetLoader.ParquetLoader;
+  }
+});
+Object.defineProperty(exports, "_ParquetWriter", {
+  enumerable: true,
+  get: function get() {
+    return _parquetWriter.ParquetWriter;
+  }
+});
+exports._typecheckParquetLoader = void 0;
+Object.defineProperty(exports, "convertParquetSchema", {
+  enumerable: true,
+  get: function get() {
+    return _convertSchemaFromParquet.convertParquetSchema;
+  }
+});
+Object.defineProperty(exports, "convertParquetToArrowSchema", {
+  enumerable: true,
+  get: function get() {
+    return _convertSchemaFromParquet.convertParquetSchema;
+  }
+});
+Object.defineProperty(exports, "geoJSONSchema", {
+  enumerable: true,
+  get: function get() {
+    return _geoparquetSchema.default;
+  }
+});
+Object.defineProperty(exports, "getGeoMetadata", {
+  enumerable: true,
+  get: function get() {
+    return _decodeGeoMetadata.getGeoMetadata;
+  }
+});
+Object.defineProperty(exports, "preloadCompressions", {
+  enumerable: true,
+  get: function get() {
+    return _compression.preloadCompressions;
+  }
+});
+Object.defineProperty(exports, "setGeoMetadata", {
+  enumerable: true,
+  get: function get() {
+    return _decodeGeoMetadata.setGeoMetadata;
+  }
+});
+Object.defineProperty(exports, "unpackGeoMetadata", {
+  enumerable: true,
+  get: function get() {
+    return _decodeGeoMetadata.unpackGeoMetadata;
+  }
+});
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _parquetLoader = require("./parquet-loader");
+var _parseParquetToRows = require("./lib/parsers/parse-parquet-to-rows");
+var _parseParquetToColumns = require("./lib/parsers/parse-parquet-to-columns");
+var _parseParquetWasm = require("./lib/wasm/parse-parquet-wasm");
+var _parquetWasmLoader = require("./parquet-wasm-loader");
+var _parquetWriter = require("./parquet-writer");
+var _parquetWasmWriter = require("./parquet-wasm-writer");
+var _compression = require("./parquetjs/compression");
+var _schema = require("./parquetjs/schema/schema");
+var _parquetReader = require("./parquetjs/parser/parquet-reader");
+var _parquetEncoder = require("./parquetjs/encoder/parquet-encoder");
+var _convertSchemaFromParquet = require("./lib/arrow/convert-schema-from-parquet");
+var _geoparquetSchema = _interopRequireDefault(require("./lib/geo/geoparquet-schema"));
+var _decodeGeoMetadata = require("./lib/geo/decode-geo-metadata");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var ParquetLoader = _objectSpread(_objectSpread({}, _parquetLoader.ParquetLoader), {}, {
+  parse: _parseParquetToRows.parseParquet,
+  parseFileInBatches: _parseParquetToRows.parseParquetFileInBatches
+});
+exports.ParquetLoader = ParquetLoader;
+var ParquetColumnarLoader = _objectSpread(_objectSpread({}, _parquetLoader.ParquetLoader), {}, {
+  parse: _parseParquetToColumns.parseParquetInColumns,
+  parseFileInBatches: _parseParquetToColumns.parseParquetFileInColumnarBatches
+});
+exports.ParquetColumnarLoader = ParquetColumnarLoader;
+var ParquetWasmLoader = _objectSpread(_objectSpread({}, _parquetWasmLoader.ParquetWasmLoader), {}, {
+  parse: _parseParquetWasm.parseParquetWasm
+});
+exports.ParquetWasmLoader = ParquetWasmLoader;
+var _typecheckParquetLoader = ParquetLoader;
+exports._typecheckParquetLoader = _typecheckParquetLoader;
+//# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_parquetLoader","require","_parseParquetToRows","_parseParquetToColumns","_parseParquetWasm","_parquetWasmLoader","_parquetWriter","_parquetWasmWriter","_compression","_schema","_parquetReader","_parquetEncoder","_convertSchemaFromParquet","_geoparquetSchema","_interopRequireDefault","_decodeGeoMetadata","ownKeys","object","enumerableOnly","keys","Object","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","target","i","arguments","length","source","forEach","key","_defineProperty2","default","getOwnPropertyDescriptors","defineProperties","defineProperty","ParquetLoader","ParquetWorkerLoader","parse","parseParquet","parseFileInBatches","parseParquetFileInBatches","exports","ParquetColumnarLoader","ParquetColumnarWorkerLoader","parseParquetInColumns","parseParquetFileInColumnarBatches","ParquetWasmLoader","ParquetWasmWorkerLoader","parseParquetWasm","_typecheckParquetLoader"],"sources":["../../src/index.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport type {\n  ObjectRowTable,\n  ObjectRowTableBatch,\n  ColumnarTable,\n  ColumnarTableBatch\n} from '@loaders.gl/schema';\nimport type {Table as ArrowTable} from 'apache-arrow';\n\n// ParquetLoader\n\nimport {\n  ParquetLoader as ParquetWorkerLoader,\n  ParquetLoader as ParquetColumnarWorkerLoader,\n  ParquetLoaderOptions\n} from './parquet-loader';\nimport {parseParquet, parseParquetFileInBatches} from './lib/parsers/parse-parquet-to-rows';\nimport {\n  parseParquetInColumns,\n  parseParquetFileInColumnarBatches\n} from './lib/parsers/parse-parquet-to-columns';\n\nimport {parseParquetWasm, ParquetWasmLoaderOptions} from './lib/wasm/parse-parquet-wasm';\nimport {ParquetWasmLoader as ParquetWasmWorkerLoader} from './parquet-wasm-loader';\n\nexport {ParquetWorkerLoader, ParquetWasmWorkerLoader};\n\n/** ParquetJS table loader */\nexport const ParquetLoader: LoaderWithParser<\n  ObjectRowTable,\n  ObjectRowTableBatch,\n  ParquetLoaderOptions\n> = {\n  ...ParquetWorkerLoader,\n  parse: parseParquet,\n  parseFileInBatches: parseParquetFileInBatches\n};\n\n/** ParquetJS table loader */\n// @ts-expect-error\nexport const ParquetColumnarLoader: LoaderWithParser<\n  ColumnarTable,\n  ColumnarTableBatch,\n  ParquetLoaderOptions\n> = {\n  ...ParquetColumnarWorkerLoader,\n  parse: parseParquetInColumns,\n  parseFileInBatches: parseParquetFileInColumnarBatches\n};\n\nexport const ParquetWasmLoader: LoaderWithParser<ArrowTable, never, ParquetWasmLoaderOptions> = {\n  ...ParquetWasmWorkerLoader,\n  parse: parseParquetWasm\n};\n\n// ParquetWriter\n\nexport {ParquetWriter as _ParquetWriter} from './parquet-writer';\nexport {ParquetWasmWriter} from './parquet-wasm-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 {ParquetEncoder} from './parquetjs/encoder/parquet-encoder';\n\nexport {\n  convertParquetSchema,\n  convertParquetSchema as convertParquetToArrowSchema\n} from './lib/arrow/convert-schema-from-parquet';\n\n// TESTS\nexport const _typecheckParquetLoader: LoaderWithParser = ParquetLoader;\n\n// Geo Metadata\nexport {default as geoJSONSchema} from './lib/geo/geoparquet-schema';\n\nexport type {GeoMetadata} from './lib/geo/decode-geo-metadata';\nexport {getGeoMetadata, setGeoMetadata, unpackGeoMetadata} from './lib/geo/decode-geo-metadata';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAaA,IAAAA,cAAA,GAAAC,OAAA;AAKA,IAAAC,mBAAA,GAAAD,OAAA;AACA,IAAAE,sBAAA,GAAAF,OAAA;AAKA,IAAAG,iBAAA,GAAAH,OAAA;AACA,IAAAI,kBAAA,GAAAJ,OAAA;AAkCA,IAAAK,cAAA,GAAAL,OAAA;AACA,IAAAM,kBAAA,GAAAN,OAAA;AAIA,IAAAO,YAAA,GAAAP,OAAA;AAEA,IAAAQ,OAAA,GAAAR,OAAA;AACA,IAAAS,cAAA,GAAAT,OAAA;AACA,IAAAU,eAAA,GAAAV,OAAA;AAEA,IAAAW,yBAAA,GAAAX,OAAA;AASA,IAAAY,iBAAA,GAAAC,sBAAA,CAAAb,OAAA;AAGA,IAAAc,kBAAA,GAAAd,OAAA;AAAgG,SAAAe,QAAAC,MAAA,EAAAC,cAAA,QAAAC,IAAA,GAAAC,MAAA,CAAAD,IAAA,CAAAF,MAAA,OAAAG,MAAA,CAAAC,qBAAA,QAAAC,OAAA,GAAAF,MAAA,CAAAC,qBAAA,CAAAJ,MAAA,GAAAC,cAAA,KAAAI,OAAA,GAAAA,OAAA,CAAAC,MAAA,WAAAC,GAAA,WAAAJ,MAAA,CAAAK,wBAAA,CAAAR,MAAA,EAAAO,GAAA,EAAAE,UAAA,OAAAP,IAAA,CAAAQ,IAAA,CAAAC,KAAA,CAAAT,IAAA,EAAAG,OAAA,YAAAH,IAAA;AAAA,SAAAU,cAAAC,MAAA,aAAAC,CAAA,MAAAA,CAAA,GAAAC,SAAA,CAAAC,MAAA,EAAAF,CAAA,UAAAG,MAAA,WAAAF,SAAA,CAAAD,CAAA,IAAAC,SAAA,CAAAD,CAAA,QAAAA,CAAA,OAAAf,OAAA,CAAAI,MAAA,CAAAc,MAAA,OAAAC,OAAA,WAAAC,GAAA,QAAAC,gBAAA,CAAAC,OAAA,EAAAR,MAAA,EAAAM,GAAA,EAAAF,MAAA,CAAAE,GAAA,SAAAhB,MAAA,CAAAmB,yBAAA,GAAAnB,MAAA,CAAAoB,gBAAA,CAAAV,MAAA,EAAAV,MAAA,CAAAmB,yBAAA,CAAAL,MAAA,KAAAlB,OAAA,CAAAI,MAAA,CAAAc,MAAA,GAAAC,OAAA,WAAAC,GAAA,IAAAhB,MAAA,CAAAqB,cAAA,CAAAX,MAAA,EAAAM,GAAA,EAAAhB,MAAA,CAAAK,wBAAA,CAAAS,MAAA,EAAAE,GAAA,iBAAAN,MAAA;AApDzF,IAAMY,aAIZ,GAAAb,aAAA,CAAAA,aAAA,KACIc,4BAAmB;EACtBC,KAAK,EAAEC,gCAAY;EACnBC,kBAAkB,EAAEC;AAAyB,EAC9C;AAACC,OAAA,CAAAN,aAAA,GAAAA,aAAA;AAIK,IAAMO,qBAIZ,GAAApB,aAAA,CAAAA,aAAA,KACIqB,4BAA2B;EAC9BN,KAAK,EAAEO,4CAAqB;EAC5BL,kBAAkB,EAAEM;AAAiC,EACtD;AAACJ,OAAA,CAAAC,qBAAA,GAAAA,qBAAA;AAEK,IAAMI,iBAAgF,GAAAxB,aAAA,CAAAA,aAAA,KACxFyB,oCAAuB;EAC1BV,KAAK,EAAEW;AAAgB,EACxB;AAACP,OAAA,CAAAK,iBAAA,GAAAA,iBAAA;AAqBK,IAAMG,uBAAyC,GAAGd,aAAa;AAACM,OAAA,CAAAQ,uBAAA,GAAAA,uBAAA"}

package/dist/es5/lib/arrow/convert-columns-to-row-group.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=convert-columns-to-row-group.js.map

package/dist/es5/lib/arrow/convert-columns-to-row-group.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-columns-to-row-group.js","names":[],"sources":["../../../../src/lib/arrow/convert-columns-to-row-group.ts"],"sourcesContent":[""],"mappings":""}

package/dist/es5/lib/arrow/convert-row-group-to-columns.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertParquetRowGroupToColumns = convertParquetRowGroupToColumns;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+function convertParquetRowGroupToColumns(schema, rowGroup) {
+  var columns = {};
+  for (var _i = 0, _Object$entries = Object.entries(rowGroup.columnData); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = (0, _slicedToArray2.default)(_Object$entries[_i], 2),
+      columnName = _Object$entries$_i[0],
+      data = _Object$entries$_i[1];
+    columns[columnName] = columns[columnName] || data.values;
+  }
+  return columns;
+}
+//# sourceMappingURL=convert-row-group-to-columns.js.map

package/dist/es5/lib/arrow/convert-row-group-to-columns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-row-group-to-columns.js","names":["convertParquetRowGroupToColumns","schema","rowGroup","columns","_i","_Object$entries","Object","entries","columnData","length","_Object$entries$_i","_slicedToArray2","default","columnName","data","values"],"sources":["../../../../src/lib/arrow/convert-row-group-to-columns.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport {Schema} from '@loaders.gl/schema';\nimport {ParquetRowGroup} from '@loaders.gl/parquet/parquetjs/schema/declare';\n\nexport function convertParquetRowGroupToColumns(\n  schema: Schema,\n  rowGroup: ParquetRowGroup\n): Record<string, any[]> {\n  const columns: Record<string, any[]> = {};\n  for (const [columnName, data] of Object.entries(rowGroup.columnData)) {\n    columns[columnName] = columns[columnName] || data.values;\n  }\n  return columns;\n}\n"],"mappings":";;;;;;;;AAKO,SAASA,+BAA+BA,CAC7CC,MAAc,EACdC,QAAyB,EACF;EACvB,IAAMC,OAA8B,GAAG,CAAC,CAAC;EACzC,SAAAC,EAAA,MAAAC,eAAA,GAAiCC,MAAM,CAACC,OAAO,CAACL,QAAQ,CAACM,UAAU,CAAC,EAAAJ,EAAA,GAAAC,eAAA,CAAAI,MAAA,EAAAL,EAAA,IAAE;IAAjE,IAAAM,kBAAA,OAAAC,eAAA,CAAAC,OAAA,EAAAP,eAAA,CAAAD,EAAA;MAAOS,UAAU,GAAAH,kBAAA;MAAEI,IAAI,GAAAJ,kBAAA;IAC1BP,OAAO,CAACU,UAAU,CAAC,GAAGV,OAAO,CAACU,UAAU,CAAC,IAAIC,IAAI,CAACC,MAAM;EAC1D;EACA,OAAOZ,OAAO;AAChB"}

package/dist/es5/lib/arrow/convert-schema-from-parquet.js

@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PARQUET_TYPE_MAPPING = void 0;
+exports.convertParquetSchema = convertParquetSchema;
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+var 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'
+};
+exports.PARQUET_TYPE_MAPPING = PARQUET_TYPE_MAPPING;
+function convertParquetSchema(parquetSchema, parquetMetadata) {
+  var fields = getFields(parquetSchema.schema);
+  var metadata = parquetMetadata && getSchemaMetadata(parquetMetadata);
+  var schema = {
+    fields: fields,
+    metadata: metadata || {}
+  };
+  return schema;
+}
+function getFields(schema) {
+  var fields = [];
+  for (var name in schema) {
+    var field = schema[name];
+    if (field.fields) {
+      var children = getFields(field.fields);
+      fields.push({
+        name: name,
+        type: {
+          type: 'struct',
+          children: children
+        },
+        nullable: field.optional
+      });
+    } else {
+      var type = PARQUET_TYPE_MAPPING[field.type];
+      var metadata = getFieldMetadata(field);
+      var arrowField = {
+        name: name,
+        type: type,
+        nullable: field.optional,
+        metadata: metadata
+      };
+      fields.push(arrowField);
+    }
+  }
+  return fields;
+}
+function getFieldMetadata(field) {
+  var metadata;
+  for (var key in field) {
+    if (key !== 'name') {
+      var value = field[key] || '';
+      value = typeof field[key] !== 'string' ? JSON.stringify(field[key]) : field[key];
+      metadata = metadata || {};
+      metadata[key] = value;
+    }
+  }
+  return metadata;
+}
+function getSchemaMetadata(parquetMetadata) {
+  var metadata;
+  var keyValueList = parquetMetadata.key_value_metadata || [];
+  var _iterator = _createForOfIteratorHelper(keyValueList),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _step.value,
+        key = _step$value.key,
+        value = _step$value.value;
+      if (typeof value === 'string') {
+        metadata = metadata || {};
+        metadata[key] = value;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return metadata;
+}
+//# sourceMappingURL=convert-schema-from-parquet.js.map

package/dist/es5/lib/arrow/convert-schema-from-parquet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-schema-from-parquet.js","names":["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","exports","convertParquetSchema","parquetSchema","parquetMetadata","fields","getFields","schema","metadata","getSchemaMetadata","name","field","children","push","type","nullable","optional","getFieldMetadata","arrowField","key","value","stringify","keyValueList","key_value_metadata","_iterator","_createForOfIteratorHelper","_step","s","n","done","_step$value","err","e","f"],"sources":["../../../../src/lib/arrow/convert-schema-from-parquet.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport {Schema, Field, DataType} from '@loaders.gl/schema';\n\nimport type {ParquetSchema} from '../../parquetjs/schema/schema';\nimport type {FieldDefinition, ParquetField, ParquetType} from '../../parquetjs/schema/declare';\nimport {FileMetaData} from '../../parquetjs/parquet-thrift';\n\nexport const PARQUET_TYPE_MAPPING: {[type in ParquetType]: 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 convertParquetSchema(\n  parquetSchema: ParquetSchema,\n  parquetMetadata: FileMetaData | null\n): Schema {\n  const fields = getFields(parquetSchema.schema);\n  const metadata = parquetMetadata && getSchemaMetadata(parquetMetadata);\n\n  const schema: Schema = {\n    fields,\n    metadata: metadata || {}\n  };\n\n  return schema;\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 children = getFields(field.fields);\n      fields.push({name, type: {type: 'struct', children}, nullable: field.optional});\n    } else {\n      const type = PARQUET_TYPE_MAPPING[field.type];\n      const metadata = getFieldMetadata(field);\n      const arrowField = {name, type, nullable: field.optional, metadata};\n      fields.push(arrowField);\n    }\n  }\n\n  return fields;\n}\n\nfunction getFieldMetadata(field: ParquetField): Record<string, string> | undefined {\n  let metadata: Record<string, string> | undefined;\n\n  for (const key in field) {\n    if (key !== 'name') {\n      let value = field[key] || '';\n      value = typeof field[key] !== 'string' ? JSON.stringify(field[key]) : field[key];\n      metadata = metadata || {};\n      metadata[key] = value;\n    }\n  }\n\n  return metadata;\n}\n\nfunction getSchemaMetadata(parquetMetadata: FileMetaData): Record<string, string> | undefined {\n  let metadata: Record<string, string> | undefined;\n\n  const keyValueList = parquetMetadata.key_value_metadata || [];\n  for (const {key, value} of keyValueList) {\n    if (typeof value === 'string') {\n      metadata = metadata || {};\n      metadata[key] = value;\n    }\n  }\n\n  return metadata;\n}\n"],"mappings":";;;;;;;;;;AAQO,IAAMA,oBAAuD,GAAG;EACrEC,OAAO,EAAE,MAAM;EACfC,KAAK,EAAE,OAAO;EACdC,KAAK,EAAE,SAAS;EAChBC,KAAK,EAAE,SAAS;EAChBC,KAAK,EAAE,SAAS;EAChBC,MAAM,EAAE,SAAS;EACjBC,UAAU,EAAE,QAAQ;EACpBC,oBAAoB,EAAE,QAAQ;EAC9BC,IAAI,EAAE,MAAM;EACZC,IAAI,EAAE,OAAO;EACbC,WAAW,EAAE,OAAO;EACpBC,WAAW,EAAE,OAAO;EACpBC,gBAAgB,EAAE,OAAO;EACzBC,gBAAgB,EAAE,OAAO;EACzBC,MAAM,EAAE,OAAO;EACfC,OAAO,EAAE,QAAQ;EACjBC,OAAO,EAAE,QAAQ;EACjBC,OAAO,EAAE,QAAQ;EACjBC,KAAK,EAAE,MAAM;EACbC,MAAM,EAAE,OAAO;EACfC,MAAM,EAAE,OAAO;EACfC,MAAM,EAAE,OAAO;EACfC,IAAI,EAAE,QAAQ;EACdC,IAAI,EAAE,QAAQ;EAEdC,QAAQ,EAAE,QAAQ;EAClBC,aAAa,EAAE,SAAS;EACxBC,aAAa,EAAE,SAAS;EACxBC,kBAAkB,EAAE,SAAS;EAC7BC,4BAA4B,EAAE;AAChC,CAAC;AAACC,OAAA,CAAA9B,oBAAA,GAAAA,oBAAA;AAEK,SAAS+B,oBAAoBA,CAClCC,aAA4B,EAC5BC,eAAoC,EAC5B;EACR,IAAMC,MAAM,GAAGC,SAAS,CAACH,aAAa,CAACI,MAAM,CAAC;EAC9C,IAAMC,QAAQ,GAAGJ,eAAe,IAAIK,iBAAiB,CAACL,eAAe,CAAC;EAEtE,IAAMG,MAAc,GAAG;IACrBF,MAAM,EAANA,MAAM;IACNG,QAAQ,EAAEA,QAAQ,IAAI,CAAC;EACzB,CAAC;EAED,OAAOD,MAAM;AACf;AAEA,SAASD,SAASA,CAACC,MAAuB,EAAW;EACnD,IAAMF,MAAe,GAAG,EAAE;EAE1B,KAAK,IAAMK,IAAI,IAAIH,MAAM,EAAE;IACzB,IAAMI,KAAK,GAAGJ,MAAM,CAACG,IAAI,CAAC;IAE1B,IAAIC,KAAK,CAACN,MAAM,EAAE;MAChB,IAAMO,QAAQ,GAAGN,SAAS,CAACK,KAAK,CAACN,MAAM,CAAC;MACxCA,MAAM,CAACQ,IAAI,CAAC;QAACH,IAAI,EAAJA,IAAI;QAAEI,IAAI,EAAE;UAACA,IAAI,EAAE,QAAQ;UAAEF,QAAQ,EAARA;QAAQ,CAAC;QAAEG,QAAQ,EAAEJ,KAAK,CAACK;MAAQ,CAAC,CAAC;IACjF,CAAC,MAAM;MACL,IAAMF,IAAI,GAAG3C,oBAAoB,CAACwC,KAAK,CAACG,IAAI,CAAC;MAC7C,IAAMN,QAAQ,GAAGS,gBAAgB,CAACN,KAAK,CAAC;MACxC,IAAMO,UAAU,GAAG;QAACR,IAAI,EAAJA,IAAI;QAAEI,IAAI,EAAJA,IAAI;QAAEC,QAAQ,EAAEJ,KAAK,CAACK,QAAQ;QAAER,QAAQ,EAARA;MAAQ,CAAC;MACnEH,MAAM,CAACQ,IAAI,CAACK,UAAU,CAAC;IACzB;EACF;EAEA,OAAOb,MAAM;AACf;AAEA,SAASY,gBAAgBA,CAACN,KAAmB,EAAsC;EACjF,IAAIH,QAA4C;EAEhD,KAAK,IAAMW,GAAG,IAAIR,KAAK,EAAE;IACvB,IAAIQ,GAAG,KAAK,MAAM,EAAE;MAClB,IAAIC,KAAK,GAAGT,KAAK,CAACQ,GAAG,CAAC,IAAI,EAAE;MAC5BC,KAAK,GAAG,OAAOT,KAAK,CAACQ,GAAG,CAAC,KAAK,QAAQ,GAAGzB,IAAI,CAAC2B,SAAS,CAACV,KAAK,CAACQ,GAAG,CAAC,CAAC,GAAGR,KAAK,CAACQ,GAAG,CAAC;MAChFX,QAAQ,GAAGA,QAAQ,IAAI,CAAC,CAAC;MACzBA,QAAQ,CAACW,GAAG,CAAC,GAAGC,KAAK;IACvB;EACF;EAEA,OAAOZ,QAAQ;AACjB;AAEA,SAASC,iBAAiBA,CAACL,eAA6B,EAAsC;EAC5F,IAAII,QAA4C;EAEhD,IAAMc,YAAY,GAAGlB,eAAe,CAACmB,kBAAkB,IAAI,EAAE;EAAC,IAAAC,SAAA,GAAAC,0BAAA,CACnCH,YAAY;IAAAI,KAAA;EAAA;IAAvC,KAAAF,SAAA,CAAAG,CAAA,MAAAD,KAAA,GAAAF,SAAA,CAAAI,CAAA,IAAAC,IAAA,GAAyC;MAAA,IAAAC,WAAA,GAAAJ,KAAA,CAAAN,KAAA;QAA7BD,GAAG,GAAAW,WAAA,CAAHX,GAAG;QAAEC,KAAK,GAAAU,WAAA,CAALV,KAAK;MACpB,IAAI,OAAOA,KAAK,KAAK,QAAQ,EAAE;QAC7BZ,QAAQ,GAAGA,QAAQ,IAAI,CAAC,CAAC;QACzBA,QAAQ,CAACW,GAAG,CAAC,GAAGC,KAAK;MACvB;IACF;EAAC,SAAAW,GAAA;IAAAP,SAAA,CAAAQ,CAAA,CAAAD,GAAA;EAAA;IAAAP,SAAA,CAAAS,CAAA;EAAA;EAED,OAAOzB,QAAQ;AACjB"}

package/dist/es5/lib/arrow/convert-schema-to-parquet.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PARQUET_TYPE_MAPPING = void 0;
+exports.convertToParquetSchema = convertToParquetSchema;
+var 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'
+};
+exports.PARQUET_TYPE_MAPPING = PARQUET_TYPE_MAPPING;
+function convertToParquetSchema(schema) {
+  var fields = [];
+  return {
+    fields: fields,
+    metadata: {}
+  };
+}
+//# sourceMappingURL=convert-schema-to-parquet.js.map

package/dist/es5/lib/arrow/convert-schema-to-parquet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-schema-to-parquet.js","names":["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","exports","convertToParquetSchema","schema","fields","metadata"],"sources":["../../../../src/lib/arrow/convert-schema-to-parquet.ts"],"sourcesContent":["// loaders.gl, MIT license\n\n// import type {ParquetSchema} from '../../parquetjs/schema/schema';\nimport type {\n  // FieldDefinition, ParquetField,\n  ParquetType\n} from '../../parquetjs/schema/declare';\n\nimport {\n  Schema,\n  // Struct,\n  // Field,\n  DataType\n} from '@loaders.gl/schema';\n\nexport const PARQUET_TYPE_MAPPING: {[type in ParquetType]: 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 interval 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 convertToParquetSchema(schema: Schema): Schema {\n  const fields = []; // getFields(schema.fields);\n\n  // TODO add metadata if needed.\n  return {fields, metadata: {}};\n}\n\n// function getFields(schema: Field[]): Definition[] {\n//   const fields: Field[] = [];\n\n//   for (const name in schema) {\n//     const field = schema[name];\n\n//     // @ts-ignore\n//     const children = field.children as DataType[];\n//     if (children) {\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\n// function 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"],"mappings":";;;;;;;AAeO,IAAMA,oBAAuD,GAAG;EACrEC,OAAO,EAAE,MAAM;EACfC,KAAK,EAAE,OAAO;EACdC,KAAK,EAAE,SAAS;EAChBC,KAAK,EAAE,SAAS;EAChBC,KAAK,EAAE,SAAS;EAChBC,MAAM,EAAE,SAAS;EACjBC,UAAU,EAAE,QAAQ;EACpBC,oBAAoB,EAAE,QAAQ;EAC9BC,IAAI,EAAE,MAAM;EACZC,IAAI,EAAE,OAAO;EACbC,WAAW,EAAE,OAAO;EACpBC,WAAW,EAAE,OAAO;EACpBC,gBAAgB,EAAE,OAAO;EACzBC,gBAAgB,EAAE,OAAO;EACzBC,MAAM,EAAE,OAAO;EACfC,OAAO,EAAE,QAAQ;EACjBC,OAAO,EAAE,QAAQ;EACjBC,OAAO,EAAE,QAAQ;EACjBC,KAAK,EAAE,MAAM;EACbC,MAAM,EAAE,OAAO;EACfC,MAAM,EAAE,OAAO;EACfC,MAAM,EAAE,OAAO;EACfC,IAAI,EAAE,QAAQ;EACdC,IAAI,EAAE,QAAQ;EAEdC,QAAQ,EAAE,QAAQ;EAClBC,aAAa,EAAE,SAAS;EACxBC,aAAa,EAAE,SAAS;EACxBC,kBAAkB,EAAE,SAAS;EAC7BC,4BAA4B,EAAE;AAChC,CAAC;AAACC,OAAA,CAAA9B,oBAAA,GAAAA,oBAAA;AAEK,SAAS+B,sBAAsBA,CAACC,MAAc,EAAU;EAC7D,IAAMC,MAAM,GAAG,EAAE;EAGjB,OAAO;IAACA,MAAM,EAANA,MAAM;IAAEC,QAAQ,EAAE,CAAC;EAAC,CAAC;AAC/B"}

package/dist/es5/lib/geo/decode-geo-metadata.js

@@ -0,0 +1,81 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getGeoMetadata = getGeoMetadata;
+exports.setGeoMetadata = setGeoMetadata;
+exports.unpackGeoMetadata = unpackGeoMetadata;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+function getGeoMetadata(schema) {
+  var stringifiedGeoMetadata = schema.metadata.geo;
+  if (!stringifiedGeoMetadata) {
+    return null;
+  }
+  try {
+    var geoMetadata = JSON.parse(stringifiedGeoMetadata);
+    return geoMetadata;
+  } catch (_unused) {
+    return null;
+  }
+}
+function setGeoMetadata(schema, geoMetadata) {
+  var stringifiedGeoMetadata = JSON.stringify(geoMetadata);
+  schema.metadata.geo = stringifiedGeoMetadata;
+}
+function unpackGeoMetadata(schema) {
+  var geoMetadata = getGeoMetadata(schema);
+  if (!geoMetadata) {
+    return;
+  }
+  var version = geoMetadata.version,
+    primary_column = geoMetadata.primary_column,
+    columns = geoMetadata.columns;
+  if (version) {
+    schema.metadata['geo.version'] = version;
+  }
+  if (primary_column) {
+    schema.metadata['geo.primary_column'] = primary_column;
+  }
+  schema.metadata['geo.columns'] = Object.keys(columns || {}).join('');
+  var _loop = function _loop() {
+    var _Object$entries$_i = (0, _slicedToArray2.default)(_Object$entries[_i], 2),
+      columnName = _Object$entries$_i[0],
+      columnMetadata = _Object$entries$_i[1];
+    var field = schema.fields.find(function (field) {
+      return field.name === columnName;
+    });
+    if (field) {
+      if (field.name === primary_column) {
+        setFieldMetadata(field, 'geo.primary_field', 'true');
+      }
+      unpackGeoFieldMetadata(field, columnMetadata);
+    }
+  };
+  for (var _i = 0, _Object$entries = Object.entries(columns || {}); _i < _Object$entries.length; _i++) {
+    _loop();
+  }
+}
+function unpackGeoFieldMetadata(field, columnMetadata) {
+  for (var _i2 = 0, _Object$entries2 = Object.entries(columnMetadata || {}); _i2 < _Object$entries2.length; _i2++) {
+    var _Object$entries2$_i = (0, _slicedToArray2.default)(_Object$entries2[_i2], 2),
+      _key = _Object$entries2$_i[0],
+      value = _Object$entries2$_i[1];
+    switch (_key) {
+      case 'geometry_type':
+        setFieldMetadata(field, "geo.".concat(_key), value.join(','));
+        break;
+      case 'bbox':
+      case 'crs':
+      case 'edges':
+      default:
+        setFieldMetadata(field, "geo.".concat(_key), typeof value === 'string' ? value : JSON.stringify(value));
+    }
+  }
+}
+function setFieldMetadata(field, key, value) {
+  field.metadata = field.metadata || {};
+  field.metadata[key] = value;
+}
+//# sourceMappingURL=decode-geo-metadata.js.map

package/dist/es5/lib/geo/decode-geo-metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode-geo-metadata.js","names":["getGeoMetadata","schema","stringifiedGeoMetadata","metadata","geo","geoMetadata","JSON","parse","_unused","setGeoMetadata","stringify","unpackGeoMetadata","version","primary_column","columns","Object","keys","join","_loop","_Object$entries$_i","_slicedToArray2","default","_Object$entries","_i","columnName","columnMetadata","field","fields","find","name","setFieldMetadata","unpackGeoFieldMetadata","entries","length","_i2","_Object$entries2","_Object$entries2$_i","key","value","concat"],"sources":["../../../../src/lib/geo/decode-geo-metadata.ts"],"sourcesContent":["// loaders.gl, MIT license\nimport {Schema, Field} from '@loaders.gl/schema';\n\n/* eslint-disable camelcase */\n\n/** A geoarrow / geoparquet geo metadata object (stored in stringified form in the top level metadata 'geo' key) */\nexport type GeoMetadata = {\n  version?: string;\n  primary_column?: string;\n  columns: Record<string, GeoColumnMetadata>;\n  [key: string]: unknown;\n};\n\n/** A geoarrow / geoparquet geo metadata for one geometry column  */\nexport type GeoColumnMetadata = {\n  bounding_box?:\n    | [number, number, number, number]\n    | [number, number, number, number, number, number];\n  crs?: string;\n  geometry_type?: string[];\n  edges?: string;\n  [key: string]: unknown;\n};\n\n/**\n * Reads the GeoMetadata object from the metadata\n * @note geoarrow / parquet schema is stringified into a single key-value pair in the parquet metadata */\nexport function getGeoMetadata(schema: Schema): GeoMetadata | null {\n  const stringifiedGeoMetadata = schema.metadata.geo;\n  if (!stringifiedGeoMetadata) {\n    return null;\n  }\n\n  try {\n    const geoMetadata = JSON.parse(stringifiedGeoMetadata) as GeoMetadata;\n    return geoMetadata;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Stores a geoarrow / geoparquet geo metadata object in the schema\n * @note geoarrow / geoparquet geo metadata is a single stringified JSON field\n */\nexport function setGeoMetadata(schema: Schema, geoMetadata: GeoMetadata): void {\n  const stringifiedGeoMetadata = JSON.stringify(geoMetadata);\n  schema.metadata.geo = stringifiedGeoMetadata;\n}\n\n/**\n * Unpacks geo metadata into separate metadata fields (parses the long JSON string)\n * @note geoarrow / parquet schema is stringified into a single key-value pair in the parquet metadata\n */\nexport function unpackGeoMetadata(schema: Schema): void {\n  const geoMetadata = getGeoMetadata(schema);\n  if (!geoMetadata) {\n    return;\n  }\n\n  // Store Parquet Schema Level Metadata\n\n  const {version, primary_column, columns} = geoMetadata;\n  if (version) {\n    schema.metadata['geo.version'] = version;\n  }\n\n  if (primary_column) {\n    schema.metadata['geo.primary_column'] = primary_column;\n  }\n\n  // store column names as comma separated list\n  schema.metadata['geo.columns'] = Object.keys(columns || {}).join('');\n\n  for (const [columnName, columnMetadata] of Object.entries(columns || {})) {\n    const field = schema.fields.find((field) => field.name === columnName);\n    if (field) {\n      if (field.name === primary_column) {\n        setFieldMetadata(field, 'geo.primary_field', 'true');\n      }\n      unpackGeoFieldMetadata(field, columnMetadata);\n    }\n  }\n}\n\nfunction unpackGeoFieldMetadata(field: Field, columnMetadata): void {\n  for (const [key, value] of Object.entries(columnMetadata || {})) {\n    switch (key) {\n      case 'geometry_type':\n        setFieldMetadata(field, `geo.${key}`, (value as string[]).join(','));\n        break;\n      case 'bbox':\n      case 'crs':\n      case 'edges':\n      default:\n        setFieldMetadata(\n          field,\n          `geo.${key}`,\n          typeof value === 'string' ? value : JSON.stringify(value)\n        );\n    }\n  }\n}\n\nfunction setFieldMetadata(field: Field, key: string, value: string): void {\n  field.metadata = field.metadata || {};\n  field.metadata[key] = value;\n}\n"],"mappings":"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"}

package/dist/es5/lib/geo/geoparquet-schema.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = {
+  $schema: 'http://json-schema.org/draft-07/schema#',
+  title: 'GeoParquet',
+  description: 'Parquet metadata included in the geo field.',
+  type: 'object',
+  required: ['version', 'primary_column', 'columns'],
+  properties: {
+    version: {
+      type: 'string',
+      const: '1.0.0-beta.1'
+    },
+    primary_column: {
+      type: 'string',
+      minLength: 1
+    },
+    columns: {
+      type: 'object',
+      minProperties: 1,
+      patternProperties: {
+        '.+': {
+          type: 'object',
+          required: ['encoding', 'geometry_types'],
+          properties: {
+            encoding: {
+              type: 'string',
+              const: 'WKB'
+            },
+            geometry_types: {
+              type: 'array',
+              uniqueItems: true,
+              items: {
+                type: 'string',
+                pattern: '^(GeometryCollection|(Multi)?(Point|LineString|Polygon))( Z)?$'
+              }
+            },
+            crs: {
+              oneOf: [{
+                $ref: 'https://proj.org/schemas/v0.5/projjson.schema.json'
+              }, {
+                type: 'null'
+              }]
+            },
+            edges: {
+              type: 'string',
+              enum: ['planar', 'spherical']
+            },
+            orientation: {
+              type: 'string',
+              const: 'counterclockwise'
+            },
+            bbox: {
+              type: 'array',
+              items: {
+                type: 'number'
+              },
+              oneOf: [{
+                description: '2D bbox consisting of (xmin, ymin, xmax, ymax)',
+                minItems: 4,
+                maxItems: 4
+              }, {
+                description: '3D bbox consisting of (xmin, ymin, zmin, xmax, ymax, zmax)',
+                minItems: 6,
+                maxItems: 6
+              }]
+            },
+            epoch: {
+              type: 'number'
+            }
+          }
+        }
+      },
+      additionalProperties: false
+    }
+  }
+};
+exports.default = _default;
+//# sourceMappingURL=geoparquet-schema.js.map

package/dist/es5/lib/geo/geoparquet-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geoparquet-schema.js","names":["$schema","title","description","type","required","properties","version","const","primary_column","minLength","columns","minProperties","patternProperties","encoding","geometry_types","uniqueItems","items","pattern","crs","oneOf","$ref","edges","enum","orientation","bbox","minItems","maxItems","epoch","additionalProperties","exports","default","_default"],"sources":["../../../../src/lib/geo/geoparquet-schema.ts"],"sourcesContent":["// loaders.gl, MIT license\n\n/* eslint-disable camelcase */\n\n/**\n * Geoparquet JSON schema for geo metadata\n * @see https://github.com/geoarrow/geoarrow/blob/main/metadata.md\n * @see https://github.com/opengeospatial/geoparquet/blob/main/format-specs/geoparquet.md\n */\nexport default {\n  $schema: 'http://json-schema.org/draft-07/schema#',\n  title: 'GeoParquet',\n  description: 'Parquet metadata included in the geo field.',\n  type: 'object',\n  required: ['version', 'primary_column', 'columns'],\n  properties: {\n    version: {type: 'string', const: '1.0.0-beta.1'},\n    primary_column: {type: 'string', minLength: 1},\n    columns: {\n      type: 'object',\n      minProperties: 1,\n      patternProperties: {\n        '.+': {\n          type: 'object',\n          required: ['encoding', 'geometry_types'],\n          properties: {\n            encoding: {type: 'string', const: 'WKB'},\n            geometry_types: {\n              type: 'array',\n              uniqueItems: true,\n              items: {\n                type: 'string',\n                pattern: '^(GeometryCollection|(Multi)?(Point|LineString|Polygon))( Z)?$'\n              }\n            },\n            crs: {\n              oneOf: [\n                {\n                  $ref: 'https://proj.org/schemas/v0.5/projjson.schema.json'\n                },\n                {type: 'null'}\n              ]\n            },\n            edges: {type: 'string', enum: ['planar', 'spherical']},\n            orientation: {type: 'string', const: 'counterclockwise'},\n            bbox: {\n              type: 'array',\n              items: {type: 'number'},\n              oneOf: [\n                {\n                  description: '2D bbox consisting of (xmin, ymin, xmax, ymax)',\n                  minItems: 4,\n                  maxItems: 4\n                },\n                {\n                  description: '3D bbox consisting of (xmin, ymin, zmin, xmax, ymax, zmax)',\n                  minItems: 6,\n                  maxItems: 6\n                }\n              ]\n            },\n            epoch: {type: 'number'}\n          }\n        }\n      },\n      additionalProperties: false\n    }\n  }\n};\n"],"mappings":";;;;;;eASe;EACbA,OAAO,EAAE,yCAAyC;EAClDC,KAAK,EAAE,YAAY;EACnBC,WAAW,EAAE,6CAA6C;EAC1DC,IAAI,EAAE,QAAQ;EACdC,QAAQ,EAAE,CAAC,SAAS,EAAE,gBAAgB,EAAE,SAAS,CAAC;EAClDC,UAAU,EAAE;IACVC,OAAO,EAAE;MAACH,IAAI,EAAE,QAAQ;MAAEI,KAAK,EAAE;IAAc,CAAC;IAChDC,cAAc,EAAE;MAACL,IAAI,EAAE,QAAQ;MAAEM,SAAS,EAAE;IAAC,CAAC;IAC9CC,OAAO,EAAE;MACPP,IAAI,EAAE,QAAQ;MACdQ,aAAa,EAAE,CAAC;MAChBC,iBAAiB,EAAE;QACjB,IAAI,EAAE;UACJT,IAAI,EAAE,QAAQ;UACdC,QAAQ,EAAE,CAAC,UAAU,EAAE,gBAAgB,CAAC;UACxCC,UAAU,EAAE;YACVQ,QAAQ,EAAE;cAACV,IAAI,EAAE,QAAQ;cAAEI,KAAK,EAAE;YAAK,CAAC;YACxCO,cAAc,EAAE;cACdX,IAAI,EAAE,OAAO;cACbY,WAAW,EAAE,IAAI;cACjBC,KAAK,EAAE;gBACLb,IAAI,EAAE,QAAQ;gBACdc,OAAO,EAAE;cACX;YACF,CAAC;YACDC,GAAG,EAAE;cACHC,KAAK,EAAE,CACL;gBACEC,IAAI,EAAE;cACR,CAAC,EACD;gBAACjB,IAAI,EAAE;cAAM,CAAC;YAElB,CAAC;YACDkB,KAAK,EAAE;cAAClB,IAAI,EAAE,QAAQ;cAAEmB,IAAI,EAAE,CAAC,QAAQ,EAAE,WAAW;YAAC,CAAC;YACtDC,WAAW,EAAE;cAACpB,IAAI,EAAE,QAAQ;cAAEI,KAAK,EAAE;YAAkB,CAAC;YACxDiB,IAAI,EAAE;cACJrB,IAAI,EAAE,OAAO;cACba,KAAK,EAAE;gBAACb,IAAI,EAAE;cAAQ,CAAC;cACvBgB,KAAK,EAAE,CACL;gBACEjB,WAAW,EAAE,gDAAgD;gBAC7DuB,QAAQ,EAAE,CAAC;gBACXC,QAAQ,EAAE;cACZ,CAAC,EACD;gBACExB,WAAW,EAAE,4DAA4D;gBACzEuB,QAAQ,EAAE,CAAC;gBACXC,QAAQ,EAAE;cACZ,CAAC;YAEL,CAAC;YACDC,KAAK,EAAE;cAACxB,IAAI,EAAE;YAAQ;UACxB;QACF;MACF,CAAC;MACDyB,oBAAoB,EAAE;IACxB;EACF;AACF,CAAC;AAAAC,OAAA,CAAAC,OAAA,GAAAC,QAAA"}