@loaders.gl/gis 4.3.2 → 4.4.0-alpha.1

package/dist/lib/wkt-crs/parse-wkt-crs.js

@@ -0,0 +1,120 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// parse-wkt-crs was forked from https://github.com/DanielJDufour/wkt-crs under Creative Commons CC0 1.0 license.
+/**
+ *
+ * @param wkt
+ * @param options
+ * @returns
+ */
+export function parseWKTCRS(wkt, options) {
+    if (options?.debug) {
+        console.log('[wktcrs] parse starting with\n', wkt);
+    }
+    // move all keywords into first array item slot
+    // from PARAM[12345, 67890] to ["PARAM", 12345, 67890]
+    wkt = wkt.replace(/[A-Z][A-Z\d_]+\[/gi, (match) => `["${match.substr(0, match.length - 1)}",`);
+    // wrap variables in strings
+    // from [...,NORTH] to [...,"NORTH"]
+    wkt = wkt.replace(/, ?([A-Z][A-Z\d_]+[,\]])/gi, (match, p1) => {
+        const varname = p1.substr(0, p1.length - 1);
+        return ',' + `"${options?.raw ? 'raw:' : ''}${varname}"${p1[p1.length - 1]}`;
+    });
+    if (options?.raw) {
+        // replace all numbers with strings
+        wkt = wkt.replace(/, {0,2}(-?[\.\d]+)(?=,|\])/g, function (match, p1) {
+            return ',' + `"${options?.raw ? 'raw:' : ''}${p1}"`;
+        });
+    }
+    // str should now be valid JSON
+    if (options?.debug) {
+        console.log(`[wktcrs] json'd wkt: '${wkt}'`);
+    }
+    let data;
+    try {
+        data = JSON.parse(wkt);
+    }
+    catch (error) {
+        console.error(`[wktcrs] failed to parse '${wkt}'`);
+        throw error;
+    }
+    if (options?.debug) {
+        console.log(`[wktcrs] json parsed: '${wkt}'`);
+    }
+    function process(data, parent) {
+        const kw = data[0];
+        // after removing the first element with .shift()
+        // data is now just an array of attributes
+        data.forEach(function (it) {
+            if (Array.isArray(it)) {
+                process(it, data);
+            }
+        });
+        const kwarr = `MULTIPLE_${kw}`;
+        if (kwarr in parent) {
+            parent[kwarr].push(data);
+        }
+        else if (kw in parent) {
+            parent[kwarr] = [parent[kw], data];
+            delete parent[kw];
+        }
+        else {
+            parent[kw] = data;
+        }
+        return parent;
+    }
+    const result = process(data, [data]);
+    if (options?.debug) {
+        console.log('[wktcrs] parse returning', result);
+    }
+    if (options?.sort) {
+        sort(result, options);
+    }
+    return result;
+}
+function sort(data, options) {
+    const keys = Object.keys(data).filter((k) => !/\d+/.test(k));
+    const keywords = options?.keywords || [];
+    if (!options?.keywords) {
+        // try to find multiples
+        const counts = {};
+        if (Array.isArray(data)) {
+            data.forEach((it) => {
+                if (Array.isArray(it) && it.length >= 2 && typeof it[1] === 'string') {
+                    const k = it[0];
+                    if (!counts[k])
+                        counts[k] = 0;
+                    counts[k]++;
+                }
+            });
+            for (const k in counts) {
+                if (counts[k] > 0)
+                    keywords.push(k);
+            }
+        }
+    }
+    keys.forEach((key) => {
+        data[key] = sort(data[key]);
+    });
+    keywords.forEach((key) => {
+        const indices = [];
+        const params = [];
+        data.forEach((item, i) => {
+            if (Array.isArray(item) && item[0] === key) {
+                indices.push(i);
+                params.push(item);
+            }
+        });
+        params.sort((a, b) => {
+            a = a[1].toString();
+            b = b[1].toString();
+            return a < b ? -1 : a > b ? 1 : 0;
+        });
+        // replace in order
+        params.forEach((param, i) => {
+            data[indices[i]] = param;
+        });
+    });
+    return data;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loaders.gl/gis",
   "description": "Helpers for GIS category data",
-  "version": "4.3.2",
+  "version": "4.4.0-alpha.1",
   "license": "MIT",
   "type": "module",
   "publishConfig": {
@@ -32,8 +32,10 @@
     "README.md"
   ],
   "dependencies": {
-    "@loaders.gl/loader-utils": "4.3.2",
-    "@loaders.gl/schema": "4.3.2",
+    "@loaders.gl/geoarrow": "4.4.0-alpha.1",
+    "@loaders.gl/loader-utils": "4.4.0-alpha.1",
+    "@loaders.gl/schema": "4.4.0-alpha.1",
+    "@loaders.gl/schema-utils": "4.4.0-alpha.1",
     "@mapbox/vector-tile": "^1.3.1",
     "@math.gl/polygon": "^4.1.0",
     "pbf": "^3.2.1"
@@ -42,7 +44,7 @@
     "@math.gl/proj4": "^4.1.0"
   },
   "peerDependencies": {
-    "@loaders.gl/core": "^4.3.0"
+    "@loaders.gl/core": "4.4.0-alpha.0"
   },
-  "gitHead": "b4203b8703f64a38d6f79a3113bc7bb51d45c93a"
+  "gitHead": "f1732de45907bd500bf4eedb4803beca8bf4bfb0"
 }

