@loaders.gl/mvt 3.1.0 → 3.1.4

package/dist/mvt-worker.js

@@ -1525,12 +1525,14 @@
 
   // src/helpers/binary-util-functions.ts
   function classifyRings2(geom) {
-    const len = geom.lines.length;
+    const len = geom.indices.length;
+    const type = "Polygon";
     if (len <= 1) {
       return {
+        type,
         data: geom.data,
         areas: [[getPolygonSignedArea(geom.data)]],
-        lines: [geom.lines]
+        indices: [geom.indices]
       };
     }
     const areas = [];
@@ -1540,8 +1542,8 @@
     let ccw;
     let offset = 0;
     for (let endIndex, i2 = 0, startIndex; i2 < len; i2++) {
-      startIndex = geom.lines[i2] - offset;
-      endIndex = geom.lines[i2 + 1] - offset || geom.data.length;
+      startIndex = geom.indices[i2] - offset;
+      endIndex = geom.indices[i2 + 1] - offset || geom.data.length;
       const shape = geom.data.slice(startIndex, endIndex);
       const area2 = getPolygonSignedArea(shape);
       if (area2 === 0) {
@@ -1569,7 +1571,7 @@
       areas.push(ringAreas);
     if (polygon.length)
       polygons.push(polygon);
-    return { areas, lines: polygons, data: geom.data };
+    return { type, areas, indices: polygons, data: geom.data };
   }
   function project(data, x0, y0, size) {
     for (let j = 0, jl = data.length; j < jl; j += 2) {
@@ -1608,10 +1610,7 @@
   var y;
   var i;
   var VectorTileFeature2 = class {
-    static get types() {
-      return ["Unknown", "Point", "LineString", "Polygon"];
-    }
-    constructor(pbf, end, extent, keys, values, firstPassData) {
+    constructor(pbf, end, extent, keys, values, geometryInfo) {
       this.properties = {};
       this.extent = extent;
       this.type = 0;
@@ -1620,7 +1619,7 @@
       this._geometry = -1;
       this._keys = keys;
       this._values = values;
-      this._firstPassData = firstPassData;
+      this._geometryInfo = geometryInfo;
       pbf.readFields(readFeature2, this, end);
     }
     loadGeometry() {
@@ -1632,7 +1631,7 @@
       x = 0;
       y = 0;
       i = 0;
-      const lines = [];
+      const indices = [];
       const data = [];
       while (pbf.pos < endPos) {
         if (length <= 0) {
@@ -1645,13 +1644,13 @@
           x += pbf.readSVarint();
           y += pbf.readSVarint();
           if (cmd === 1) {
-            lines.push(i);
+            indices.push(i);
           }
           data.push(x, y);
           i += 2;
         } else if (cmd === 7) {
           if (i > 0) {
-            const start = lines[lines.length - 1];
+            const start = indices[indices.length - 1];
             data.push(data[start], data[start + 1]);
             i += 2;
           }
@@ -1659,42 +1658,38 @@
           throw new Error(`unknown command ${cmd}`);
         }
       }
-      return { data, lines };
+      return { data, indices };
     }
     _toBinaryCoordinates(transform) {
-      let geom = this.loadGeometry();
+      const geom = this.loadGeometry();
+      let geometry;
       transform(geom.data, this);
       const coordLength = 2;
       switch (this.type) {
         case 1:
-          this._firstPassData.pointFeaturesCount++;
-          this._firstPassData.pointPositionsCount += geom.lines.length;
+          this._geometryInfo.pointFeaturesCount++;
+          this._geometryInfo.pointPositionsCount += geom.indices.length;
+          geometry = { type: "Point", ...geom };
           break;
         case 2:
-          this._firstPassData.lineFeaturesCount++;
-          this._firstPassData.linePathsCount += geom.lines.length;
-          this._firstPassData.linePositionsCount += geom.data.length / coordLength;
+          this._geometryInfo.lineFeaturesCount++;
+          this._geometryInfo.linePathsCount += geom.indices.length;
+          this._geometryInfo.linePositionsCount += geom.data.length / coordLength;
+          geometry = { type: "LineString", ...geom };
           break;
         case 3:
-          const classified = classifyRings2(geom);
-          this._firstPassData.polygonFeaturesCount++;
-          this._firstPassData.polygonObjectsCount += classified.lines.length;
-          for (const lines of classified.lines) {
-            this._firstPassData.polygonRingsCount += lines.length;
+          geometry = classifyRings2(geom);
+          this._geometryInfo.polygonFeaturesCount++;
+          this._geometryInfo.polygonObjectsCount += geometry.indices.length;
+          for (const indices of geometry.indices) {
+            this._geometryInfo.polygonRingsCount += indices.length;
           }
-          this._firstPassData.polygonPositionsCount += classified.data.length / coordLength;
-          geom = classified;
+          this._geometryInfo.polygonPositionsCount += geometry.data.length / coordLength;
           break;
+        default:
+          throw new Error(`Invalid geometry type: ${this.type}`);
       }
-      geom.type = VectorTileFeature2.types[this.type];
-      if (geom.lines.length > 1) {
-        geom.type = `Multi${geom.type}`;
-      }
-      const result = {
-        type: "Feature",
-        geometry: geom,
-        properties: this.properties
-      };
+      const result = { type: "Feature", geometry, properties: this.properties };
       if (this.id !== null) {
         result.id = this.id;
       }
@@ -1722,13 +1717,13 @@
       pbf.readFields(readLayer2, this, end);
       this.length = this._features.length;
     }
-    feature(i2, firstPassData) {
+    feature(i2, geometryInfo) {
       if (i2 < 0 || i2 >= this._features.length) {
         throw new Error("feature index out of bounds");
       }
       this._pbf.pos = this._features[i2];
       const end = this._pbf.readVarint() + this._pbf.pos;
-      return new VectorTileFeature2(this._pbf, end, this.extent, this._keys, this._values, firstPassData);
+      return new VectorTileFeature2(this._pbf, end, this.extent, this._keys, this._values, geometryInfo);
     }
   };
   function readLayer2(tag, layer, pbf) {
@@ -1774,13 +1769,15 @@
     }
   }
 
-  // src/lib/binary-vector-tile/features-to-binary.ts
-  function featuresToBinary(features, firstPassData, options) {
+  // ../gis/src/lib/flat-geojson-to-binary.ts
+  function flatGeojsonToBinary(features, geometryInfo, options) {
     const propArrayTypes = extractNumericPropTypes(features);
     const numericPropKeys = Object.keys(propArrayTypes).filter((k) => propArrayTypes[k] !== Array);
-    return fillArrays(features, firstPassData, {
-      numericPropKeys: options ? options.numericPropKeys : numericPropKeys,
+    return fillArrays(features, {
       propArrayTypes,
+      ...geometryInfo
+    }, {
+      numericPropKeys: options && options.numericPropKeys || numericPropKeys,
       PositionDataType: options ? options.PositionDataType : Float32Array
     });
   }
@@ -1796,7 +1793,7 @@
     }
     return propArrayTypes;
   }
-  function fillArrays(features, firstPassData, options) {
+  function fillArrays(features, geometryInfo, options) {
     const {
       pointPositionsCount,
       pointFeaturesCount,
@@ -1806,13 +1803,15 @@
       polygonPositionsCount,
       polygonObjectsCount,
       polygonRingsCount,
-      polygonFeaturesCount
-    } = firstPassData;
-    const { numericPropKeys, propArrayTypes, PositionDataType = Float32Array } = options;
+      polygonFeaturesCount,
+      propArrayTypes,
+      coordLength
+    } = geometryInfo;
+    const { numericPropKeys = [], PositionDataType = Float32Array } = options;
     const hasGlobalId = features[0] && "id" in features[0];
-    const coordLength = 2;
     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),
@@ -1821,6 +1820,7 @@
       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),
@@ -1830,6 +1830,7 @@
       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),
@@ -1842,8 +1843,8 @@
     };
     for (const object of [points, lines, polygons]) {
       for (const propName of numericPropKeys) {
-        const TypedArray = propArrayTypes[propName];
-        object.numericProps[propName] = new TypedArray(object.positions.length / coordLength);
+        const T = propArrayTypes[propName];
+        object.numericProps[propName] = new T(object.positions.length / coordLength);
       }
     }
     lines.pathIndices[linePathsCount] = linePositionsCount;
@@ -1866,7 +1867,6 @@
       const properties = feature.properties || {};
       switch (geometry.type) {
         case "Point":
-        case "MultiPoint":
           handlePoint(geometry, points, indexMap, coordLength, properties);
           points.properties.push(keepStringProperties(properties, numericPropKeys));
           if (hasGlobalId) {
@@ -1875,7 +1875,6 @@
           indexMap.pointFeature++;
           break;
         case "LineString":
-        case "MultiLineString":
           handleLineString(geometry, lines, indexMap, coordLength, properties);
           lines.properties.push(keepStringProperties(properties, numericPropKeys));
           if (hasGlobalId) {
@@ -1884,7 +1883,6 @@
           indexMap.lineFeature++;
           break;
         case "Polygon":
-        case "MultiPolygon":
           handlePolygon(geometry, polygons, indexMap, coordLength, properties);
           polygons.properties.push(keepStringProperties(properties, numericPropKeys));
           if (hasGlobalId) {
@@ -1913,9 +1911,9 @@
     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 i2 = 0, il = geometry.lines.length; i2 < il; ++i2) {
-      const start = geometry.lines[i2];
-      const end = i2 === il - 1 ? geometry.data.length : geometry.lines[i2 + 1];
+    for (let i2 = 0, il = geometry.indices.length; i2 < il; ++i2) {
+      const start = geometry.indices[i2];
+      const end = i2 === il - 1 ? geometry.data.length : geometry.indices[i2 + 1];
       lines.pathIndices[indexMap.linePath++] = indexMap.linePosition;
       indexMap.linePosition += (end - start) / coordLength;
     }
@@ -1926,23 +1924,23 @@
     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);
-    for (let l = 0, ll = geometry.lines.length; l < ll; ++l) {
+    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 lines = geometry.lines[l];
-      const nextLines = geometry.lines[l + 1];
-      for (let i2 = 0, il = lines.length; i2 < il; ++i2) {
-        const start = lines[i2];
-        const end = i2 === il - 1 ? nextLines === void 0 ? geometry.data.length : nextLines[0] : lines[i2 + 1];
+      const indices = geometry.indices[l];
+      const nextIndices = geometry.indices[l + 1];
+      for (let i2 = 0, il = indices.length; i2 < il; ++i2) {
+        const start = indices[i2];
+        const end = i2 === il - 1 ? nextIndices === void 0 ? geometry.data.length : nextIndices[0] : indices[i2 + 1];
         polygons.primitivePolygonIndices[indexMap.polygonRing++] = indexMap.polygonPosition;
         indexMap.polygonPosition += (end - start) / coordLength;
       }
       const endPosition = indexMap.polygonPosition;
-      triangulatePolygon(polygons, areas, lines, { startPosition, endPosition, coordLength });
+      triangulatePolygon(polygons, areas, indices, { startPosition, endPosition, coordLength });
     }
   }
-  function triangulatePolygon(polygons, areas, lines, {
+  function triangulatePolygon(polygons, areas, indices, {
     startPosition,
     endPosition,
     coordLength
@@ -1950,52 +1948,54 @@
     const start = startPosition * coordLength;
     const end = endPosition * coordLength;
     const polygonPositions = polygons.positions.subarray(start, end);
-    const offset = lines[0];
-    const holes = lines.slice(1).map((n) => (n - offset) / coordLength);
-    const indices = earcut(polygonPositions, holes, coordLength, areas);
-    for (let t = 0, tl = indices.length; t < tl; ++t) {
-      polygons.triangles.push(startPosition + indices[t]);
+    const offset = indices[0];
+    const holes = indices.slice(1).map((n) => (n - offset) / coordLength);
+    const triangles = earcut(polygonPositions, holes, coordLength, areas);
+    for (let t = 0, tl = triangles.length; t < tl; ++t) {
+      polygons.triangles.push(startPosition + triangles[t]);
     }
   }
+  function wrapProps(obj, size) {
+    const returnObj = {};
+    for (const key in obj) {
+      returnObj[key] = { value: obj[key], size };
+    }
+    return returnObj;
+  }
   function makeAccessorObjects(points, lines, polygons, coordLength) {
-    const returnObj = {
+    return {
       points: {
         ...points,
         positions: { value: points.positions, size: coordLength },
         globalFeatureIds: { value: points.globalFeatureIds, size: 1 },
-        featureIds: { value: points.featureIds, size: 1 }
+        featureIds: { value: points.featureIds, size: 1 },
+        numericProps: wrapProps(points.numericProps, 1)
       },
       lines: {
         ...lines,
-        pathIndices: { value: lines.pathIndices, size: 1 },
         positions: { value: lines.positions, size: coordLength },
+        pathIndices: { value: lines.pathIndices, size: 1 },
         globalFeatureIds: { value: lines.globalFeatureIds, size: 1 },
-        featureIds: { value: lines.featureIds, 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 },
-        positions: { value: polygons.positions, size: coordLength },
         triangles: { value: new Uint32Array(polygons.triangles), size: 1 },
         globalFeatureIds: { value: polygons.globalFeatureIds, size: 1 },
-        featureIds: { value: polygons.featureIds, size: 1 }
+        featureIds: { value: polygons.featureIds, size: 1 },
+        numericProps: wrapProps(polygons.numericProps, 1)
       }
     };
-    for (const geomType in returnObj) {
-      for (const numericProp in returnObj[geomType].numericProps) {
-        returnObj[geomType].numericProps[numericProp] = {
-          value: returnObj[geomType].numericProps[numericProp],
-          size: 1
-        };
-      }
-    }
-    return returnObj;
   }
   function fillNumericProperties(object, properties, index, length2) {
     for (const numericPropName in object.numericProps) {
       if (numericPropName in properties) {
-        object.numericProps[numericPropName].fill(properties[numericPropName], index, index + length2);
+        const value = properties[numericPropName];
+        object.numericProps[numericPropName].fill(value, index, index + length2);
       }
     }
   }
@@ -2022,7 +2022,8 @@
     const features = [];
     if (options) {
       const binary = options.gis.format === "binary";
-      const firstPassData = {
+      const geometryInfo = {
+        coordLength: 2,
         pointPositionsCount: 0,
         pointFeaturesCount: 0,
         linePositionsCount: 0,
@@ -2044,14 +2045,14 @@
             return;
           }
           for (let i2 = 0; i2 < vectorTileLayer.length; i2++) {
-            const vectorTileFeature = vectorTileLayer.feature(i2, firstPassData);
+            const vectorTileFeature = vectorTileLayer.feature(i2, geometryInfo);
             const decodedFeature = binary ? getDecodedFeatureBinary(vectorTileFeature, featureOptions) : getDecodedFeature(vectorTileFeature, featureOptions);
             features.push(decodedFeature);
           }
         });
       }
       if (binary) {
-        const data = featuresToBinary(features, firstPassData);
+        const data = flatGeojsonToBinary(features, geometryInfo);
         data.byteLength = arrayBuffer.byteLength;
         return data;
       }
@@ -2083,7 +2084,7 @@
   }
   function getDecodedFeatureBinary(feature, options) {
     const decodedFeature = feature.toBinaryCoordinates(options.coordinates === "wgs84" ? options.tileIndex : transformToLocalCoordinatesBinary);
-    if (options.layerProperty) {
+    if (options.layerProperty && decodedFeature.properties) {
       decodedFeature.properties[options.layerProperty] = options.layerName;
     }
     return decodedFeature;
@@ -2104,7 +2105,7 @@
   }
 
   // src/mvt-loader.ts
-  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION = true ? "3.1.4" : "latest";
   var MVTWorkerLoader = {
     name: "Mapbox Vector Tile",
     id: "mvt",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loaders.gl/mvt",
   "description": "Loader for Mapbox Vector Tiles",
-  "version": "3.1.0",
+  "version": "3.1.4",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -28,17 +28,18 @@
   ],
   "scripts": {
     "pre-build": "npm run build-worker && npm run build-worker --env.dev && npm run build-bundle",
-    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/bundle.js",
-    "build-worker": "esbuild src/workers/mvt-worker.ts --bundle --outfile=dist/mvt-worker.js"
+    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/dist.min.js",
+    "build-worker": "esbuild src/workers/mvt-worker.ts --bundle --outfile=dist/mvt-worker.js --define:__VERSION__=\\\"$npm_package_version\\\""
   },
   "dependencies": {
-    "@loaders.gl/gis": "3.1.0",
-    "@loaders.gl/loader-utils": "3.1.0",
+    "@loaders.gl/gis": "3.1.4",
+    "@loaders.gl/loader-utils": "3.1.4",
+    "@loaders.gl/schema": "3.1.4",
     "@math.gl/polygon": "^3.5.1",
     "pbf": "^3.2.1"
   },
   "devDependencies": {
     "@types/pbf": "^3.0.2"
   },
-  "gitHead": "b02a011b5a6d6aa6c5870819045c70db168cb930"
+  "gitHead": "4d27d3ac6023e53b562dcad83b9254b198e81ee5"
 }

package/src/helpers/binary-util-functions.ts

@@ -1,6 +1,6 @@
 import Protobuf from 'pbf';
 import {getPolygonSignedArea} from '@math.gl/polygon';
-import {MvtBinaryGeometry} from '../lib/types';
+import {FlatIndexedGeometry, FlatPolygon} from '@loaders.gl/schema';
 import VectorTileFeature from '../lib/binary-vector-tile/vector-tile-feature';
 
 /**
@@ -13,14 +13,16 @@ import VectorTileFeature from '../lib/binary-vector-tile/vector-tile-feature';
  * @returns object
  */
 // eslint-disable-next-line max-statements
-export function classifyRings(geom: MvtBinaryGeometry) {
-  const len = geom.lines.length;
+export function classifyRings(geom: FlatIndexedGeometry): FlatPolygon {
+  const len = geom.indices.length;
+  const type = 'Polygon';
 
   if (len <= 1) {
     return {
+      type,
       data: geom.data,
       areas: [[getPolygonSignedArea(geom.data)]],
-      lines: [geom.lines]
+      indices: [geom.indices]
     };
   }
 
@@ -32,9 +34,9 @@ export function classifyRings(geom: MvtBinaryGeometry) {
   let offset = 0;
 
   for (let endIndex: number, i = 0, startIndex: number; i < len; i++) {
-    startIndex = geom.lines[i] - offset;
+    startIndex = geom.indices[i] - offset;
 
-    endIndex = geom.lines[i + 1] - offset || geom.data.length;
+    endIndex = geom.indices[i + 1] - offset || geom.data.length;
     const shape = geom.data.slice(startIndex, endIndex);
     const area = getPolygonSignedArea(shape);
 
@@ -70,7 +72,7 @@ export function classifyRings(geom: MvtBinaryGeometry) {
   if (ringAreas) areas.push(ringAreas);
   if (polygon.length) polygons.push(polygon);
 
-  return {areas, lines: polygons, data: geom.data};
+  return {type, areas, indices: polygons, data: geom.data};
 }
 
 /**