@loaders.gl/parquet 3.3.2 → 3.4.0-alpha.2

package/dist/esm/parquet-loader.js

@@ -1,10 +1,11 @@
 
-const VERSION = typeof "3.3.2" !== 'undefined' ? "3.3.2" : 'latest';
+const VERSION = typeof "3.4.0-alpha.2" !== 'undefined' ? "3.4.0-alpha.2" : 'latest';
 const DEFAULT_PARQUET_LOADER_OPTIONS = {
   parquet: {
     type: 'object-row-table',
     url: undefined,
-    columnList: []
+    columnList: [],
+    geoparquet: true
   }
 };
 

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

@@ -1 +1 @@
-{"version":3,"file":"parquet-loader.js","names":["VERSION","DEFAULT_PARQUET_LOADER_OPTIONS","parquet","type","url","undefined","columnList","ParquetLoader","name","id","module","version","worker","category","extensions","mimeTypes","binary","tests","options","_typecheckParquetLoader"],"sources":["../../src/parquet-loader.ts"],"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    columnList?: string[] | string[][];\n  };\n};\n\nconst DEFAULT_PARQUET_LOADER_OPTIONS: ParquetLoaderOptions = {\n  parquet: {\n    type: 'object-row-table',\n    url: undefined,\n    columnList: []\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"],"mappings":";AAIA,MAAMA,OAAO,GAAG,cAAkB,KAAK,WAAW,aAAiB,QAAQ;AAU3E,MAAMC,8BAAoD,GAAG;EAC3DC,OAAO,EAAE;IACPC,IAAI,EAAE,kBAAkB;IACxBC,GAAG,EAAEC,SAAS;IACdC,UAAU,EAAE;EACd;AACF,CAAC;;AAGD,OAAO,MAAMC,aAAa,GAAG;EAC3BC,IAAI,EAAE,gBAAgB;EACtBC,EAAE,EAAE,SAAS;EACbC,MAAM,EAAE,SAAS;EACjBC,OAAO,EAAEX,OAAO;EAChBY,MAAM,EAAE,IAAI;EACZC,QAAQ,EAAE,OAAO;EACjBC,UAAU,EAAE,CAAC,SAAS,CAAC;EACvBC,SAAS,EAAE,CAAC,0BAA0B,CAAC;EACvCC,MAAM,EAAE,IAAI;EACZC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC;EACvBC,OAAO,EAAEjB;AACX,CAAC;AAED,OAAO,MAAMkB,uBAA+B,GAAGZ,aAAa"}
+{"version":3,"file":"parquet-loader.js","names":["VERSION","DEFAULT_PARQUET_LOADER_OPTIONS","parquet","type","url","undefined","columnList","geoparquet","ParquetLoader","name","id","module","version","worker","category","extensions","mimeTypes","binary","tests","options","_typecheckParquetLoader"],"sources":["../../src/parquet-loader.ts"],"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    columnList?: string[] | string[][];\n    geoparquet?: boolean;\n  };\n};\n\nconst DEFAULT_PARQUET_LOADER_OPTIONS: ParquetLoaderOptions = {\n  parquet: {\n    type: 'object-row-table',\n    url: undefined,\n    columnList: [],\n    geoparquet: true\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"],"mappings":";AAIA,MAAMA,OAAO,GAAG,sBAAkB,KAAK,WAAW,qBAAiB,QAAQ;AAW3E,MAAMC,8BAAoD,GAAG;EAC3DC,OAAO,EAAE;IACPC,IAAI,EAAE,kBAAkB;IACxBC,GAAG,EAAEC,SAAS;IACdC,UAAU,EAAE,EAAE;IACdC,UAAU,EAAE;EACd;AACF,CAAC;;AAGD,OAAO,MAAMC,aAAa,GAAG;EAC3BC,IAAI,EAAE,gBAAgB;EACtBC,EAAE,EAAE,SAAS;EACbC,MAAM,EAAE,SAAS;EACjBC,OAAO,EAAEZ,OAAO;EAChBa,MAAM,EAAE,IAAI;EACZC,QAAQ,EAAE,OAAO;EACjBC,UAAU,EAAE,CAAC,SAAS,CAAC;EACvBC,SAAS,EAAE,CAAC,0BAA0B,CAAC;EACvCC,MAAM,EAAE,IAAI;EACZC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC;EACvBC,OAAO,EAAElB;AACX,CAAC;AAED,OAAO,MAAMmB,uBAA+B,GAAGZ,aAAa"}

package/dist/esm/parquet-wasm-loader.js

@@ -1,5 +1,5 @@
 
