@loaders.gl/geoarrow 4.4.0-alpha.1

package/LICENSE

@@ -0,0 +1,41 @@
+loaders.gl is licensed under the MIT license
+
+Copyright (c) vis.gl contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+--- 
+
+Copyright (c) 2015 Uber Technologies, Inc.
+
+loaders.gl includes certain files from Cesium (https://github.com/AnalyticalGraphicsInc/cesium) 
+under the  Apache 2 License (found in the submodule: modules/3d-tiles):)
+
+Copyright 2011-2018 CesiumJS Contributors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and limitations under the License.
+

package/README.md

@@ -0,0 +1,7 @@
+# @loaders.gl/geoarrow
+
+This module contains support for the Apache Arrow GeoArrow format.
+
+[loaders.gl](https://loaders.gl/docs) is a collection of loaders for big data visualizations.
+
+For documentation please visit the [website](https://loaders.gl).

package/dist/geo-column/geo-column-info.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Information about a binary geometry
+ */
+export type geoColumnInfo = {
+    type: 'Point' | 'LineString' | 'Polygon';
+    /** The GeoJSON style geometry type corresponding to this particular binary geometry */
+    multiGeometryType: 'Point' | 'LineString' | 'Polygon' | 'MultiPoint' | 'MultiLineString' | 'MultiPolygon';
+    /** Is this a "Multi" version of the binary geometry? */
+    isMultiGeometry: boolean;
+    /** How many dimensions are the coordinates? */
+    dimension: number;
+    /** How many points does this geometry have? */
+    pointCount: number;
+    /** How many coordinates does this geometry have? */
+    coordinateCount: number;
+};
+/**
+ * @returns information about a binary geometry
+ */
+//# sourceMappingURL=geo-column-info.d.ts.map

package/dist/geo-column/geo-column-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geo-column-info.d.ts","sourceRoot":"","sources":["../../src/geo-column/geo-column-info.ts"],"names":[],"mappings":"AAQA;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,OAAO,GAAG,YAAY,GAAG,SAAS,CAAC;IACzC,uFAAuF;IACvF,iBAAiB,EACb,OAAO,GACP,YAAY,GACZ,SAAS,GACT,YAAY,GACZ,iBAAiB,GACjB,cAAc,CAAC;IACnB,wDAAwD;IACxD,eAAe,EAAE,OAAO,CAAC;IACzB,+CAA+C;IAC/C,SAAS,EAAE,MAAM,CAAC;IAClB,+CAA+C;IAC/C,UAAU,EAAE,MAAM,CAAC;IACnB,oDAAoD;IACpD,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF;;GAEG"}

package/dist/geo-column/geo-column-info.js

@@ -0,0 +1,74 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+export {};
+/**
+ * @returns information about a binary geometry
+ */
+// export function getGeoColumnInfo(geometry: GeoColumn): GeoColumnInfo {
+// }
+// // loaders.gl
+// // SPDX-License-Identifier: MIT
+// // Copyright (c) vis.gl contributors
+// import type {Schema, Field, GeoArrowMetadata, GeoArrowEncoding, Geometry} from '@loaders.gl/schema';
+// import {convertArrowToSchema} from '@loaders.gl/schema-utils';
+// import * as arrow from 'apache-arrow';
+// import {getGeometryColumnsFromSchema, getGeometryMetadataForField} from '../geoarrow/geoarrow-metadata';
+// import { getGeoMetadata as getParquetMe} from './geoparquet-metadata';
+// /**
+// * 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 GeoTableMetadata = {
+//  version?: string;
+//  primaryGeometryColumn?: string;
+//  columns: Record<string, GeoColumnInfo>;
+//  [key: string]: unknown;
+// };
+// /** A geoarrow / geoparquet geo metadata for one geometry column  */
+// export type GeoColumnInfo = {
+//  encoding: 'wkb' | 'wkt' | 'none';
+//  geometryTypes: Geometry['type'][];
+//  dimension: number;
+//  crs?: object | null;
+//  orientation?: 'counterclockwise';
+//  bbox?: [number, number, number, number] | [number, number, number, number, number, number];
+//  edges?: 'planar' | 'spherical';
+//  epoch?: number;
+//  [key: string]: unknown;
+//  // geoParquetGeometryType:
+// };
+// export type GeoArrowInfo = {
+//   geometryColumns: Record<string, GeometryColumnInfo>
+// };
+// /**
+//  * get geometry columns from arrow table
+//  */
+// export function getGeoArrowInfo(arrowTable: arrow.Table): GeoArrowInfo {
+//  const schema = convertArrowToSchema(arrowTable.schema);
+//   const geometryColumns = getGeometryColumnsFromSchema(schema);
+//   // get encoding from geometryColumns['geometry']
+//   const encoding = geometryColumns.geometry.encoding;
+//   // Remove geometry columns
+//   const propertyColumnNames = arrowTable.schema.fields
+//     .map((field) => field.name)
+//     // TODO - this deletes all geometry columns
+//     .filter((name) => name in geometryColumns);
+//   const propertiesTable = arrowTable.select(propertyColumnNames);
+//   const arrowGeometryColumn = arrowTable.getChild('geometry');
+//   for (let row = 0; row < arrowTable.numRows; row++) {
+//     // get the geometry value from arrow geometry column
+//     // Note that type can vary
+//     const arrowGeometry = arrowGeometryColumn?.get(row);
+//     // parse arrow geometry to geojson feature
+//     const feature = convertGeoArrowGeometryToGeoJSON(arrowGeometry, encoding);
+//     if (feature) {
+//       const properties = propertiesTable.get(row)?.toJSON() || {};
+//       features.push({type: 'Feature', geometry: feature, properties});
+//     }
+//   }
+//   return {
+//   };
+// }

package/dist/geo-column/geo-column.d.ts

@@ -0,0 +1,61 @@
+import type { TypedArray } from '@math.gl/types';
+export type GeoColumnType = 'Point' | 'LineString' | 'Polygon';
+/** A geometry column can be built from list of geometry column data chunks */
+export type GeoColumn<MetadataT = Record<string, unknown>> = {
+    shape: 'geo-column';
+    metadata?: MetadataT;
+    data: GeoColumnData[];
+};
+export type GeoColumnData = GeoColumnPointData | GeoColumnLineData | GeoColumnPolygonData;
+/**
+ * Describes a single contiguous chunk of geometries in binary columnar format
+ * Extracts the nested position and offset arrays from a GeoArrow column
+ * @note Designed to be a cheap operation: does not create any new arrays, just holds extracted references the existing arrays
+ */
+export type GeoColumnCommonData = {
+    shape: 'geo-column-data';
+    /** Number of rows geometries (can be less than pointCount if representing multipoints) */
+    numRows: number;
+    /** Offset to the end of the next geometry (length = rowCount) */
+    rowOffsets: Uint32Array;
+    /** Number of positions */
+    numPositions: number;
+    /** Data for coordinates, either interleaved or separate arrays */
+    positions: GeoColumnPositions;
+};
+/** Columnar point geometry: an array of positions */
+export type GeoColumnPointData = GeoColumnCommonData & {
+    type: 'Point';
+};
+/** Columnar line geometry, array of positions and indices to the start of each line */
+export type GeoColumnLineData = GeoColumnCommonData & {
+    type: 'LineString';
+    /** Offset to the next path within the multi feature */
+    pathOffsets: Uint32Array;
+};
+/** Columnar polygon geometry, an array of positions to each primitite polygon and polygon */
+export type GeoColumnPolygonData = GeoColumnCommonData & {
+    type: 'Polygon';
+    /** Offset to next polygon */
+    polygonOffsets: Uint32Array;
+    /** Offset to next primitive polygon */
+    ringOffsets: Uint32Array;
+};
+export type GeoColumnPositions = GeoColumnInterleavedPositions | GeoColumnSeparatePositions;
+/** Positions are in a single coordinate array */
+export type GeoColumnInterleavedPositions = {
+    layout: 'interleaved';
+    /** Dimension, i.e. number of coordinates per position: 2, 3 or 4 */
+    stride: 2 | 3 | 4;
+    /** Flat array of position coordinates (length = positionCount * positionStride */
+    coordinates: TypedArray;
+};
+/** Positions are in separate coordinate arrays */
+export type GeoColumnSeparatePositions = {
+    layout: 'separate';
+    /** Dimension, i.e. number of coordinates per position: 2, 3 or 4 */
+    stride: 2 | 3 | 4;
+    /** Flat array of position coordinates (length = positionCount * positionStride */
+    coordinates: TypedArray[];
+};
+//# sourceMappingURL=geo-column.d.ts.map

package/dist/geo-column/geo-column.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geo-column.d.ts","sourceRoot":"","sources":["../../src/geo-column/geo-column.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,gBAAgB,CAAC;AAI/C,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,YAAY,GAAG,SAAS,CAAC;AAE/D,8EAA8E;AAC9E,MAAM,MAAM,SAAS,CAAC,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI;IAC3D,KAAK,EAAE,YAAY,CAAC;IACpB,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,IAAI,EAAE,aAAa,EAAE,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,kBAAkB,GAAG,iBAAiB,GAAG,oBAAoB,CAAC;AAE1F;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,iBAAiB,CAAC;IAEzB,0FAA0F;IAC1F,OAAO,EAAE,MAAM,CAAC;IAChB,iEAAiE;IACjE,UAAU,EAAE,WAAW,CAAC;IAExB,0BAA0B;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,kEAAkE;IAClE,SAAS,EAAE,kBAAkB,CAAC;CAM/B,CAAC;AAEF,qDAAqD;AACrD,MAAM,MAAM,kBAAkB,GAAG,mBAAmB,GAAG;IACrD,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAEF,uFAAuF;AACvF,MAAM,MAAM,iBAAiB,GAAG,mBAAmB,GAAG;IACpD,IAAI,EAAE,YAAY,CAAC;IAEnB,uDAAuD;IACvD,WAAW,EAAE,WAAW,CAAC;CAC1B,CAAC;AAEF,6FAA6F;AAC7F,MAAM,MAAM,oBAAoB,GAAG,mBAAmB,GAAG;IACvD,IAAI,EAAE,SAAS,CAAC;IAChB,6BAA6B;IAC7B,cAAc,EAAE,WAAW,CAAC;IAC5B,uCAAuC;IACvC,WAAW,EAAE,WAAW,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,6BAA6B,GAAG,0BAA0B,CAAC;AAE5F,iDAAiD;AACjD,MAAM,MAAM,6BAA6B,GAAG;IAC1C,MAAM,EAAE,aAAa,CAAC;IACtB,oEAAoE;IACpE,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAClB,kFAAkF;IAClF,WAAW,EAAE,UAAU,CAAC;CACzB,CAAC;AAEF,kDAAkD;AAClD,MAAM,MAAM,0BAA0B,GAAG;IACvC,MAAM,EAAE,UAAU,CAAC;IACnB,oEAAoE;IACpE,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAClB,kFAAkF;IAClF,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B,CAAC"}

package/dist/geo-column/geo-column.js

@@ -0,0 +1,4 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+export {};

package/dist/geoarrow-functions.d.ts

@@ -0,0 +1,131 @@
+/**
+ * @note Conforms to the GeoArrow memory layout
+ * @see https://geoarrow.org/format.html#memory-layouts
+ * @note this is aligned with the geoarrow-js library (MIT license)
+ * @see https://github.com/geoarrow/geoarrow-js/
+ */
+import { DataType } from 'apache-arrow/type';
+import type { GeoArrowPoint, GeoArrowLineString, GeoArrowPolygon, GeoArrowMultiPoint, GeoArrowMultiLineString, GeoArrowMultiPolygon, GeoArrowGeometry } from "./geoarrow-types.js";
+/** Checks whether the given Apache Arrow JS type is a Point data type */
+export declare function isGeoArrowPoint(type: DataType): type is GeoArrowPoint;
+/** Checks whether the given Apache Arrow JS type is a Point data type */
+export declare function isGeoArrowLineString(type: DataType): type is GeoArrowLineString;
+/** Checks whether the given Apache Arrow JS type is a Polygon data type */
+export declare function isGeoArrowPolygon(type: DataType): type is GeoArrowPolygon;
+/** Checks whether the given Apache Arrow JS type is a Polygon data type */
+export declare function isGeoArrowMultiPoint(type: DataType): type is GeoArrowMultiPoint;
+/** Checks whether the given Apache Arrow JS type is a Polygon data type */
+export declare function isGeoArrowMultiLineString(type: DataType): type is GeoArrowMultiLineString;
+/** Checks whether the given Apache Arrow JS type is a Polygon data type */
+export declare function isGeoArrowMultiPolygon(type: DataType): type is GeoArrowMultiPolygon;
+/**
+ * Checks if a given Arrow data type is a valid GeoArrowGeometry
+ * @note this is somewhat inefficient, it checks the same things multiple times
+ */
+export declare function isGeoArrowGeometry(type: DataType): type is GeoArrowGeometry;
+/**
+ * Strongly typed accessors for children, since arrow.Data.children[] is untyped
+ 
+import { Data } from "apache-arrow/data";
+import { Vector } from "apache-arrow/vector";
+import { Float } from "apache-arrow/type";
+import {
+  LineStringData,
+  MultiLineStringData,
+  MultiPointData,
+  MultiPolygonData,
+  PointData,
+  PolygonData,
+} from "./data";
+import {
+  LineStringVector,
+  MultiLineStringVector,
+  MultiPointVector,
+  MultiPolygonVector,
+  PointVector,
+  PolygonVector,
+} from "./vector";
+
+export function getPointChild(input: PointData): Data<Float>;
+export function getPointChild(input: PointVector): Vector<Float>;
+
+export function getPointChild(
+  input: PointData | PointVector,
+): Data<Float> | Vector<Float> {
+  if ("data" in input) {
+    return input.getChildAt(0)!;
+  }
+
+  return input.children[0] as Data<Float>;
+}
+
+export function getLineStringChild(input: LineStringData): PointData;
+export function getLineStringChild(input: LineStringVector): PointVector;
+
+export function getLineStringChild(
+  input: LineStringData | LineStringVector,
+): PointData | PointVector {
+  if ("data" in input) {
+    return input.getChildAt(0)!;
+  }
+
+  return input.children[0] as PointData;
+}
+
+export function getPolygonChild(input: PolygonData): LineStringData;
+export function getPolygonChild(input: PolygonVector): LineStringVector;
+
+export function getPolygonChild(
+  input: PolygonData | PolygonVector,
+): LineStringData | LineStringVector {
+  if ("data" in input) {
+    return input.getChildAt(0)!;
+  }
+
+  return input.children[0] as LineStringData;
+}
+
+export function getMultiPointChild(input: MultiPointData): PointData;
+export function getMultiPointChild(input: MultiPointVector): PointVector;
+
+export function getMultiPointChild(
+  input: MultiPointData | MultiPointVector,
+): PointData | PointVector {
+  if ("data" in input) {
+    return input.getChildAt(0)!;
+  }
+
+  return input.children[0] as PointData;
+}
+
+export function getMultiLineStringChild(
+  input: MultiLineStringData,
+): LineStringData;
+export function getMultiLineStringChild(
+  input: MultiLineStringVector,
+): LineStringVector;
+
+export function getMultiLineStringChild(
+  input: MultiLineStringData | MultiLineStringVector,
+): LineStringData | LineStringVector {
+  if ("data" in input) {
+    return input.getChildAt(0)!;
+  }
+
+  return input.children[0] as LineStringData;
+}
+
+export function getMultiPolygonChild(input: MultiPolygonData): PolygonData;
+export function getMultiPolygonChild(input: MultiPolygonVector): PolygonVector;
+
+export function getMultiPolygonChild(
+  input: MultiPolygonData | MultiPolygonVector,
+): PolygonData | PolygonVector {
+  if ("data" in input) {
+    return input.getChildAt(0)!;
+  }
+
+  return input.children[0] as PolygonData;
+}
+*/
+//# sourceMappingURL=geoarrow-functions.d.ts.map

package/dist/geoarrow-functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geoarrow-functions.d.ts","sourceRoot":"","sources":["../src/geoarrow-functions.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AAEH,OAAO,EAAC,QAAQ,EAAC,MAAM,mBAAmB,CAAC;AAE3C,OAAO,KAAK,EACV,aAAa,EACb,kBAAkB,EAClB,eAAe,EACf,kBAAkB,EAClB,uBAAuB,EACvB,oBAAoB,EACpB,gBAAgB,EACjB,4BAAyB;AAE1B,yEAAyE;AACzE,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,IAAI,aAAa,CAmCrE;AAED,yEAAyE;AACzE,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,IAAI,kBAAkB,CAY/E;AAED,2EAA2E;AAC3E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,IAAI,eAAe,CAYzE;AAED,2EAA2E;AAC3E,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,IAAI,kBAAkB,CAY/E;AAED,2EAA2E;AAC3E,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,IAAI,uBAAuB,CAYzF;AAED,2EAA2E;AAC3E,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,IAAI,oBAAoB,CAYnF;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,IAAI,gBAAgB,CAS3E;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwGE"}

package/dist/geoarrow-functions.js

@@ -0,0 +1,218 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/**
+ * @note Conforms to the GeoArrow memory layout
+ * @see https://geoarrow.org/format.html#memory-layouts
+ * @note this is aligned with the geoarrow-js library (MIT license)
+ * @see https://github.com/geoarrow/geoarrow-js/
+ */
+import { DataType } from 'apache-arrow/type';
+/** Checks whether the given Apache Arrow JS type is a Point data type */
+export function isGeoArrowPoint(type) {
+    if (DataType.isFixedSizeList(type)) {
+        // Check list size
+        if (![2, 3, 4].includes(type.listSize)) {
+            return false;
+        }
+        // Check child of FixedSizeList is floating type
+        if (!DataType.isFloat(type.children[0])) {
+            return false;
+        }
+        return true;
+    }
+    // TODO - support separated coordinates
+    // if (DataType.isStruct(type)) {
+    //   // Check number of children
+    //   if (![2, 3, 4].includes(type.children.length)) {
+    //     return false;
+    //   }
+    //   // Check that children have correct field names
+    //   if (!type.children.every((field) => ['x', 'y', 'z', 'm'].includes(field.name))) {
+    //     return false;
+    //   }
+    //   if (!type.children.every((field) => DataType.isFloat(field))) {
+    //     return false;
+    //   }
+    //   return true;
+    // }
+    return false;
+}
+/** Checks whether the given Apache Arrow JS type is a Point data type */
+export function isGeoArrowLineString(type) {
+    // Check the outer type is a List
+    if (!DataType.isList(type)) {
+        return false;
+    }
+    // Check the child is a point type
+    if (!isGeoArrowPoint(type.children[0].type)) {
+        return false;
+    }
+    return true;
+}
+/** Checks whether the given Apache Arrow JS type is a Polygon data type */
+export function isGeoArrowPolygon(type) {
+    // Check the outer vector is a List
+    if (!DataType.isList(type)) {
+        return false;
+    }
+    // Check the child is a linestring vector
+    if (!isGeoArrowLineString(type.children[0].type)) {
+        return false;
+    }
+    return true;
+}
+/** Checks whether the given Apache Arrow JS type is a Polygon data type */
+export function isGeoArrowMultiPoint(type) {
+    // Check the outer vector is a List
+    if (!DataType.isList(type)) {
+        return false;
+    }
+    // Check the child is a point vector
+    if (!isGeoArrowPoint(type.children[0].type)) {
+        return false;
+    }
+    return true;
+}
+/** Checks whether the given Apache Arrow JS type is a Polygon data type */
+export function isGeoArrowMultiLineString(type) {
+    // Check the outer vector is a List
+    if (!DataType.isList(type)) {
+        return false;
+    }
+    // Check the child is a linestring vector
+    if (!isGeoArrowLineString(type.children[0].type)) {
+        return false;
+    }
+    return true;
+}
+/** Checks whether the given Apache Arrow JS type is a Polygon data type */
+export function isGeoArrowMultiPolygon(type) {
+    // Check the outer vector is a List
+    if (!DataType.isList(type)) {
+        return false;
+    }
+    // Check the child is a polygon vector
+    if (!isGeoArrowPolygon(type.children[0].type)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Checks if a given Arrow data type is a valid GeoArrowGeometry
+ * @note this is somewhat inefficient, it checks the same things multiple times
+ */
+export function isGeoArrowGeometry(type) {
+    return (isGeoArrowPoint(type) ||
+        isGeoArrowLineString(type) ||
+        isGeoArrowPolygon(type) ||
+        isGeoArrowMultiPoint(type) ||
+        isGeoArrowMultiLineString(type) ||
+        isGeoArrowMultiPolygon(type));
+}
+// CHILD EXTRACTION
+/**
+ * Strongly typed accessors for children, since arrow.Data.children[] is untyped
+ 
+import { Data } from "apache-arrow/data";
+import { Vector } from "apache-arrow/vector";
+import { Float } from "apache-arrow/type";
+import {
+  LineStringData,
+  MultiLineStringData,
+  MultiPointData,
+  MultiPolygonData,
+  PointData,
+  PolygonData,
+} from "./data";
+import {
+  LineStringVector,
+  MultiLineStringVector,
+  MultiPointVector,
+  MultiPolygonVector,
+  PointVector,
+  PolygonVector,
+} from "./vector";
+
+export function getPointChild(input: PointData): Data<Float>;
+export function getPointChild(input: PointVector): Vector<Float>;
+
+export function getPointChild(
+  input: PointData | PointVector,
+): Data<Float> | Vector<Float> {
+  if ("data" in input) {
+    return input.getChildAt(0)!;
+  }
+
+  return input.children[0] as Data<Float>;
+}
+
+export function getLineStringChild(input: LineStringData): PointData;
+export function getLineStringChild(input: LineStringVector): PointVector;
+
+export function getLineStringChild(
+  input: LineStringData | LineStringVector,
+): PointData | PointVector {
+  if ("data" in input) {
+    return input.getChildAt(0)!;
+  }
+
+  return input.children[0] as PointData;
+}
+
+export function getPolygonChild(input: PolygonData): LineStringData;
+export function getPolygonChild(input: PolygonVector): LineStringVector;
+
+export function getPolygonChild(
+  input: PolygonData | PolygonVector,
+): LineStringData | LineStringVector {
+  if ("data" in input) {
+    return input.getChildAt(0)!;
+  }
+
+  return input.children[0] as LineStringData;
+}
+
+export function getMultiPointChild(input: MultiPointData): PointData;
+export function getMultiPointChild(input: MultiPointVector): PointVector;
+
+export function getMultiPointChild(
+  input: MultiPointData | MultiPointVector,
+): PointData | PointVector {
+  if ("data" in input) {
+    return input.getChildAt(0)!;
+  }
+
+  return input.children[0] as PointData;
+}
+
+export function getMultiLineStringChild(
+  input: MultiLineStringData,
+): LineStringData;
+export function getMultiLineStringChild(
+  input: MultiLineStringVector,
+): LineStringVector;
+
+export function getMultiLineStringChild(
+  input: MultiLineStringData | MultiLineStringVector,
+): LineStringData | LineStringVector {
+  if ("data" in input) {
+    return input.getChildAt(0)!;
+  }
+
+  return input.children[0] as LineStringData;
+}
+
+export function getMultiPolygonChild(input: MultiPolygonData): PolygonData;
+export function getMultiPolygonChild(input: MultiPolygonVector): PolygonVector;
+
+export function getMultiPolygonChild(
+  input: MultiPolygonData | MultiPolygonVector,
+): PolygonData | PolygonVector {
+  if ("data" in input) {
+    return input.getChildAt(0)!;
+  }
+
+  return input.children[0] as PolygonData;
+}
+*/

package/dist/geoarrow-types.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @note Conforms to the GeoArrow memory layout
+ * @see https://geoarrow.org/format.html#memory-layouts
+ * @note this is aligned with the geoarrow-js library (MIT license)
+ * @see https://github.com/geoarrow/geoarrow-js/
+ */
+import type { Struct, Float, List, FixedSizeList, Utf8, Binary } from 'apache-arrow/type';
+export type GeoArrowWKB = Binary;
+export type GeoArrowWKT = Utf8;
+/**
+ * @note arrow.Float (not arrow.Float64) ensures that recreating a data instance with arrow.makeData type checks using the input's data type.
+ */
+/** Interleaved GeoArrow coordinates */
+export type GeoArrowCoordInterleaved = FixedSizeList<Float>;
+/** Separated GeoArrow coordinates */
+export type GeoArrowCoordSeparated = Struct<{
+    x: Float;
+    y: Float;
+}>;
+export type GeoArrowCoord = GeoArrowCoordInterleaved;
+/** Arrow type for GeoArrow geometry */
+export type GeoArrowPoint = GeoArrowCoordInterleaved;
+/** Arrow type for GeoArrow geometry */
+export type GeoArrowLineString = List<GeoArrowCoordInterleaved>;
+/** Arrow type for GeoArrow geometry */
+export type GeoArrowPolygon = List<List<GeoArrowCoordInterleaved>>;
+/** Arrow type for GeoArrow geometry */
+export type GeoArrowMultiPoint = List<GeoArrowCoordInterleaved>;
+/** Arrow type for GeoArrow geometry */
+export type GeoArrowMultiLineString = List<List<GeoArrowCoordInterleaved>>;
+/** Arrow type for GeoArrow geometry */
+export type GeoArrowMultiPolygon = List<List<List<GeoArrowCoordInterleaved>>>;
+/** Arrow type for GeoArrow geometry */
+export type GeoArrowGeometry = GeoArrowPoint | GeoArrowLineString | GeoArrowPolygon | GeoArrowMultiPoint | GeoArrowMultiLineString | GeoArrowMultiPolygon;
+/** Arrow type for GeoArrow geometry */
+export type GeoArrowPointSeparated = GeoArrowCoordSeparated;
+/** Arrow type for GeoArrow geometry */
+export type GeoArrowLineStringSeparated = List<GeoArrowCoordSeparated>;
+/** Arrow type for GeoArrow geometry */
+export type GeoArrowPolygonSeparated = List<List<GeoArrowCoordSeparated>>;
+/** Arrow type for GeoArrow geometry */
+export type GeoArrowMultiPointSeparated = List<GeoArrowCoordSeparated>;
+/** Arrow type for GeoArrow geometry */
+export type GeoArrowMultiLineStringSeparated = List<List<GeoArrowCoordSeparated>>;
+/** Arrow type for GeoArrow geometry */
+export type GeoArrowMultiPolygonSeparated = List<List<List<GeoArrowCoordSeparated>>>;
+/** Arrow type for GeoArrow geometry */
+export type GeoArrowGeometrySeparated = GeoArrowPointSeparated | GeoArrowLineStringSeparated | GeoArrowPolygonSeparated | GeoArrowMultiPointSeparated | GeoArrowMultiLineStringSeparated | GeoArrowMultiPolygonSeparated;
+//# sourceMappingURL=geoarrow-types.d.ts.map

package/dist/geoarrow-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geoarrow-types.d.ts","sourceRoot":"","sources":["../src/geoarrow-types.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AAEH,OAAO,KAAK,EAAC,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,EAAC,MAAM,mBAAmB,CAAC;AAExF,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC;AACjC,MAAM,MAAM,WAAW,GAAG,IAAI,CAAC;AAC/B;;GAEG;AAEH,uCAAuC;AACvC,MAAM,MAAM,wBAAwB,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;AAC5D,qCAAqC;AACrC,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC;IAAC,CAAC,EAAE,KAAK,CAAC;IAAC,CAAC,EAAE,KAAK,CAAA;CAAC,CAAC,CAAC;AAIlE,MAAM,MAAM,aAAa,GAAG,wBAAwB,CAAC;AAErD,uCAAuC;AACvC,MAAM,MAAM,aAAa,GAAG,wBAAwB,CAAC;AACrD,uCAAuC;AACvC,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,wBAAwB,CAAC,CAAC;AAChE,uCAAuC;AACvC,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC,CAAC;AACnE,uCAAuC;AACvC,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,wBAAwB,CAAC,CAAC;AAChE,uCAAuC;AACvC,MAAM,MAAM,uBAAuB,GAAG,IAAI,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC,CAAC;AAC3E,uCAAuC;AACvC,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC,CAAC,CAAC;AAE9E,uCAAuC;AACvC,MAAM,MAAM,gBAAgB,GACxB,aAAa,GACb,kBAAkB,GAClB,eAAe,GACf,kBAAkB,GAClB,uBAAuB,GACvB,oBAAoB,CAAC;AAGzB,uCAAuC;AACvC,MAAM,MAAM,sBAAsB,GAAG,sBAAsB,CAAC;AAC5D,uCAAuC;AACvC,MAAM,MAAM,2BAA2B,GAAG,IAAI,CAAC,sBAAsB,CAAC,CAAC;AACvE,uCAAuC;AACvC,MAAM,MAAM,wBAAwB,GAAG,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC,CAAC;AAC1E,uCAAuC;AACvC,MAAM,MAAM,2BAA2B,GAAG,IAAI,CAAC,sBAAsB,CAAC,CAAC;AACvE,uCAAuC;AACvC,MAAM,MAAM,gCAAgC,GAAG,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC,CAAC;AAClF,uCAAuC;AACvC,MAAM,MAAM,6BAA6B,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC;AAErF,uCAAuC;AACvC,MAAM,MAAM,yBAAyB,GACjC,sBAAsB,GACtB,2BAA2B,GAC3B,wBAAwB,GACxB,2BAA2B,GAC3B,gCAAgC,GAChC,6BAA6B,CAAC"}

package/dist/geoarrow-types.js

@@ -0,0 +1,4 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+export {};

package/dist/get-arrow-bounds.d.ts

@@ -0,0 +1,11 @@
+/**
+ *  Update bounds from geoarrow sample data
+ *
+ * @param flatCoords the flattend coordinates array from one chunk of geoarrow column
+ * @param nDim the number of dimensions of the coordinates
+ * @param bounds the bounds to be updated
+ * @param sampleSize how many samples to be used to update the bounds, default is 1000 per chunk
+ * @returns the updated bounds
+ */
+export declare function updateBoundsFromGeoArrowSamples(flatCoords: Float64Array, nDim: number, bounds: [number, number, number, number], sampleSize?: number): [number, number, number, number];
+//# sourceMappingURL=get-arrow-bounds.d.ts.map

package/dist/get-arrow-bounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-arrow-bounds.d.ts","sourceRoot":"","sources":["../src/get-arrow-bounds.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,YAAY,EACxB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACxC,UAAU,GAAE,MAAY,GACvB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAsBlC"}