@loaders.gl/gis 4.0.0-alpha.23 → 4.0.0-alpha.25

package/src/lib/flat-geojson-to-binary.ts

@@ -2,8 +2,8 @@
 import {earcut} from '@math.gl/polygon';
 import type {
   BinaryAttribute,
-  BinaryFeatures,
-  BinaryPolygonFeatures,
+  BinaryFeatureCollection,
+  BinaryPolygonFeature,
   FlatFeature,
   FlatPoint,
   FlatLineString,
@@ -485,8 +485,8 @@ function makeAccessorObjects(
   lines: Lines,
   polygons: Polygons,
   coordLength: number
-): BinaryFeatures {
-  const binaryFeatures = {
+): BinaryFeatureCollection {
+  const binaryFeatures: BinaryFeatureCollection = {
     points: {
       ...points,
       positions: {value: points.positions, size: coordLength},
@@ -510,10 +510,10 @@ function makeAccessorObjects(
       globalFeatureIds: {value: polygons.globalFeatureIds, size: 1},
       featureIds: {value: polygons.featureIds, size: 1},
       numericProps: wrapProps(polygons.numericProps, 1)
-    } as BinaryPolygonFeatures
+    } as BinaryPolygonFeature // triangles not expected
   };
 
-  if (polygons.triangles) {
+  if (binaryFeatures.polygons && polygons.triangles) {
     binaryFeatures.polygons.triangles = {value: new Uint32Array(polygons.triangles), size: 1};
   }
 

package/src/lib/geojson-to-binary.ts

@@ -1,5 +1,5 @@
 import type {Feature} from '@loaders.gl/schema';
-import type {BinaryFeatures} from '@loaders.gl/schema';
+import type {BinaryFeatureCollection} from '@loaders.gl/schema';
 
 import {extractGeometryInfo} from './extract-geometry-info';
 import {geojsonToFlatGeojson} from './geojson-to-flat-geojson';
@@ -25,7 +25,7 @@ export type GeojsonToBinaryOptions = {
 export function geojsonToBinary(
   features: Feature[],
   options: GeojsonToBinaryOptions = {fixRingWinding: true, triangulate: true}
-): BinaryFeatures {
+): BinaryFeatureCollection {
   const geometryInfo = extractGeometryInfo(features);
   const coordLength = geometryInfo.coordLength;
   const {fixRingWinding} = options;

package/src/lib/transform.ts

@@ -1,4 +1,4 @@
-import type {BinaryFeatures, BinaryGeometry, Feature} from '@loaders.gl/schema';
+import type {BinaryFeatureCollection, BinaryGeometry, Feature} from '@loaders.gl/schema';
 
 type TransformCoordinate = (coord: number[]) => number[];
 
@@ -9,9 +9,9 @@ type TransformCoordinate = (coord: number[]) => number[];
  * @return Transformed binary features
  */
 export function transformBinaryCoords(
-  binaryFeatures: BinaryFeatures,
+  binaryFeatures: BinaryFeatureCollection,
   transformCoordinate: TransformCoordinate
-): BinaryFeatures {
+): BinaryFeatureCollection {
   if (binaryFeatures.points) {
     transformBinaryGeometryPositions(binaryFeatures.points, transformCoordinate);
   }

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 });