@mapwhit/tilerenderer 1.3.0 → 1.4.0

package/src/source/geojson_tiler.js

@@ -0,0 +1,89 @@
+import rewind from '@mapwhit/geojson-rewind';
+import geojsonvt from 'geojson-vt';
+import Supercluster from 'supercluster';
+import FeatureIndex from '../data/feature_index.js';
+import GeoJSONWrapper from './geojson_wrapper.js';
+import { makeSingleSourceLayerWorkerTile as makeWorkerTile } from './worker_tile.js';
+
+/**
+ * Creates tiles from GeoJSON data.
+ */
+export default function makeTiler(resources, layerIndex) {
+  let geoJSONIndex;
+  let createGeoJSONIndex;
+
+  /**
+   * Fetches (if appropriate), parses, and index geojson data into tiles. This
+   * preparatory method must be called before {@link GeoJSONWorkerSource#loadTile}
+   * can correctly serve up tiles.
+   *
+   * Defers to {@link GeoJSONWorkerSource#loadGeoJSON} for the fetching/parsing,
+   * expecting `callback(error, data)` to be called with either an error or a
+   * parsed GeoJSON object.
+   *
+   * @param params
+   */
+  function loadData(params) {
+    const { cluster, data, geojsonVtOptions, superclusterOptions } = params;
+    geoJSONIndex = undefined;
+    createGeoJSONIndex = cluster
+      ? () => {
+          rewind(data, true);
+          return new Supercluster(superclusterOptions).load(data.features);
+        }
+      : () => {
+          rewind(data, true);
+          return geojsonvt(data, geojsonVtOptions);
+        };
+  }
+
+  function getTile(tileID) {
+    if (!geoJSONIndex) {
+      if (!createGeoJSONIndex) {
+        return; // we couldn't load the file
+      }
+
+      try {
+        geoJSONIndex = createGeoJSONIndex();
+      } finally {
+        createGeoJSONIndex = undefined;
+      }
+    }
+    const { z, x, y } = tileID.canonical;
+    return geoJSONIndex.getTile(z, x, y);
+  }
+
+  /**
+   * Returns a single tile.
+   */
+  async function loadTile(params) {
+    const { tileID, source, promoteId } = params;
+    const geoJSONTile = getTile(tileID);
+    if (!geoJSONTile) {
+      return; // nothing in the given tile
+    }
+    const sourceLayer = new GeoJSONWrapper(geoJSONTile.features);
+    const layerFamilies = layerIndex.familiesBySource.get(source);
+    if (!layerFamilies) {
+      return;
+    }
+    params.featureIndex = new FeatureIndex(tileID, promoteId);
+    const { name } = sourceLayer;
+    const features = new Array(sourceLayer.length);
+    for (let index = 0; index < sourceLayer.length; index++) {
+      const feature = sourceLayer.feature(index);
+      const id = params.featureIndex.getId(feature, name);
+      features[index] = { feature, id, index, sourceLayerIndex: 0 };
+    }
+
+    const result = await makeWorkerTile(params, features, layerFamilies.get(name), resources);
+
+    result.vectorTile = sourceLayer;
+    return result;
+  }
+
+  return {
+    loadData,
+    loadTile
+  };
+}

package/src/source/source.js

@@ -25,6 +25,7 @@ import { bindAll } from '../util/object.js';
  */
 
 import geojson from './geojson_source.js';
+import geojsonTiler from './geojson_tiler.js';
 import image from './image_source.js';
 import rasterDem from './raster_dem_tile_source.js';
 import raster from './raster_tile_source.js';
@@ -38,6 +39,9 @@ const sourceTypes = {
   image
 };
 
