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

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

@@ -1,3 +1,5 @@
+
+
 import { Schema, Struct, Field, Bool, Float64, Int32, Float32, Binary, Utf8, Int64, Uint16, Uint32, Uint64, Int8, Int16 } from '@loaders.gl/schema';
 export const PARQUET_TYPE_MAPPING = {
   BOOLEAN: Bool,
@@ -30,28 +32,18 @@ export const PARQUET_TYPE_MAPPING = {
   DECIMAL_BYTE_ARRAY: Float64,
   DECIMAL_FIXED_LEN_BYTE_ARRAY: Float64
 };
-export function convertParquetToArrowSchema(parquetSchema) {
+export function convertSchemaFromParquet(parquetSchema, parquetMetadata) {
   const fields = getFields(parquetSchema.schema);
-
-  return new Schema(fields);
-}
-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(fields, metadata);
 }
 function getFields(schema) {
   const fields = [];
   for (const name in schema) {
     const field = schema[name];
     if (field.fields) {
-      const childField = getFields(field.fields);
-      const nestedField = new Field(name, new Struct(childField), field.optional);
+      const childFields = getFields(field.fields);
+      const nestedField = new Field(name, new Struct(childFields), field.optional);
       fields.push(nestedField);
     } else {
       const FieldType = PARQUET_TYPE_MAPPING[field.type];
@@ -62,4 +54,28 @@ function getFields(schema) {
   }
   return fields;
 }
-//# sourceMappingURL=convert-schema.js.map
+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;
+}
+//# sourceMappingURL=convert-schema-from-parquet.js.map

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

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

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

@@ -0,0 +1,40 @@
+
+
+import { Schema, Bool, Float64, Int32, Float32, Binary, Utf8, Int64, Uint16, Uint32, Uint64, Int8, Int16 } from '@loaders.gl/schema';
+export const PARQUET_TYPE_MAPPING = {
+  BOOLEAN: Bool,
+  INT32: Int32,
+  INT64: Float64,
+  INT96: Float64,
+  FLOAT: Float32,
+  DOUBLE: Float64,
+  BYTE_ARRAY: Binary,
+  FIXED_LEN_BYTE_ARRAY: Binary,
+  UTF8: Utf8,
+  DATE: Int32,
+  TIME_MILLIS: Int64,
+  TIME_MICROS: Int64,
+  TIMESTAMP_MILLIS: Int64,
+  TIMESTAMP_MICROS: Int64,
+  UINT_8: Int32,
+  UINT_16: Uint16,
+  UINT_32: Uint32,
+  UINT_64: Uint64,
+  INT_8: Int8,
+  INT_16: Int16,
+  INT_32: Int32,
+  INT_64: Int64,
+  JSON: Binary,
+  BSON: Binary,
+  INTERVAL: Binary,
+  DECIMAL_INT32: Float32,
+  DECIMAL_INT64: Float64,
+  DECIMAL_BYTE_ARRAY: Float64,
+  DECIMAL_FIXED_LEN_BYTE_ARRAY: Float64
+};
+export function convertToParquetSchema(schema) {
+  const fields = [];
+
+  return new Schema(fields);
+}
+//# sourceMappingURL=convert-schema-to-parquet.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"convert-schema-to-parquet.js","names":["Schema","Bool","Float64","Int32","Float32","Binary","Utf8","Int64","Uint16","Uint32","Uint64","Int8","Int16","PARQUET_TYPE_MAPPING","BOOLEAN","INT32","INT64","INT96","FLOAT","DOUBLE","BYTE_ARRAY","FIXED_LEN_BYTE_ARRAY","UTF8","DATE","TIME_MILLIS","TIME_MICROS","TIMESTAMP_MILLIS","TIMESTAMP_MICROS","UINT_8","UINT_16","UINT_32","UINT_64","INT_8","INT_16","INT_32","INT_64","JSON","BSON","INTERVAL","DECIMAL_INT32","DECIMAL_INT64","DECIMAL_BYTE_ARRAY","DECIMAL_FIXED_LEN_BYTE_ARRAY","convertToParquetSchema","schema","fields"],"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  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 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 new Schema(fields);\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":";;AAQA,SACEA,MAAM,EAINC,IAAI,EACJC,OAAO,EACPC,KAAK,EACLC,OAAO,EACPC,MAAM,EACNC,IAAI,EACJC,KAAK,EACLC,MAAM,EACNC,MAAM,EACNC,MAAM,EACNC,IAAI,EACJC,KAAK,QACA,oBAAoB;AAE3B,OAAO,MAAMC,oBAA8D,GAAG;EAC5EC,OAAO,EAAEb,IAAI;EACbc,KAAK,EAAEZ,KAAK;EACZa,KAAK,EAAEd,OAAO;EACde,KAAK,EAAEf,OAAO;EACdgB,KAAK,EAAEd,OAAO;EACde,MAAM,EAAEjB,OAAO;EACfkB,UAAU,EAAEf,MAAM;EAClBgB,oBAAoB,EAAEhB,MAAM;EAC5BiB,IAAI,EAAEhB,IAAI;EACViB,IAAI,EAAEpB,KAAK;EACXqB,WAAW,EAAEjB,KAAK;EAClBkB,WAAW,EAAElB,KAAK;EAClBmB,gBAAgB,EAAEnB,KAAK;EACvBoB,gBAAgB,EAAEpB,KAAK;EACvBqB,MAAM,EAAEzB,KAAK;EACb0B,OAAO,EAAErB,MAAM;EACfsB,OAAO,EAAErB,MAAM;EACfsB,OAAO,EAAErB,MAAM;EACfsB,KAAK,EAAErB,IAAI;EACXsB,MAAM,EAAErB,KAAK;EACbsB,MAAM,EAAE/B,KAAK;EACbgC,MAAM,EAAE5B,KAAK;EACb6B,IAAI,EAAE/B,MAAM;EACZgC,IAAI,EAAEhC,MAAM;EAEZiC,QAAQ,EAAEjC,MAAM;EAChBkC,aAAa,EAAEnC,OAAO;EACtBoC,aAAa,EAAEtC,OAAO;EACtBuC,kBAAkB,EAAEvC,OAAO;EAC3BwC,4BAA4B,EAAExC;AAChC,CAAC;AAED,OAAO,SAASyC,sBAAsB,CAACC,MAAc,EAAU;EAC7D,MAAMC,MAAM,GAAG,EAAE;;EAGjB,OAAO,IAAI7C,MAAM,CAAC6C,MAAM,CAAC;AAC3B"}

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

@@ -0,0 +1,64 @@
+
+
+export function getGeoMetadata(schema) {
+  const stringifiedGeoMetadata = schema.metadata.get('geo');
+  if (!stringifiedGeoMetadata) {
+    return null;
+  }
+  try {
+    const geoMetadata = JSON.parse(stringifiedGeoMetadata);
+    return geoMetadata;
+  } catch {
+    return null;
+  }
+}
+
+export function setGeoMetadata(schema, geoMetadata) {
+  const stringifiedGeoMetadata = JSON.stringify(geoMetadata);
+  schema.metadata.set('geo', stringifiedGeoMetadata);
+}
+
+export function unpackGeoMetadata(schema) {
+  const geoMetadata = getGeoMetadata(schema);
+  if (!geoMetadata) {
+    return;
+  }
+
+  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);
+  }
+
+  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);
+    }
+  }
+}
+function unpackGeoFieldMetadata(field, columnMetadata) {
+  for (const [key, value] of Object.entries(columnMetadata || {})) {
+    switch (key) {
+      case 'geometry_type':
+        field.metadata.set("geo.".concat(key), value.join(','));
+        break;
+      case 'bbox':
+      case 'crs':
+      case 'edges':
+      default:
+        field.metadata.set("geo.".concat(key), typeof value === 'string' ? value : JSON.stringify(value));
+    }
+  }
+}
+//# sourceMappingURL=decode-geo-metadata.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decode-geo-metadata.js","names":["getGeoMetadata","schema","stringifiedGeoMetadata","metadata","get","geoMetadata","JSON","parse","setGeoMetadata","stringify","set","unpackGeoMetadata","version","primary_column","columns","Object","keys","join","columnName","columnMetadata","entries","field","fields","find","name","unpackGeoFieldMetadata","key","value"],"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.get('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.set('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.set('geo.version', version);\n  }\n\n  if (primary_column) {\n    schema.metadata.set('geo.primary_column', primary_column);\n  }\n\n  // store column names as comma separated list\n  schema.metadata.set('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        field.metadata.set('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        field.metadata.set(`geo.${key}`, (value as string[]).join(','));\n        break;\n      case 'bbox':\n      case 'crs':\n      case 'edges':\n      default:\n        field.metadata.set(`geo.${key}`, typeof value === 'string' ? value : JSON.stringify(value));\n    }\n  }\n}\n"],"mappings":";;AA2BA,OAAO,SAASA,cAAc,CAACC,MAAc,EAAsB;EACjE,MAAMC,sBAAsB,GAAGD,MAAM,CAACE,QAAQ,CAACC,GAAG,CAAC,KAAK,CAAC;EACzD,IAAI,CAACF,sBAAsB,EAAE;IAC3B,OAAO,IAAI;EACb;EAEA,IAAI;IACF,MAAMG,WAAW,GAAGC,IAAI,CAACC,KAAK,CAACL,sBAAsB,CAAgB;IACrE,OAAOG,WAAW;EACpB,CAAC,CAAC,MAAM;IACN,OAAO,IAAI;EACb;AACF;;AAMA,OAAO,SAASG,cAAc,CAACP,MAAc,EAAEI,WAAwB,EAAQ;EAC7E,MAAMH,sBAAsB,GAAGI,IAAI,CAACG,SAAS,CAACJ,WAAW,CAAC;EAC1DJ,MAAM,CAACE,QAAQ,CAACO,GAAG,CAAC,KAAK,EAAER,sBAAsB,CAAC;AACpD;;AAMA,OAAO,SAASS,iBAAiB,CAACV,MAAc,EAAQ;EACtD,MAAMI,WAAW,GAAGL,cAAc,CAACC,MAAM,CAAC;EAC1C,IAAI,CAACI,WAAW,EAAE;IAChB;EACF;;EAIA,MAAM;IAACO,OAAO;IAAEC,cAAc;IAAEC;EAAO,CAAC,GAAGT,WAAW;EACtD,IAAIO,OAAO,EAAE;IACXX,MAAM,CAACE,QAAQ,CAACO,GAAG,CAAC,aAAa,EAAEE,OAAO,CAAC;EAC7C;EAEA,IAAIC,cAAc,EAAE;IAClBZ,MAAM,CAACE,QAAQ,CAACO,GAAG,CAAC,oBAAoB,EAAEG,cAAc,CAAC;EAC3D;;EAGAZ,MAAM,CAACE,QAAQ,CAACO,GAAG,CAAC,aAAa,EAAEK,MAAM,CAACC,IAAI,CAACF,OAAO,IAAI,CAAC,CAAC,CAAC,CAACG,IAAI,CAAC,EAAE,CAAC,CAAC;EAEvE,KAAK,MAAM,CAACC,UAAU,EAAEC,cAAc,CAAC,IAAIJ,MAAM,CAACK,OAAO,CAACN,OAAO,IAAI,CAAC,CAAC,CAAC,EAAE;IACxE,MAAMO,KAAK,GAAGpB,MAAM,CAACqB,MAAM,CAACC,IAAI,CAAEF,KAAK,IAAKA,KAAK,CAACG,IAAI,KAAKN,UAAU,CAAC;IACtE,IAAIG,KAAK,EAAE;MACT,IAAIA,KAAK,CAACG,IAAI,KAAKX,cAAc,EAAE;QACjCQ,KAAK,CAAClB,QAAQ,CAACO,GAAG,CAAC,mBAAmB,EAAE,MAAM,CAAC;MACjD;MACAe,sBAAsB,CAACJ,KAAK,EAAEF,cAAc,CAAC;IAC/C;EACF;AACF;AAEA,SAASM,sBAAsB,CAACJ,KAAY,EAAEF,cAAc,EAAQ;EAClE,KAAK,MAAM,CAACO,GAAG,EAAEC,KAAK,CAAC,IAAIZ,MAAM,CAACK,OAAO,CAACD,cAAc,IAAI,CAAC,CAAC,CAAC,EAAE;IAC/D,QAAQO,GAAG;MACT,KAAK,eAAe;QAClBL,KAAK,CAAClB,QAAQ,CAACO,GAAG,eAAQgB,GAAG,GAAKC,KAAK,CAAcV,IAAI,CAAC,GAAG,CAAC,CAAC;QAC/D;MACF,KAAK,MAAM;MACX,KAAK,KAAK;MACV,KAAK,OAAO;MACZ;QACEI,KAAK,CAAClB,QAAQ,CAACO,GAAG,eAAQgB,GAAG,GAAI,OAAOC,KAAK,KAAK,QAAQ,GAAGA,KAAK,GAAGrB,IAAI,CAACG,SAAS,CAACkB,KAAK,CAAC,CAAC;IAAC;EAElG;AACF"}

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