package/src/index.ts

@@ -3,21 +3,94 @@
 // 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 {GEOPARQUET_METADATA_JSON_SCHEMA} from './lib/geoarrow/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 {GeoMetadata} from './lib/geoarrow/geoparquet-metadata';
+// export {
+//   getGeoMetadata,
+//   setGeoMetadata,
+//   unpackGeoMetadata
+// } from './lib/geoarrow/geoparquet-metadata';
+// export {unpackJSONStringMetadata} from './lib/geoarrow/geoparquet-metadata';
 
-export type {GeoArrowEncoding, GeoArrowMetadata} from './lib/geo/geoarrow-metadata';
-export {getGeometryColumnsFromSchema} from './lib/geo/geoarrow-metadata';
+//
+export type {GeojsonGeometryInfo} from './lib/geometry-api/geometry-info';
+export {getGeometryInfo} from './lib/geometry-api/geometry-info';
 
-// Table conversion
-export {convertWKBTableToGeoJSON} from './lib/tables/convert-table-to-geojson';
+// Binary Geometry Utilities
+export type {BinaryGeometryInfo} from './lib/binary-geometry-api/binary-geometry-info';
+export {getBinaryGeometryInfo} from './lib/binary-geometry-api/binary-geometry-info';
+export {
+  transformBinaryCoords,
+  transformGeoJsonCoords
+} from './lib/binary-geometry-api/transform-coordinates';
 
