@loaders.gl/gis 3.4.11 → 3.4.12

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loaders.gl/gis",
   "description": "Helpers for GIS category data",
-  "version": "3.4.11",
+  "version": "3.4.12",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -24,8 +24,8 @@
     "README.md"
   ],
   "dependencies": {
-    "@loaders.gl/loader-utils": "3.4.11",
-    "@loaders.gl/schema": "3.4.11",
+    "@loaders.gl/loader-utils": "3.4.12",
+    "@loaders.gl/schema": "3.4.12",
     "@mapbox/vector-tile": "^1.3.1",
     "@math.gl/polygon": "^3.5.1",
     "pbf": "^3.2.1"
@@ -33,5 +33,5 @@
   "devDependencies": {
     "@math.gl/proj4": "^3.5.1"
   },
-  "gitHead": "2b8d490d2372e70dd89eef8f6b215a5205c16621"
+  "gitHead": "85254762ae3082f608a863291deef09f2b40c6cf"
 }

package/dist/bundle.js

@@ -1,5 +0,0 @@
-"use strict";
-// @ts-nocheck
-const moduleExports = require('./index');
-globalThis.loaders = globalThis.loaders || {};
-module.exports = Object.assign(globalThis.loaders, moduleExports);

package/dist/index.js

@@ -1,18 +0,0 @@
-"use strict";
-// Types from `@loaders.gl/schema`
-Object.defineProperty(exports, "__esModule", { value: true });
-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; } });
-Object.defineProperty(exports, "binaryToGeometry", { enumerable: true, get: function () { return binary_to_geojson_1.binaryToGeometry; } });
-var transform_1 = require("./lib/transform");
-Object.defineProperty(exports, "transformBinaryCoords", { enumerable: true, get: function () { return transform_1.transformBinaryCoords; } });
-Object.defineProperty(exports, "transformGeoJsonCoords", { enumerable: true, get: function () { return transform_1.transformGeoJsonCoords; } });

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