-const VERSION = typeof "3.3.2" !== 'undefined' ? "3.3.2" : 'latest';
+const VERSION = typeof "3.4.0-alpha.2" !== 'undefined' ? "3.4.0-alpha.2" : 'latest';
 const DEFAULT_PARQUET_LOADER_OPTIONS = {
   parquet: {
     type: 'arrow-table',

package/dist/esm/parquet-wasm-loader.js.map

@@ -1 +1 @@
-{"version":3,"file":"parquet-wasm-loader.js","names":["VERSION","DEFAULT_PARQUET_LOADER_OPTIONS","parquet","type","wasmUrl","ParquetWasmLoader","name","id","module","version","worker","category","extensions","mimeTypes","binary","tests","options","_typecheckParquetLoader"],"sources":["../../src/parquet-wasm-loader.ts"],"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?: 'arrow-table';\n    wasmUrl?: string;\n  };\n};\n\nconst DEFAULT_PARQUET_LOADER_OPTIONS: ParquetLoaderOptions = {\n  parquet: {\n    type: 'arrow-table',\n    wasmUrl: 'https://unpkg.com/parquet-wasm@0.3.1/esm2/arrow1_bg.wasm'\n  }\n};\n\n/** ParquetJS table loader */\nexport const ParquetWasmLoader = {\n  name: 'Apache Parquet',\n  id: 'parquet-wasm',\n  module: 'parquet',\n  version: VERSION,\n  worker: false,\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 = ParquetWasmLoader;\n"],"mappings":";AAIA,MAAMA,OAAO,GAAG,cAAkB,KAAK,WAAW,aAAiB,QAAQ;AAS3E,MAAMC,8BAAoD,GAAG;EAC3DC,OAAO,EAAE;IACPC,IAAI,EAAE,aAAa;IACnBC,OAAO,EAAE;EACX;AACF,CAAC;;AAGD,OAAO,MAAMC,iBAAiB,GAAG;EAC/BC,IAAI,EAAE,gBAAgB;EACtBC,EAAE,EAAE,cAAc;EAClBC,MAAM,EAAE,SAAS;EACjBC,OAAO,EAAET,OAAO;EAChBU,MAAM,EAAE,KAAK;EACbC,QAAQ,EAAE,OAAO;EACjBC,UAAU,EAAE,CAAC,SAAS,CAAC;EACvBC,SAAS,EAAE,CAAC,0BAA0B,CAAC;EACvCC,MAAM,EAAE,IAAI;EACZC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC;EACvBC,OAAO,EAAEf;AACX,CAAC;AAED,OAAO,MAAMgB,uBAA+B,GAAGZ,iBAAiB"}
+{"version":3,"file":"parquet-wasm-loader.js","names":["VERSION","DEFAULT_PARQUET_LOADER_OPTIONS","parquet","type","wasmUrl","ParquetWasmLoader","name","id","module","version","worker","category","extensions","mimeTypes","binary","tests","options","_typecheckParquetLoader"],"sources":["../../src/parquet-wasm-loader.ts"],"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?: 'arrow-table';\n    wasmUrl?: string;\n  };\n};\n\nconst DEFAULT_PARQUET_LOADER_OPTIONS: ParquetLoaderOptions = {\n  parquet: {\n    type: 'arrow-table',\n    wasmUrl: 'https://unpkg.com/parquet-wasm@0.3.1/esm2/arrow1_bg.wasm'\n  }\n};\n\n/** ParquetJS table loader */\nexport const ParquetWasmLoader = {\n  name: 'Apache Parquet',\n  id: 'parquet-wasm',\n  module: 'parquet',\n  version: VERSION,\n  worker: false,\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 = ParquetWasmLoader;\n"],"mappings":";AAIA,MAAMA,OAAO,GAAG,sBAAkB,KAAK,WAAW,qBAAiB,QAAQ;AAS3E,MAAMC,8BAAoD,GAAG;EAC3DC,OAAO,EAAE;IACPC,IAAI,EAAE,aAAa;IACnBC,OAAO,EAAE;EACX;AACF,CAAC;;AAGD,OAAO,MAAMC,iBAAiB,GAAG;EAC/BC,IAAI,EAAE,gBAAgB;EACtBC,EAAE,EAAE,cAAc;EAClBC,MAAM,EAAE,SAAS;EACjBC,OAAO,EAAET,OAAO;EAChBU,MAAM,EAAE,KAAK;EACbC,QAAQ,EAAE,OAAO;EACjBC,UAAU,EAAE,CAAC,SAAS,CAAC;EACvBC,SAAS,EAAE,CAAC,0BAA0B,CAAC;EACvCC,MAAM,EAAE,IAAI;EACZC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC;EACvBC,OAAO,EAAEf;AACX,CAAC;AAED,OAAO,MAAMgB,uBAA+B,GAAGZ,iBAAiB"}

package/dist/esm/parquet-wasm-writer.js

@@ -1,6 +1,6 @@
 import { encode } from './lib/wasm/encode-parquet-wasm';
 