@@ -0,0 +1,78 @@
+
+
+export 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
+    }
+  }
+};
+//# sourceMappingURL=geoparquet-schema.js.map

package/dist/esm/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"],"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":";;AASA,eAAe;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"}

package/dist/esm/lib/parsers/parse-parquet-to-columns.js

@@ -0,0 +1,37 @@
+
+
+import { makeReadableFile } from '@loaders.gl/loader-utils';
+import { ParquetReader } from '../../parquetjs/parser/parquet-reader';
+import { convertSchemaFromParquet } from '../arrow/convert-schema-from-parquet';
+import { convertParquetRowGroupToColumns } from '../arrow/convert-row-group-to-columns';
+import { unpackGeoMetadata } from '../geo/decode-geo-metadata';
+export async function parseParquetInColumns(arrayBuffer, options) {
+  const blob = new Blob([arrayBuffer]);
+  for await (const batch of parseParquetFileInColumnarBatches(blob, options)) {
+    return batch;
+  }
+  return null;
+}
+export async function* parseParquetFileInColumnarBatches(blob, options) {
+  const file = makeReadableFile(blob);
+  const reader = new ParquetReader(file);
+  const parquetSchema = await reader.getSchema();
+  const parquetMetadata = await reader.getFileMetadata();
+  const schema = convertSchemaFromParquet(parquetSchema, parquetMetadata);
+  unpackGeoMetadata(schema);
+  const rowGroups = reader.rowGroupIterator(options === null || options === void 0 ? void 0 : options.parquet);
+  for await (const rowGroup of rowGroups) {
+    yield convertRowGroupToTableBatch(schema, rowGroup);
+  }
+}
+function convertRowGroupToTableBatch(schema, rowGroup) {
+  const data = convertParquetRowGroupToColumns(schema, rowGroup);
+  return {
+    shape: 'columnar-table',
+    batchType: 'data',
+    schema,
+    data,
+    length: rowGroup.rowCount
+  };
+}
+//# sourceMappingURL=parse-parquet-to-columns.js.map