@@ -1,233 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.binaryToGeometry = exports.binaryToGeoJson = exports.binaryToGeojson = void 0;
-/**
- * Convert binary geometry representation to GeoJSON
- * @param data   geometry data in binary representation
- * @param options
- * @param options.type  Input data type: Point, LineString, or Polygon
- * @param options.featureId  Global feature id. If specified, only a single feature is extracted
- * @return GeoJSON objects
- */
-function binaryToGeojson(data, options) {
-    const globalFeatureId = options?.globalFeatureId;
-    if (globalFeatureId !== undefined) {
-        return getSingleFeature(data, globalFeatureId);
-    }
-    return parseFeatures(data, options?.type);
-}
-exports.binaryToGeojson = binaryToGeojson;
-/** @deprecated use `binaryToGeojson` or `binaryToGeometry` instead */
-function binaryToGeoJson(data, type, format = 'feature') {
-    switch (format) {
-        case 'feature':
-            return parseFeatures(data, type);
-        case 'geometry':
-            return binaryToGeometry(data);
-        default:
-            throw new Error(format);
-    }
-}
-exports.binaryToGeoJson = binaryToGeoJson;
-/**
- * Return a single feature from a binary geometry representation as GeoJSON
- * @param data   geometry data in binary representation
- * @return GeoJSON feature
- */
-function getSingleFeature(data, globalFeatureId) {
-    const dataArray = normalizeInput(data);
-    for (const data of dataArray) {
-        let lastIndex = 0;
-        let lastValue = data.featureIds.value[0];
-        // Scan through data until we find matching feature
-        for (let i = 0; i < data.featureIds.value.length; i++) {
-            const currValue = data.featureIds.value[i];
-            if (currValue === lastValue) {
-                // eslint-disable-next-line no-continue
-                continue;
-            }
-            if (globalFeatureId === data.globalFeatureIds.value[lastIndex]) {
-                return parseFeature(data, lastIndex, i);
-            }
-            lastIndex = i;
-            lastValue = currValue;
-        }
-        if (globalFeatureId === data.globalFeatureIds.value[lastIndex]) {
-            return parseFeature(data, lastIndex, data.featureIds.value.length);
-        }
-    }
-    throw new Error(`featureId:${globalFeatureId} not found`);
-}
-function parseFeatures(data, type) {
-    const dataArray = normalizeInput(data, type);
-    return parseFeatureCollection(dataArray);
-}
-/** Parse input binary data and return a valid GeoJSON geometry object */
-function binaryToGeometry(data, startIndex, endIndex) {
-    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 = data;
-            throw new Error(`Unsupported geometry type: ${unexpectedInput?.type}`);
-    }
-}
-exports.binaryToGeometry = binaryToGeometry;
-// Normalize features
-// Return an array of data objects, each of which have a type key
-function normalizeInput(data, type) {
-    const isHeterogeneousType = Boolean(data.points || data.lines || data.polygons);
-    if (!isHeterogeneousType) {
-        // @ts-expect-error This is a legacy check which allowed `data` to be an instance of the values
-        // here. Aka the new data.points, data.lines, or data.polygons.
-        data.type = type || parseType(data);
-        return [data];
-    }
-    const features = [];
-    if (data.points) {
-        data.points.type = 'Point';
-        features.push(data.points);
-    }
-    if (data.lines) {
-        data.lines.type = 'LineString';
-        features.push(data.lines);
-    }
-    if (data.polygons) {
-        data.polygons.type = 'Polygon';
-        features.push(data.polygons);
-    }
-    return features;
-}
-/** Parse input binary data and return an array of GeoJSON Features */
-function parseFeatureCollection(dataArray) {
-    const features = [];
-    for (const data of dataArray) {
-        if (data.featureIds.value.length === 0) {
-            // eslint-disable-next-line no-continue
-            continue;
-        }
-        let lastIndex = 0;
-        let lastValue = data.featureIds.value[0];
-        // Need to deduce start, end indices of each feature
-        for (let i = 0; i < data.featureIds.value.length; i++) {
-            const currValue = data.featureIds.value[i];
-            if (currValue === lastValue) {
-                // eslint-disable-next-line no-continue
-                continue;
-            }
-            features.push(parseFeature(data, lastIndex, i));
-            lastIndex = i;
-            lastValue = currValue;
-        }
-        // Last feature
-        features.push(parseFeature(data, lastIndex, data.featureIds.value.length));
-    }
-    return features;
-}
-/** Parse input binary data and return a single GeoJSON Feature */
-function parseFeature(data, startIndex, endIndex) {
-    const geometry = binaryToGeometry(data, startIndex, endIndex);
-    const properties = parseProperties(data, startIndex, endIndex);
-    const fields = parseFields(data, startIndex, endIndex);
-    return { type: 'Feature', geometry, properties, ...fields };
-}
-/** Parse input binary data and return an object of fields */
-function parseFields(data, startIndex = 0, endIndex) {
-    return data.fields && data.fields[data.featureIds.value[startIndex]];
-}
-/** Parse input binary data and return an object of properties */
-function parseProperties(data, startIndex = 0, endIndex) {
-    const properties = Object.assign({}, data.properties[data.featureIds.value[startIndex]]);
-    for (const key in data.numericProps) {
-        properties[key] = data.numericProps[key].value[startIndex];
-    }
-    return properties;
-}
-/** Parse binary data of type Polygon */
-function polygonToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
-    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 = [];
-        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 = [];
-    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);
-    }
-    return { type: 'MultiPolygon', coordinates };
-}
-/** Parse binary data of type LineString */
-function lineStringToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
-    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 = [];
-    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, startIndex, endIndex) {
-    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, startIndex, endIndex) {
-    startIndex = startIndex || 0;
-    endIndex = endIndex || positions.value.length / positions.size;
-    const ringCoordinates = [];
-    for (let j = startIndex; j < endIndex; j++) {
-        const coord = Array();
-        for (let k = j * positions.size; k < (j + 1) * positions.size; k++) {
-            coord.push(Number(positions.value[k]));
-        }
-        ringCoordinates.push(coord);
-    }
-    return ringCoordinates;
-}
-// Deduce geometry type of data object
-function parseType(data) {
-    if (data.pathIndices) {
-        return 'LineString';
-    }
-    if (data.polygonIndices) {
-        return 'Polygon';
-    }
-    return 'Point';
-}

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

