@loaders.gl/gis 4.0.0 → 4.0.1

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

@@ -0,0 +1,37 @@
+const GEOARROW_ENCODINGS = ['geoarrow.multipolygon', 'geoarrow.polygon', 'geoarrow.multilinestring', 'geoarrow.linestring', 'geoarrow.multipoint', 'geoarrow.point', 'geoarrow.wkb', 'geoarrow.wkt'];
+const GEOARROW_COLUMN_METADATA_ENCODING = 'ARROW:extension:name';
+const GEOARROW_COLUMN_METADATA_METADATA = 'ARROW:extension:metadata';
+export function getGeometryColumnsFromSchema(schema) {
+  const geometryColumns = {};
+  for (const field of schema.fields) {
+    const metadata = getGeometryMetadataForField(field);
+    if (metadata) {
+      geometryColumns[field.name] = metadata;
+    }
+  }
+  return geometryColumns;
+}
+export function getGeometryMetadataForField(field) {
+  var _field$metadata, _field$metadata2;
+  let metadata = null;
+  const columnMetadata = (_field$metadata = field.metadata) === null || _field$metadata === void 0 ? void 0 : _field$metadata[GEOARROW_COLUMN_METADATA_METADATA];
+  if (columnMetadata) {
+    try {
+      metadata = JSON.parse(columnMetadata);
+    } catch (error) {
+      console.warn('Failed to parse GeoArrow metadata', error);
+    }
+  }
+  let geoEncoding = (_field$metadata2 = field.metadata) === null || _field$metadata2 === void 0 ? void 0 : _field$metadata2[GEOARROW_COLUMN_METADATA_ENCODING];
+  if (geoEncoding) {
+    geoEncoding = geoEncoding.toLowerCase();
+    if (!GEOARROW_ENCODINGS.includes(geoEncoding)) {
+      console.warn(`Invalid GeoArrow encoding: ${geoEncoding}`);
+    } else {
+      metadata = metadata || {};
+      metadata.encoding = geoEncoding;
+    }
+  }
+  return metadata || null;
+}
+//# sourceMappingURL=geoarrow-metadata.js.map

