@loaders.gl/gis 3.1.0 → 3.1.1

package/dist/index.js

@@ -1,10 +1,14 @@
 "use strict";
 // Types from `@loaders.gl/schema`
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformGeoJsonCoords = exports.transformBinaryCoords = exports.binaryToGeometry = exports.binaryToGeoJson = exports.binaryToGeojson = exports.geojsonToBinary = void 0;
+exports.transformGeoJsonCoords = exports.transformBinaryCoords = exports.binaryToGeometry = exports.binaryToGeoJson = exports.binaryToGeojson = exports.geojsonToFlatGeojson = exports.geojsonToBinary = exports.flatGeojsonToBinary = void 0;
 // Functions
+var flat_geojson_to_binary_1 = require("./lib/flat-geojson-to-binary");
+Object.defineProperty(exports, "flatGeojsonToBinary", { enumerable: true, get: function () { return flat_geojson_to_binary_1.flatGeojsonToBinary; } });
 var geojson_to_binary_1 = require("./lib/geojson-to-binary");
 Object.defineProperty(exports, "geojsonToBinary", { enumerable: true, get: function () { return geojson_to_binary_1.geojsonToBinary; } });
+var geojson_to_flat_geojson_1 = require("./lib/geojson-to-flat-geojson");
+Object.defineProperty(exports, "geojsonToFlatGeojson", { enumerable: true, get: function () { return geojson_to_flat_geojson_1.geojsonToFlatGeojson; } });
 var binary_to_geojson_1 = require("./lib/binary-to-geojson");
 Object.defineProperty(exports, "binaryToGeojson", { enumerable: true, get: function () { return binary_to_geojson_1.binaryToGeojson; } });
 Object.defineProperty(exports, "binaryToGeoJson", { enumerable: true, get: function () { return binary_to_geojson_1.binaryToGeoJson; } });

package/dist/lib/extract-geometry-info.d.ts

@@ -0,0 +1,8 @@
+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
+ */
+export declare function extractGeometryInfo(features: Feature[]): GeojsonGeometryInfo;
+//# sourceMappingURL=extract-geometry-info.d.ts.map

package/dist/lib/extract-geometry-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-geometry-info.d.ts","sourceRoot":"","sources":["../../src/lib/extract-geometry-info.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAE,mBAAmB,EAAC,MAAM,oBAAoB,CAAC;AAEhE;;;;GAIG;AAEH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,mBAAmB,CA4F5E"}