@@ -1,96 +0,0 @@
-"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.js

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

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

@@ -1,385 +0,0 @@
-"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,
-        triangulate: options ? options.triangulate : true
-    });
-}
-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, triangulate = true } = 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),
-        globalFeatureIds: new GlobalFeatureIdsDataType(polygonPositionsCount),
-        featureIds: polygonFeaturesCount > 65535
-            ? new Uint32Array(polygonPositionsCount)
-            : new Uint16Array(polygonPositionsCount),
-        numericProps: {},
-        properties: [],
-        fields: []
-    };
-    if (triangulate) {
-        polygons.triangles = [];
-    }
-    // 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 }) {
-    if (!polygons.triangles) {
-        return;
-    }
-    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
-    // @ts-expect-error TODO can earcut handle binary arrays? Add tests?
-    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) {
-    const binaryFeatures = {
-        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 },
-            globalFeatureIds: { value: polygons.globalFeatureIds, size: 1 },
-            featureIds: { value: polygons.featureIds, size: 1 },
-            numericProps: wrapProps(polygons.numericProps, 1)
-        }
-    };
-    if (polygons.triangles) {
-        binaryFeatures.polygons.triangles = { value: new Uint32Array(polygons.triangles), size: 1 };
-    }
-    return binaryFeatures;
-}
-/**
- * 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.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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, triangulate: 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,
-        triangulate: options.triangulate
-    });
-}
-exports.geojsonToBinary = geojsonToBinary;

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

@@ -1,128 +0,0 @@
-"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/dist/lib/transform.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformGeoJsonCoords = exports.transformBinaryCoords = void 0;
-/**
- * Apply transformation to every coordinate of binary features
- * @param  binaryFeatures binary features
- * @param  transformCoordinate Function to call on each coordinate
- * @return Transformed binary features
- */
-function transformBinaryCoords(binaryFeatures, transformCoordinate) {
-    if (binaryFeatures.points) {
-        transformBinaryGeometryPositions(binaryFeatures.points, transformCoordinate);
-    }
-    if (binaryFeatures.lines) {
-        transformBinaryGeometryPositions(binaryFeatures.lines, transformCoordinate);
-    }
-    if (binaryFeatures.polygons) {
-        transformBinaryGeometryPositions(binaryFeatures.polygons, transformCoordinate);
-    }
-    return binaryFeatures;
-}
-exports.transformBinaryCoords = transformBinaryCoords;
-/** Transform one binary geometry */
-function transformBinaryGeometryPositions(binaryGeometry, fn) {
-    const { positions } = binaryGeometry;
-    for (let i = 0; i < positions.value.length; i += positions.size) {
-        // @ts-ignore inclusion of bigint causes problems
-        const coord = Array.from(positions.value.subarray(i, i + positions.size));
-        const transformedCoord = fn(coord);
-        // @ts-ignore typescript typing for .set seems to require bigint?
-        positions.value.set(transformedCoord, i);
-    }
-}
-/**
- * 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
- */
-function transformGeoJsonCoords(features, fn) {
-    for (const feature of features) {
-        // @ts-ignore
-        feature.geometry.coordinates = coordMap(feature.geometry.coordinates, fn);
-    }
-    return features;
-}
-exports.transformGeoJsonCoords = transformGeoJsonCoords;
-function coordMap(array, fn) {
-    if (isCoord(array)) {
-        return fn(array);
-    }
-    return array.map((item) => {
-        return coordMap(item, fn);
-    });
-}
-function isCoord(array) {
-    return Number.isFinite(array[0]) && Number.isFinite(array[1]);
-}