-// 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';
+// TABLE CONVERSION
+export {convertGeoArrowToTable} from './lib/table-converters/convert-geoarrow-table';
+export {convertWKBTableToGeoJSON} from './lib/table-converters/convert-wkb-table-to-geojson';
+
+// FEATURE COLLECTION CONVERSION
+export {
+  convertFlatGeojsonToBinaryFeatureCollection,
+  // deprecated
+  convertFlatGeojsonToBinaryFeatureCollection as flatGeojsonToBinary
+} from './lib/feature-collection-converters/convert-flat-geojson-to-binary-features';
+export {
+  convertGeojsonToBinaryFeatureCollection,
+  // deprecated
+  convertGeojsonToBinaryFeatureCollection as geojsonToBinary
+} from './lib/feature-collection-converters/convert-geojson-to-binary-features';
+export {
+  convertGeojsonToFlatGeojson,
+  // deprecated
+  convertGeojsonToFlatGeojson as geojsonToFlatGeojson
+} from './lib/feature-collection-converters/convert-geojson-to-flat-geojson';
+export {
+  convertBinaryFeatureCollectionToGeojson,
+  convertBinaryFeatureCollectionToGeojson as binaryToGeojson
+} from './lib/feature-collection-converters/convert-binary-features-to-geojson';
+
+// GEOMETRY ENCODING DETECTION
+export {isWKB, isTWKB, isWKT} from './lib/geometry-converters/wkb/helpers/parse-wkb-header';
+
+export type {WKBHeader} from './lib/geometry-converters/wkb/helpers/wkb-types';
+export {WKT_MAGIC_STRINGS} from './lib/geometry-converters/wkb/helpers/wkb-types';
+
+// GEOMETRY CONVERSION
+export {convertBinaryGeometryToGeometry} from './lib/geometry-converters/convert-binary-geometry-to-geojson';
+
+export {convertWKTToGeometry} from './lib/geometry-converters/wkb/convert-wkt-to-geometry';
+export {convertWKBToGeometry} from './lib/geometry-converters/wkb/convert-wkb-to-geometry';
+export {convertWKBToBinaryGeometry} from './lib/geometry-converters/wkb/convert-wkb-to-binary-geometry';
+export {convertTWKBToGeometry} from './lib/geometry-converters/wkb/convert-twkb-to-geometry';
+
+export {convertGeometryToWKT} from './lib/geometry-converters/wkb/convert-geometry-to-wkt';
+export {convertGeometryToWKB} from './lib/geometry-converters/wkb/convert-geometry-to-wkb';
+export {convertGeometryToTWKB} from './lib/geometry-converters/wkb/convert-geometry-to-twkb';
+
+// CRS
+export type {WKTCRS, ParseWKTCRSOptions} from './lib//wkt-crs/parse-wkt-crs';
+export {parseWKTCRS} from './lib//wkt-crs/parse-wkt-crs';
+export type {EncodeWKTCRSOptions} from './lib//wkt-crs/encode-wkt-crs';
+export {encodeWKTCRS} from './lib//wkt-crs/encode-wkt-crs';
+
+// GEOARROW
+export type {
+  BinaryDataFromGeoArrow,
+  BinaryGeometriesFromArrowOptions
+} from './lib/feature-collection-converters/convert-geoarrow-to-binary-features';
+export {
+  convertGeoArrowToBinaryFeatureCollection,
+  // deprecated
+  convertGeoArrowToBinaryFeatureCollection as getBinaryGeometriesFromArrow,
+  getBinaryGeometryTemplate,
+  getTriangleIndices,
+  getMeanCentersFromBinaryGeometries
+} from './lib/feature-collection-converters/convert-geoarrow-to-binary-features';
+
+export {convertGeoArrowGeometryToGeoJSON} from './lib/geometry-converters/convert-geoarrow-to-geojson';
+
+// EXPERIMENTAL APIs
+
+export {encodeHex, decodeHex} from './lib/utils/hex-transcoder';
+export {extractNumericPropTypes as _extractNumericPropTypes} from './lib/feature-collection-converters/convert-flat-geojson-to-binary-features';

package/src/lib/binary-geometry-api/binary-geometry-info.ts