-const VERSION = typeof "3.3.2" !== 'undefined' ? "3.3.2" : 'latest';
+const VERSION = typeof "3.4.0-alpha.2" !== 'undefined' ? "3.4.0-alpha.2" : 'latest';
 const DEFAULT_PARQUET_WRITER_OPTIONS = {
   parquet: {
     wasmUrl: 'https://unpkg.com/parquet-wasm@0.3.1/esm2/arrow1_bg.wasm'

package/dist/esm/parquet-wasm-writer.js.map

@@ -1 +1 @@
-{"version":3,"file":"parquet-wasm-writer.js","names":["encode","VERSION","DEFAULT_PARQUET_WRITER_OPTIONS","parquet","wasmUrl","ParquetWasmWriter","name","id","module","version","extensions","mimeTypes","binary","options"],"sources":["../../src/parquet-wasm-writer.ts"],"sourcesContent":["import type {Writer} from '@loaders.gl/loader-utils';\nimport {encode, ParquetWriterOptions} from './lib/wasm/encode-parquet-wasm';\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\nconst DEFAULT_PARQUET_WRITER_OPTIONS: ParquetWriterOptions = {\n  parquet: {\n    wasmUrl: 'https://unpkg.com/parquet-wasm@0.3.1/esm2/arrow1_bg.wasm'\n  }\n};\n\nexport const ParquetWasmWriter: Writer = {\n  name: 'Apache Parquet',\n  id: 'parquet-wasm',\n  module: 'parquet',\n  version: VERSION,\n  extensions: ['parquet'],\n  mimeTypes: ['application/octet-stream'],\n  encode,\n  binary: true,\n  options: DEFAULT_PARQUET_WRITER_OPTIONS\n};\n"],"mappings":"AACA,SAAQA,MAAM,QAA6B,gCAAgC;;AAI3E,MAAMC,OAAO,GAAG,cAAkB,KAAK,WAAW,aAAiB,QAAQ;AAE3E,MAAMC,8BAAoD,GAAG;EAC3DC,OAAO,EAAE;IACPC,OAAO,EAAE;EACX;AACF,CAAC;AAED,OAAO,MAAMC,iBAAyB,GAAG;EACvCC,IAAI,EAAE,gBAAgB;EACtBC,EAAE,EAAE,cAAc;EAClBC,MAAM,EAAE,SAAS;EACjBC,OAAO,EAAER,OAAO;EAChBS,UAAU,EAAE,CAAC,SAAS,CAAC;EACvBC,SAAS,EAAE,CAAC,0BAA0B,CAAC;EACvCX,MAAM;EACNY,MAAM,EAAE,IAAI;EACZC,OAAO,EAAEX;AACX,CAAC"}
+{"version":3,"file":"parquet-wasm-writer.js","names":["encode","VERSION","DEFAULT_PARQUET_WRITER_OPTIONS","parquet","wasmUrl","ParquetWasmWriter","name","id","module","version","extensions","mimeTypes","binary","options"],"sources":["../../src/parquet-wasm-writer.ts"],"sourcesContent":["import type {Writer} from '@loaders.gl/loader-utils';\nimport {encode, ParquetWriterOptions} from './lib/wasm/encode-parquet-wasm';\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\nconst DEFAULT_PARQUET_WRITER_OPTIONS: ParquetWriterOptions = {\n  parquet: {\n    wasmUrl: 'https://unpkg.com/parquet-wasm@0.3.1/esm2/arrow1_bg.wasm'\n  }\n};\n\nexport const ParquetWasmWriter: Writer = {\n  name: 'Apache Parquet',\n  id: 'parquet-wasm',\n  module: 'parquet',\n  version: VERSION,\n  extensions: ['parquet'],\n  mimeTypes: ['application/octet-stream'],\n  encode,\n  binary: true,\n  options: DEFAULT_PARQUET_WRITER_OPTIONS\n};\n"],"mappings":"AACA,SAAQA,MAAM,QAA6B,gCAAgC;;AAI3E,MAAMC,OAAO,GAAG,sBAAkB,KAAK,WAAW,qBAAiB,QAAQ;AAE3E,MAAMC,8BAAoD,GAAG;EAC3DC,OAAO,EAAE;IACPC,OAAO,EAAE;EACX;AACF,CAAC;AAED,OAAO,MAAMC,iBAAyB,GAAG;EACvCC,IAAI,EAAE,gBAAgB;EACtBC,EAAE,EAAE,cAAc;EAClBC,MAAM,EAAE,SAAS;EACjBC,OAAO,EAAER,OAAO;EAChBS,UAAU,EAAE,CAAC,SAAS,CAAC;EACvBC,SAAS,EAAE,CAAC,0BAA0B,CAAC;EACvCX,MAAM;EACNY,MAAM,EAAE,IAAI;EACZC,OAAO,EAAEX;AACX,CAAC"}

package/dist/esm/parquet-writer.js

@@ -1,5 +1,5 @@
 
-const VERSION = typeof "3.3.2" !== 'undefined' ? "3.3.2" : 'latest';
+const VERSION = typeof "3.4.0-alpha.2" !== 'undefined' ? "3.4.0-alpha.2" : 'latest';
 const DEFAULT_PARQUET_LOADER_OPTIONS = {};
 export const ParquetWriter = {
   name: 'Apache Parquet',

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

@@ -1 +1 @@
-{"version":3,"file":"parquet-writer.js","names":["VERSION","DEFAULT_PARQUET_LOADER_OPTIONS","ParquetWriter","name","id","module","version","extensions","mimeTypes","encodeSync","binary","options","data","ArrayBuffer"],"sources":["../../src/parquet-writer.ts"],"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"],"mappings":";AAIA,MAAMA,OAAO,GAAG,cAAkB,KAAK,WAAW,aAAiB,QAAQ;AAI3E,MAAMC,8BAA8B,GAAG,CAAC,CAAC;AAEzC,OAAO,MAAMC,aAAqB,GAAG;EACnCC,IAAI,EAAE,gBAAgB;EACtBC,EAAE,EAAE,SAAS;EACbC,MAAM,EAAE,SAAS;EACjBC,OAAO,EAAEN,OAAO;EAChBO,UAAU,EAAE,CAAC,SAAS,CAAC;EACvBC,SAAS,EAAE,CAAC,0BAA0B,CAAC;EACvCC,UAAU;EACVC,MAAM,EAAE,IAAI;EACZC,OAAO,EAAEV;AACX,CAAC;AAED,SAASQ,UAAU,CAACG,IAAI,EAAED,OAA8B,EAAE;EACxD,OAAO,IAAIE,WAAW,CAAC,CAAC,CAAC;AAC3B"}
+{"version":3,"file":"parquet-writer.js","names":["VERSION","DEFAULT_PARQUET_LOADER_OPTIONS","ParquetWriter","name","id","module","version","extensions","mimeTypes","encodeSync","binary","options","data","ArrayBuffer"],"sources":["../../src/parquet-writer.ts"],"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"],"mappings":";AAIA,MAAMA,OAAO,GAAG,sBAAkB,KAAK,WAAW,qBAAiB,QAAQ;AAI3E,MAAMC,8BAA8B,GAAG,CAAC,CAAC;AAEzC,OAAO,MAAMC,aAAqB,GAAG;EACnCC,IAAI,EAAE,gBAAgB;EACtBC,EAAE,EAAE,SAAS;EACbC,MAAM,EAAE,SAAS;EACjBC,OAAO,EAAEN,OAAO;EAChBO,UAAU,EAAE,CAAC,SAAS,CAAC;EACvBC,SAAS,EAAE,CAAC,0BAA0B,CAAC;EACvCC,UAAU;EACVC,MAAM,EAAE,IAAI;EACZC,OAAO,EAAEV;AACX,CAAC;AAED,SAASQ,UAAU,CAACG,IAAI,EAAED,OAA8B,EAAE;EACxD,OAAO,IAAIE,WAAW,CAAC,CAAC,CAAC;AAC3B"}

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import type { LoaderWithParser } from '@loaders.gl/loader-utils';
 import { ParquetWasmLoader as ParquetWasmWorkerLoader } from './parquet-wasm-loader';
 import { ParquetLoader as ParquetWorkerLoader } from './parquet-loader';
-import { parseParquet, parseParquetFileInBatches } from './lib/parse-parquet';
+import { parseParquet, parseParquetFileInBatches } from './lib/parsers/parse-parquet-to-rows';
+import { parseParquetInColumns, parseParquetFileInColumnarBatches } from './lib/parsers/parse-parquet-to-columns';
 import { parseParquet as parseParquetWasm } from './lib/wasm/parse-parquet-wasm';
 export { ParquetWorkerLoader, ParquetWasmWorkerLoader };
 /** ParquetJS table loader */
@@ -10,7 +11,23 @@ export declare const ParquetLoader: {
     parseFileInBatches: typeof parseParquetFileInBatches;
     name: string;
     id: string;
-    module: string;
+    module: string; /** ParquetJS table loader */
+    version: any;
+    worker: boolean;
+    category: string;
+    extensions: string[];
+    mimeTypes: string[];
+    binary: boolean;
+    tests: string[];
+    options: import("./parquet-loader").ParquetLoaderOptions;
+};
+/** ParquetJS table loader */
+export declare const ParquetColumnarLoader: {
+    parse: typeof parseParquetInColumns;
+    parseFileInBatches: typeof parseParquetFileInColumnarBatches;
+    name: string;
+    id: string;
+    module: string; /** ParquetJS table loader */
     version: any;
     worker: boolean;
     category: string;
@@ -40,6 +57,9 @@ export { preloadCompressions } from './parquetjs/compression';
 export { ParquetSchema } from './parquetjs/schema/schema';
 export { ParquetReader } from './parquetjs/parser/parquet-reader';
 export { ParquetEncoder } from './parquetjs/encoder/parquet-encoder';
-export { convertParquetToArrowSchema } from './lib/convert-schema';
+export { convertSchemaFromParquet, convertSchemaFromParquet as convertParquetToArrowSchema } from './lib/arrow/convert-schema-from-parquet';
 export declare const _typecheckParquetLoader: LoaderWithParser;
+export { default as geoJSONSchema } from './lib/geo/geoparquet-schema';
+export type { GeoMetadata } from './lib/geo/decode-geo-metadata';
+export { getGeoMetadata, setGeoMetadata, unpackGeoMetadata } from './lib/geo/decode-geo-metadata';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAI/D,OAAO,EAAC,iBAAiB,IAAI,uBAAuB,EAAC,MAAM,uBAAuB,CAAC;AACnF,OAAO,EAAC,aAAa,IAAI,mBAAmB,EAAC,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAC,YAAY,EAAE,yBAAyB,EAAC,MAAM,qBAAqB,CAAC;AAC5E,OAAO,EAAC,YAAY,IAAI,gBAAgB,EAAC,MAAM,+BAA+B,CAAC;AAE/E,OAAO,EAAC,mBAAmB,EAAE,uBAAuB,EAAC,CAAC;AAEtD,6BAA6B;AAC7B,eAAO,MAAM,aAAa;;;;;;;;;;;;;;CAIzB,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;CAG7B,CAAC;AAIF,OAAO,EAAC,aAAa,IAAI,cAAc,EAAC,MAAM,kBAAkB,CAAC;AACjE,OAAO,EAAC,iBAAiB,EAAC,MAAM,uBAAuB,CAAC;AAIxD,OAAO,EAAC,mBAAmB,EAAC,MAAM,yBAAyB,CAAC;AAE5D,OAAO,EAAC,aAAa,EAAC,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAC,aAAa,EAAC,MAAM,mCAAmC,CAAC;AAChE,OAAO,EAAC,cAAc,EAAC,MAAM,qCAAqC,CAAC;AAEnE,OAAO,EAAC,2BAA2B,EAAC,MAAM,sBAAsB,CAAC;AAGjE,eAAO,MAAM,uBAAuB,EAAE,gBAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAI/D,OAAO,EAAC,iBAAiB,IAAI,uBAAuB,EAAC,MAAM,uBAAuB,CAAC;AACnF,OAAO,EAAC,aAAa,IAAI,mBAAmB,EAAC,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAC,YAAY,EAAE,yBAAyB,EAAC,MAAM,qCAAqC,CAAC;AAC5F,OAAO,EACL,qBAAqB,EACrB,iCAAiC,EAClC,MAAM,wCAAwC,CAAC;AAChD,OAAO,EAAC,YAAY,IAAI,gBAAgB,EAAC,MAAM,+BAA+B,CAAC;AAE/E,OAAO,EAAC,mBAAmB,EAAE,uBAAuB,EAAC,CAAC;AAEtD,6BAA6B;AAC7B,eAAO,MAAM,aAAa;;;;;oBAM1B,6BAA6B;;;;;;;;;CAF5B,CAAC;AAEF,6BAA6B;AAC7B,eAAO,MAAM,qBAAqB;;;;;oBADlC,6BAA6B;;;;;;;;;CAK5B,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;CAG7B,CAAC;AAIF,OAAO,EAAC,aAAa,IAAI,cAAc,EAAC,MAAM,kBAAkB,CAAC;AACjE,OAAO,EAAC,iBAAiB,EAAC,MAAM,uBAAuB,CAAC;AAIxD,OAAO,EAAC,mBAAmB,EAAC,MAAM,yBAAyB,CAAC;AAE5D,OAAO,EAAC,aAAa,EAAC,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAC,aAAa,EAAC,MAAM,mCAAmC,CAAC;AAChE,OAAO,EAAC,cAAc,EAAC,MAAM,qCAAqC,CAAC;AAEnE,OAAO,EACL,wBAAwB,EACxB,wBAAwB,IAAI,2BAA2B,EACxD,MAAM,yCAAyC,CAAC;AAGjD,eAAO,MAAM,uBAAuB,EAAE,gBAAgC,CAAC;AAGvE,OAAO,EAAC,OAAO,IAAI,aAAa,EAAC,MAAM,6BAA6B,CAAC;AAErE,YAAY,EAAC,WAAW,EAAC,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAC,cAAc,EAAE,cAAc,EAAE,iBAAiB,EAAC,MAAM,+BAA+B,CAAC"}

package/dist/index.js

@@ -1,18 +1,28 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._typecheckParquetLoader = exports.convertParquetToArrowSchema = exports.ParquetEncoder = exports.ParquetReader = exports.ParquetSchema = exports.preloadCompressions = exports.ParquetWasmWriter = exports._ParquetWriter = exports.ParquetWasmLoader = exports.ParquetLoader = exports.ParquetWasmWorkerLoader = exports.ParquetWorkerLoader = void 0;
+exports.unpackGeoMetadata = exports.setGeoMetadata = exports.getGeoMetadata = exports.geoJSONSchema = exports._typecheckParquetLoader = exports.convertParquetToArrowSchema = exports.convertSchemaFromParquet = exports.ParquetEncoder = exports.ParquetReader = exports.ParquetSchema = exports.preloadCompressions = exports.ParquetWasmWriter = exports._ParquetWriter = exports.ParquetWasmLoader = exports.ParquetColumnarLoader = exports.ParquetLoader = exports.ParquetWasmWorkerLoader = exports.ParquetWorkerLoader = void 0;
 // ParquetLoader
 const parquet_wasm_loader_1 = require("./parquet-wasm-loader");
 Object.defineProperty(exports, "ParquetWasmWorkerLoader", { enumerable: true, get: function () { return parquet_wasm_loader_1.ParquetWasmLoader; } });
 const parquet_loader_1 = require("./parquet-loader");
 Object.defineProperty(exports, "ParquetWorkerLoader", { enumerable: true, get: function () { return parquet_loader_1.ParquetLoader; } });
-const parse_parquet_1 = require("./lib/parse-parquet");
+const parse_parquet_to_rows_1 = require("./lib/parsers/parse-parquet-to-rows");
+const parse_parquet_to_columns_1 = require("./lib/parsers/parse-parquet-to-columns");
 const parse_parquet_wasm_1 = require("./lib/wasm/parse-parquet-wasm");
 /** ParquetJS table loader */
 exports.ParquetLoader = {
     ...parquet_loader_1.ParquetLoader,
-    parse: parse_parquet_1.parseParquet,
-    parseFileInBatches: parse_parquet_1.parseParquetFileInBatches
+    parse: parse_parquet_to_rows_1.parseParquet,
+    parseFileInBatches: parse_parquet_to_rows_1.parseParquetFileInBatches
+};
+/** ParquetJS table loader */
+exports.ParquetColumnarLoader = {
+    ...parquet_loader_1.ParquetLoader,
+    parse: parse_parquet_to_columns_1.parseParquetInColumns,
+    parseFileInBatches: parse_parquet_to_columns_1.parseParquetFileInColumnarBatches
 };
 exports.ParquetWasmLoader = {
     ...parquet_wasm_loader_1.ParquetWasmLoader,
@@ -32,7 +42,15 @@ var parquet_reader_1 = require("./parquetjs/parser/parquet-reader");
 Object.defineProperty(exports, "ParquetReader", { enumerable: true, get: function () { return parquet_reader_1.ParquetReader; } });
 var parquet_encoder_1 = require("./parquetjs/encoder/parquet-encoder");
 Object.defineProperty(exports, "ParquetEncoder", { enumerable: true, get: function () { return parquet_encoder_1.ParquetEncoder; } });
-var convert_schema_1 = require("./lib/convert-schema");
-Object.defineProperty(exports, "convertParquetToArrowSchema", { enumerable: true, get: function () { return convert_schema_1.convertParquetToArrowSchema; } });
+var convert_schema_from_parquet_1 = require("./lib/arrow/convert-schema-from-parquet");
+Object.defineProperty(exports, "convertSchemaFromParquet", { enumerable: true, get: function () { return convert_schema_from_parquet_1.convertSchemaFromParquet; } });
+Object.defineProperty(exports, "convertParquetToArrowSchema", { enumerable: true, get: function () { return convert_schema_from_parquet_1.convertSchemaFromParquet; } });
 // TESTS
 exports._typecheckParquetLoader = exports.ParquetLoader;
+// Geo Metadata
+var geoparquet_schema_1 = require("./lib/geo/geoparquet-schema");
+Object.defineProperty(exports, "geoJSONSchema", { enumerable: true, get: function () { return __importDefault(geoparquet_schema_1).default; } });
+var decode_geo_metadata_1 = require("./lib/geo/decode-geo-metadata");
+Object.defineProperty(exports, "getGeoMetadata", { enumerable: true, get: function () { return decode_geo_metadata_1.getGeoMetadata; } });
+Object.defineProperty(exports, "setGeoMetadata", { enumerable: true, get: function () { return decode_geo_metadata_1.setGeoMetadata; } });
+Object.defineProperty(exports, "unpackGeoMetadata", { enumerable: true, get: function () { return decode_geo_metadata_1.unpackGeoMetadata; } });

package/dist/lib/arrow/convert-columns-to-row-group.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=convert-columns-to-row-group.d.ts.map

package/dist/lib/arrow/convert-columns-to-row-group.d.ts.map

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

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

@@ -0,0 +1 @@
+"use strict";

package/dist/lib/arrow/convert-row-group-to-columns.d.ts

@@ -0,0 +1,4 @@
+import { Schema } from '@loaders.gl/schema';
+import { ParquetBuffer } from '@loaders.gl/parquet/parquetjs/schema/declare';
+export declare function convertParquetRowGroupToColumns(schema: Schema, rowGroup: ParquetBuffer): Record<string, any[]>;
+//# sourceMappingURL=convert-row-group-to-columns.d.ts.map

package/dist/lib/arrow/convert-row-group-to-columns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-row-group-to-columns.d.ts","sourceRoot":"","sources":["../../../src/lib/arrow/convert-row-group-to-columns.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,MAAM,EAAC,MAAM,oBAAoB,CAAC;AAC1C,OAAO,EAAC,aAAa,EAAC,MAAM,8CAA8C,CAAC;AAE3E,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,aAAa,GACtB,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,CAMvB"}

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

@@ -0,0 +1,12 @@
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertParquetRowGroupToColumns = void 0;
+function convertParquetRowGroupToColumns(schema, rowGroup) {
+    const columns = {};
+    for (const [columnName, data] of Object.entries(rowGroup.columnData)) {
+        columns[columnName] = columns[columnName] || data.values;
+    }
+    return columns;
+}
+exports.convertParquetRowGroupToColumns = convertParquetRowGroupToColumns;

package/dist/lib/arrow/convert-schema-from-parquet.d.ts

@@ -0,0 +1,9 @@
+import type { ParquetSchema } from '../../parquetjs/schema/schema';
+import type { ParquetType } from '../../parquetjs/schema/declare';
+import { FileMetaData } from '@loaders.gl/parquet/parquetjs/parquet-thrift';
+import { Schema, DataType } from '@loaders.gl/schema';
+export declare const PARQUET_TYPE_MAPPING: {
+    [type in ParquetType]: typeof DataType;
+};
+export declare function convertSchemaFromParquet(parquetSchema: ParquetSchema, parquetMetadata?: FileMetaData): Schema;
+//# sourceMappingURL=convert-schema-from-parquet.d.ts.map

package/dist/lib/arrow/convert-schema-from-parquet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-schema-from-parquet.d.ts","sourceRoot":"","sources":["../../../src/lib/arrow/convert-schema-from-parquet.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,+BAA+B,CAAC;AACjE,OAAO,KAAK,EAAgC,WAAW,EAAC,MAAM,gCAAgC,CAAC;AAC/F,OAAO,EAAC,YAAY,EAAC,MAAM,8CAA8C,CAAC;AAE1E,OAAO,EACL,MAAM,EAGN,QAAQ,EAaT,MAAM,oBAAoB,CAAC;AAE5B,eAAO,MAAM,oBAAoB,EAAE;KAAE,IAAI,IAAI,WAAW,GAAG,OAAO,QAAQ;CA+BzE,CAAC;AAEF,wBAAgB,wBAAwB,CACtC,aAAa,EAAE,aAAa,EAC5B,eAAe,CAAC,EAAE,YAAY,GAC7B,MAAM,CAIR"}

package/dist/lib/{convert-schema.js → arrow/convert-schema-from-parquet.js}

@@ -1,6 +1,7 @@
 "use strict";
+// loaders.gl, MIT license
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertParquetToArrowSchema = exports.PARQUET_TYPE_MAPPING = void 0;
+exports.convertSchemaFromParquet = exports.PARQUET_TYPE_MAPPING = void 0;
 const schema_1 = require("@loaders.gl/schema");
 exports.PARQUET_TYPE_MAPPING = {
     BOOLEAN: schema_1.Bool,
@@ -27,36 +28,26 @@ exports.PARQUET_TYPE_MAPPING = {
     INT_64: schema_1.Int64,
     JSON: schema_1.Binary,
     BSON: schema_1.Binary,
-    // TODO check interal type
+    // TODO check interval type
     INTERVAL: schema_1.Binary,
     DECIMAL_INT32: schema_1.Float32,
     DECIMAL_INT64: schema_1.Float64,
     DECIMAL_BYTE_ARRAY: schema_1.Float64,
     DECIMAL_FIXED_LEN_BYTE_ARRAY: schema_1.Float64
 };
-function convertParquetToArrowSchema(parquetSchema) {
+function convertSchemaFromParquet(parquetSchema, parquetMetadata) {
     const fields = getFields(parquetSchema.schema);
-    // TODO add metadata if needed.
-    return new schema_1.Schema(fields);
-}
-exports.convertParquetToArrowSchema = convertParquetToArrowSchema;
-function getFieldMetadata(field) {
-    const metadata = new Map();
-    for (const key in field) {
-        if (key !== 'name') {
-            const value = typeof field[key] !== 'string' ? JSON.stringify(field[key]) : field[key];
-            metadata.set(key, value);
-        }
-    }
-    return metadata;
+    const metadata = parquetMetadata && getSchemaMetadata(parquetMetadata);
+    return new schema_1.Schema(fields, metadata);
 }
+exports.convertSchemaFromParquet = convertSchemaFromParquet;
 function getFields(schema) {
     const fields = [];
     for (const name in schema) {
         const field = schema[name];
         if (field.fields) {
-            const childField = getFields(field.fields);
-            const nestedField = new schema_1.Field(name, new schema_1.Struct(childField), field.optional);
+            const childFields = getFields(field.fields);
+            const nestedField = new schema_1.Field(name, new schema_1.Struct(childFields), field.optional);
             fields.push(nestedField);
         }
         else {
@@ -68,3 +59,24 @@ function getFields(schema) {
     }
     return fields;
 }
+function getFieldMetadata(field) {
+    const metadata = new Map();
+    for (const key in field) {
+        if (key !== 'name') {
+            let value = field[key] || '';
+            value = typeof field[key] !== 'string' ? JSON.stringify(field[key]) : field[key];
+            metadata.set(key, value);
+        }
+    }
+    return metadata;
+}
+function getSchemaMetadata(parquetMetadata) {
+    const metadata = new Map();
+    const keyValueList = parquetMetadata.key_value_metadata || [];
+    for (const { key, value } of keyValueList) {
+        if (typeof value === 'string') {
+            metadata.set(key, value);
+        }
+    }
+    return metadata;
+}

package/dist/lib/arrow/convert-schema-to-parquet.d.ts

@@ -0,0 +1,7 @@
+import type { ParquetType } from '../../parquetjs/schema/declare';
+import { Schema, DataType } from '@loaders.gl/schema';
+export declare const PARQUET_TYPE_MAPPING: {
+    [type in ParquetType]: typeof DataType;
+};
+export declare function convertToParquetSchema(schema: Schema): Schema;
+//# sourceMappingURL=convert-schema-to-parquet.d.ts.map

package/dist/lib/arrow/convert-schema-to-parquet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-schema-to-parquet.d.ts","sourceRoot":"","sources":["../../../src/lib/arrow/convert-schema-to-parquet.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAEV,WAAW,EACZ,MAAM,gCAAgC,CAAC;AAExC,OAAO,EACL,MAAM,EAGN,QAAQ,EAaT,MAAM,oBAAoB,CAAC;AAE5B,eAAO,MAAM,oBAAoB,EAAE;KAAE,IAAI,IAAI,WAAW,GAAG,OAAO,QAAQ;CA+BzE,CAAC;AAEF,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAK7D"}

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

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

package/dist/lib/geo/decode-geo-metadata.d.ts

@@ -0,0 +1,31 @@
+import { Schema } from '@loaders.gl/schema';
+/** A geoarrow / geoparquet geo metadata object (stored in stringified form in the top level metadata 'geo' key) */
+export type GeoMetadata = {
+    version?: string;
+    primary_column?: string;
+    columns: Record<string, GeoColumnMetadata>;
+    [key: string]: unknown;
+};
+/** A geoarrow / geoparquet geo metadata for one geometry column  */
+export type GeoColumnMetadata = {
+    bounding_box?: [number, number, number, number] | [number, number, number, number, number, number];
+    crs?: string;
+    geometry_type?: string[];
+    edges?: string;
+    [key: string]: unknown;
+};
+/**
+ * Reads the GeoMetadata object from the metadata
+ * @note geoarrow / parquet schema is stringified into a single key-value pair in the parquet metadata */
+export declare function getGeoMetadata(schema: Schema): GeoMetadata | null;
+/**
+ * Stores a geoarrow / geoparquet geo metadata object in the schema
+ * @note geoarrow / geoparquet geo metadata is a single stringified JSON field
+ */
+export declare function setGeoMetadata(schema: Schema, geoMetadata: GeoMetadata): void;
+/**
+ * Unpacks geo metadata into separate metadata fields (parses the long JSON string)
+ * @note geoarrow / parquet schema is stringified into a single key-value pair in the parquet metadata
+ */
+export declare function unpackGeoMetadata(schema: Schema): void;
+//# sourceMappingURL=decode-geo-metadata.d.ts.map

package/dist/lib/geo/decode-geo-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode-geo-metadata.d.ts","sourceRoot":"","sources":["../../../src/lib/geo/decode-geo-metadata.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,MAAM,EAAQ,MAAM,oBAAoB,CAAC;AAIjD,mHAAmH;AACnH,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IAC3C,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AAEF,oEAAoE;AACpE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,YAAY,CAAC,EACT,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAChC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACrD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AAEF;;yGAEyG;AACzG,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAYjE;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,GAAG,IAAI,CAG7E;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CA6BtD"}

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

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unpackGeoMetadata = exports.setGeoMetadata = exports.getGeoMetadata = void 0;
+/**
+ * Reads the GeoMetadata object from the metadata
+ * @note geoarrow / parquet schema is stringified into a single key-value pair in the parquet metadata */
+function getGeoMetadata(schema) {
+    const stringifiedGeoMetadata = schema.metadata.get('geo');
+    if (!stringifiedGeoMetadata) {
+        return null;
+    }
+    try {
+        const geoMetadata = JSON.parse(stringifiedGeoMetadata);
+        return geoMetadata;
+    }
+    catch {
+        return null;
+    }
+}
+exports.getGeoMetadata = getGeoMetadata;
+/**
+ * Stores a geoarrow / geoparquet geo metadata object in the schema
+ * @note geoarrow / geoparquet geo metadata is a single stringified JSON field
+ */
+function setGeoMetadata(schema, geoMetadata) {
+    const stringifiedGeoMetadata = JSON.stringify(geoMetadata);
+    schema.metadata.set('geo', stringifiedGeoMetadata);
+}
+exports.setGeoMetadata = setGeoMetadata;
+/**
+ * Unpacks geo metadata into separate metadata fields (parses the long JSON string)
+ * @note geoarrow / parquet schema is stringified into a single key-value pair in the parquet metadata
+ */
+function unpackGeoMetadata(schema) {
+    const geoMetadata = getGeoMetadata(schema);
+    if (!geoMetadata) {
+        return;
+    }
+    // Store Parquet Schema Level Metadata
+    const { version, primary_column, columns } = geoMetadata;
+    if (version) {
+        schema.metadata.set('geo.version', version);
+    }
+    if (primary_column) {
+        schema.metadata.set('geo.primary_column', primary_column);
+    }
+    // store column names as comma separated list
+    schema.metadata.set('geo.columns', Object.keys(columns || {}).join(''));
+    for (const [columnName, columnMetadata] of Object.entries(columns || {})) {
+        const field = schema.fields.find((field) => field.name === columnName);
+        if (field) {
+            if (field.name === primary_column) {
+                field.metadata.set('geo.primary_field', 'true');
+            }
+            unpackGeoFieldMetadata(field, columnMetadata);
+        }
+    }
+}
+exports.unpackGeoMetadata = unpackGeoMetadata;
+function unpackGeoFieldMetadata(field, columnMetadata) {
+    for (const [key, value] of Object.entries(columnMetadata || {})) {
+        switch (key) {
+            case 'geometry_type':
+                field.metadata.set(`geo.${key}`, value.join(','));
+                break;
+            case 'bbox':
+            case 'crs':
+            case 'edges':
+            default:
+                field.metadata.set(`geo.${key}`, typeof value === 'string' ? value : JSON.stringify(value));
+        }
+    }
+}

package/dist/lib/geo/geoparquet-schema.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Geoparquet JSON schema for geo metadata
+ * @see https://github.com/geoarrow/geoarrow/blob/main/metadata.md
+ * @see https://github.com/opengeospatial/geoparquet/blob/main/format-specs/geoparquet.md
+ */
+declare const _default: {
+    $schema: string;
+    title: string;
+    description: string;
+    type: string;
+    required: string[];
+    properties: {
+        version: {
+            type: string;
+            const: string;
+        };
+        primary_column: {
+            type: string;
+            minLength: number;
+        };
+        columns: {
+            type: string;
+            minProperties: number;
+            patternProperties: {
+                '.+': {
+                    type: string;
+                    required: string[];
+                    properties: {
+                        encoding: {
+                            type: string;
+                            const: string;
+                        };
+                        geometry_types: {
+                            type: string;
+                            uniqueItems: boolean;
+                            items: {
+                                type: string;
+                                pattern: string;
+                            };
+                        };
+                        crs: {
+                            oneOf: ({
+                                $ref: string;
+                                type?: undefined;
+                            } | {
+                                type: string;
+                                $ref?: undefined;
+                            })[];
+                        };
+                        edges: {
+                            type: string;
+                            enum: string[];
+                        };
+                        orientation: {
+                            type: string;
+                            const: string;
+                        };
+                        bbox: {
+                            type: string;
+                            items: {
+                                type: string;
+                            };
+                            oneOf: {
+                                description: string;
+                                minItems: number;
+                                maxItems: number;
+                            }[];
+                        };
+                        epoch: {
+                            type: string;
+                        };
+                    };
+                };
+            };
+            additionalProperties: boolean;
+        };
+    };
+};
+export default _default;
+//# sourceMappingURL=geoparquet-schema.d.ts.map

package/dist/lib/geo/geoparquet-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geoparquet-schema.d.ts","sourceRoot":"","sources":["../../../src/lib/geo/geoparquet-schema.ts"],"names":[],"mappings":"AAIA;;;;GAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACH,wBA2DE"}