package/dist/lib/geo/geoarrow-metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geoarrow-metadata.js","names":["GEOARROW_ENCODINGS","GEOARROW_COLUMN_METADATA_ENCODING","GEOARROW_COLUMN_METADATA_METADATA","getGeometryColumnsFromSchema","schema","geometryColumns","field","fields","metadata","getGeometryMetadataForField","name","_field$metadata","_field$metadata2","columnMetadata","JSON","parse","error","console","warn","geoEncoding","toLowerCase","includes","encoding"],"sources":["../../../src/lib/geo/geoarrow-metadata.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Copyright (c) vis.gl contributors\n\nimport {Schema, Field} from '@loaders.gl/schema';\n\nexport type GeoArrowEncoding =\n  | 'geoarrow.multipolygon'\n  | 'geoarrow.polygon'\n  | 'geoarrow.multilinestring'\n  | 'geoarrow.linestring'\n  | 'geoarrow.multipoint'\n  | 'geoarrow.point'\n  | 'geoarrow.wkb'\n  | 'geoarrow.wkt';\n\n/** Array containing all encodings */\nconst GEOARROW_ENCODINGS = [\n  'geoarrow.multipolygon',\n  'geoarrow.polygon',\n  'geoarrow.multilinestring',\n  'geoarrow.linestring',\n  'geoarrow.multipoint',\n  'geoarrow.point',\n  'geoarrow.wkb',\n  'geoarrow.wkt'\n];\n\nconst GEOARROW_COLUMN_METADATA_ENCODING = 'ARROW:extension:name';\nconst GEOARROW_COLUMN_METADATA_METADATA = 'ARROW:extension:metadata';\n\n/** Geospatial metadata for one column, extracted from Apache Arrow metadata */\nexport type GeoArrowMetadata = {\n  encoding?: GeoArrowEncoding;\n  crs?: Record<string, unknown>;\n  egdes?: 'spherical';\n  [key: string]: unknown;\n};\n\n/**\n * get geometry columns from arrow table\n */\nexport function getGeometryColumnsFromSchema(schema: Schema): Record<string, GeoArrowMetadata> {\n  const geometryColumns: Record<string, GeoArrowMetadata> = {};\n  for (const field of schema.fields) {\n    const metadata = getGeometryMetadataForField(field);\n    if (metadata) {\n      geometryColumns[field.name] = metadata;\n    }\n  }\n  return geometryColumns;\n}\n\nexport function getGeometryMetadataForField(field: Field): GeoArrowMetadata | null {\n  let metadata: GeoArrowMetadata | null = null;\n\n  // Check for GeoArrow metadata\n  const columnMetadata = field.metadata?.[GEOARROW_COLUMN_METADATA_METADATA];\n  if (columnMetadata) {\n    try {\n      metadata = JSON.parse(columnMetadata);\n    } catch (error) {\n      // eslint-disable-next-line no-console\n      console.warn('Failed to parse GeoArrow metadata', error);\n    }\n  }\n\n  // Check for GeoArrow column encoding\n  let geoEncoding = field.metadata?.[GEOARROW_COLUMN_METADATA_ENCODING];\n  if (geoEncoding) {\n    geoEncoding = geoEncoding.toLowerCase();\n    if (!GEOARROW_ENCODINGS.includes(geoEncoding)) {\n      // eslint-disable-next-line no-console\n      console.warn(`Invalid GeoArrow encoding: ${geoEncoding}`);\n    } else {\n      metadata = metadata || ({} as GeoArrowMetadata);\n      metadata.encoding = geoEncoding as GeoArrowEncoding;\n    }\n  }\n\n  return metadata || null;\n}\n"],"mappings":"AAgBA,MAAMA,kBAAkB,GAAG,CACzB,uBAAuB,EACvB,kBAAkB,EAClB,0BAA0B,EAC1B,qBAAqB,EACrB,qBAAqB,EACrB,gBAAgB,EAChB,cAAc,EACd,cAAc,CACf;AAED,MAAMC,iCAAiC,GAAG,sBAAsB;AAChE,MAAMC,iCAAiC,GAAG,0BAA0B;AAapE,OAAO,SAASC,4BAA4BA,CAACC,MAAc,EAAoC;EAC7F,MAAMC,eAAiD,GAAG,CAAC,CAAC;EAC5D,KAAK,MAAMC,KAAK,IAAIF,MAAM,CAACG,MAAM,EAAE;IACjC,MAAMC,QAAQ,GAAGC,2BAA2B,CAACH,KAAK,CAAC;IACnD,IAAIE,QAAQ,EAAE;MACZH,eAAe,CAACC,KAAK,CAACI,IAAI,CAAC,GAAGF,QAAQ;IACxC;EACF;EACA,OAAOH,eAAe;AACxB;AAEA,OAAO,SAASI,2BAA2BA,CAACH,KAAY,EAA2B;EAAA,IAAAK,eAAA,EAAAC,gBAAA;EACjF,IAAIJ,QAAiC,GAAG,IAAI;EAG5C,MAAMK,cAAc,IAAAF,eAAA,GAAGL,KAAK,CAACE,QAAQ,cAAAG,eAAA,uBAAdA,eAAA,CAAiBT,iCAAiC,CAAC;EAC1E,IAAIW,cAAc,EAAE;IAClB,IAAI;MACFL,QAAQ,GAAGM,IAAI,CAACC,KAAK,CAACF,cAAc,CAAC;IACvC,CAAC,CAAC,OAAOG,KAAK,EAAE;MAEdC,OAAO,CAACC,IAAI,CAAC,mCAAmC,EAAEF,KAAK,CAAC;IAC1D;EACF;EAGA,IAAIG,WAAW,IAAAP,gBAAA,GAAGN,KAAK,CAACE,QAAQ,cAAAI,gBAAA,uBAAdA,gBAAA,CAAiBX,iCAAiC,CAAC;EACrE,IAAIkB,WAAW,EAAE;IACfA,WAAW,GAAGA,WAAW,CAACC,WAAW,CAAC,CAAC;IACvC,IAAI,CAACpB,kBAAkB,CAACqB,QAAQ,CAACF,WAAW,CAAC,EAAE;MAE7CF,OAAO,CAACC,IAAI,CAAE,8BAA6BC,WAAY,EAAC,CAAC;IAC3D,CAAC,MAAM;MACLX,QAAQ,GAAGA,QAAQ,IAAK,CAAC,CAAsB;MAC/CA,QAAQ,CAACc,QAAQ,GAAGH,WAA+B;IACrD;EACF;EAEA,OAAOX,QAAQ,IAAI,IAAI;AACzB"}

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

@@ -0,0 +1,79 @@
+/**
+ * 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
+ */
+export declare const GEOPARQUET_METADATA_JSON_SCHEMA: {
+    $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;
+        };
+    };
+};
+//# sourceMappingURL=geoparquet-metadata-schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geoparquet-metadata-schema.d.ts","sourceRoot":"","sources":["../../../src/lib/geo/geoparquet-metadata-schema.ts"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2D3C,CAAC"}

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