+const tilerTypes = {
+  geojson: geojsonTiler
+};
 /*
  * Creates a tiled data source instance given an options object.
  *
@@ -48,11 +52,18 @@ const sourceTypes = {
  * @returns {Source}
  */
 export function create(id, specification, eventedParent, { resources, layerIndex, showTileBoundaries }) {
-  const source = new sourceTypes[specification.type](id, specification, eventedParent, {
-    resources,
-    layerIndex,
-    showTileBoundaries
-  });
+  const tiler = tilerTypes[specification.type]?.(resources, layerIndex);
+
+  const source = new sourceTypes[specification.type](
+    id,
+    specification,
+    eventedParent,
+    tiler ?? {
+      resources,
+      layerIndex,
+      showTileBoundaries
+    }
+  );
 
   bindAll(['load', 'abort', 'unload', 'serialize', 'prepare'], source);
   return source;

package/src/source/source_cache.js

@@ -799,27 +799,27 @@ class SourceCache extends Evented {
    * Set the value of a particular state for a feature
    * @private
    */
-  setFeatureState(sourceLayer, feature, state) {
+  setFeatureState(sourceLayer, featureId, state) {
     sourceLayer = sourceLayer || '_geojsonTileLayer';
-    this._state.updateState(sourceLayer, feature, state);
+    this._state.updateState(sourceLayer, featureId, state);
   }
 
   /**
    * Resets the value of a particular state key for a feature
    * @private
    */
-  removeFeatureState(sourceLayer, feature, key) {
+  removeFeatureState(sourceLayer, featureId, key) {
     sourceLayer = sourceLayer || '_geojsonTileLayer';
-    this._state.removeFeatureState(sourceLayer, feature, key);
+    this._state.removeFeatureState(sourceLayer, featureId, key);
   }
 
   /**
    * Get the entire state object for a feature
    * @private
    */
-  getFeatureState(sourceLayer, feature) {
+  getFeatureState(sourceLayer, featureId) {
     sourceLayer = sourceLayer || '_geojsonTileLayer';
-    return this._state.getState(sourceLayer, feature);
+    return this._state.getState(sourceLayer, featureId);
   }
 }
 

package/src/source/source_state.js

@@ -13,7 +13,8 @@ class SourceFeatureState {
   #stateChanges = {};
   #deletedStates = {};
 
-  updateState(sourceLayer, feature, newState) {
+  updateState(sourceLayer, featureId, newState) {
+    const feature = String(featureId);
     const changes = (this.#stateChanges[sourceLayer] ??= {});
     const featureState = (changes[feature] ??= {});
     Object.assign(featureState, newState);
@@ -76,7 +77,8 @@ class SourceFeatureState {
     }
   }
 
-  getState(sourceLayer, feature) {
+  getState(sourceLayer, featureId) {
+    const feature = String(featureId);
     const base = this.#state[sourceLayer];
     const changes = this.#stateChanges[sourceLayer];
     const reconciledState = Object.assign({}, base?.[feature], changes?.[feature]);

package/src/source/tile.js

@@ -191,11 +191,12 @@ class Tile {
   }
 
   querySourceFeatures(result, params) {
-    if (!this.latestFeatureIndex?.vectorTile) {
+    const featureIndex = this.latestFeatureIndex;
+    if (!featureIndex?.vectorTile) {
       return;
     }
 
-    const vtLayers = this.latestFeatureIndex.loadVTLayers();
+    const vtLayers = featureIndex.loadVTLayers();
 
     const sourceLayer = params ? params.sourceLayer : '';
     const layer = vtLayers._geojsonTileLayer || vtLayers[sourceLayer];
@@ -211,7 +212,8 @@ class Tile {
     for (let i = 0; i < layer.length; i++) {
       const feature = layer.feature(i);
       if (filter(new EvaluationParameters(this.tileID.overscaledZ), feature)) {
-        const geojsonFeature = new GeoJSONFeature(feature, z, x, y);
+        const id = featureIndex.getId(feature, sourceLayer);
+        const geojsonFeature = new GeoJSONFeature(feature, z, x, y, id);
         geojsonFeature.tile = coord;
         result.push(geojsonFeature);
       }

package/src/source/vector_tile_source.js

@@ -22,6 +22,7 @@ class VectorTileSource extends Evented {
     this.url = options.url;
     this.scheme = options.scheme ?? 'xyz';
     this.tileSize = options.tileSize ?? 512;
+    this.promoteId = options.promoteId;
 
     if (this.tileSize !== 512) {
       throw new Error('vector tile sources must have a tileSize of 512');
@@ -93,6 +94,7 @@ class VectorTileSource extends Evented {
         source: this.id,
         pixelRatio: browser.devicePixelRatio,
         showCollisionBoxes: this.map.showCollisionBoxes,
+        promoteId: this.promoteId,
         painter: this.map.painter
       };
       tile.workerID ??= true;

package/src/source/worker_tile.js

@@ -27,7 +27,9 @@ async function makeWorkerTile(params, { layers }, layerIndex, resources) {
     const sourceLayerIndex = sourceLayerCoder.encode(sourceLayerId);
     const features = new Array(sourceLayer.length);
     for (let index = 0; index < sourceLayer.length; index++) {
-      features[index] = { feature: sourceLayer.feature(index), index, sourceLayerIndex };
+      const feature = sourceLayer.feature(index);
+      const id = options.featureIndex.getId(feature, sourceLayerId);
+      features[index] = { feature, id, index, sourceLayerIndex };
     }
 
     makeBucketsForSourceLayer(sourceLayerFamilies, sourceLayerIndex, features, params, options);
@@ -47,7 +49,7 @@ export async function makeSingleSourceLayerWorkerTile(params, features, sourceLa
 function initializeBucketsOptions(params) {
   const tileID = createTileID(params);
 
-  const featureIndex = new FeatureIndex(tileID);
+  const featureIndex = params.featureIndex ?? new FeatureIndex(tileID, params.promoteId);
   featureIndex.bucketLayerIDs = [];
 
   return {

package/src/style/pauseable_placement.js

@@ -2,27 +2,59 @@ import { Placement } from '../symbol/placement.js';
 import browser from '../util/browser.js';
 
 class LayerPlacement {
-  constructor() {
+  constructor(styleLayer) {
+    this._sortAcrossTiles =
+      styleLayer._layout.get('symbol-z-order') !== 'viewport-y' &&
+      styleLayer._layout.get('symbol-sort-key').constantOr(1) !== undefined;
+
     this._currentTileIndex = 0;
+    this._currentPartIndex = 0;
     this._seenCrossTileIDs = {};
+    this._bucketParts = [];
   }
 
   continuePlacement(tiles, placement, showCollisionBoxes, styleLayer, shouldPausePlacement) {
+    const bucketParts = this._bucketParts;
+
     while (this._currentTileIndex < tiles.length) {
       const tile = tiles[this._currentTileIndex];
-      placement.placeLayerTile(styleLayer, tile, showCollisionBoxes, this._seenCrossTileIDs);
+      placement.getBucketParts(bucketParts, styleLayer, tile, this._sortAcrossTiles);
 
       this._currentTileIndex++;
       if (shouldPausePlacement()) {
         return true;
       }
     }
+
+    if (this._sortAcrossTiles) {
+      this._sortAcrossTiles = false;
+      bucketParts.sort((a, b) => a.sortKey - b.sortKey);
+    }
+
+    while (this._currentPartIndex < bucketParts.length) {
+      const bucketPart = bucketParts[this._currentPartIndex];
+      placement.placeLayerBucketPart(bucketPart, this._seenCrossTileIDs, showCollisionBoxes);
+
+      this._currentPartIndex++;
+      if (shouldPausePlacement()) {
+        return true;
+      }
+    }
+    return false;
   }
 }
 
 class PauseablePlacement {
-  constructor(transform, maxIndex, forceFullPlacement, showCollisionBoxes, fadeDuration, crossSourceCollisions) {
-    this.placement = new Placement(transform, fadeDuration, crossSourceCollisions);
+  constructor(
+    transform,
+    maxIndex,
+    forceFullPlacement,
+    showCollisionBoxes,
+    fadeDuration,
+    crossSourceCollisions,
+    prevPlacement
+  ) {
+    this.placement = new Placement(transform, fadeDuration, crossSourceCollisions, prevPlacement);
     this._currentPlacementIndex = maxIndex;
     this._forceFullPlacement = forceFullPlacement;
     this._showCollisionBoxes = showCollisionBoxes;
@@ -50,7 +82,7 @@ class PauseablePlacement {
         (!layer.maxzoom || layer.maxzoom > placementZoom)
       ) {
         if (!this._inProgressLayer) {
-          this._inProgressLayer = new LayerPlacement();
+          this._inProgressLayer = new LayerPlacement(layer);
         }
 
         const pausePlacement = this._inProgressLayer.continuePlacement(
@@ -77,8 +109,8 @@ class PauseablePlacement {
     this._done = true;
   }
 
-  commit(previousPlacement, now) {
-    this.placement.commit(previousPlacement, now);
+  commit(now) {
+    this.placement.commit(now);
     return this.placement;
   }
 }

package/src/style/style.js

@@ -784,13 +784,13 @@ class Style extends Evented {
     return this.getLayer(layer).getPaintProperty(name);
   }
 
-  setFeatureState(feature, state) {
+  setFeatureState(target, state) {
     if (!this._loaded) {
-      this.#opsQueue.push(() => this.setFeatureState(feature, state));
+      this.#opsQueue.push(() => this.setFeatureState(target, state));
       return;
     }
-    const sourceId = feature.source;
-    const sourceLayer = feature.sourceLayer;
+    const sourceId = target.source;
+    const sourceLayer = target.sourceLayer;
     const sourceCache = this._sources[sourceId];
 
     if (sourceCache === undefined) {
@@ -806,12 +806,12 @@ class Style extends Evented {
       this.fire(new ErrorEvent(new Error('The sourceLayer parameter must be provided for vector source types.')));
       return;
     }
-    if (feature.id == null || feature.id === '') {
+    if (target.id === undefined) {
       this.fire(new ErrorEvent(new Error('The feature id parameter must be provided.')));
       return;
     }
 
-    sourceCache.setFeatureState(sourceLayer, feature.id, state);
+    sourceCache.setFeatureState(sourceLayer, target.id, state);
   }
 
   removeFeatureState(target, key) {
@@ -843,12 +843,12 @@ class Style extends Evented {
     sourceCache.removeFeatureState(sourceLayer, target.id, key);
   }
 
-  getFeatureState(feature) {
+  getFeatureState(target) {
     if (!this._loaded) {
       return;
     }
-    const sourceId = feature.source;
-    const sourceLayer = feature.sourceLayer;
+    const sourceId = target.source;
+    const sourceLayer = target.sourceLayer;
     const sourceCache = this._sources[sourceId];
 
     if (sourceCache === undefined) {
@@ -861,7 +861,11 @@ class Style extends Evented {
       return;
     }
 
-    return sourceCache.getFeatureState(sourceLayer, feature.id);
+    if (target.id === undefined) {
+      this.fire(new ErrorEvent(new Error('The feature id parameter must be provided.')));
+    }
+
+    return sourceCache.getFeatureState(sourceLayer, target.id);
   }
 
   getTransition() {
@@ -1117,7 +1121,8 @@ class Style extends Evented {
         forceFullPlacement,
         showCollisionBoxes,
         fadeDuration,
-        crossSourceCollisions
+        crossSourceCollisions,
+        this.placement
       );
       this._layerOrderChanged = false;
     }
@@ -1132,7 +1137,7 @@ class Style extends Evented {
       this.pauseablePlacement.continuePlacement(Array.from(this._layers.values()), layerTiles);
 
       if (this.pauseablePlacement.isDone()) {
-        this.placement = this.pauseablePlacement.commit(this.placement, browser.now());
+        this.placement = this.pauseablePlacement.commit(browser.now());
         placementCommitted = true;
       }
 

package/src/style/style_layer/circle_style_layer_properties.js

@@ -2,6 +2,13 @@
 
 import { DataConstantProperty, DataDrivenProperty, Properties } from '../properties.js';
 
+const layout = new Properties({
+  'circle-sort-key': new DataDrivenProperty({
+    type: 'number',
+    expression: { parameters: ['zoom', 'feature'] }
+  })
+});
+
 const paint = new Properties({
   'circle-radius': new DataDrivenProperty({
     type: 'number',
@@ -73,4 +80,4 @@ const paint = new Properties({
   })
 });
 
-export default { paint };
+export default { paint, layout };

package/src/style/style_layer/fill_style_layer_properties.js

@@ -2,6 +2,13 @@
 
 import { CrossFadedDataDrivenProperty, DataConstantProperty, DataDrivenProperty, Properties } from '../properties.js';
 
+const layout = new Properties({
+  'fill-sort-key': new DataDrivenProperty({
+    type: 'number',
+    expression: { parameters: ['zoom', 'feature'] }
+  })
+});
+
 const paint = new Properties({
   'fill-antialias': new DataConstantProperty({ type: 'boolean', default: true, expression: { parameters: ['zoom'] } }),
   'fill-opacity': new DataDrivenProperty({
@@ -42,4 +49,4 @@ const paint = new Properties({
   })
 });
 
-export default { paint };
+export default { paint, layout };

package/src/style/style_layer/line_style_layer_properties.js

@@ -31,6 +31,10 @@ const layout = new Properties({
     type: 'number',
     default: 1.05,
     expression: { interpolated: true, parameters: ['zoom'] }
+  }),
+  'line-sort-key': new DataDrivenProperty({
+    type: 'number',
+    expression: { parameters: ['zoom', 'feature'] }
   })
 });
 const paint = new Properties({

package/src/style/style_layer/symbol_style_layer_properties.js

@@ -19,10 +19,14 @@ const layout = new Properties({
     default: false,
     expression: { parameters: ['zoom'] }
   }),
+  'symbol-sort-key': new DataDrivenProperty({
+    type: 'number',
+    expression: { parameters: ['zoom', 'feature'] }
+  }),
   'symbol-z-order': new DataConstantProperty({
     type: 'enum',
-    values: ['viewport-y', 'source'],
-    default: 'viewport-y',
+    values: ['auto', 'viewport-y', 'source'],
+    default: 'auto',
     expression: { parameters: ['zoom'] }
   }),
   'icon-allow-overlap': new DataConstantProperty({
@@ -149,6 +153,17 @@ const layout = new Properties({
     default: 'center',
     expression: { parameters: ['zoom', 'feature'] }
   }),
+  'text-radial-offset': new DataDrivenProperty({
+    type: 'number',
+    default: 0,
+    expression: { interpolated: true, parameters: ['zoom', 'feature'] }
+  }),
+  'text-variable-anchor': new DataConstantProperty({
+    type: 'array',
+    value: 'enum',
+    values: ['center', 'left', 'right', 'top', 'bottom', 'top-left', 'top-right', 'bottom-left', 'bottom-right'],
+    expression: { parameters: ['zoom'] }
+  }),
   'text-anchor': new DataDrivenProperty({
     type: 'enum',
     values: ['center', 'left', 'right', 'top', 'bottom', 'top-left', 'top-right', 'bottom-left', 'bottom-right'],