@@ -0,0 +1,75 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {BinaryGeometry} from '@loaders.gl/schema';
+
+/**
+ * Information about a binary geometry
+ */
+export type BinaryGeometryInfo = {
+  /** 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
+ */
+export function getBinaryGeometryInfo(geometry: BinaryGeometry): BinaryGeometryInfo {
+  return {
+    isMultiGeometry: isMultiGeometryType(geometry),
+    multiGeometryType: getMultiGeometryType(geometry),
+    dimension: geometry.positions.size,
+    pointCount: geometry.positions.value.length / geometry.positions.size,
+    coordinateCount: geometry.positions.value.length
+  };
+}
+
+/** @returns true if a binary geometry corresponds to a MultiPoint, MultiLineString or MultiPolygon */
+function isMultiGeometryType(geometry: BinaryGeometry) {
+  switch (geometry.type) {
+    case 'Point':
+      const {positions} = geometry;
+      return positions.value.length / positions.size > 1;
+    case 'LineString':
+      const {pathIndices} = geometry;
+      return pathIndices.value.length > 1;
+    case 'Polygon':
+      const {polygonIndices} = geometry;
+      return polygonIndices.value.length > 1;
+    default:
+      return false;
+  }
+}
+
+/**
+ * @returns geometry type of binary geometry, including MultiPoint, MultiLineString or MultiPolygon
+ */
+function getMultiGeometryType(geometry: BinaryGeometry) {
+  const isMulti = isMultiGeometryType(geometry);
+  switch (geometry.type) {
+    case 'Point':
+      return isMulti ? 'MultiPoint' : 'Point';
+    case 'LineString':
+      return isMulti ? 'MultiLineString' : 'LineString';
+    case 'Polygon':
+      return isMulti ? 'MultiPolygon' : 'Polygon';
+    default:
+      // @ts-expect-error
+      throw new Error(`Illegal geometry type: ${type}`);
+  }
+}

package/src/lib/binary-geometry-api/concat-binary-geometry.ts

@@ -0,0 +1,78 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {
+  TypedArray,
+  BinaryPointGeometry,
+  BinaryLineGeometry,
+  BinaryPolygonGeometry
+} from '@loaders.gl/schema';
+import {concatTypedArrays} from '../utils/concat-typed-arrays';
+
+export function concatenateBinaryPointGeometries(
+  binaryPointGeometries: BinaryPointGeometry[],
+  dimension: number
+): BinaryPointGeometry {
+  const positions: TypedArray[] = binaryPointGeometries.map((geometry) => geometry.positions.value);
+  const concatenatedPositions = new Float64Array(concatTypedArrays(positions).buffer);
+
+  return {
+    type: 'Point',
+    positions: {value: concatenatedPositions, size: dimension}
+  };
+}
+
+export function concatenateBinaryLineGeometries(
+  binaryLineGeometries: BinaryLineGeometry[],
+  dimension: number
+): BinaryLineGeometry {
+  const lines: TypedArray[] = binaryLineGeometries.map((geometry) => geometry.positions.value);
+  const concatenatedPositions = new Float64Array(concatTypedArrays(lines).buffer);
+  const pathIndices = lines.map((line) => line.length / dimension).map(cumulativeSum(0));
+  pathIndices.unshift(0);
+
+  return {
+    type: 'LineString',
+    positions: {value: concatenatedPositions, size: dimension},
+    pathIndices: {value: new Uint32Array(pathIndices), size: 1}
+  };
+}
+
+export function concatenateBinaryPolygonGeometries(
+  binaryPolygonGeometries: BinaryPolygonGeometry[],
+  dimension: number
+): BinaryPolygonGeometry {
+  const polygons: TypedArray[] = [];
+  const primitivePolygons: TypedArray[] = [];
+
+  for (const binaryPolygon of binaryPolygonGeometries) {
+    const {positions, primitivePolygonIndices} = binaryPolygon;
+    polygons.push(positions.value);
+    primitivePolygons.push(primitivePolygonIndices.value);
+  }
+
+  const concatenatedPositions = new Float64Array(concatTypedArrays(polygons).buffer);
+  const polygonIndices = polygons.map((p) => p.length / dimension).map(cumulativeSum(0));
+  polygonIndices.unshift(0);
+
+  // Combine primitivePolygonIndices from each individual polygon
+  const primitivePolygonIndices = [0];
+  for (const primitivePolygon of primitivePolygons) {
+    primitivePolygonIndices.push(
+      ...primitivePolygon
+        .filter((x: number) => x > 0)
+        .map((x: number) => x + primitivePolygonIndices[primitivePolygonIndices.length - 1])
+    );
+  }
+
+  return {
+    type: 'Polygon',
+    positions: {value: concatenatedPositions, size: dimension},
+    polygonIndices: {value: new Uint32Array(polygonIndices), size: 1},
+    primitivePolygonIndices: {value: new Uint32Array(primitivePolygonIndices), size: 1}
+  };
+}
+
+// https://stackoverflow.com/a/55261098
+const cumulativeSum = (sum: number) => (value: number) => (sum += value);

package/src/lib/{binary-features/transform.ts → binary-geometry-api/transform-coordinates.ts}

@@ -38,7 +38,6 @@ function transformBinaryGeometryPositions(binaryGeometry: BinaryGeometry, fn: Tr
 
 /**
  * Apply transformation to every coordinate of GeoJSON features
- *
  * @param  features Array of GeoJSON features
  * @param  fn       Function to call on each coordinate
  * @return          Transformed GeoJSON features

package/src/lib/{binary-features/binary-to-geojson.ts → feature-collection-converters/convert-binary-features-to-geojson.ts}

@@ -3,30 +3,18 @@
 // Copyright (c) vis.gl contributors
 
 import type {
-  BinaryGeometry,
   BinaryGeometryType,
-  BinaryPointGeometry,
-  BinaryLineGeometry,
-  BinaryPolygonGeometry,
   BinaryFeatureCollection,
   BinaryFeature,
   // BinaryPointFeature,
   // BinaryLineFeature,
   // BinaryPolygonFeature,
-  BinaryAttribute,
   Feature,
-  Geometry,
-  Position,
-  GeoJsonProperties,
-  Point,
-  MultiPoint,
-  LineString,
-  MultiLineString,
-  Polygon,
-  MultiPolygon
+  GeoJsonProperties
 } from '@loaders.gl/schema';
+import {convertBinaryGeometryToGeometry} from '../geometry-converters/convert-binary-geometry-to-geojson';
 
-// Note:L We do not handle GeometryCollection, define a limited Geometry type that always has coordinates.
+// Note: We do not handle GeometryCollection, define a limited Geometry type that always has coordinates.
 // type FeatureGeometry = Point | MultiPoint | LineString | MultiLineString | Polygon | MultiPolygon;
 
 type BinaryToGeoJsonOptions = {
@@ -42,7 +30,7 @@ type BinaryToGeoJsonOptions = {
  * @param options.featureId  Global feature id. If specified, only a single feature is extracted
  * @return GeoJSON objects
  */
-export function binaryToGeojson(
+export function convertBinaryFeatureCollectionToGeojson(
   data: BinaryFeatureCollection,
   options?: BinaryToGeoJsonOptions
 ): Feature[] | Feature {
@@ -91,25 +79,6 @@ function parseFeatures(data: BinaryFeatureCollection, type?: BinaryGeometryType)
   return parseFeatureCollection(dataArray);
 }
 
-/** Parse input binary data and return a valid GeoJSON geometry object */
-export function binaryToGeometry(
-  data: BinaryGeometry,
-  startIndex?: number,
-  endIndex?: number
-): Geometry {
-  switch (data.type) {
-    case 'Point':
-      return pointToGeoJson(data, startIndex, endIndex);
-    case 'LineString':
-      return lineStringToGeoJson(data, startIndex, endIndex);
-    case 'Polygon':
-      return polygonToGeoJson(data, startIndex, endIndex);
-    default:
-      const unexpectedInput: never = data;
-      throw new Error(`Unsupported geometry type: ${(unexpectedInput as any)?.type}`);
-  }
-}
-
 // Normalize features
 // Return an array of data objects, each of which have a type key
 function normalizeInput(data: BinaryFeatureCollection, type?: BinaryGeometryType): BinaryFeature[] {
@@ -162,7 +131,7 @@ function parseFeatureCollection(dataArray: BinaryFeature[]): Feature[] {
 
 /** Parse input binary data and return a single GeoJSON Feature */
 function parseFeature(data: BinaryFeature, startIndex?: number, endIndex?: number): Feature {
-  const geometry = binaryToGeometry(data, startIndex, endIndex);
+  const geometry = convertBinaryGeometryToGeometry(data, startIndex, endIndex);
   const properties = parseProperties(data, startIndex, endIndex);
   const fields = parseFields(data, startIndex, endIndex);
   return {type: 'Feature', geometry, properties, ...fields};
@@ -181,109 +150,3 @@ function parseProperties(data, startIndex: number = 0, endIndex?: number): GeoJs
   }
   return properties;
 }
-
-/** Parse binary data of type Polygon */
-function polygonToGeoJson(
-  data: BinaryPolygonGeometry,
-  startIndex: number = -Infinity,
-  endIndex: number = Infinity
-): Polygon | MultiPolygon {
-  const {positions} = data;
-  const polygonIndices = data.polygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
-  const primitivePolygonIndices = data.primitivePolygonIndices.value.filter(
-    (x) => x >= startIndex && x <= endIndex
-  );
-  const multi = polygonIndices.length > 2;
-
-  // Polygon
-  if (!multi) {
-    const coordinates: Position[][] = [];
-    for (let i = 0; i < primitivePolygonIndices.length - 1; i++) {
-      const startRingIndex = primitivePolygonIndices[i];
-      const endRingIndex = primitivePolygonIndices[i + 1];
-      const ringCoordinates = ringToGeoJson(positions, startRingIndex, endRingIndex);
-      coordinates.push(ringCoordinates);
-    }
-
-    return {type: 'Polygon', coordinates};
-  }
-
-  // MultiPolygon
-  const coordinates: Position[][][] = [];
-  for (let i = 0; i < polygonIndices.length - 1; i++) {
-    const startPolygonIndex = polygonIndices[i];
-    const endPolygonIndex = polygonIndices[i + 1];
-    const polygonCoordinates = polygonToGeoJson(
-      data,
-      startPolygonIndex,
-      endPolygonIndex
-    ).coordinates;
-    coordinates.push(polygonCoordinates as Position[][]);
-  }
-
-  return {type: 'MultiPolygon', coordinates};
-}
-
-/** Parse binary data of type LineString */
-function lineStringToGeoJson(
-  data: BinaryLineGeometry,
-  startIndex: number = -Infinity,
-  endIndex: number = Infinity
-): LineString | MultiLineString {
-  const {positions} = data;
-  const pathIndices = data.pathIndices.value.filter((x) => x >= startIndex && x <= endIndex);
-  const multi = pathIndices.length > 2;
-
-  if (!multi) {
-    const coordinates = ringToGeoJson(positions, pathIndices[0], pathIndices[1]);
-    return {type: 'LineString', coordinates};
-  }
-
-  const coordinates: Position[][] = [];
-  for (let i = 0; i < pathIndices.length - 1; i++) {
-    const ringCoordinates = ringToGeoJson(positions, pathIndices[i], pathIndices[i + 1]);
-    coordinates.push(ringCoordinates);
-  }
-
-  return {type: 'MultiLineString', coordinates};
-}
-
-/** Parse binary data of type Point */
-function pointToGeoJson(data: BinaryPointGeometry, startIndex, endIndex): Point | MultiPoint {
-  const {positions} = data;
-  const coordinates = ringToGeoJson(positions, startIndex, endIndex);
-  const multi = coordinates.length > 1;
-
-  if (multi) {
-    return {type: 'MultiPoint', coordinates};
-  }
-
-  return {type: 'Point', coordinates: coordinates[0]};
-}
-
-/**
- * Parse a linear ring of positions to a GeoJSON linear ring
- *
- * @param positions Positions TypedArray
- * @param startIndex Start index to include in ring
- * @param endIndex End index to include in ring
- * @returns GeoJSON ring
- */
-function ringToGeoJson(
-  positions: BinaryAttribute,
-  startIndex?: number,
-  endIndex?: number
-): Position[] {
-  startIndex = startIndex || 0;
-  endIndex = endIndex || positions.value.length / positions.size;
-
-  const ringCoordinates: Position[] = [];
-  for (let j = startIndex; j < endIndex; j++) {
-    const coord = Array<number>();
-    for (let k = j * positions.size; k < (j + 1) * positions.size; k++) {
-      coord.push(Number(positions.value[k]));
-    }
-    ringCoordinates.push(coord);
-  }
-  return ringCoordinates;
-}

package/src/lib/{binary-features/flat-geojson-to-binary.ts → feature-collection-converters/convert-flat-geojson-to-binary-features.ts}

@@ -1,3 +1,7 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 /* eslint-disable indent */
 import {earcut} from '@math.gl/polygon';
 import type {
@@ -8,10 +12,15 @@ import type {
   FlatPoint,
   FlatLineString,
   FlatPolygon,
-  GeojsonGeometryInfo,
   TypedArray
 } from '@loaders.gl/schema';
-import {PropArrayConstructor, Lines, Points, Polygons} from './flat-geojson-to-binary-types';
+import {GeojsonGeometryInfo} from '../geometry-api/geometry-info';
+import {
+  PropArrayConstructor,
+  Lines,
+  Points,
+  Polygons
+} from './helpers/flat-geojson-to-binary-types';
 
 /**
  * Convert binary features to flat binary arrays. Similar to
@@ -26,11 +35,11 @@ import {PropArrayConstructor, Lines, Points, Polygons} from './flat-geojson-to-b
  * @param options
  * @returns filled arrays
  */
-export function flatGeojsonToBinary(
+export function convertFlatGeojsonToBinaryFeatureCollection(
   features: FlatFeature[],
   geometryInfo: GeojsonGeometryInfo,
   options?: FlatGeojsonToBinaryOptions
-) {
+): BinaryFeatureCollection {
   const propArrayTypes = extractNumericPropTypes(features);
   const numericPropKeys = Object.keys(propArrayTypes).filter((k) => propArrayTypes[k] !== Array);
   return fillArrays(
@@ -56,17 +65,13 @@ export type FlatGeojsonToBinaryOptions = {
   triangulate?: boolean;
 };
 
-export const TEST_EXPORTS = {
-  extractNumericPropTypes
-};
-
 /**
  * Extracts properties that are always numeric
  *
  * @param features
  * @returns object with numeric types
  */
-function extractNumericPropTypes(features: FlatFeature[]): {
+export function extractNumericPropTypes(features: FlatFeature[]): {
   [key: string]: PropArrayConstructor;
 } {
   const propArrayTypes = {};