@@ -0,0 +1,76 @@
+export const GEOPARQUET_METADATA_JSON_SCHEMA = {
+  $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-metadata-schema.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geoparquet-metadata-schema.js","names":["GEOPARQUET_METADATA_JSON_SCHEMA","$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-metadata-schema.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Copyright (c) vis.gl contributors\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 const GEOPARQUET_METADATA_JSON_SCHEMA = {\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":"AAUA,OAAO,MAAMA,+BAA+B,GAAG;EAC7CC,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/lib/geo/geoparquet-metadata-schema.json

@@ -0,0 +1,60 @@
+{
+  "$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
+    }
+  }
+}

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

@@ -0,0 +1,45 @@
+import { Schema } from '@loaders.gl/schema';
+/**
+ * A geoarrow / geoparquet geo metadata object
+ * (stored in stringified form in the top level metadata 'geo' key)
+ * @see https://github.com/opengeospatial/geoparquet/blob/main/format-specs/geoparquet.md
+ * @see https://github.com/geoarrow/geoarrow
+ * */
+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 = {
+    encoding: 'wkb' | 'wkt';
+    geometry_types: GeoParquetGeometryType[];
+    crs?: object | null;
+    orientation?: 'counterclockwise';
+    bbox?: [number, number, number, number] | [number, number, number, number, number, number];
+    edges?: 'planar' | 'spherical';
+    epoch?: number;
+    [key: string]: unknown;
+};
+/** A GeoParquet metadata geometry type */
+export type GeoParquetGeometryType = 'Point' | 'LineString' | 'Polygon' | 'MultiPoint' | 'MultiLineString' | 'MultiPolygon' | 'GeometryCollection' | 'Point Z' | 'LineString Z' | 'Polygon Z' | 'MultiPoint Z' | 'MultiLineString Z' | 'MultiPolygon Z' | 'GeometryCollection Z';
+/**
+ * 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;
+/** Parse a key with stringified arrow metadata */
+export declare function parseJSONStringMetadata(schema: Schema, metadataKey: string): Record<string, unknown> | null;
+export declare function unpackJSONStringMetadata(schema: Schema, metadataKey: string): void;
+//# sourceMappingURL=geoparquet-metadata.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geoparquet-metadata.d.ts","sourceRoot":"","sources":["../../../src/lib/geo/geoparquet-metadata.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,MAAM,EAAQ,MAAM,oBAAoB,CAAC;AAIjD;;;;;KAKK;AACL,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,QAAQ,EAAE,KAAK,GAAG,KAAK,CAAC;IACxB,cAAc,EAAE,sBAAsB,EAAE,CAAC;IACzC,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3F,KAAK,CAAC,EAAE,QAAQ,GAAG,WAAW,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AAEF,0CAA0C;AAC1C,MAAM,MAAM,sBAAsB,GAC9B,OAAO,GACP,YAAY,GACZ,SAAS,GACT,YAAY,GACZ,iBAAiB,GACjB,cAAc,GACd,oBAAoB,GACpB,SAAS,GACT,cAAc,GACd,WAAW,GACX,cAAc,GACd,mBAAmB,GACnB,gBAAgB,GAChB,sBAAsB,CAAC;AAI3B;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAWjE;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;AAoDD,kDAAkD;AAClD,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAClB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAehC;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,CAMlF"}

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