package/dist/lib/extract-geometry-info.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractGeometryInfo = void 0;
+/**
+ *  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 extractGeometryInfo(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();
+    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
+    };
+}
+exports.extractGeometryInfo = extractGeometryInfo;

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

@@ -0,0 +1,58 @@
+import type { TypedArray } from '@loaders.gl/schema';
+/**
+ * Permissable constructor for numeric props
+ */
+export declare type PropArrayConstructor = Float32ArrayConstructor | Float64ArrayConstructor | ArrayConstructor;
+/**
+ * Collection type for holding intermediate binary data before conversion to `BinaryPointGeometry`
+ */
+export declare type Points = {
+    type: 'Point';
+    positions: Float32Array | Float64Array;
+    globalFeatureIds: Uint16Array | Uint32Array;
+    featureIds: Uint16Array | Uint32Array;
+    numericProps: {
+        [key: string]: TypedArray;
+    };
+    properties: {}[];
+    fields: {
+        id?: string | number;
+    }[];
+};
+/**
+ * Collection type for holding intermediate binary data before conversion to `BinaryLineStringGeometry`
+ */
+export declare type Lines = {
+    type: 'LineString';
+    positions: Float32Array | Float64Array;
+    pathIndices: Uint16Array | Uint32Array;
+    globalFeatureIds: Uint16Array | Uint32Array;
+    featureIds: Uint16Array | Uint32Array;
+    numericProps: {
+        [key: string]: TypedArray;
+    };
+    properties: {}[];
+    fields: {
+        id?: string | number;
+    }[];
+};
+/**
+ * Collection type for holding intermediate binary data before conversion to `BinaryPolygonGeometry`
+ */
+export declare type Polygons = {
+    type: 'Polygon';
+    positions: Float32Array | Float64Array;
+    polygonIndices: Uint16Array | Uint32Array;
+    primitivePolygonIndices: Uint16Array | Uint32Array;
+    triangles: number[];
+    globalFeatureIds: Uint16Array | Uint32Array;
+    featureIds: Uint16Array | Uint32Array;
+    numericProps: {
+        [key: string]: TypedArray;
+    };
+    properties: {}[];
+    fields: {
+        id?: string | number;
+    }[];
+};
+//# sourceMappingURL=flat-geojson-to-binary-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flat-geojson-to-binary-types.d.ts","sourceRoot":"","sources":["../../src/lib/flat-geojson-to-binary-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAEnD;;GAEG;AACH,oBAAY,oBAAoB,GAC5B,uBAAuB,GACvB,uBAAuB,GACvB,gBAAgB,CAAC;AAErB;;GAEG;AACH,oBAAY,MAAM,GAAG;IACnB,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,EAAE,YAAY,GAAG,YAAY,CAAC;IACvC,gBAAgB,EAAE,WAAW,GAAG,WAAW,CAAC;IAC5C,UAAU,EAAE,WAAW,GAAG,WAAW,CAAC;IACtC,YAAY,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;KAAC,CAAC;IAC1C,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,MAAM,EAAE;QACN,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;KACtB,EAAE,CAAC;CACL,CAAC;AAEF;;GAEG;AACH,oBAAY,KAAK,GAAG;IAClB,IAAI,EAAE,YAAY,CAAC;IACnB,SAAS,EAAE,YAAY,GAAG,YAAY,CAAC;IACvC,WAAW,EAAE,WAAW,GAAG,WAAW,CAAC;IACvC,gBAAgB,EAAE,WAAW,GAAG,WAAW,CAAC;IAC5C,UAAU,EAAE,WAAW,GAAG,WAAW,CAAC;IACtC,YAAY,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;KAAC,CAAC;IAC1C,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,MAAM,EAAE;QACN,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;KACtB,EAAE,CAAC;CACL,CAAC;AAEF;;GAEG;AACH,oBAAY,QAAQ,GAAG;IACrB,IAAI,EAAE,SAAS,CAAC;IAChB,SAAS,EAAE,YAAY,GAAG,YAAY,CAAC;IACvC,cAAc,EAAE,WAAW,GAAG,WAAW,CAAC;IAC1C,uBAAuB,EAAE,WAAW,GAAG,WAAW,CAAC;IACnD,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,gBAAgB,EAAE,WAAW,GAAG,WAAW,CAAC;IAC5C,UAAU,EAAE,WAAW,GAAG,WAAW,CAAC;IACtC,YAAY,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;KAAC,CAAC;IAC1C,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,MAAM,EAAE;QACN,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;KACtB,EAAE,CAAC;CACL,CAAC"}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,37 @@
+import type { BinaryFeatures, FlatFeature, GeojsonGeometryInfo } from '@loaders.gl/schema';
+import { PropArrayConstructor } from './flat-geojson-to-binary-types';
+/**
+ * Convert binary features to flat binary arrays. Similar to
+ * `geojsonToBinary` helper function, except that it expects
+ * a binary representation of the feature data, which enables
+ * 2X-3X speed increase in parse speed, compared to using
+ * geoJSON. See `binary-vector-tile/VectorTileFeature` for
+ * data format detais
+ *
+ * @param features
+ * @param geometryInfo
+ * @param options
+ * @returns filled arrays
+ */
+export declare function flatGeojsonToBinary(features: FlatFeature[], geometryInfo: GeojsonGeometryInfo, options?: FlatGeojsonToBinaryOptions): BinaryFeatures;
+/**
+ * Options for `flatGeojsonToBinary`
+ */
+export declare type FlatGeojsonToBinaryOptions = {
+    numericPropKeys?: string[];
+    PositionDataType?: Float32ArrayConstructor | Float64ArrayConstructor;
+};
+export declare const TEST_EXPORTS: {
+    extractNumericPropTypes: typeof extractNumericPropTypes;
+};
+/**
+ * Extracts properties that are always numeric
+ *
+ * @param features
+ * @returns object with numeric types
+ */
+declare function extractNumericPropTypes(features: FlatFeature[]): {
+    [key: string]: PropArrayConstructor;
+};
+export {};
+//# sourceMappingURL=flat-geojson-to-binary.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flat-geojson-to-binary.d.ts","sourceRoot":"","sources":["../../src/lib/flat-geojson-to-binary.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,cAAc,EACd,WAAW,EAIX,mBAAmB,EAEpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAC,oBAAoB,EAA0B,MAAM,gCAAgC,CAAC;AAE7F;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,WAAW,EAAE,EACvB,YAAY,EAAE,mBAAmB,EACjC,OAAO,CAAC,EAAE,0BAA0B,kBAerC;AAED;;GAEG;AACH,oBAAY,0BAA0B,GAAG;IACvC,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,gBAAgB,CAAC,EAAE,uBAAuB,GAAG,uBAAuB,CAAC;CACtE,CAAC;AAEF,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF;;;;;GAKG;AACH,iBAAS,uBAAuB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG;IACzD,CAAC,GAAG,EAAE,MAAM,GAAG,oBAAoB,CAAC;CACrC,CAgBA"}

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