package/dist/esm/lib/parsers/parse-parquet-to-columns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-parquet-to-columns.js","names":["makeReadableFile","ParquetReader","convertSchemaFromParquet","convertParquetRowGroupToColumns","unpackGeoMetadata","parseParquetInColumns","arrayBuffer","options","blob","Blob","batch","parseParquetFileInColumnarBatches","file","reader","parquetSchema","getSchema","parquetMetadata","getFileMetadata","schema","rowGroups","rowGroupIterator","parquet","rowGroup","convertRowGroupToTableBatch","data","shape","batchType","length","rowCount"],"sources":["../../../../src/lib/parsers/parse-parquet-to-columns.ts"],"sourcesContent":["// loaders.gl, MIT license\n\n// import type {LoaderWithParser, Loader, LoaderOptions} from '@loaders.gl/loader-utils';\nimport {ColumnarTableBatch, Schema} from '@loaders.gl/schema';\nimport {makeReadableFile} from '@loaders.gl/loader-utils';\nimport type {ParquetLoaderOptions} from '../../parquet-loader';\nimport {ParquetReader} from '../../parquetjs/parser/parquet-reader';\nimport {ParquetBuffer} from '../../parquetjs/schema/declare';\nimport {convertSchemaFromParquet} from '../arrow/convert-schema-from-parquet';\nimport {convertParquetRowGroupToColumns} from '../arrow/convert-row-group-to-columns';\nimport {unpackGeoMetadata} from '../geo/decode-geo-metadata';\n\nexport async function parseParquetInColumns(\n  arrayBuffer: ArrayBuffer,\n  options?: ParquetLoaderOptions\n) {\n  const blob = new Blob([arrayBuffer]);\n  for await (const batch of parseParquetFileInColumnarBatches(blob, options)) {\n    return batch;\n  }\n  return null;\n}\n\nexport async function* parseParquetFileInColumnarBatches(\n  blob: Blob,\n  options?: ParquetLoaderOptions\n): AsyncIterable<ColumnarTableBatch> {\n  const file = makeReadableFile(blob);\n  const reader = new ParquetReader(file);\n  const parquetSchema = await reader.getSchema();\n  const parquetMetadata = await reader.getFileMetadata();\n  const schema = convertSchemaFromParquet(parquetSchema, parquetMetadata);\n  unpackGeoMetadata(schema);\n  const rowGroups = reader.rowGroupIterator(options?.parquet);\n  for await (const rowGroup of rowGroups) {\n    yield convertRowGroupToTableBatch(schema, rowGroup);\n  }\n}\n\nfunction convertRowGroupToTableBatch(schema: Schema, rowGroup: ParquetBuffer): ColumnarTableBatch {\n  const data = convertParquetRowGroupToColumns(schema, rowGroup);\n  return {\n    shape: 'columnar-table',\n    batchType: 'data',\n    schema,\n    data,\n    length: rowGroup.rowCount\n  };\n}\n"],"mappings":";;AAIA,SAAQA,gBAAgB,QAAO,0BAA0B;AAEzD,SAAQC,aAAa,QAAO,uCAAuC;AAEnE,SAAQC,wBAAwB,QAAO,sCAAsC;AAC7E,SAAQC,+BAA+B,QAAO,uCAAuC;AACrF,SAAQC,iBAAiB,QAAO,4BAA4B;AAE5D,OAAO,eAAeC,qBAAqB,CACzCC,WAAwB,EACxBC,OAA8B,EAC9B;EACA,MAAMC,IAAI,GAAG,IAAIC,IAAI,CAAC,CAACH,WAAW,CAAC,CAAC;EACpC,WAAW,MAAMI,KAAK,IAAIC,iCAAiC,CAACH,IAAI,EAAED,OAAO,CAAC,EAAE;IAC1E,OAAOG,KAAK;EACd;EACA,OAAO,IAAI;AACb;AAEA,OAAO,gBAAgBC,iCAAiC,CACtDH,IAAU,EACVD,OAA8B,EACK;EACnC,MAAMK,IAAI,GAAGZ,gBAAgB,CAACQ,IAAI,CAAC;EACnC,MAAMK,MAAM,GAAG,IAAIZ,aAAa,CAACW,IAAI,CAAC;EACtC,MAAME,aAAa,GAAG,MAAMD,MAAM,CAACE,SAAS,EAAE;EAC9C,MAAMC,eAAe,GAAG,MAAMH,MAAM,CAACI,eAAe,EAAE;EACtD,MAAMC,MAAM,GAAGhB,wBAAwB,CAACY,aAAa,EAAEE,eAAe,CAAC;EACvEZ,iBAAiB,CAACc,MAAM,CAAC;EACzB,MAAMC,SAAS,GAAGN,MAAM,CAACO,gBAAgB,CAACb,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAEc,OAAO,CAAC;EAC3D,WAAW,MAAMC,QAAQ,IAAIH,SAAS,EAAE;IACtC,MAAMI,2BAA2B,CAACL,MAAM,EAAEI,QAAQ,CAAC;EACrD;AACF;AAEA,SAASC,2BAA2B,CAACL,MAAc,EAAEI,QAAuB,EAAsB;EAChG,MAAME,IAAI,GAAGrB,+BAA+B,CAACe,MAAM,EAAEI,QAAQ,CAAC;EAC9D,OAAO;IACLG,KAAK,EAAE,gBAAgB;IACvBC,SAAS,EAAE,MAAM;IACjBR,MAAM;IACNM,IAAI;IACJG,MAAM,EAAEL,QAAQ,CAACM;EACnB,CAAC;AACH"}

