@math.gl/geospatial 5.0.0-alpha.18 → 5.0.0-alpha.19

package/src/geoarrow/tessellate.ts

@@ -0,0 +1,133 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {earcut} from '@math.gl/geometry/polygon';
+import type {GeoArrowColumn, GeoArrowGeometryValue} from './types';
+import {getGeoArrowDimensionSize} from './types';
+import {materializeGeoArrowRows} from './layout';
+import {assertGeoArrowResourceLimits, type GeoArrowResourceLimitOptions} from './kernels';
+
+/** Options for polygon tessellation. */
+export type TessellateGeoArrowPolygonsOptions = Readonly<{
+  /** Number of values emitted for each output vertex. Defaults to the input dimension. */
+  positionSize?: 2 | 3 | 4;
+  /** Value added to every source row index. */
+  sourceRowOffset?: number;
+  limits?: GeoArrowResourceLimitOptions;
+}>;
+
+/** Flat, renderer-ready output for polygon and multipolygon rows. */
+export type GeoArrowTessellation = Readonly<{
+  positions: Float32Array;
+  /** Source column row for every emitted vertex. */
+  sourceRowIndices: Uint32Array;
+  indices: Uint16Array | Uint32Array;
+  sourceDimension: 2 | 3 | 4;
+  positionSize: 2 | 3 | 4;
+  rowCount: number;
+  polygonCount: number;
+  vertexCount: number;
+  triangleCount: number;
+}>;
+
+/**
+ * Tessellates Polygon and MultiPolygon values with stable source-row attribution.
+ *
+ * Non-polygon members of mixed columns and geometry collections are skipped. Closing coordinates
+ * are removed before triangulation and all input descriptors remain borrowed and untouched.
+ */
+export function tessellateGeoArrowPolygons(
+  column: GeoArrowColumn,
+  options: TessellateGeoArrowPolygonsOptions = {}
+): GeoArrowTessellation {
+  assertGeoArrowResourceLimits(column, options.limits);
+  const rows = materializeGeoArrowRows(column);
+  const sourceDimension = getGeoArrowDimensionSize(column.dimension);
+  const positionSize = options.positionSize || sourceDimension;
+  const sourceRowOffset = options.sourceRowOffset || 0;
+  const positions: number[] = [];
+  const sourceRowIndices: number[] = [];
+  const indices: number[] = [];
+  let polygonCount = 0;
+
+  for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+    const row = rows[rowIndex];
+    if (row) {
+      visitPolygons(row, polygon => {
+        const vertexOffset = positions.length / positionSize;
+        const flatCoordinates: number[] = [];
+        const holeIndices: number[] = [];
+        let localVertexCount = 0;
+
+        for (let ringIndex = 0; ringIndex < polygon.length; ringIndex++) {
+          const ring = removeClosingCoordinate(polygon[ringIndex]);
+          if (ring.length < 3) continue;
+          if (localVertexCount > 0) holeIndices.push(localVertexCount);
+          for (const coordinate of ring) {
+            for (let component = 0; component < sourceDimension; component++) {
+              flatCoordinates.push(coordinate[component] ?? 0);
+            }
+            for (let component = 0; component < positionSize; component++) {
+              positions.push(coordinate[component] ?? 0);
+            }
+            sourceRowIndices.push(sourceRowOffset + rowIndex);
+            localVertexCount++;
+          }
+        }
+
+        if (localVertexCount >= 3) {
+          const localIndices = earcut(flatCoordinates, holeIndices, sourceDimension);
+          for (const index of localIndices) indices.push(vertexOffset + index);
+          polygonCount++;
+        }
+      });
+    }
+  }
+
+  const vertexCount = positions.length / positionSize;
+  const IndexArray = vertexCount <= 65535 ? Uint16Array : Uint32Array;
+  return {
+    positions: Float32Array.from(positions),
+    sourceRowIndices: Uint32Array.from(sourceRowIndices),
+    indices: IndexArray.from(indices),
+    sourceDimension,
+    positionSize,
+    rowCount: rows.length,
+    polygonCount,
+    vertexCount,
+    triangleCount: indices.length / 3
+  };
+}
+
+function visitPolygons(
+  geometry: GeoArrowGeometryValue,
+  visitor: (polygon: readonly (readonly (readonly number[])[])[]) => void
+): void {
+  switch (geometry.type) {
+    case 'Polygon':
+      visitor(geometry.coordinates);
+      break;
+    case 'MultiPolygon':
+      for (const polygon of geometry.coordinates) visitor(polygon);
+      break;
+    case 'GeometryCollection':
+      for (const child of geometry.geometries) visitPolygons(child, visitor);
+      break;
+    default:
+      break;
+  }
+}
+
+function removeClosingCoordinate(
+  ring: readonly (readonly number[])[]
+): readonly (readonly number[])[] {
+  if (ring.length < 2) return ring;
+  const first = ring[0];
+  const last = ring[ring.length - 1];
+  if (first.length !== last.length) return ring;
+  for (let index = 0; index < first.length; index++) {
+    if (first[index] !== last[index]) return ring;
+  }
+  return ring.slice(0, -1);
+}

