@mapwhit/tilerenderer 1.1.1 → 1.2.1

package/src/style-spec/reference/v8.json

@@ -393,6 +393,11 @@
       "type": "boolean",
       "default": false,
       "doc": "Whether to calculate line distance metrics. This is required for line layers that specify `line-gradient` values."
+    },
+    "generateId": {
+        "type": "boolean",
+        "default": false,
+        "doc": "Whether to generate ids for the geojson features. When enabled, the `feature.id` property will be auto assigned based on it's index in the `features` array, over-writing any previous values."
     }
   },
   "source_video": {
@@ -635,7 +640,13 @@
           "macos": "0.1.0"
         }
       },
-      "property-type": "constant"
+      "expression": {
+        "interpolated": false,
+        "parameters": [
+          "global-state"
+        ]
+      },
+      "property-type": "data-constant"
     }
   },
   "layout_fill": {
@@ -659,7 +670,13 @@
           "macos": "0.1.0"
         }
       },
-      "property-type": "constant"
+      "expression": {
+        "interpolated": false,
+        "parameters": [
+          "global-state"
+        ]
+      },
+      "property-type": "data-constant"
     }
   },
   "layout_circle": {
@@ -683,7 +700,13 @@
           "macos": "0.1.0"
         }
       },
-      "property-type": "constant"
+      "expression": {
+        "interpolated": false,
+        "parameters": [
+          "global-state"
+        ]
+      },
+      "property-type": "data-constant"
     }
   },
   "layout_heatmap": {
@@ -707,7 +730,13 @@
           "macos": "0.7.0"
         }
       },
-      "property-type": "constant"
+      "expression": {
+        "interpolated": false,
+        "parameters": [
+          "global-state"
+        ]
+      },
+      "property-type": "data-constant"
     }
   },
   "layout_fill-extrusion": {
@@ -731,7 +760,13 @@
           "macos": "0.5.0"
         }
       },
-      "property-type": "constant"
+      "expression": {
+        "interpolated": false,
+        "parameters": [
+          "global-state"
+        ]
+      },
+      "property-type": "data-constant"
     }
   },
   "layout_line": {
@@ -878,7 +913,13 @@
         },
         "data-driven styling": {}
       },
-      "property-type": "constant"
+      "expression": {
+        "interpolated": false,
+        "parameters": [
+          "global-state"
+        ]
+      },
+      "property-type": "data-constant"
     }
   },
   "layout_symbol": {
@@ -2121,7 +2162,13 @@
         },
         "data-driven styling": {}
       },
-      "property-type": "constant"
+      "expression": {
+        "interpolated": false,
+        "parameters": [
+          "global-state"
+        ]
+      },
+      "property-type": "data-constant"
     }
   },
   "layout_raster": {
@@ -2146,7 +2193,13 @@
         },
         "data-driven styling": {}
       },
-      "property-type": "constant"
+      "expression": {
+        "interpolated": false,
+        "parameters": [
+          "global-state"
+        ]
+      },
+      "property-type": "data-constant"
     }
   },
   "layout_hillshade": {
@@ -2171,7 +2224,13 @@
         },
         "data-driven styling": {}
       },
