@loaders.gl/gis 3.1.0 → 3.1.1

package/dist/lib/geojson-to-binary.js

@@ -1,366 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TEST_EXPORTS = exports.geojsonToBinary = void 0;
-/** Convert GeoJSON features to flat binary arrays */
-function geojsonToBinary(features, options = {}) {
-    const firstPassData = firstPass(features);
-    return secondPass(features, firstPassData, {
-        coordLength: options.coordLength || firstPassData.coordLength,
-        numericPropKeys: options.numericPropKeys || firstPassData.numericPropKeys,
+exports.geojsonToBinary = void 0;
+const extract_geometry_info_1 = require("./extract-geometry-info");
+const geojson_to_flat_geojson_1 = require("./geojson-to-flat-geojson");
+const flat_geojson_to_binary_1 = require("./flat-geojson-to-binary");
+/**
+ * Convert GeoJSON features to flat binary arrays
+ *
+ * @param features
+ * @param options
+ * @returns features in binary format, grouped by geometry type
+ */
+function geojsonToBinary(features, options = { fixRingWinding: true }) {
+    const geometryInfo = (0, extract_geometry_info_1.extractGeometryInfo)(features);
+    const coordLength = geometryInfo.coordLength;
+    const { fixRingWinding } = options;
+    const flatFeatures = (0, geojson_to_flat_geojson_1.geojsonToFlatGeojson)(features, { coordLength, fixRingWinding });
+    return (0, flat_geojson_to_binary_1.flatGeojsonToBinary)(flatFeatures, geometryInfo, {
+        numericPropKeys: options.numericPropKeys,
         PositionDataType: options.PositionDataType || Float32Array
     });
 }
 exports.geojsonToBinary = geojsonToBinary;
-exports.TEST_EXPORTS = {
-    firstPass,
-    secondPass
-};
-/**
- *  Initial scan over GeoJSON features
- *  Counts number of coordinates of each geometry type and
- *  keeps track of the max coordinate dimensions
- */
-// eslint-disable-next-line complexity, max-statements
-function firstPass(features) {
-    // Counts the number of _positions_, so [x, y, z] counts as one
-    let pointPositionsCount = 0;
-    let pointFeaturesCount = 0;
-    let linePositionsCount = 0;
-    let linePathsCount = 0;
-    let lineFeaturesCount = 0;
-    let polygonPositionsCount = 0;
-    let polygonObjectsCount = 0;
-    let polygonRingsCount = 0;
-    let polygonFeaturesCount = 0;
-    const coordLengths = new Set();
-    const propArrayTypes = {};
-    for (const feature of features) {
-        const geometry = feature.geometry;
-        switch (geometry.type) {
-            case 'Point':
-                pointFeaturesCount++;
-                pointPositionsCount++;
-                coordLengths.add(geometry.coordinates.length);
-                break;
-            case 'MultiPoint':
-                pointFeaturesCount++;
-                pointPositionsCount += geometry.coordinates.length;
-                for (const point of geometry.coordinates) {
-                    coordLengths.add(point.length);
-                }
-                break;
-            case 'LineString':
-                lineFeaturesCount++;
-                linePositionsCount += geometry.coordinates.length;
-                linePathsCount++;
-                for (const coord of geometry.coordinates) {
-                    coordLengths.add(coord.length);
-                }
-                break;
-            case 'MultiLineString':
-                lineFeaturesCount++;
-                for (const line of geometry.coordinates) {
-                    linePositionsCount += line.length;
-                    linePathsCount++;
-                    // eslint-disable-next-line max-depth
-                    for (const coord of line) {
-                        coordLengths.add(coord.length);
-                    }
-                }
-                break;
-            case 'Polygon':
-                polygonFeaturesCount++;
-                polygonObjectsCount++;
-                polygonRingsCount += geometry.coordinates.length;
-                polygonPositionsCount += flatten(geometry.coordinates).length;
-                for (const coord of flatten(geometry.coordinates)) {
-                    coordLengths.add(coord.length);
-                }
-                break;
-            case 'MultiPolygon':
-                polygonFeaturesCount++;
-                for (const polygon of geometry.coordinates) {
-                    polygonObjectsCount++;
-                    polygonRingsCount += polygon.length;
-                    polygonPositionsCount += flatten(polygon).length;
-                    // eslint-disable-next-line max-depth
-                    for (const coord of flatten(polygon)) {
-                        coordLengths.add(coord.length);
-                    }
-                }
-                break;
-            default:
-                throw new Error(`Unsupported geometry type: ${geometry.type}`);
-        }
-        if (feature.properties) {
-            for (const key in feature.properties) {
-                const val = feature.properties[key];
-                // If property has not been seen before, or if property has been numeric
-                // in all previous features, check if numeric in this feature
-                // If not numeric, Array is stored to prevent rechecking in the future
-                // Additionally, detects if 64 bit precision is required
-                propArrayTypes[key] = deduceArrayType(val, propArrayTypes[key]);
-            }
-        }
-    }
-    return {
-        coordLength: coordLengths.size > 0 ? Math.max(...coordLengths) : 2,
-        pointPositionsCount,
-        pointFeaturesCount,
-        linePositionsCount,
-        linePathsCount,
-        lineFeaturesCount,
-        polygonPositionsCount,
-        polygonObjectsCount,
-        polygonRingsCount,
-        polygonFeaturesCount,
-        // Array of keys whose values are always numeric
-        numericPropKeys: Object.keys(propArrayTypes).filter((k) => propArrayTypes[k] !== Array),
-        propArrayTypes
-    };
-}
-/**
- * Second scan over GeoJSON features
- * Fills coordinates into pre-allocated typed arrays
- */
-// eslint-disable-next-line complexity
-function secondPass(features, firstPassData, options) {
-    const { pointPositionsCount, pointFeaturesCount, linePositionsCount, linePathsCount, lineFeaturesCount, polygonPositionsCount, polygonObjectsCount, polygonRingsCount, propArrayTypes, polygonFeaturesCount } = firstPassData;
-    const { coordLength, numericPropKeys, PositionDataType = Float32Array } = options;
-    const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;
-    const points = {
-        // @ts-ignore Typescript doesn't like dynamic constructors
-        positions: new PositionDataType(pointPositionsCount * coordLength),
-        globalFeatureIds: new GlobalFeatureIdsDataType(pointPositionsCount),
-        featureIds: pointFeaturesCount > 65535
-            ? new Uint32Array(pointPositionsCount)
-            : new Uint16Array(pointPositionsCount),
-        numericProps: {},
-        properties: Array(),
-        fields: Array()
-    };
-    const lines = {
-        // @ts-ignore Typescript doesn't like dynamic constructors
-        positions: new PositionDataType(linePositionsCount * coordLength),
-        pathIndices: linePositionsCount > 65535
-            ? new Uint32Array(linePathsCount + 1)
-            : new Uint16Array(linePathsCount + 1),
-        globalFeatureIds: new GlobalFeatureIdsDataType(linePositionsCount),
-        featureIds: lineFeaturesCount > 65535
-            ? new Uint32Array(linePositionsCount)
-            : new Uint16Array(linePositionsCount),
-        numericProps: {},
-        properties: Array(),
-        fields: Array()
-    };
-    const polygons = {
-        // @ts-ignore Typescript doesn't like dynamic constructors
-        positions: new PositionDataType(polygonPositionsCount * coordLength),
-        polygonIndices: polygonPositionsCount > 65535
-            ? new Uint32Array(polygonObjectsCount + 1)
-            : new Uint16Array(polygonObjectsCount + 1),
-        primitivePolygonIndices: polygonPositionsCount > 65535
-            ? new Uint32Array(polygonRingsCount + 1)
-            : new Uint16Array(polygonRingsCount + 1),
-        globalFeatureIds: new GlobalFeatureIdsDataType(polygonPositionsCount),
-        featureIds: polygonFeaturesCount > 65535
-            ? new Uint32Array(polygonPositionsCount)
-            : new Uint16Array(polygonPositionsCount),
-        numericProps: {},
-        properties: Array(),
-        fields: Array()
-    };
-    // Instantiate numeric properties arrays; one value per vertex
-    for (const object of [points, lines, polygons]) {
-        for (const propName of numericPropKeys || []) {
-            // If property has been numeric in all previous features in which the property existed, check
-            // if numeric in this feature
-            const TypedArray = propArrayTypes[propName];
-            object.numericProps[propName] = new TypedArray(object.positions.length / coordLength);
-        }
-    }
-    // Set last element of path/polygon indices as positions length
-    lines.pathIndices[linePathsCount] = linePositionsCount;
-    polygons.polygonIndices[polygonObjectsCount] = polygonPositionsCount;
-    polygons.primitivePolygonIndices[polygonRingsCount] = polygonPositionsCount;
-    const indexMap = {
-        pointPosition: 0,
-        pointFeature: 0,
-        linePosition: 0,
-        linePath: 0,
-        lineFeature: 0,
-        polygonPosition: 0,
-        polygonObject: 0,
-        polygonRing: 0,
-        polygonFeature: 0,
-        feature: 0
-    };
-    for (const feature of features) {
-        const geometry = feature.geometry;
-        const properties = feature.properties || {};
-        switch (geometry.type) {
-            case 'Point':
-                handlePoint(geometry.coordinates, points, indexMap, coordLength, properties);
-                points.properties.push(keepStringProperties(properties, numericPropKeys));
-                indexMap.pointFeature++;
-                break;
-            case 'MultiPoint':
-                handleMultiPoint(geometry.coordinates, points, indexMap, coordLength, properties);
-                points.properties.push(keepStringProperties(properties, numericPropKeys));
-                indexMap.pointFeature++;
-                break;
-            case 'LineString':
-                handleLineString(geometry.coordinates, lines, indexMap, coordLength, properties);
-                lines.properties.push(keepStringProperties(properties, numericPropKeys));
-                indexMap.lineFeature++;
-                break;
-            case 'MultiLineString':
-                handleMultiLineString(geometry.coordinates, lines, indexMap, coordLength, properties);
-                lines.properties.push(keepStringProperties(properties, numericPropKeys));
-                indexMap.lineFeature++;
-                break;
-            case 'Polygon':
-                handlePolygon(geometry.coordinates, polygons, indexMap, coordLength, properties);
-                polygons.properties.push(keepStringProperties(properties, numericPropKeys));
-                indexMap.polygonFeature++;
-                break;
-            case 'MultiPolygon':
-                handleMultiPolygon(geometry.coordinates, polygons, indexMap, coordLength, properties);
-                polygons.properties.push(keepStringProperties(properties, numericPropKeys));
-                indexMap.polygonFeature++;
-                break;
-            default:
-                throw new Error('Invalid geometry type');
-        }
-        indexMap.feature++;
-    }
-    // Wrap each array in an accessor object with value and size keys
-    return makeAccessorObjects(points, lines, polygons, coordLength);
-}
-/** Fills Point coordinates into points object of arrays */
-function handlePoint(coords, points, indexMap, coordLength, properties) {
-    points.positions.set(coords, indexMap.pointPosition * coordLength);
-    points.globalFeatureIds[indexMap.pointPosition] = indexMap.feature;
-    points.featureIds[indexMap.pointPosition] = indexMap.pointFeature;
-    fillNumericProperties(points, properties, indexMap.pointPosition, 1);
-    indexMap.pointPosition++;
-}
-/** Fills MultiPoint coordinates into points object of arrays */
-function handleMultiPoint(coords, points, indexMap, coordLength, properties) {
-    for (const point of coords) {
-        handlePoint(point, points, indexMap, coordLength, properties);
-    }
-}
-/** Fills LineString coordinates into lines object of arrays */
-function handleLineString(coords, lines, indexMap, coordLength, properties) {
-    lines.pathIndices[indexMap.linePath] = indexMap.linePosition;
-    indexMap.linePath++;
-    fillCoords(lines.positions, coords, indexMap.linePosition, coordLength);
-    const nPositions = coords.length;
-    fillNumericProperties(lines, properties, indexMap.linePosition, nPositions);
-    lines.globalFeatureIds.set(new Uint32Array(nPositions).fill(indexMap.feature), indexMap.linePosition);
-    lines.featureIds.set(new Uint32Array(nPositions).fill(indexMap.lineFeature), indexMap.linePosition);
-    indexMap.linePosition += nPositions;
-}
-/** Fills MultiLineString coordinates into lines object of arrays */
-function handleMultiLineString(coords, lines, indexMap, coordLength, properties) {
-    for (const line of coords) {
-        handleLineString(line, lines, indexMap, coordLength, properties);
-    }
-}
-/** Fills Polygon coordinates into polygons object of arrays */
-function handlePolygon(coords, polygons, indexMap, coordLength, properties) {
-    polygons.polygonIndices[indexMap.polygonObject] = indexMap.polygonPosition;
-    indexMap.polygonObject++;
-    for (const ring of coords) {
-        polygons.primitivePolygonIndices[indexMap.polygonRing] = indexMap.polygonPosition;
-        indexMap.polygonRing++;
-        fillCoords(polygons.positions, ring, indexMap.polygonPosition, coordLength);
-        const nPositions = ring.length;
-        fillNumericProperties(polygons, properties, indexMap.polygonPosition, nPositions);
-        polygons.globalFeatureIds.set(new Uint32Array(nPositions).fill(indexMap.feature), indexMap.polygonPosition);
-        polygons.featureIds.set(new Uint32Array(nPositions).fill(indexMap.polygonFeature), indexMap.polygonPosition);
-        indexMap.polygonPosition += nPositions;
-    }
-}
-/** Fills MultiPolygon coordinates into polygons object of arrays */
-function handleMultiPolygon(coords, polygons, indexMap, coordLength, properties) {
-    for (const polygon of coords) {
-        handlePolygon(polygon, polygons, indexMap, coordLength, properties);
-    }
-}
-/** Wrap each array in an accessor object with value and size keys */
-function makeAccessorObjects(points, lines, polygons, coordLength) {
-    const returnObj = {
-        points: {
-            ...points,
-            positions: { value: points.positions, size: coordLength },
-            globalFeatureIds: { value: points.globalFeatureIds, size: 1 },
-            featureIds: { value: points.featureIds, size: 1 },
-            type: 'Point'
-        },
-        lines: {
-            ...lines,
-            pathIndices: { value: lines.pathIndices, size: 1 },
-            positions: { value: lines.positions, size: coordLength },
-            globalFeatureIds: { value: lines.globalFeatureIds, size: 1 },
-            featureIds: { value: lines.featureIds, size: 1 },
-            type: 'LineString'
-        },
-        polygons: {
-            ...polygons,
-            polygonIndices: { value: polygons.polygonIndices, size: 1 },
-            primitivePolygonIndices: { value: polygons.primitivePolygonIndices, size: 1 },
-            positions: { value: polygons.positions, size: coordLength },
-            globalFeatureIds: { value: polygons.globalFeatureIds, size: 1 },
-            featureIds: { value: polygons.featureIds, size: 1 },
-            type: 'Polygon'
-        }
-    };
-    for (const geomType in returnObj) {
-        for (const numericProp in returnObj[geomType].numericProps) {
-            returnObj[geomType].numericProps[numericProp] = {
-                value: returnObj[geomType].numericProps[numericProp],
-                size: 1
-            };
-        }
-    }
-    return returnObj;
-}
-/** Add numeric properties to object */
-function fillNumericProperties(object, properties, index, length) {
-    for (const numericPropName in object.numericProps) {
-        if (numericPropName in properties) {
-            object.numericProps[numericPropName].set(new Array(length).fill(properties[numericPropName]), index);
-        }
-    }
-}
-/** Keep string properties in object */
-function keepStringProperties(properties, numericKeys) {
-    const props = {};
-    for (const key in properties) {
-        if (!numericKeys.includes(key)) {
-            props[key] = properties[key];
-        }
-    }
-    return props;
-}
-/** @param coords is expected to be a list of arrays, each with length 2-3 */
-function fillCoords(array, coords, startVertex, coordLength) {
-    let index = startVertex * coordLength;
-    for (const coord of coords) {
-        array.set(coord, index);
-        index += coordLength;
-    }
-}
-// TODO - how does this work? Different `coordinates` have different nesting
-function flatten(arrays) {
-    return [].concat(...arrays);
-}
-function deduceArrayType(x, constructor) {
-    if (constructor === Array || !Number.isFinite(x)) {
-        return Array;
-    }
-    // If this or previous value required 64bits use Float64Array
-    return constructor === Float64Array || Math.fround(x) !== x ? Float64Array : Float32Array;
-}

package/dist/lib/geojson-to-flat-geojson.d.ts

@@ -0,0 +1,17 @@
+import { Feature, FlatFeature } from '@loaders.gl/schema';
+/**
+ * Options for `geojsonToFlatGeojson`
+ */
+export declare type GeojsonToFlatGeojsonOptions = {
+    coordLength: number;
+    fixRingWinding: boolean;
+};
+/**
+ * Convert GeoJSON features to Flat GeoJSON features
+ *
+ * @param features
+ * @param options
+ * @returns an Array of Flat GeoJSON features
+ */
+export declare function geojsonToFlatGeojson(features: Feature[], options?: GeojsonToFlatGeojsonOptions): FlatFeature[];
+//# sourceMappingURL=geojson-to-flat-geojson.d.ts.map

package/dist/lib/geojson-to-flat-geojson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geojson-to-flat-geojson.d.ts","sourceRoot":"","sources":["../../src/lib/geojson-to-flat-geojson.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,OAAO,EAAY,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAElE;;GAEG;AACH,oBAAY,2BAA2B,GAAG;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AASF;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,GAAE,2BAAoE,GAC5E,WAAW,EAAE,CAEf"}

package/dist/lib/geojson-to-flat-geojson.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geojsonToFlatGeojson = void 0;
+const polygon_1 = require("@math.gl/polygon");
+/**
+ * Convert GeoJSON features to Flat GeoJSON features
+ *
+ * @param features
+ * @param options
+ * @returns an Array of Flat GeoJSON features
+ */
+function geojsonToFlatGeojson(features, options = { coordLength: 2, fixRingWinding: true }) {
+    return features.map((feature) => flattenFeature(feature, options));
+}
+exports.geojsonToFlatGeojson = geojsonToFlatGeojson;
+/**
+ * Helper function to copy Point values from `coordinates` into `data` & `indices`
+ *
+ * @param coordinates
+ * @param data
+ * @param indices
+ * @param options
+ */
+function flattenPoint(coordinates, data, indices, options) {
+    indices.push(data.length);
+    data.push(...coordinates);
+    // Pad up to coordLength
+    for (let i = coordinates.length; i < options.coordLength; i++) {
+        data.push(0);
+    }
+}
+/**
+ * Helper function to copy LineString values from `coordinates` into `data` & `indices`
+ *
+ * @param coordinates
+ * @param data
+ * @param indices
+ * @param options
+ */
+function flattenLineString(coordinates, data, indices, options) {
+    indices.push(data.length);
+    for (const c of coordinates) {
+        data.push(...c);
+        // Pad up to coordLength
+        for (let i = c.length; i < options.coordLength; i++) {
+            data.push(0);
+        }
+    }
+}
+/**
+ * Helper function to copy Polygon values from `coordinates` into `data` & `indices` & `areas`
+ *
+ * @param coordinates
+ * @param data
+ * @param indices
+ * @param areas
+ * @param options
+ */
+function flattenPolygon(coordinates, data, indices, areas, options) {
+    let count = 0;
+    const ringAreas = [];
+    const polygons = [];
+    for (const lineString of coordinates) {
+        const lineString2d = lineString.map((p) => p.slice(0, 2));
+        let area = (0, polygon_1.getPolygonSignedArea)(lineString2d.flat());
+        const ccw = area < 0;
+        // Exterior ring must be CCW and interior rings CW
+        if (options.fixRingWinding && ((count === 0 && !ccw) || (count > 0 && ccw))) {
+            lineString.reverse();
+            area = -area;
+        }
+        ringAreas.push(area);
+        flattenLineString(lineString, data, polygons, options);
+        count++;
+    }
+    if (count > 0) {
+        areas.push(ringAreas);
+        indices.push(polygons);
+    }
+}
+/**
+ * Flatten single GeoJSON feature into Flat GeoJSON
+ *
+ * @param feature
+ * @param options
+ * @returns A Flat GeoJSON feature
+ */
+function flattenFeature(feature, options) {
+    const { geometry } = feature;
+    if (geometry.type === 'GeometryCollection') {
+        throw new Error('GeometryCollection type not supported');
+    }
+    const data = [];
+    const indices = [];
+    let areas;
+    let type;
+    switch (geometry.type) {
+        case 'Point':
+            type = 'Point';
+            flattenPoint(geometry.coordinates, data, indices, options);
+            break;
+        case 'MultiPoint':
+            type = 'Point';
+            geometry.coordinates.map((c) => flattenPoint(c, data, indices, options));
+            break;
+        case 'LineString':
+            type = 'LineString';
+            flattenLineString(geometry.coordinates, data, indices, options);
+            break;
+        case 'MultiLineString':
+            type = 'LineString';
+            geometry.coordinates.map((c) => flattenLineString(c, data, indices, options));
+            break;
+        case 'Polygon':
+            type = 'Polygon';
+            areas = [];
+            flattenPolygon(geometry.coordinates, data, indices, areas, options);
+            break;
+        case 'MultiPolygon':
+            type = 'Polygon';
+            areas = [];
+            geometry.coordinates.map((c) => flattenPolygon(c, data, indices, areas, options));
+            break;
+        default:
+            throw new Error(`Unknown type: ${type}`);
+    }
+    return { ...feature, geometry: { type, indices, data, areas } };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loaders.gl/gis",
   "description": "Helpers for GIS category data",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -24,13 +24,14 @@
     "README.md"
   ],
   "dependencies": {
-    "@loaders.gl/loader-utils": "3.1.0",
-    "@loaders.gl/schema": "3.1.0",
+    "@loaders.gl/loader-utils": "3.1.1",
+    "@loaders.gl/schema": "3.1.1",
     "@mapbox/vector-tile": "^1.3.1",
+    "@math.gl/polygon": "^3.5.1",
     "pbf": "^3.2.1"
   },
   "devDependencies": {
     "@math.gl/proj4": "^3.5.1"
   },
-  "gitHead": "b02a011b5a6d6aa6c5870819045c70db168cb930"
+  "gitHead": "ed3c238bcb68ab5a2d4ddc64319f6f4c02a20df7"
 }

package/src/index.ts

@@ -1,6 +1,8 @@
 // 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, binaryToGeoJson, binaryToGeometry} from './lib/binary-to-geojson';
 export {transformBinaryCoords, transformGeoJsonCoords} from './lib/transform';

package/src/lib/extract-geometry-info.ts

@@ -0,0 +1,101 @@
+import {Feature, GeojsonGeometryInfo} from '@loaders.gl/schema';
+
+/**
+ *  Initial scan over GeoJSON features
+ *  Counts number of coordinates of each geometry type and
+ *  keeps track of the max coordinate dimensions
+ */
+// eslint-disable-next-line complexity, max-statements
+export function extractGeometryInfo(features: Feature[]): GeojsonGeometryInfo {
+  // Counts the number of _positions_, so [x, y, z] counts as one
+  let pointPositionsCount = 0;
+  let pointFeaturesCount = 0;
+  let linePositionsCount = 0;
+  let linePathsCount = 0;
+  let lineFeaturesCount = 0;
+  let polygonPositionsCount = 0;
+  let polygonObjectsCount = 0;
+  let polygonRingsCount = 0;
+  let polygonFeaturesCount = 0;
+  const coordLengths = new Set<number>();
+
+  for (const feature of features) {
+    const geometry = feature.geometry;
+    switch (geometry.type) {
+      case 'Point':
+        pointFeaturesCount++;
+        pointPositionsCount++;
+        coordLengths.add(geometry.coordinates.length);
+        break;
+      case 'MultiPoint':
+        pointFeaturesCount++;
+        pointPositionsCount += geometry.coordinates.length;
+        for (const point of geometry.coordinates) {
+          coordLengths.add(point.length);
+        }
+        break;
+      case 'LineString':
+        lineFeaturesCount++;
+        linePositionsCount += geometry.coordinates.length;
+        linePathsCount++;
+
+        for (const coord of geometry.coordinates) {
+          coordLengths.add(coord.length);
+        }
+        break;
+      case 'MultiLineString':
+        lineFeaturesCount++;
+        for (const line of geometry.coordinates) {
+          linePositionsCount += line.length;
+          linePathsCount++;
+
+          // eslint-disable-next-line max-depth
+          for (const coord of line) {
+            coordLengths.add(coord.length);
+          }
+        }
+        break;
+      case 'Polygon':
+        polygonFeaturesCount++;
+        polygonObjectsCount++;
+        polygonRingsCount += geometry.coordinates.length;
+        const flattened = geometry.coordinates.flat();
+        polygonPositionsCount += flattened.length;
+
+        for (const coord of flattened) {
+          coordLengths.add(coord.length);
+        }
+        break;
+      case 'MultiPolygon':
+        polygonFeaturesCount++;
+        for (const polygon of geometry.coordinates) {
+          polygonObjectsCount++;
+          polygonRingsCount += polygon.length;
+          const flattened = polygon.flat();
+          polygonPositionsCount += flattened.length;
+
+          // eslint-disable-next-line max-depth
+          for (const coord of flattened) {
+            coordLengths.add(coord.length);
+          }
+        }
+        break;
+      default:
+        throw new Error(`Unsupported geometry type: ${geometry.type}`);
+    }
+  }
+
+  return {
+    coordLength: coordLengths.size > 0 ? Math.max(...coordLengths) : 2,
+
+    pointPositionsCount,
+    pointFeaturesCount,
+    linePositionsCount,
+    linePathsCount,
+    lineFeaturesCount,
+    polygonPositionsCount,
+    polygonObjectsCount,
+    polygonRingsCount,
+    polygonFeaturesCount
+  };
+}