@@ -0,0 +1,375 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEST_EXPORTS = exports.flatGeojsonToBinary = void 0;
+/* eslint-disable indent */
+const polygon_1 = require("@math.gl/polygon");
+/**
+ * Convert binary features to flat binary arrays. Similar to
+ * `geojsonToBinary` helper function, except that it expects
+ * a binary representation of the feature data, which enables
+ * 2X-3X speed increase in parse speed, compared to using
+ * geoJSON. See `binary-vector-tile/VectorTileFeature` for
+ * data format detais
+ *
+ * @param features
+ * @param geometryInfo
+ * @param options
+ * @returns filled arrays
+ */
+function flatGeojsonToBinary(features, geometryInfo, options) {
+    const propArrayTypes = extractNumericPropTypes(features);
+    const numericPropKeys = Object.keys(propArrayTypes).filter((k) => propArrayTypes[k] !== Array);
+    return fillArrays(features, {
+        propArrayTypes,
+        ...geometryInfo
+    }, {
+        numericPropKeys: (options && options.numericPropKeys) || numericPropKeys,
+        PositionDataType: options ? options.PositionDataType : Float32Array
+    });
+}
+exports.flatGeojsonToBinary = flatGeojsonToBinary;
+exports.TEST_EXPORTS = {
+    extractNumericPropTypes
+};
+/**
+ * Extracts properties that are always numeric
+ *
+ * @param features
+ * @returns object with numeric types
+ */
+function extractNumericPropTypes(features) {
+    const propArrayTypes = {};
+    for (const feature of features) {
+        if (feature.properties) {
+            for (const key in feature.properties) {
+                // 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
+                const val = feature.properties[key];
+                propArrayTypes[key] = deduceArrayType(val, propArrayTypes[key]);
+            }
+        }
+    }
+    return propArrayTypes;
+}
+/**
+ * Fills coordinates into pre-allocated typed arrays
+ *
+ * @param features
+ * @param geometryInfo
+ * @param options
+ * @returns an accessor object with value and size keys
+ */
+// eslint-disable-next-line complexity
+function fillArrays(features, geometryInfo, options) {
+    const { pointPositionsCount, pointFeaturesCount, linePositionsCount, linePathsCount, lineFeaturesCount, polygonPositionsCount, polygonObjectsCount, polygonRingsCount, polygonFeaturesCount, propArrayTypes, coordLength } = geometryInfo;
+    const { numericPropKeys = [], PositionDataType = Float32Array } = options;
+    const hasGlobalId = features[0] && 'id' in features[0];
+    const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;
+    const points = {
+        type: 'Point',
+        positions: new PositionDataType(pointPositionsCount * coordLength),
+        globalFeatureIds: new GlobalFeatureIdsDataType(pointPositionsCount),
+        featureIds: pointFeaturesCount > 65535
+            ? new Uint32Array(pointPositionsCount)
+            : new Uint16Array(pointPositionsCount),
+        numericProps: {},
+        properties: [],
+        fields: []
+    };
+    const lines = {
+        type: 'LineString',
+        pathIndices: linePositionsCount > 65535
+            ? new Uint32Array(linePathsCount + 1)
+            : new Uint16Array(linePathsCount + 1),
+        positions: new PositionDataType(linePositionsCount * coordLength),
+        globalFeatureIds: new GlobalFeatureIdsDataType(linePositionsCount),
+        featureIds: lineFeaturesCount > 65535
+            ? new Uint32Array(linePositionsCount)
+            : new Uint16Array(linePositionsCount),
+        numericProps: {},
+        properties: [],
+        fields: []
+    };
+    const polygons = {
+        type: 'Polygon',
+        polygonIndices: polygonPositionsCount > 65535
+            ? new Uint32Array(polygonObjectsCount + 1)
+            : new Uint16Array(polygonObjectsCount + 1),
+        primitivePolygonIndices: polygonPositionsCount > 65535
+            ? new Uint32Array(polygonRingsCount + 1)
+            : new Uint16Array(polygonRingsCount + 1),
+        positions: new PositionDataType(polygonPositionsCount * coordLength),
+        triangles: [],
+        globalFeatureIds: new GlobalFeatureIdsDataType(polygonPositionsCount),
+        featureIds: polygonFeaturesCount > 65535
+            ? new Uint32Array(polygonPositionsCount)
+            : new Uint16Array(polygonPositionsCount),
+        numericProps: {},
+        properties: [],
+        fields: []
+    };
+    // 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 T = propArrayTypes[propName];
+            object.numericProps[propName] = new T(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, points, indexMap, coordLength, properties);
+                points.properties.push(keepStringProperties(properties, numericPropKeys));
+                if (hasGlobalId) {
+                    points.fields.push({ id: feature.id });
+                }
+                indexMap.pointFeature++;
+                break;
+            case 'LineString':
+                handleLineString(geometry, lines, indexMap, coordLength, properties);
+                lines.properties.push(keepStringProperties(properties, numericPropKeys));
+                if (hasGlobalId) {
+                    lines.fields.push({ id: feature.id });
+                }
+                indexMap.lineFeature++;
+                break;
+            case 'Polygon':
+                handlePolygon(geometry, polygons, indexMap, coordLength, properties);
+                polygons.properties.push(keepStringProperties(properties, numericPropKeys));
+                if (hasGlobalId) {
+                    polygons.fields.push({ id: feature.id });
+                }
+                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 (Multi)Point coordinates into points object of arrays
+ *
+ * @param geometry
+ * @param points
+ * @param indexMap
+ * @param coordLength
+ * @param properties
+ */
+function handlePoint(geometry, points, indexMap, coordLength, properties) {
+    points.positions.set(geometry.data, indexMap.pointPosition * coordLength);
+    const nPositions = geometry.data.length / coordLength;
+    fillNumericProperties(points, properties, indexMap.pointPosition, nPositions);
+    points.globalFeatureIds.fill(indexMap.feature, indexMap.pointPosition, indexMap.pointPosition + nPositions);
+    points.featureIds.fill(indexMap.pointFeature, indexMap.pointPosition, indexMap.pointPosition + nPositions);
+    indexMap.pointPosition += nPositions;
+}
+/**
+ * Fills (Multi)LineString coordinates into lines object of arrays
+ *
+ * @param geometry
+ * @param lines
+ * @param indexMap
+ * @param coordLength
+ * @param properties
+ */
+function handleLineString(geometry, lines, indexMap, coordLength, properties) {
+    lines.positions.set(geometry.data, indexMap.linePosition * coordLength);
+    const nPositions = geometry.data.length / coordLength;
+    fillNumericProperties(lines, properties, indexMap.linePosition, nPositions);
+    lines.globalFeatureIds.fill(indexMap.feature, indexMap.linePosition, indexMap.linePosition + nPositions);
+    lines.featureIds.fill(indexMap.lineFeature, indexMap.linePosition, indexMap.linePosition + nPositions);
+    for (let i = 0, il = geometry.indices.length; i < il; ++i) {
+        // Extract range of data we are working with, defined by start
+        // and end indices (these index into the geometry.data array)
+        const start = geometry.indices[i];
+        const end = i === il - 1
+            ? geometry.data.length // last line, so read to end of data
+            : geometry.indices[i + 1]; // start index for next line
+        lines.pathIndices[indexMap.linePath++] = indexMap.linePosition;
+        indexMap.linePosition += (end - start) / coordLength;
+    }
+}
+/**
+ * Fills (Multi)Polygon coordinates into polygons object of arrays
+ *
+ * @param geometry
+ * @param polygons
+ * @param indexMap
+ * @param coordLength
+ * @param properties
+ */
+function handlePolygon(geometry, polygons, indexMap, coordLength, properties) {
+    polygons.positions.set(geometry.data, indexMap.polygonPosition * coordLength);
+    const nPositions = geometry.data.length / coordLength;
+    fillNumericProperties(polygons, properties, indexMap.polygonPosition, nPositions);
+    polygons.globalFeatureIds.fill(indexMap.feature, indexMap.polygonPosition, indexMap.polygonPosition + nPositions);
+    polygons.featureIds.fill(indexMap.polygonFeature, indexMap.polygonPosition, indexMap.polygonPosition + nPositions);
+    // Unlike Point & LineString geometry.indices is a 2D array
+    for (let l = 0, ll = geometry.indices.length; l < ll; ++l) {
+        const startPosition = indexMap.polygonPosition;
+        polygons.polygonIndices[indexMap.polygonObject++] = startPosition;
+        const areas = geometry.areas[l];
+        const indices = geometry.indices[l];
+        const nextIndices = geometry.indices[l + 1];
+        for (let i = 0, il = indices.length; i < il; ++i) {
+            const start = indices[i];
+            const end = i === il - 1
+                ? // last line, so either read to:
+                    nextIndices === undefined
+                        ? geometry.data.length // end of data (no next indices)
+                        : nextIndices[0] // start of first line in nextIndices
+                : indices[i + 1]; // start index for next line
+            polygons.primitivePolygonIndices[indexMap.polygonRing++] = indexMap.polygonPosition;
+            indexMap.polygonPosition += (end - start) / coordLength;
+        }
+        const endPosition = indexMap.polygonPosition;
+        triangulatePolygon(polygons, areas, indices, { startPosition, endPosition, coordLength });
+    }
+}
+/**
+ * Triangulate polygon using earcut
+ *
+ * @param polygons
+ * @param areas
+ * @param indices
+ * @param param3
+ */
+function triangulatePolygon(polygons, areas, indices, { startPosition, endPosition, coordLength }) {
+    const start = startPosition * coordLength;
+    const end = endPosition * coordLength;
+    // Extract positions and holes for just this polygon
+    const polygonPositions = polygons.positions.subarray(start, end);
+    // Holes are referenced relative to outer polygon
+    const offset = indices[0];
+    const holes = indices.slice(1).map((n) => (n - offset) / coordLength);
+    // Compute triangulation
+    const triangles = (0, polygon_1.earcut)(polygonPositions, holes, coordLength, areas);
+    // Indices returned by triangulation are relative to start
+    // of polygon, so we need to offset
+    for (let t = 0, tl = triangles.length; t < tl; ++t) {
+        polygons.triangles.push(startPosition + triangles[t]);
+    }
+}
+/**
+ * Wraps an object containing array into accessors
+ *
+ * @param obj
+ * @param size
+ */
+function wrapProps(obj, size) {
+    const returnObj = {};
+    for (const key in obj) {
+        returnObj[key] = { value: obj[key], size };
+    }
+    return returnObj;
+}
+/**
+ * Wrap each array in an accessor object with value and size keys
+ *
+ * @param points
+ * @param lines
+ * @param polygons
+ * @param coordLength
+ * @returns object
+ */
+function makeAccessorObjects(points, lines, polygons, coordLength) {
+    return {
+        points: {
+            ...points,
+            positions: { value: points.positions, size: coordLength },
+            globalFeatureIds: { value: points.globalFeatureIds, size: 1 },
+            featureIds: { value: points.featureIds, size: 1 },
+            numericProps: wrapProps(points.numericProps, 1)
+        },
+        lines: {
+            ...lines,
+            positions: { value: lines.positions, size: coordLength },
+            pathIndices: { value: lines.pathIndices, size: 1 },
+            globalFeatureIds: { value: lines.globalFeatureIds, size: 1 },
+            featureIds: { value: lines.featureIds, size: 1 },
+            numericProps: wrapProps(lines.numericProps, 1)
+        },
+        polygons: {
+            ...polygons,
+            positions: { value: polygons.positions, size: coordLength },
+            polygonIndices: { value: polygons.polygonIndices, size: 1 },
+            primitivePolygonIndices: { value: polygons.primitivePolygonIndices, size: 1 },
+            triangles: { value: new Uint32Array(polygons.triangles), size: 1 },
+            globalFeatureIds: { value: polygons.globalFeatureIds, size: 1 },
+            featureIds: { value: polygons.featureIds, size: 1 },
+            numericProps: wrapProps(polygons.numericProps, 1)
+        }
+    };
+}
+/**
+ * Add numeric properties to object
+ *
+ * @param object
+ * @param properties
+ * @param index
+ * @param length
+ */
+function fillNumericProperties(object, properties, index, length) {
+    for (const numericPropName in object.numericProps) {
+        if (numericPropName in properties) {
+            const value = properties[numericPropName];
+            object.numericProps[numericPropName].fill(value, index, index + length);
+        }
+    }
+}
+/**
+ * Keep string properties in object
+ *
+ * @param properties
+ * @param numericKeys
+ * @returns object
+ */
+function keepStringProperties(properties, numericKeys) {
+    const props = {};
+    for (const key in properties) {
+        if (!numericKeys.includes(key)) {
+            props[key] = properties[key];
+        }
+    }
+    return props;
+}
+/**
+ *
+ * Deduce correct array constructor to use for a given value
+ *
+ * @param x value to test
+ * @param constructor previous constructor deduced
+ * @returns PropArrayConstructor
+ */
+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-binary.d.ts

@@ -1,43 +1,19 @@
-import { Feature } from '@loaders.gl/schema';
+import type { Feature } from '@loaders.gl/schema';
 import type { BinaryFeatures } from '@loaders.gl/schema';
+/**
+ * Options for `geojsonToBinary`
+ */
 export declare type GeojsonToBinaryOptions = {
-    coordLength?: number;
+    fixRingWinding: boolean;
     numericPropKeys?: string[];
-    PositionDataType?: Function;
-};
-/** Convert GeoJSON features to flat binary arrays */
-export declare function geojsonToBinary(features: Feature[], options?: GeojsonToBinaryOptions): BinaryFeatures;
-export declare const TEST_EXPORTS: {
-    firstPass: typeof firstPass;
-    secondPass: typeof secondPass;
+    PositionDataType?: Float32ArrayConstructor | Float64ArrayConstructor;
 };
-declare type PropArrayConstructor = Float32ArrayConstructor | Float64ArrayConstructor | ArrayConstructor;
-declare type FirstPassData = {
-    coordLength: number;
-    numericPropKeys: string[];
-    propArrayTypes: {
-        [key: string]: PropArrayConstructor;
-    };
-    pointPositionsCount: number;
-    pointFeaturesCount: number;
-    linePositionsCount: number;
-    linePathsCount: number;
-    lineFeaturesCount: number;
-    polygonPositionsCount: number;
-    polygonObjectsCount: number;
-    polygonRingsCount: number;
-    polygonFeaturesCount: number;
-};
-/**
- *  Initial scan over GeoJSON features
- *  Counts number of coordinates of each geometry type and
- *  keeps track of the max coordinate dimensions
- */
-declare function firstPass(features: Feature[]): FirstPassData;
 /**
- * Second scan over GeoJSON features
- * Fills coordinates into pre-allocated typed arrays
+ * Convert GeoJSON features to flat binary arrays
+ *
+ * @param features
+ * @param options
+ * @returns features in binary format, grouped by geometry type
  */
-declare function secondPass(features: any, firstPassData: FirstPassData, options: Required<GeojsonToBinaryOptions>): BinaryFeatures;
-export {};
+export declare function geojsonToBinary(features: Feature[], options?: GeojsonToBinaryOptions): BinaryFeatures;
 //# sourceMappingURL=geojson-to-binary.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"geojson-to-binary.d.ts","sourceRoot":"","sources":["../../src/lib/geojson-to-binary.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAoB,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAEvD,oBAAY,sBAAsB,GAAG;IACnC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,gBAAgB,CAAC,EAAE,QAAQ,CAAC;CAC7B,CAAC;AAEF,qDAAqD;AACrD,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,GAAE,sBAA2B,GACnC,cAAc,CAOhB;AAED,eAAO,MAAM,YAAY;;;CAGxB,CAAC;AAEF,aAAK,oBAAoB,GAAG,uBAAuB,GAAG,uBAAuB,GAAG,gBAAgB,CAAC;AAEjG,aAAK,aAAa,GAAG;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,cAAc,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,oBAAoB,CAAA;KAAC,CAAC;IAEtD,mBAAmB,EAAE,MAAM,CAAC;IAC5B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,oBAAoB,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF;;;;GAIG;AAEH,iBAAS,SAAS,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,aAAa,CA2GrD;AAED;;;GAGG;AAEH,iBAAS,UAAU,CACjB,QAAQ,KAAA,EACR,aAAa,EAAE,aAAa,EAC5B,OAAO,EAAE,QAAQ,CAAC,sBAAsB,CAAC,kBAyI1C"}
+{"version":3,"file":"geojson-to-binary.d.ts","sourceRoot":"","sources":["../../src/lib/geojson-to-binary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,oBAAoB,CAAC;AAChD,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAMvD;;GAEG;AACH,oBAAY,sBAAsB,GAAG;IACnC,cAAc,EAAE,OAAO,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,gBAAgB,CAAC,EAAE,uBAAuB,GAAG,uBAAuB,CAAC;CACtE,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,GAAE,sBAA+C,GACvD,cAAc,CAShB"}