package/src/geoarrow/tessellation-entry.ts

@@ -0,0 +1,7 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+/** Optional polygon tessellation subpath. */
+export type {GeoArrowTessellation, TessellateGeoArrowPolygonsOptions} from './tessellate';
+export {tessellateGeoArrowPolygons} from './tessellate';

package/src/geoarrow/types.ts

@@ -0,0 +1,219 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {SpatialReference} from '../crs/index';
+import type {TypedArray} from '@math.gl/core/types';
+/** Minimal tagged geometry shape used only by compatibility builders.
+ *
+ * The physical GeoArrow APIs never create these values. Keeping the structural type here avoids
+ * making the descriptor package depend on the WKB format package.
+ */
+export type GeoArrowGeometryValue =
+  | {type: 'Point'; coordinates: readonly number[]}
+  | {type: 'LineString'; coordinates: readonly (readonly number[])[]}
+  | {type: 'Polygon'; coordinates: readonly (readonly (readonly number[])[])[]}
+  | {type: 'MultiPoint'; coordinates: readonly (readonly number[])[]}
+  | {type: 'MultiLineString'; coordinates: readonly (readonly (readonly number[])[])[]}
+  | {type: 'MultiPolygon'; coordinates: readonly (readonly (readonly (readonly number[])[])[])[]}
+  | {type: 'GeometryCollection'; geometries: readonly GeoArrowGeometryValue[]};
+
+/** GeoArrow concrete, mixed, bounding-box, and serialized encodings. */
+export type GeoArrowEncoding =
+  | 'geoarrow.point'
+  | 'geoarrow.linestring'
+  | 'geoarrow.polygon'
+  | 'geoarrow.multipoint'
+  | 'geoarrow.multilinestring'
+  | 'geoarrow.multipolygon'
+  | 'geoarrow.geometry'
+  | 'geoarrow.geometrycollection'
+  | 'geoarrow.box'
+  | 'geoarrow.wkb'
+  | 'geoarrow.wkt';
+
+/** Semantic coordinate dimensions. M is never interpreted as Z. */
+export type GeoArrowDimension = 'xy' | 'xyz' | 'xym' | 'xyzm';
+
+/** Physical coordinate organization for native geometries. */
+export type GeoArrowCoordinateLayout = 'interleaved' | 'separated';
+
+/** Supported list-offset buffers. */
+export type GeoArrowOffsets = Int32Array | BigInt64Array;
+
+/** Numeric physical storage accepted by GeoArrow descriptors. */
+export type GeoArrowNumericArray = TypedArray | BigInt64Array | BigUint64Array;
+
+/** Borrowed validity bitmap. Set bits are valid rows. */
+export type GeoArrowValidity = Readonly<{
+  values: Uint8Array;
+  /** Bit position corresponding to logical row zero. */
+  bitOffset?: number;
+}>;
+
+/** Properties shared by all physical arrays. */
+export type GeoArrowArrayBase = Readonly<{
+  /** Number of logical values represented by this array. */
+  length: number;
+  /** Optional borrowed validity bitmap for this nesting level. */
+  validity?: GeoArrowValidity;
+}>;
+
+/** Primitive scalar storage, optionally strided within a typed array. */
+export type GeoArrowPrimitive = GeoArrowArrayBase &
+  Readonly<{
+    kind: 'primitive';
+    values: GeoArrowNumericArray;
+    /** Scalar offset of logical value zero. */
+    offset?: number;
+    /** Scalars between consecutive logical values. Defaults to one. */
+    stride?: number;
+  }>;
+
+/** Fixed-size list storage, used for interleaved coordinate tuples. */
+export type GeoArrowFixedSizeList = GeoArrowArrayBase &
+  Readonly<{
+    kind: 'fixed-size-list';
+    size: number;
+    child: GeoArrowArray;
+    /** Logical list offset into the child. */
+    offset?: number;
+  }>;
+
+/** Variable-size list storage. */
+export type GeoArrowList = GeoArrowArrayBase &
+  Readonly<{
+    kind: 'list';
+    offsets: GeoArrowOffsets;
+    /** Index of logical row zero in `offsets`. */
+    offset?: number;
+    /** Value subtracted from offsets before indexing the supplied child view. */
+    offsetBase?: number | bigint;
+    child: GeoArrowArray;
+  }>;
+
+/** Named separated children, used for separated coordinates and boxes. */
+export type GeoArrowStruct = GeoArrowArrayBase &
+  Readonly<{
+    kind: 'struct';
+    children: Readonly<Record<string, GeoArrowArray>>;
+    /** Logical struct offset applied to every child. */
+    offset?: number;
+  }>;
+
+/** Struct storage used by `geoarrow.box` minimum/maximum ordinate columns. */
+export type GeoArrowBox = GeoArrowStruct;
+
+/** One dense-union child and its stable type ID. */
+export type GeoArrowDenseUnionChild = Readonly<{
+  name: string;
+  typeId: number;
+  /** Child-specific physical encoding (required for mixed-dimensional unions). */
+  encoding?: GeoArrowEncoding;
+  /** Child-specific semantic dimension. Falls back to the column dimension for legacy data. */
+  dimension?: GeoArrowDimension;
+  /** Child-specific coordinate layout. Falls back to the column layout for legacy data. */
+  coordinateLayout?: GeoArrowCoordinateLayout | null;
+  data: GeoArrowArray;
+}>;
+
+/** Dense-union storage for mixed geometry families. */
+export type GeoArrowDenseUnion = GeoArrowArrayBase &
+  Readonly<{
+    kind: 'dense-union';
+    typeIds: Int8Array | Uint8Array;
+    valueOffsets: Int32Array;
+    children: readonly GeoArrowDenseUnionChild[];
+    /** Logical row offset into typeIds and valueOffsets. */
+    offset?: number;
+  }>;
+
+/** Variable-width binary or UTF-8 storage for WKB and WKT. */
+export type GeoArrowSerialized = GeoArrowArrayBase &
+  Readonly<{
+    kind: 'serialized';
+    encoding: 'binary' | 'utf8';
+    offsets: GeoArrowOffsets;
+    values: Uint8Array;
+    /** Optional Arrow BinaryView-style records (four uint32 words per row). */
+    views?: Uint32Array;
+    /** Borrowed out-of-line buffers referenced by BinaryView records. */
+    dataBuffers?: readonly Uint8Array[];
+    /** Index of logical row zero in `offsets`. */
+    offset?: number;
+    /** Value subtracted from offsets before indexing `values`. */
+    offsetBase?: number | bigint;
+  }>;
+
+/** Arrow-compatible physical array tree without Arrow runtime classes. */
+export type GeoArrowArray =
+  | GeoArrowPrimitive
+  | GeoArrowFixedSizeList
+  | GeoArrowList
+  | GeoArrowStruct
+  | GeoArrowDenseUnion
+  | GeoArrowSerialized;
+
+/** One logical GeoArrow geometry column backed by borrowed chunks. */
+export type GeoArrowColumn = Readonly<{
+  encoding: GeoArrowEncoding;
+  dimension: GeoArrowDimension;
+  coordinateLayout: GeoArrowCoordinateLayout | null;
+  chunks: readonly GeoArrowArray[];
+  spatialReference?: SpatialReference | null;
+  edges?: 'planar' | 'spherical';
+  metadata?: Readonly<Record<string, unknown>>;
+}>;
+
+/** Coordinate callback used by mapping kernels. */
+export type GeoArrowCoordinateMapper = (
+  coordinate: readonly number[],
+  rowIndex: number
+) => readonly number[];
+
+/** Four-value XY bounds. */
+export type GeoArrowBounds = readonly [number, number, number, number];
+
+/** Returns the number of coordinate components for a semantic dimension. */
+export function getGeoArrowDimensionSize(dimension: GeoArrowDimension): 2 | 3 | 4 {
+  switch (dimension) {
+    case 'xy':
+      return 2;
+    case 'xyz':
+    case 'xym':
+      return 3;
+    case 'xyzm':
+      return 4;
+  }
+}
+
+/** Returns the concrete geometry family associated with an encoding. */
+export function getGeoArrowGeometryType(
+  encoding: GeoArrowEncoding
+): Exclude<GeoArrowGeometryValue['type'], 'GeometryCollection'> | 'GeometryCollection' | null {
+  switch (encoding) {
+    case 'geoarrow.point':
+      return 'Point';
+    case 'geoarrow.linestring':
+      return 'LineString';
+    case 'geoarrow.polygon':
+      return 'Polygon';
+    case 'geoarrow.multipoint':
+      return 'MultiPoint';
+    case 'geoarrow.multilinestring':
+      return 'MultiLineString';
+    case 'geoarrow.multipolygon':
+      return 'MultiPolygon';
+    case 'geoarrow.geometrycollection':
+      return 'GeometryCollection';
+    default:
+      return null;
+  }
+}
+
+/** Returns the canonical concrete encoding for a materialized geometry family. */
+export function getGeoArrowEncodingForGeometry(
+  type: GeoArrowGeometryValue['type']
+): GeoArrowEncoding {
+  return `geoarrow.${type.toLowerCase()}` as GeoArrowEncoding;
+}