package/dist/esm/lib/parsers/parse-parquet-to-rows.js

@@ -0,0 +1,19 @@
+
+import { makeReadableFile } from '@loaders.gl/loader-utils';
+import { ParquetReader } from '../../parquetjs/parser/parquet-reader';
+export async function parseParquet(arrayBuffer, options) {
+  const blob = new Blob([arrayBuffer]);
+  for await (const batch of parseParquetFileInBatches(blob, options)) {
+    return batch;
+  }
+  return null;
+}
+export async function* parseParquetFileInBatches(blob, options) {
+  const file = makeReadableFile(blob);
+  const reader = new ParquetReader(file);
+  const rowBatches = reader.rowBatchIterator(options === null || options === void 0 ? void 0 : options.parquet);
+  for await (const rows of rowBatches) {
+    yield rows;
+  }
+}
+//# sourceMappingURL=parse-parquet-to-rows.js.map

package/dist/esm/lib/parsers/parse-parquet-to-rows.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-parquet-to-rows.js","names":["makeReadableFile","ParquetReader","parseParquet","arrayBuffer","options","blob","Blob","batch","parseParquetFileInBatches","file","reader","rowBatches","rowBatchIterator","parquet","rows"],"sources":["../../../../src/lib/parsers/parse-parquet-to-rows.ts"],"sourcesContent":["// import type {LoaderWithParser, Loader, LoaderOptions} from '@loaders.gl/loader-utils';\n// import {ColumnarTableBatch} from '@loaders.gl/schema';\nimport {makeReadableFile} from '@loaders.gl/loader-utils';\nimport type {ParquetLoaderOptions} from '../../parquet-loader';\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 file = makeReadableFile(blob);\n  const reader = new ParquetReader(file);\n  const rowBatches = reader.rowBatchIterator(options?.parquet);\n  for await (const rows of rowBatches) {\n    yield rows;\n  }\n}\n\n// export async function* parseParquetFileInColumnarBatches(blob: Blob, options?: {columnList?: string[][]}): AsyncIterable<ColumnarTableBatch> {\n//   const rowGroupReader = new ParquetRowGroupReader({data: blob, columnList: options?.columnList});\n//   try {\n//     for await (const rowGroup of rowGroupReader) {\n//       yield convertRowGroupToTableBatch(rowGroup);\n//     }\n//   } finally {\n//     await rowGroupReader.close();\n//   }\n// }\n\n// function convertRowGroupToTableBatch(rowGroup): ColumnarTableBatch {\n//   // @ts-expect-error\n//   return {\n//     data: rowGroup\n//   };\n// }\n"],"mappings":";AAEA,SAAQA,gBAAgB,QAAO,0BAA0B;AAEzD,SAAQC,aAAa,QAAO,uCAAuC;AAEnE,OAAO,eAAeC,YAAY,CAACC,WAAwB,EAAEC,OAA8B,EAAE;EAC3F,MAAMC,IAAI,GAAG,IAAIC,IAAI,CAAC,CAACH,WAAW,CAAC,CAAC;EACpC,WAAW,MAAMI,KAAK,IAAIC,yBAAyB,CAACH,IAAI,EAAED,OAAO,CAAC,EAAE;IAClE,OAAOG,KAAK;EACd;EACA,OAAO,IAAI;AACb;AAEA,OAAO,gBAAgBC,yBAAyB,CAACH,IAAU,EAAED,OAA8B,EAAE;EAC3F,MAAMK,IAAI,GAAGT,gBAAgB,CAACK,IAAI,CAAC;EACnC,MAAMK,MAAM,GAAG,IAAIT,aAAa,CAACQ,IAAI,CAAC;EACtC,MAAME,UAAU,GAAGD,MAAM,CAACE,gBAAgB,CAACR,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAES,OAAO,CAAC;EAC5D,WAAW,MAAMC,IAAI,IAAIH,UAAU,EAAE;IACnC,MAAMG,IAAI;EACZ;AACF"}