@loaders.gl/gis 4.0.0-alpha.4 → 4.0.0-alpha.6

package/dist/lib/transform.js

@@ -1,50 +1,59 @@
-export 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;
+"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) {
-    const coord = Array.from(positions.value.subarray(i, i + positions.size));
-    const transformedCoord = fn(coord);
-    positions.value.set(transformedCoord, i);
-  }
+    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);
+    }
 }
-
-export function transformGeoJsonCoords(features, fn) {
-  for (const feature of features) {
-    feature.geometry.coordinates = coordMap(feature.geometry.coordinates, fn);
-  }
-
-  return features;
+/**
+ * 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);
-  });
+    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]);
+    return Number.isFinite(array[0]) && Number.isFinite(array[1]);
 }
-//# sourceMappingURL=transform.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loaders.gl/gis",
   "description": "Helpers for GIS category data",
-  "version": "4.0.0-alpha.4",
+  "version": "4.0.0-alpha.6",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -14,9 +14,9 @@
     "geometry",
     "GeoJSON"
   ],
-  "types": "src/index.ts",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "main": "dist/es5/index.js",
+  "module": "dist/esm/index.js",
   "sideEffects": false,
   "files": [
     "src",
@@ -24,13 +24,14 @@
     "README.md"
   ],
   "dependencies": {
-    "@loaders.gl/loader-utils": "4.0.0-alpha.4",
-    "@loaders.gl/schema": "4.0.0-alpha.4",
+    "@loaders.gl/loader-utils": "4.0.0-alpha.6",
+    "@loaders.gl/schema": "4.0.0-alpha.6",
     "@mapbox/vector-tile": "^1.3.1",
+    "@math.gl/polygon": "^3.5.1",
     "pbf": "^3.2.1"
   },
   "devDependencies": {
     "@math.gl/proj4": "^3.5.1"
   },
-  "gitHead": "53026061b3c8871f7e96d3a5826125cc6613bddc"
+  "gitHead": "acc1985050dfaa0f1f0c066f8da5bce7454a046c"
 }

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

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

@@ -0,0 +1,58 @@
+import type {TypedArray} from '@loaders.gl/schema';
+
+/**
+ * Permissable constructor for numeric props
+ */
+export type PropArrayConstructor =
+  | Float32ArrayConstructor
+  | Float64ArrayConstructor
+  | ArrayConstructor;
+
+/**
+ * Collection type for holding intermediate binary data before conversion to `BinaryPointGeometry`
+ */
+export 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 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 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;
+  }[];
+};