package/src/geoarrow/views.ts

@@ -0,0 +1,150 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {GeoArrowArray, GeoArrowColumn} from './types';
+import {getEncodingFromChildName, isGeoArrowValueValid, sliceGeoArrowArray} from './layout';
+
+/** One physical batch borrowed from a native geometry column. */
+export type GeoArrowBatchView = Readonly<{
+  /** Single-chunk column retaining the source semantics and typed arrays. */
+  column: GeoArrowColumn;
+  /** Index of the physical chunk in the source column, including empty chunks. */
+  chunkIndex: number;
+  /** First logical row in the source column; not a feature ID or byte cursor. */
+  rowOffset: number;
+}>;
+
+/** One logical row, with top-level union dispatch resolved without decoding coordinates. */
+export type GeoArrowRowView = Readonly<{
+  /** One-row column, preserving nulls, collections, and exact single/multi identity. */
+  column: GeoArrowColumn;
+  /** Logical row index relative to the input column, including null rows. */
+  rowIndex: number;
+  /** Physical chunk index in the input column. */
+  chunkIndex: number;
+  /** Logical row index within that chunk, before union dispatch. */
+  chunkRowIndex: number;
+}>;
+
+/**
+ * Iterates native physical chunks lazily, including empty chunks, without new typed arrays.
+ * This is not a loader record-batch protocol: one loader batch may contain several chunks.
+ * Views borrow storage; callers must not mutate, recycle, or detach it while views are in use.
+ * Assumes valid physical descriptors; use validateGeoArrowColumn for untrusted input.
+ */
+export function* iterateGeoArrowBatches(
+  column: GeoArrowColumn
+): IterableIterator<GeoArrowBatchView> {
+  assertNativeGeometryColumn(column);
+  let rowOffset = 0;
+  for (let chunkIndex = 0; chunkIndex < column.chunks.length; chunkIndex++) {
+    const chunk = column.chunks[chunkIndex];
+    yield {column: {...column, chunks: [chunk]}, chunkIndex, rowOffset};
+    rowOffset += chunk.length;
+  }
+}
+
+/**
+ * Borrows one native geometry row, allocating descriptors but no typed arrays or coordinates.
+ * Resolves the top-level union by type ID and retains collection grouping inside the row.
+ * Indices are relative to the supplied column (including when it is already sliced).
+ * Throws for an invalid row index, serialized/box encoding, or invalid union dispatch.
+ * Assumes valid physical descriptors beyond the selected union dispatch.
+ */
+export function getGeoArrowRowView(column: GeoArrowColumn, rowIndex: number): GeoArrowRowView {
+  assertNativeGeometryColumn(column);
+  if (!Number.isSafeInteger(rowIndex) || rowIndex < 0) {
+    throw new RangeError('GeoArrow row index must be a nonnegative safe integer');
+  }
+  let chunkRowIndex = rowIndex;
+  for (let chunkIndex = 0; chunkIndex < column.chunks.length; chunkIndex++) {
+    const chunk = column.chunks[chunkIndex];
+    if (chunkRowIndex >= chunk.length) {
+      chunkRowIndex -= chunk.length;
+      continue;
+    }
+    let rowColumn = {
+      ...column,
+      chunks: [sliceGeoArrowArray(chunk, chunkRowIndex, chunkRowIndex + 1)]
+    };
+    // A parent-masked union row has no child value to resolve; dispatch may be unused.
+    if (
+      column.encoding === 'geoarrow.geometry' &&
+      isGeoArrowValueValid(chunk.validity, chunkRowIndex)
+    ) {
+      if (chunk.kind !== 'dense-union') {
+        throw new Error('Mixed GeoArrow geometry requires dense-union storage');
+      }
+      const physicalIndex = (chunk.offset || 0) + chunkRowIndex;
+      const child = chunk.children.find(
+        candidate => candidate.typeId === chunk.typeIds[physicalIndex]
+      );
+      const valueOffset = chunk.valueOffsets[physicalIndex];
+      if (
+        !child ||
+        !Number.isInteger(valueOffset) ||
+        valueOffset < 0 ||
+        valueOffset >= child.data.length
+      ) {
+        throw new Error('Invalid GeoArrow union row dispatch');
+      }
+      const encoding = child.encoding || getEncodingFromChildName(child.name);
+      if (encoding === 'geoarrow.geometry') {
+        throw new Error('GeoArrow geometry union children must be concrete geometries');
+      }
+      const data = sliceGeoArrowArray(child.data, valueOffset, valueOffset + 1);
+      rowColumn = {
+        ...column,
+        encoding,
+        dimension: child.dimension ?? column.dimension,
+        coordinateLayout: child.coordinateLayout ?? column.coordinateLayout,
+        chunks: [data]
+      };
+      assertNativeGeometryColumn(rowColumn);
+    }
+    return {column: rowColumn, rowIndex, chunkIndex, chunkRowIndex};
+  }
+  throw new RangeError('GeoArrow row index exceeds column length');
+}
+
+/**
+ * Assembles a nonempty iterable of compatible native columns without merging physical chunks.
+ * Encodings, dimensions, and layouts must match. CRS and opaque metadata must be the same
+ * references (or both absent); no semantic equivalence, metadata merging, or reprojection is
+ * attempted. Missing edges mean planar. Empty columns/chunks are permitted and retained.
+ * Returns a new envelope and chunk-reference list, never new typed arrays.
+ */
+export function concatenateGeoArrowColumns(columns: Iterable<GeoArrowColumn>): GeoArrowColumn {
+  let firstColumn: GeoArrowColumn | undefined;
+  const chunks: GeoArrowArray[] = [];
+  for (const column of columns) {
+    assertNativeGeometryColumn(column);
+    if (!firstColumn) {
+      firstColumn = column;
+    } else if (
+      column.encoding !== firstColumn.encoding ||
+      column.dimension !== firstColumn.dimension ||
+      column.coordinateLayout !== firstColumn.coordinateLayout ||
+      (column.edges ?? 'planar') !== (firstColumn.edges ?? 'planar') ||
+      column.spatialReference !== firstColumn.spatialReference ||
+      column.metadata !== firstColumn.metadata
+    ) {
+      throw new Error('Cannot concatenate GeoArrow columns with different semantic envelopes');
+    }
+    for (const chunk of column.chunks) chunks.push(chunk);
+  }
+  if (!firstColumn) throw new Error('At least one GeoArrow column is required');
+  return {...firstColumn, chunks};
+}
+
+/** Keeps borrowed geometry access distinct from decoding serialized data or interpreting boxes. */
+function assertNativeGeometryColumn(column: GeoArrowColumn): void {
+  if (
+    column.encoding === 'geoarrow.wkb' ||
+    column.encoding === 'geoarrow.wkt' ||
+    column.encoding === 'geoarrow.box'
+  ) {
+    throw new Error('GeoArrow geometry views require native geometry; decode WKB/WKT first');
+  }
+}