@@ -0,0 +1,97 @@
+export function getGeoMetadata(schema) {
+  const geoMetadata = parseJSONStringMetadata(schema, 'geo');
+  if (!geoMetadata) {
+    return null;
+  }
+  for (const column of Object.values(geoMetadata.columns || {})) {
+    if (column.encoding) {
+      column.encoding = column.encoding.toLowerCase();
+    }
+  }
+  return geoMetadata;
+}
+export function setGeoMetadata(schema, geoMetadata) {
+  const stringifiedGeoMetadata = JSON.stringify(geoMetadata);
+  schema.metadata.geo = stringifiedGeoMetadata;
+}
+export function unpackGeoMetadata(schema) {
+  const geoMetadata = getGeoMetadata(schema);
+  if (!geoMetadata) {
+    return;
+  }
+  const {
+    version,
+    primary_column,
+    columns
+  } = geoMetadata;
+  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('');
+  for (const [columnName, columnMetadata] of Object.entries(columns || {})) {
+    const field = schema.fields.find(field => field.name === columnName);
+    if (field) {
+      if (field.name === primary_column) {
+        setFieldMetadata(field, 'geo.primary_field', 'true');
+      }
+      unpackGeoFieldMetadata(field, columnMetadata);
+    }
+  }
+}
+function unpackGeoFieldMetadata(field, columnMetadata) {
+  for (const [key, value] of Object.entries(columnMetadata || {})) {
+    switch (key) {
+      case 'geometry_types':
+        setFieldMetadata(field, `geo.${key}`, value.join(','));
+        break;
+      case 'bbox':
+        setFieldMetadata(field, `geo.crs.${key}`, JSON.stringify(value));
+        break;
+      case 'crs':
+        for (const [crsKey, crsValue] of Object.entries(value || {})) {
+          switch (crsKey) {
+            case 'id':
+              const crsId = typeof crsValue === 'object' ? `${crsValue === null || crsValue === void 0 ? void 0 : crsValue.authority}:${crsValue === null || crsValue === void 0 ? void 0 : crsValue.code}` : JSON.stringify(crsValue);
+              setFieldMetadata(field, `geo.crs.${crsKey}`, crsId);
+              break;
+            default:
+              setFieldMetadata(field, `geo.crs.${crsKey}`, typeof crsValue === 'string' ? crsValue : JSON.stringify(crsValue));
+              break;
+          }
+        }
+        break;
+      case 'edges':
+      default:
+        setFieldMetadata(field, `geo.${key}`, typeof value === 'string' ? value : JSON.stringify(value));
+    }
+  }
+}
+function setFieldMetadata(field, key, value) {
+  field.metadata = field.metadata || {};
+  field.metadata[key] = value;
+}
+export function parseJSONStringMetadata(schema, metadataKey) {
+  const stringifiedMetadata = schema.metadata[metadataKey];
+  if (!stringifiedMetadata) {
+    return null;
+  }
+  try {
+    const metadata = JSON.parse(stringifiedMetadata);
+    if (!metadata || typeof metadata !== 'object') {
+      return null;
+    }
+    return metadata;
+  } catch {
+    return null;
+  }
+}
+export function unpackJSONStringMetadata(schema, metadataKey) {
+  const json = parseJSONStringMetadata(schema, metadataKey);
+  for (const [key, value] of Object.entries(json || {})) {
+    schema.metadata[`${metadataKey}.${key}`] = typeof value === 'string' ? value : JSON.stringify(value);
+  }
+}
+//# sourceMappingURL=geoparquet-metadata.js.map