-      "property-type": "constant"
+      "expression": {
+        "interpolated": false,
+        "parameters": [
+          "global-state"
+        ]
+      },
+      "property-type": "data-constant"
     }
   },
   "filter": {

package/src/style-spec/visibility.js

@@ -0,0 +1,37 @@
+import { createExpression, findGlobalStateRefs } from '@mapwhit/style-expressions';
+
+const visibilitySpec = {
+  type: 'enum',
+  values: ['visible', 'none'],
+  default: 'visible',
+  expression: {
+    parameters: ['global-state']
+  }
+};
+
+export default function createVisibility(visibility, globalState) {
+  const expression = {
+    setValue
+  };
+  setValue(visibility);
+  return expression;
+
+  function setValue(visibility) {
+    if (visibility === null || visibility === undefined || visibility === 'visible' || visibility === 'none') {
+      expression.evaluate = visibility === 'none' ? () => 'none' : () => 'visible';
+      addGlobalStateRefs(expression);
+      return;
+    }
+
+    const compiled = createExpression(visibility, visibilitySpec, globalState);
+    if (compiled.result === 'error') {
+      throw new Error(compiled.value.map(err => `${err.key}: ${err.message}`).join(', '));
+    }
+    expression.evaluate = () => compiled.value.evaluate({});
+    addGlobalStateRefs(expression, () => findGlobalStateRefs(compiled.value.expression));
+  }
+}
+
+function addGlobalStateRefs(visibility, getGlobalStateRefs = () => new Set()) {
+  visibility.getGlobalStateRefs = getGlobalStateRefs;
+}

package/src/symbol/collision_index.js

@@ -1,6 +1,6 @@
 import Point from '@mapbox/point-geometry';
+import { polygonIntersectsPolygon } from '@mapwhit/geometry';
 import * as projection from '../symbol/projection.js';
-import * as intersectionTests from '../util/intersection_tests.js';
 import Grid from './grid_index.js';
 
 // When a symbol crosses the edge that causes it to be included in
@@ -293,7 +293,7 @@ class CollisionIndex {
         new Point(feature.x2, feature.y2),
         new Point(feature.x1, feature.y2)
       ];
-      if (!intersectionTests.polygonIntersectsPolygon(query, bbox)) {
+      if (!polygonIntersectsPolygon(query, bbox)) {
         continue;
       }
 

package/src/symbol/symbol_layout.js

@@ -1,9 +1,9 @@
+import { findPoleOfInaccessibility } from '@mapwhit/geometry';
 import murmur3 from 'murmurhash-js';
 import SymbolBucket from '../data/bucket/symbol_bucket.js';
 import EXTENT from '../data/extent.js';
 import EvaluationParameters from '../style/evaluation_parameters.js';
 import classifyRings from '../util/classify_rings.js';
-import findPoleOfInaccessibility from '../util/find_pole_of_inaccessibility.js';
 import { allowsLetterSpacing, allowsVerticalWritingMode } from '../util/script_detection.js';
 import warn from '../util/warn.js';
 import Anchor from './anchor.js';

package/src/ui/map.js

@@ -1069,11 +1069,17 @@ class Map extends Camera {
    *
    * @param {Object} [feature] Feature identifier. Feature objects returned from
    * {@link Map#queryRenderedFeatures} or event handlers can be used as feature identifiers.
+   * @param {string} [feature.id] Unique id of the feature.
    * @param {string} [feature.source] The Id of the vector source or GeoJSON source for the feature.
    * @param {string} [feature.sourceLayer] (optional)  *For vector tile sources, the sourceLayer is
    *  required.*
-   * @param {string} [feature.id] Unique id of the feature.
    * @param {Object} state A set of key-value pairs. The values should be valid JSON types.
+   *
+   * This method requires the `feature.id` attribute on data sets. For GeoJSON sources without
+   * feature ids, set the `generateIds` option in the `GeoJSONSourceSpecification` to auto-assign them. This
+   * option assigns ids based on a feature's index in the source data. Changing the feature data using
+   * `map.getSource('some id').setData(..)` resets the cache of feature states and requires the
+   * caller re-apply the state as needed with the updated `id` values.
    */
   setFeatureState(feature, state) {
     this.style.setFeatureState(feature, state);
@@ -1320,8 +1326,7 @@ class Map extends Camera {
         now,
         fadeDuration: this._fadeDuration,
         zoomHistory: this.style.zoomHistory,
-        transition: this.style.getTransition(),
-        globalState: this.style.getGlobalState()
+        transition: this.style.getTransition()
       });
 
       const factor = parameters.crossFadingFactor();
@@ -1383,6 +1388,8 @@ class Map extends Camera {
     // Style#_updateSources could have caused them to be set again.
     if (this._sourcesDirty || this._repaint || this._styleDirty || this._placementDirty) {
       this._rerender();
+    } else if (!this.isMoving() && this.loaded()) {
+      this.fire(new Event('idle'));
     }
 
     return this;

package/src/util/classify_rings.js

@@ -1,5 +1,5 @@
+import { calculateSignedArea } from '@mapwhit/geometry';
 import quickselect from 'quickselect';
-import { calculateSignedArea } from './util.js';
 
 // classifies an array of rings into polygons with outer rings and holes
 export default function classifyRings(rings, maxRings) {

package/src/util/group_layers.js

@@ -15,7 +15,7 @@ function groupBySource(layers) {
 
   // Iterate through each layer and group them by source, source-layer, and layout properties
   for (const layer of layers) {
-    if (layer.visibility === 'none') {
+    if (layer.isHidden()) {
       continue;
     }
 

package/src/util/object.js

@@ -1,22 +1,3 @@
-/**
- * Given an object and a number of properties as strings, return version
- * of that object with only those properties.
- *
- * @param src the object
- * @param properties an array of property names chosen
- * to appear on the resulting object.
- * @returns object with limited properties.
- * @example
- * var foo = { name: 'Charlie', age: 10 };
- * var justName = pick(foo, ['name']);
- * // justName = { name: 'Charlie' }
- * @private
- */
-export function pick(src, properties) {
-  const entries = properties.filter(p => p in src).map(p => [p, src[p]]);
-  return Object.fromEntries(entries);
-}
-
 /**
  * Given an array of member function names as strings, replace all of them
  * with bound versions that will always refer to `context` as `this`. This
@@ -59,17 +40,6 @@ export function mapObject(input, iterator, context) {
   return Object.fromEntries(entries);
 }
 
-/**
- * Create an object by filtering out values of an existing object.
- *
- * @private
- */
-export function filterObject(input, iterator, context) {
-  context ??= this;
-  const entries = Object.entries(input).filter(([k, v]) => iterator.call(context, v, k, input));
-  return Object.fromEntries(entries);
-}
-
 /**
  * Deeply compares two object literals.
  *
@@ -105,21 +75,6 @@ export function deepEqual(a, b) {
   return a === b;
 }
 
-/**
- * Deeply clones two objects.
- *
- * @private
- */
-export function clone(input) {
-  if (Array.isArray(input)) {
-    return input.map(clone);
-  }
-  if (typeof input === 'object' && input) {
-    return mapObject(input, clone);
-  }
-  return input;
-}
-
 /**
  * Check if two arrays have at least one common element.
  *

package/src/util/util.js

@@ -104,61 +104,6 @@ export function getCoordinatesCenter(coords) {
   return new Coordinate((minX + maxX) / 2, (minY + maxY) / 2, 0).zoomTo(zoom);
 }
 
-/**
- * Indicates if the provided Points are in a counter clockwise (true) or clockwise (false) order
- *
- * @private
- * @returns true for a counter clockwise set of points
- */
-// http://bryceboe.com/2006/10/23/line-segment-intersection-algorithm/
-export function isCounterClockwise(a, b, c) {
-  return (c.y - a.y) * (b.x - a.x) > (b.y - a.y) * (c.x - a.x);
-}
-
-/**
- * Returns the signed area for the polygon ring.  Postive areas are exterior rings and
- * have a clockwise winding.  Negative areas are interior rings and have a counter clockwise
- * ordering.
- *
- * @private
- * @param ring Exterior or interior ring
- */
-export function calculateSignedArea(ring) {
-  let sum = 0;
-  const len = ring.length;
-  let p2 = ring[len - 1]; // last point
-  for (const p1 of ring) {
-    sum += (p2.x - p1.x) * (p1.y + p2.y);
-    p2 = p1;
-  }
-  return sum;
-}
-
-/**
- * Detects closed polygons, first + last point are equal
- *
- * @private
- * @param points array of points
- * @return true if the points are a closed polygon
- */
-export function isClosedPolygon(points) {
-  // If it is 2 points that are the same then it is a point
-  // If it is 3 points with start and end the same then it is a line
-  if (points.length < 4) {
-    return false;
-  }
-
-  const p1 = points[0];
-  const p2 = points[points.length - 1];
-
-  if (Math.abs(p1.x - p2.x) > 0 || Math.abs(p1.y - p2.y) > 0) {
-    return false;
-  }
-
-  // polygon simplification can produce polygons with zero area and more than 3 points
-  return Math.abs(calculateSignedArea(points)) > 0.01;
-}
-
 /**
  * Converts spherical coordinates to cartesian coordinates.
  *

package/src/util/async.js

@@ -1,29 +0,0 @@
-/*
- * Call an asynchronous function on an array of arguments,
- * calling `callback` with the completed results of all calls.
- *
- * @param array input to each call of the async function.
- * @param fn an async function with signature (data, callback)
- * @param callback a callback run after all async work is done.
- * called with an array, containing the results of each async call.
- * @private
- */
-export function all(array, fn, callback) {
-  if (!array.length) {
-    return callback(null, []);
-  }
-  let remaining = array.length;
-  const results = new Array(array.length);
-  let error = null;
-  array.forEach((item, i) => {
-    fn(item, (err, result) => {
-      if (err) {
-        error = err;
-      }
-      results[i] = result;
-      if (--remaining === 0) {
-        callback(error, results);
-      }
-    });
-  });
-}

package/src/util/find_pole_of_inaccessibility.js

@@ -1,144 +0,0 @@
-import Point from '@mapbox/point-geometry';
-import Queue from 'tinyqueue';
-import { distToSegmentSquared } from './intersection_tests.js';
-
-/**
- * Finds an approximation of a polygon's Pole Of Inaccessibiliy https://en.wikipedia.org/wiki/Pole_of_inaccessibility
- * This is a copy of http://github.com/mapbox/polylabel adapted to use Points
- *
- * @param polygonRings first item in array is the outer ring followed optionally by the list of holes, should be an element of the result of util/classify_rings
- * @param precision Specified in input coordinate units. If 0 returns after first run, if > 0 repeatedly narrows the search space until the radius of the area searched for the best pole is less than precision
- * @param debug Print some statistics to the console during execution
- * @returns Pole of Inaccessibiliy.
- * @private
- */
-export default function (polygonRings, precision = 1, debug = false) {
-  // find the bounding box of the outer ring
-  let minX = Number.POSITIVE_INFINITY;
-  let minY = Number.POSITIVE_INFINITY;
-  let maxX = Number.NEGATIVE_INFINITY;
-  let maxY = Number.NEGATIVE_INFINITY;
-  const outerRing = polygonRings[0];
-  for (let i = 0; i < outerRing.length; i++) {
-    const p = outerRing[i];
-    if (!i || p.x < minX) {
-      minX = p.x;
-    }
-    if (!i || p.y < minY) {
-      minY = p.y;
-    }
-    if (!i || p.x > maxX) {
-      maxX = p.x;
-    }
-    if (!i || p.y > maxY) {
-      maxY = p.y;
-    }
-  }
-
-  const width = maxX - minX;
-  const height = maxY - minY;
-  const cellSize = Math.min(width, height);
-  let h = cellSize / 2;
-
-  // a priority queue of cells in order of their "potential" (max distance to polygon)
-  const cellQueue = new Queue(undefined, compareMax);
-
-  if (cellSize === 0) {
-    return new Point(minX, minY);
-  }
-
-  // cover polygon with initial cells
-  for (let x = minX; x < maxX; x += cellSize) {
-    for (let y = minY; y < maxY; y += cellSize) {
-      cellQueue.push(new Cell(x + h, y + h, h, polygonRings));
-    }
-  }
-
-  // take centroid as the first best guess
-  let bestCell = getCentroidCell(polygonRings);
-  let numProbes = cellQueue.length;
-
-  while (cellQueue.length) {
-    // pick the most promising cell from the queue
-    const cell = cellQueue.pop();
-
-    // update the best cell if we found a better one
-    if (cell.d > bestCell.d || !bestCell.d) {
-      bestCell = cell;
-      if (debug) {
-        console.log('found best %d after %d probes', Math.round(1e4 * cell.d) / 1e4, numProbes);
-      }
-    }
-
-    // do not drill down further if there's no chance of a better solution
-    if (cell.max - bestCell.d <= precision) {
-      continue;
-    }
-
-    // split the cell into four cells
-    h = cell.h / 2;
-    cellQueue.push(new Cell(cell.p.x - h, cell.p.y - h, h, polygonRings));
-    cellQueue.push(new Cell(cell.p.x + h, cell.p.y - h, h, polygonRings));
-    cellQueue.push(new Cell(cell.p.x - h, cell.p.y + h, h, polygonRings));
-    cellQueue.push(new Cell(cell.p.x + h, cell.p.y + h, h, polygonRings));
-    numProbes += 4;
-  }
-
-  if (debug) {
-    console.log(`num probes: ${numProbes}`);
-    console.log(`best distance: ${bestCell.d}`);
-  }
-
-  return bestCell.p;
-}
-
-function compareMax(a, b) {
-  return b.max - a.max;
-}
-
-function Cell(x, y, h, polygon) {
-  this.p = new Point(x, y);
-  this.h = h; // half the cell size
-  this.d = pointToPolygonDist(this.p, polygon); // distance from cell center to polygon
-  this.max = this.d + this.h * Math.SQRT2; // max distance to polygon within a cell
-}
-
-// signed distance from point to polygon outline (negative if point is outside)
-function pointToPolygonDist(p, polygon) {
-  let inside = false;
-  let minDistSq = Number.POSITIVE_INFINITY;
-
-  for (let k = 0; k < polygon.length; k++) {
-    const ring = polygon[k];
-
-    for (let i = 0, len = ring.length, j = len - 1; i < len; j = i++) {
-      const a = ring[i];
-      const b = ring[j];
-
-      if (a.y > p.y !== b.y > p.y && p.x < ((b.x - a.x) * (p.y - a.y)) / (b.y - a.y) + a.x) {
-        inside = !inside;
-      }
-
-      minDistSq = Math.min(minDistSq, distToSegmentSquared(p, a, b));
-    }
-  }
-
-  return (inside ? 1 : -1) * Math.sqrt(minDistSq);
-}
-
-// get polygon centroid
-function getCentroidCell(polygon) {
-  let area = 0;
-  let x = 0;
-  let y = 0;
-  const points = polygon[0];
-  for (let i = 0, len = points.length, j = len - 1; i < len; j = i++) {
-    const a = points[i];
-    const b = points[j];
-    const f = a.x * b.y - b.x * a.y;
-    x += (a.x + b.x) * f;
-    y += (a.y + b.y) * f;
-    area += f * 3;
-  }
-  return new Cell(x / area, y / area, 0, polygon);
-}