package/src/geoarrow/wkb-entry.ts

@@ -0,0 +1,13 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+/** Optional serialized-format bridge. The parser implementation lives in @math.gl/geospatial/wkb. */
+export {
+  decodeGeoArrowWKB,
+  decodeGeoArrowWKT,
+  encodeGeoArrowWKB,
+  encodeGeoArrowWKT,
+  getGeoArrowWKBVertexCount
+} from './codecs';
+export type {DecodeGeoArrowWKBOptions} from './codecs';

package/src/geoarrow/worker.ts

@@ -0,0 +1,20 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {GeoArrowColumn} from './types';
+import {getGeoArrowTransferList} from './layout';
+
+export {getGeoArrowTransferList} from './layout';
+export type {GeoArrowColumn} from './types';
+
+/** A column and the unique borrowed buffers that may be transferred with it. */
+export type GeoArrowTransfer = Readonly<{
+  column: GeoArrowColumn;
+  transferList: ArrayBuffer[];
+}>;
+
+/** Prepares an explicit structured-clone transfer payload without detaching any buffers. */
+export function prepareGeoArrowTransfer(column: GeoArrowColumn): GeoArrowTransfer {
+  return {column, transferList: getGeoArrowTransferList(column)};
+}

package/src/globe.ts

@@ -0,0 +1,14 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {LngLatRectangle} from './lng-lat-rectangle';
+export {makeOBBFromRegion} from './make-obb-from-region';
+export type {GeodeticRegion, MakeOBBFromRegionOptions} from './make-obb-from-region';
+export {EllipsoidOccluder} from './ellipsoid-occluder';
+export type {EllipsoidHorizon} from './ellipsoid-occluder';
+export {getGlobeHorizonBounds, splitGlobeBounds} from './globe-horizon-bounds';
+export type {GlobeBounds} from './globe-horizon-bounds';
+
+export {subdivideGlobeMesh} from './subdivide-globe-mesh';
+export type {SubdivideGlobeMeshOptions} from './subdivide-globe-mesh';