package/dist/lib/geo/geoparquet-metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geoparquet-metadata.js","names":["getGeoMetadata","schema","geoMetadata","parseJSONStringMetadata","column","Object","values","columns","encoding","toLowerCase","setGeoMetadata","stringifiedGeoMetadata","JSON","stringify","metadata","geo","unpackGeoMetadata","version","primary_column","keys","join","columnName","columnMetadata","entries","field","fields","find","name","setFieldMetadata","unpackGeoFieldMetadata","key","value","crsKey","crsValue","crsId","authority","code","metadataKey","stringifiedMetadata","parse","unpackJSONStringMetadata","json"],"sources":["../../../src/lib/geo/geoparquet-metadata.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Copyright (c) vis.gl contributors\nimport {Schema, Field} from '@loaders.gl/schema';\n\n/* eslint-disable camelcase */\n\n/**\n * A geoarrow / geoparquet geo metadata object\n * (stored in stringified form in the top level metadata 'geo' key)\n * @see https://github.com/opengeospatial/geoparquet/blob/main/format-specs/geoparquet.md\n * @see https://github.com/geoarrow/geoarrow\n * */\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  encoding: 'wkb' | 'wkt';\n  geometry_types: GeoParquetGeometryType[];\n  crs?: object | null;\n  orientation?: 'counterclockwise';\n  bbox?: [number, number, number, number] | [number, number, number, number, number, number];\n  edges?: 'planar' | 'spherical';\n  epoch?: number;\n  [key: string]: unknown;\n};\n\n/** A GeoParquet metadata geometry type */\nexport type GeoParquetGeometryType =\n  | 'Point'\n  | 'LineString'\n  | 'Polygon'\n  | 'MultiPoint'\n  | 'MultiLineString'\n  | 'MultiPolygon'\n  | 'GeometryCollection'\n  | 'Point Z'\n  | 'LineString Z'\n  | 'Polygon Z'\n  | 'MultiPoint Z'\n  | 'MultiLineString Z'\n  | 'MultiPolygon Z'\n  | 'GeometryCollection Z';\n\n// GEO METADATA\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\n */\nexport function getGeoMetadata(schema: Schema): GeoMetadata | null {\n  const geoMetadata = parseJSONStringMetadata(schema, 'geo');\n  if (!geoMetadata) {\n    return null;\n  }\n  for (const column of Object.values(geoMetadata.columns || {})) {\n    if (column.encoding) {\n      column.encoding = column.encoding.toLowerCase();\n    }\n  }\n  return geoMetadata as GeoMetadata;\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\n// eslint-disable-next-line complexity\nfunction unpackGeoFieldMetadata(field: Field, columnMetadata): void {\n  for (const [key, value] of Object.entries(columnMetadata || {})) {\n    switch (key) {\n      case 'geometry_types':\n        setFieldMetadata(field, `geo.${key}`, (value as string[]).join(','));\n        break;\n      case 'bbox':\n        setFieldMetadata(field, `geo.crs.${key}`, JSON.stringify(value));\n        break;\n      case 'crs':\n        // @ts-ignore\n        for (const [crsKey, crsValue] of Object.entries(value || {})) {\n          switch (crsKey) {\n            case 'id':\n              const crsId =\n                typeof crsValue === 'object'\n                  ? // @ts-ignore\n                    `${crsValue?.authority}:${crsValue?.code}`\n                  : JSON.stringify(crsValue);\n              setFieldMetadata(field, `geo.crs.${crsKey}`, crsId);\n              break;\n            default:\n              setFieldMetadata(\n                field,\n                `geo.crs.${crsKey}`,\n                typeof crsValue === 'string' ? crsValue : JSON.stringify(crsValue)\n              );\n              break;\n          }\n        }\n        break;\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\n// HELPERS\n\n/** Parse a key with stringified arrow metadata */\nexport function parseJSONStringMetadata(\n  schema: Schema,\n  metadataKey: string\n): Record<string, unknown> | null {\n  const stringifiedMetadata = schema.metadata[metadataKey];\n  if (!stringifiedMetadata) {\n    return null;\n  }\n\n  try {\n    const metadata = JSON.parse(stringifiedMetadata);\n    if (!metadata || typeof metadata !== 'object') {\n      return null;\n    }\n    return metadata;\n  } catch {\n    return null;\n  }\n}\n\nexport function unpackJSONStringMetadata(schema: Schema, metadataKey: string): void {\n  const json = parseJSONStringMetadata(schema, metadataKey);\n  for (const [key, value] of Object.entries(json || {})) {\n    schema.metadata[`${metadataKey}.${key}`] =\n      typeof value === 'string' ? value : JSON.stringify(value);\n  }\n}\n"],"mappings":"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"}

package/dist/lib/tables/convert-table-to-geojson.d.ts

@@ -0,0 +1,5 @@
+import type { LoaderWithParser } from '@loaders.gl/loader-utils';
+import type { ArrayRowTable, GeoJSONTable, ObjectRowTable, Schema } from '@loaders.gl/schema';
+/** TODO - move to loaders.gl/gis? */
+export declare function convertWKBTableToGeoJSON(table: ArrayRowTable | ObjectRowTable, schema: Schema, loaders: LoaderWithParser[]): GeoJSONTable;
+//# sourceMappingURL=convert-table-to-geojson.d.ts.map

package/dist/lib/tables/convert-table-to-geojson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-table-to-geojson.d.ts","sourceRoot":"","sources":["../../../src/lib/tables/convert-table-to-geojson.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAC,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,EAAC,MAAM,oBAAoB,CAAC;AAM5F,qCAAqC;AACrC,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,aAAa,GAAG,cAAc,EACrC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,gBAAgB,EAAE,GAC1B,YAAY,CAoBd"}

package/dist/lib/tables/convert-table-to-geojson.js

@@ -0,0 +1,48 @@
+import { getTableLength, getTableRowAsObject } from '@loaders.gl/schema';
+import { getGeoMetadata } from "../geo/geoparquet-metadata.js";
+export function convertWKBTableToGeoJSON(table, schema, loaders) {
+  const geoMetadata = getGeoMetadata(schema);
+  const primaryColumn = geoMetadata === null || geoMetadata === void 0 ? void 0 : geoMetadata.primary_column;
+  if (!primaryColumn) {
+    throw new Error('no geometry column');
+  }
+  const columnMetadata = geoMetadata.columns[primaryColumn];
+  const features = [];
+  const length = getTableLength(table);
+  for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+    const row = getTableRowAsObject(table, rowIndex);
+    const geometry = parseGeometry(row[primaryColumn], columnMetadata, loaders);
+    delete row[primaryColumn];
+    const feature = {
+      type: 'Feature',
+      geometry: geometry,
+      properties: row
+    };
+    features.push(feature);
+  }
+  return {
+    shape: 'geojson-table',
+    schema,
+    type: 'FeatureCollection',
+    features
+  };
+}
+function parseGeometry(geometry, columnMetadata, loaders) {
+  var _wktLoader$parseTextS, _wkbLoader$parseSync;
+  switch (columnMetadata.encoding) {
+    case 'wkt':
+      const wktLoader = loaders.find(loader => loader.id === 'wkt');
+      return (wktLoader === null || wktLoader === void 0 ? void 0 : (_wktLoader$parseTextS = wktLoader.parseTextSync) === null || _wktLoader$parseTextS === void 0 ? void 0 : _wktLoader$parseTextS.call(wktLoader, geometry)) || null;
+    case 'wkb':
+    default:
+      const wkbLoader = loaders.find(loader => loader.id === 'wkb');
+      const arrayBuffer = ArrayBuffer.isView(geometry) ? geometry.buffer.slice(geometry.byteOffset, geometry.byteOffset + geometry.byteLength) : geometry;
+      const geojson = wkbLoader === null || wkbLoader === void 0 ? void 0 : (_wkbLoader$parseSync = wkbLoader.parseSync) === null || _wkbLoader$parseSync === void 0 ? void 0 : _wkbLoader$parseSync.call(wkbLoader, arrayBuffer, {
+        wkb: {
+          shape: 'geometry'
+        }
+      });
+      return geojson;
+  }
+}
+//# sourceMappingURL=convert-table-to-geojson.js.map