package/src/index.ts

@@ -2,33 +2,6 @@
 // SPDX-License-Identifier: MIT
 // SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
-export {Ellipsoid} from './ellipsoid';
-export {EllipsoidTangentPlane} from './ellipsoid-tangent-plane';
-export {LngLatRectangle} from './lng-lat-rectangle';
-export {makeOBBFromRegion} from './make-obb-from-region';
-export type {GeodeticRegion, MakeOBBFromRegionOptions} from './make-obb-from-region';
-export {isWGS84} from './type-utils';
-
-export type {SpheroidParameters} from '@math.gl/types';
-
-export {EllipsoidOccluder} from './ellipsoid-occluder';
-export type {EllipsoidHorizon} from './ellipsoid-occluder';
-export {getGlobeHorizonBounds, splitGlobeBounds} from './globe-horizon-bounds';
-export type {GlobeBounds} from './globe-horizon-bounds';
-
-export {
-  getGeographicTile,
-  getGeographicTileBounds,
-  getGeographicTileRanges
-} from './geographic-tiles';
-export type {GeographicTile, GeographicTileRange} from './geographic-tiles';
-
-export {
-  validateTileMatrix,
-  isTileIndexInRange,
-  getTileBounds,
-  getTileIndex,
-  getTileRange,
-  selectTileMatrix
-} from './tile-matrix';
-export type {TileMatrix, TileMatrixSet, TileMatrixLimits, TileMatrixBounds} from './tile-matrix';
+export * from './entries/ellipsoid';
+export * from './globe';
+export * from './tiles';

package/src/make-obb-from-region.ts

@@ -8,7 +8,7 @@
 // See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
 
 import {Matrix3, Matrix4, Vector2, Vector3, degrees, radians, _MathUtils} from '@math.gl/core';
-import {OrientedBoundingBox, Plane} from '@math.gl/culling';
+import {OrientedBoundingBox, Plane} from '@math.gl/geometry/culling';
 // @ts-ignore
 // eslint-disable-next-line import/no-unresolved
 import {LngLatRectangle} from './lng-lat-rectangle';