package/dist/lib/tables/convert-table-to-geojson.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-table-to-geojson.js","names":["getTableLength","getTableRowAsObject","getGeoMetadata","convertWKBTableToGeoJSON","table","schema","loaders","geoMetadata","primaryColumn","primary_column","Error","columnMetadata","columns","features","length","rowIndex","row","geometry","parseGeometry","feature","type","properties","push","shape","_wktLoader$parseTextS","_wkbLoader$parseSync","encoding","wktLoader","find","loader","id","parseTextSync","call","wkbLoader","arrayBuffer","ArrayBuffer","isView","buffer","slice","byteOffset","byteLength","geojson","parseSync","wkb"],"sources":["../../../src/lib/tables/convert-table-to-geojson.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Copyright (c) vis.gl contributors\n\nimport type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport type {ArrayRowTable, GeoJSONTable, ObjectRowTable, Schema} from '@loaders.gl/schema';\nimport type {Feature, Geometry} from '@loaders.gl/schema';\nimport {getTableLength, getTableRowAsObject} from '@loaders.gl/schema';\n\nimport {GeoColumnMetadata, getGeoMetadata} from '../geo/geoparquet-metadata';\n\n/** TODO - move to loaders.gl/gis? */\nexport function convertWKBTableToGeoJSON(\n  table: ArrayRowTable | ObjectRowTable,\n  schema: Schema,\n  loaders: LoaderWithParser[]\n): GeoJSONTable {\n  const geoMetadata = getGeoMetadata(schema);\n  const primaryColumn = geoMetadata?.primary_column;\n  if (!primaryColumn) {\n    throw new Error('no geometry column');\n  }\n  const columnMetadata = geoMetadata.columns[primaryColumn];\n\n  const features: Feature[] = [];\n\n  const length = getTableLength(table);\n  for (let rowIndex = 0; rowIndex < length; rowIndex++) {\n    const row = getTableRowAsObject(table, rowIndex);\n    const geometry = parseGeometry(row[primaryColumn], columnMetadata, loaders);\n    delete row[primaryColumn];\n    const feature: Feature = {type: 'Feature', geometry: geometry!, properties: row};\n    features.push(feature);\n  }\n\n  return {shape: 'geojson-table', schema, type: 'FeatureCollection', features};\n}\n\nfunction parseGeometry(\n  geometry: unknown,\n  columnMetadata: GeoColumnMetadata,\n  loaders: LoaderWithParser[]\n): Geometry | null {\n  switch (columnMetadata.encoding) {\n    case 'wkt':\n      const wktLoader = loaders.find((loader) => loader.id === 'wkt');\n      return wktLoader?.parseTextSync?.(geometry as string) || null;\n    case 'wkb':\n    default:\n      const wkbLoader = loaders.find((loader) => loader.id === 'wkb');\n      const arrayBuffer = ArrayBuffer.isView(geometry)\n        ? geometry.buffer.slice(geometry.byteOffset, geometry.byteOffset + geometry.byteLength)\n        : (geometry as ArrayBuffer);\n      const geojson = wkbLoader?.parseSync?.(arrayBuffer, {\n        wkb: {shape: 'geometry'}\n      }) as unknown as Geometry;\n      return geojson; // binaryGeometry ? binaryToGeometry(binaryGeometry) : null;\n    // const binaryGeometry = WKBLoader.parseSync?.(geometry);\n    // ts-ignore\n    // return binaryGeometry ? binaryToGeometry(binaryGeometry) : null;\n  }\n}\n"],"mappings":"AAMA,SAAQA,cAAc,EAAEC,mBAAmB,QAAO,oBAAoB;AAAC,SAE5CC,cAAc;AAGzC,OAAO,SAASC,wBAAwBA,CACtCC,KAAqC,EACrCC,MAAc,EACdC,OAA2B,EACb;EACd,MAAMC,WAAW,GAAGL,cAAc,CAACG,MAAM,CAAC;EAC1C,MAAMG,aAAa,GAAGD,WAAW,aAAXA,WAAW,uBAAXA,WAAW,CAAEE,cAAc;EACjD,IAAI,CAACD,aAAa,EAAE;IAClB,MAAM,IAAIE,KAAK,CAAC,oBAAoB,CAAC;EACvC;EACA,MAAMC,cAAc,GAAGJ,WAAW,CAACK,OAAO,CAACJ,aAAa,CAAC;EAEzD,MAAMK,QAAmB,GAAG,EAAE;EAE9B,MAAMC,MAAM,GAAGd,cAAc,CAACI,KAAK,CAAC;EACpC,KAAK,IAAIW,QAAQ,GAAG,CAAC,EAAEA,QAAQ,GAAGD,MAAM,EAAEC,QAAQ,EAAE,EAAE;IACpD,MAAMC,GAAG,GAAGf,mBAAmB,CAACG,KAAK,EAAEW,QAAQ,CAAC;IAChD,MAAME,QAAQ,GAAGC,aAAa,CAACF,GAAG,CAACR,aAAa,CAAC,EAAEG,cAAc,EAAEL,OAAO,CAAC;IAC3E,OAAOU,GAAG,CAACR,aAAa,CAAC;IACzB,MAAMW,OAAgB,GAAG;MAACC,IAAI,EAAE,SAAS;MAAEH,QAAQ,EAAEA,QAAS;MAAEI,UAAU,EAAEL;IAAG,CAAC;IAChFH,QAAQ,CAACS,IAAI,CAACH,OAAO,CAAC;EACxB;EAEA,OAAO;IAACI,KAAK,EAAE,eAAe;IAAElB,MAAM;IAAEe,IAAI,EAAE,mBAAmB;IAAEP;EAAQ,CAAC;AAC9E;AAEA,SAASK,aAAaA,CACpBD,QAAiB,EACjBN,cAAiC,EACjCL,OAA2B,EACV;EAAA,IAAAkB,qBAAA,EAAAC,oBAAA;EACjB,QAAQd,cAAc,CAACe,QAAQ;IAC7B,KAAK,KAAK;MACR,MAAMC,SAAS,GAAGrB,OAAO,CAACsB,IAAI,CAAEC,MAAM,IAAKA,MAAM,CAACC,EAAE,KAAK,KAAK,CAAC;MAC/D,OAAO,CAAAH,SAAS,aAATA,SAAS,wBAAAH,qBAAA,GAATG,SAAS,CAAEI,aAAa,cAAAP,qBAAA,uBAAxBA,qBAAA,CAAAQ,IAAA,CAAAL,SAAS,EAAkBV,QAAkB,CAAC,KAAI,IAAI;IAC/D,KAAK,KAAK;IACV;MACE,MAAMgB,SAAS,GAAG3B,OAAO,CAACsB,IAAI,CAAEC,MAAM,IAAKA,MAAM,CAACC,EAAE,KAAK,KAAK,CAAC;MAC/D,MAAMI,WAAW,GAAGC,WAAW,CAACC,MAAM,CAACnB,QAAQ,CAAC,GAC5CA,QAAQ,CAACoB,MAAM,CAACC,KAAK,CAACrB,QAAQ,CAACsB,UAAU,EAAEtB,QAAQ,CAACsB,UAAU,GAAGtB,QAAQ,CAACuB,UAAU,CAAC,GACpFvB,QAAwB;MAC7B,MAAMwB,OAAO,GAAGR,SAAS,aAATA,SAAS,wBAAAR,oBAAA,GAATQ,SAAS,CAAES,SAAS,cAAAjB,oBAAA,uBAApBA,oBAAA,CAAAO,IAAA,CAAAC,SAAS,EAAcC,WAAW,EAAE;QAClDS,GAAG,EAAE;UAACpB,KAAK,EAAE;QAAU;MACzB,CAAC,CAAwB;MACzB,OAAOkB,OAAO;EAIlB;AACF"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loaders.gl/gis",
   "description": "Helpers for GIS category data",
-  "version": "4.0.0",
+  "version": "4.0.1",
   "license": "MIT",
   "type": "module",
   "publishConfig": {
@@ -32,8 +32,8 @@
     "README.md"
   ],
   "dependencies": {
-    "@loaders.gl/loader-utils": "4.0.0",
-    "@loaders.gl/schema": "4.0.0",
+    "@loaders.gl/loader-utils": "4.0.1",
+    "@loaders.gl/schema": "4.0.1",
     "@mapbox/vector-tile": "^1.3.1",
     "@math.gl/polygon": "^4.0.0",
     "pbf": "^3.2.1"
@@ -41,5 +41,5 @@
   "devDependencies": {
     "@math.gl/proj4": "^4.0.0"
   },
-  "gitHead": "9b4211dc0ecd4134a1638ac0a29c5ea9008fd971"
+  "gitHead": "765e5a26a6bf3f2cc02cabffc4a1e3665ec92a53"
 }

package/src/index.ts

@@ -1,8 +1,23 @@
 // Types from `@loaders.gl/schema`
 
-// Functions
-export {flatGeojsonToBinary} from './lib/flat-geojson-to-binary';
-export {geojsonToBinary} from './lib/geojson-to-binary';
-export {geojsonToFlatGeojson} from './lib/geojson-to-flat-geojson';
-export {binaryToGeojson, binaryToGeometry} from './lib/binary-to-geojson';
-export {transformBinaryCoords, transformGeoJsonCoords} from './lib/transform';
+// Geo Metadata
+// import {default as GEOPARQUET_METADATA_SCHEMA} from './lib/geo/geoparquet-metadata-schema.json';
+// export {GEOPARQUET_METADATA_SCHEMA};
+export {GEOPARQUET_METADATA_JSON_SCHEMA} from './lib/geo/geoparquet-metadata-schema';
+
+export type {GeoMetadata} from './lib/geo/geoparquet-metadata';
+export {getGeoMetadata, setGeoMetadata, unpackGeoMetadata} from './lib/geo/geoparquet-metadata';
+export {unpackJSONStringMetadata} from './lib/geo/geoparquet-metadata';
+
+export type {GeoArrowEncoding, GeoArrowMetadata} from './lib/geo/geoarrow-metadata';
+export {getGeometryColumnsFromSchema} from './lib/geo/geoarrow-metadata';
+
+// Table conversion
+export {convertWKBTableToGeoJSON} from './lib/tables/convert-table-to-geojson';
+
+// Binary Geometries
+export {flatGeojsonToBinary} from './lib/binary-features/flat-geojson-to-binary';
+export {geojsonToBinary} from './lib/binary-features/geojson-to-binary';
+export {geojsonToFlatGeojson} from './lib/binary-features/geojson-to-flat-geojson';
+export {binaryToGeojson, binaryToGeometry} from './lib/binary-features/binary-to-geojson';
+export {transformBinaryCoords, transformGeoJsonCoords} from './lib/binary-features/transform';