@mapwhit/tilerenderer 0.52.1 → 1.1.0

package/src/util/find_pole_of_inaccessibility.js

@@ -1,7 +1,6 @@
-const { default: Queue } = require('tinyqueue');
-
-const { default: Point } = require('@mapbox/point-geometry');
-const { distToSegmentSquared } = require('./intersection_tests');
+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
@@ -13,7 +12,7 @@ const { distToSegmentSquared } = require('./intersection_tests');
  * @returns Pole of Inaccessibiliy.
  * @private
  */
-module.exports = function (polygonRings, precision = 1, debug = false) {
+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;
@@ -22,10 +21,18 @@ module.exports = function (polygonRings, precision = 1, debug = false) {
   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;
+    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;
@@ -36,7 +43,9 @@ module.exports = function (polygonRings, precision = 1, debug = false) {
   // 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);
+  if (cellSize === 0) {
+    return new Point(minX, minY);
+  }
 
   // cover polygon with initial cells
   for (let x = minX; x < maxX; x += cellSize) {
@@ -56,11 +65,15 @@ module.exports = function (polygonRings, precision = 1, debug = false) {
     // 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);
+      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;
+    if (cell.max - bestCell.d <= precision) {
+      continue;
+    }
 
     // split the cell into four cells
     h = cell.h / 2;
@@ -77,7 +90,7 @@ module.exports = function (polygonRings, precision = 1, debug = false) {
   }
 
   return bestCell.p;
-};
+}
 
 function compareMax(a, b) {
   return b.max - a.max;
@@ -102,7 +115,9 @@ function pointToPolygonDist(p, polygon) {
       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;
+      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));
     }

package/src/util/group_layers.js

@@ -0,0 +1,41 @@
+export default groupBySource;
+
+/**
+ * Given an collection of layers, divide them by property 'source', then by 'source-layer',
+ * and then by layout-affecting properties: 'type', , 'minzoom', 'maxzoom', 'filter', and 'layout'.
+ *
+ * The input is not modified. The output layers are references to the
+ * input layers.
+ *
+ * @param layers iterable collection of layers
+ * @returns Map source to {Map source-layer to {Map layout key to Array of layers}}
+ */
+function groupBySource(layers) {
+  const groups = new Map();
+
+  // Iterate through each layer and group them by source, source-layer, and layout properties
+  for (const layer of layers) {
+    if (layer.visibility === 'none') {
+      continue;
+    }
+
+    const { source = '', sourceLayer = '_geojsonTileLayer' } = layer;
+    let sourceGroup = groups.get(source);
+    if (!sourceGroup) {
+      sourceGroup = new Map();
+      groups.set(source, sourceGroup);
+    }
+    let sourceLayerGroup = sourceGroup.get(sourceLayer);
+    if (!sourceLayerGroup) {
+      sourceLayerGroup = new Map();
+      sourceGroup.set(sourceLayer, sourceLayerGroup);
+    }
+    let layoutGroup = sourceLayerGroup.get(layer.key);
+    if (!layoutGroup) {
+      layoutGroup = [];
+      sourceLayerGroup.set(layer.key, layoutGroup);
+    }
+    layoutGroup.push(layer);
+  }
+  return groups;
+}

package/src/util/image.js

@@ -1,6 +1,4 @@
-const assert = require('assert');
-
-const { register } = require('./transfer_registry');
+import assert from 'assert';
 
 function createImage(image, { width, height }, channels, data) {
   if (!data) {
@@ -77,7 +75,7 @@ function copyImage(srcImg, dstImg, srcPt, dstPt, size, channels) {
   return dstImg;
 }
 
-class AlphaImage {
+export class AlphaImage {
   constructor(size, data) {
     createImage(this, size, 1, data);
   }
@@ -97,7 +95,7 @@ class AlphaImage {
 
 // Not premultiplied, because ImageData is not premultiplied.
 // UNPACK_PREMULTIPLY_ALPHA_WEBGL must be used when uploading to a texture.
-class RGBAImage {
+export class RGBAImage {
   constructor(size, data) {
     createImage(this, size, 4, data);
   }
@@ -114,11 +112,3 @@ class RGBAImage {
     copyImage(srcImg, dstImg, srcPt, dstPt, size, 4);
   }
 }
-
-register('AlphaImage', AlphaImage);
-register('RGBAImage', RGBAImage);
-
-module.exports = {
-  AlphaImage,
-  RGBAImage
-};

package/src/util/interpolate.js

@@ -1,4 +1,4 @@
-module.exports = interpolate;
+export default interpolate;
 
 function interpolate(a, b, t) {
   return a * (1 - t) + b * t;

package/src/util/intersection_tests.js

@@ -1,36 +1,37 @@
-const { isCounterClockwise } = require('./util');
-const { default: Point } = require('@mapbox/point-geometry');
-
-module.exports = {
-  polygonIntersectsBufferedPoint,
-  polygonIntersectsMultiPolygon,
-  polygonIntersectsBufferedMultiLine,
-  polygonIntersectsPolygon,
-  distToSegmentSquared,
-  polygonIntersectsBox
-};
-
-function polygonIntersectsPolygon(polygonA, polygonB) {
+import Point from '@mapbox/point-geometry';
+import { isCounterClockwise } from './util.js';
+
+export function polygonIntersectsPolygon(polygonA, polygonB) {
   for (let i = 0; i < polygonA.length; i++) {
-    if (polygonContainsPoint(polygonB, polygonA[i])) return true;
+    if (polygonContainsPoint(polygonB, polygonA[i])) {
+      return true;
+    }
   }
 
   for (let i = 0; i < polygonB.length; i++) {
-    if (polygonContainsPoint(polygonA, polygonB[i])) return true;
+    if (polygonContainsPoint(polygonA, polygonB[i])) {
+      return true;
+    }
   }
 
-  if (lineIntersectsLine(polygonA, polygonB)) return true;
+  if (lineIntersectsLine(polygonA, polygonB)) {
+    return true;
+  }
 
   return false;
 }
 
-function polygonIntersectsBufferedPoint(polygon, point, radius) {
-  if (polygonContainsPoint(polygon, point)) return true;
-  if (pointIntersectsBufferedLine(point, polygon, radius)) return true;
+export function polygonIntersectsBufferedPoint(polygon, point, radius) {
+  if (polygonContainsPoint(polygon, point)) {
+    return true;
+  }
+  if (pointIntersectsBufferedLine(point, polygon, radius)) {
+    return true;
+  }
   return false;
 }
 
-function polygonIntersectsMultiPolygon(polygon, multiPolygon) {
+export function polygonIntersectsMultiPolygon(polygon, multiPolygon) {
   if (polygon.length === 1) {
     return multiPolygonContainsPoint(multiPolygon, polygon[0]);
   }
@@ -38,62 +39,82 @@ function polygonIntersectsMultiPolygon(polygon, multiPolygon) {
   for (let m = 0; m < multiPolygon.length; m++) {
     const ring = multiPolygon[m];
     for (let n = 0; n < ring.length; n++) {
-      if (polygonContainsPoint(polygon, ring[n])) return true;
+      if (polygonContainsPoint(polygon, ring[n])) {
+        return true;
+      }
     }
   }
 
   for (let i = 0; i < polygon.length; i++) {
-    if (multiPolygonContainsPoint(multiPolygon, polygon[i])) return true;
+    if (multiPolygonContainsPoint(multiPolygon, polygon[i])) {
+      return true;
+    }
   }
 
   for (let k = 0; k < multiPolygon.length; k++) {
-    if (lineIntersectsLine(polygon, multiPolygon[k])) return true;
+    if (lineIntersectsLine(polygon, multiPolygon[k])) {
+      return true;
+    }
   }
 
   return false;
 }
 
-function polygonIntersectsBufferedMultiLine(polygon, multiLine, radius) {
+export function polygonIntersectsBufferedMultiLine(polygon, multiLine, radius) {
   for (let i = 0; i < multiLine.length; i++) {
     const line = multiLine[i];
 
     if (polygon.length >= 3) {
       for (let k = 0; k < line.length; k++) {
-        if (polygonContainsPoint(polygon, line[k])) return true;
+        if (polygonContainsPoint(polygon, line[k])) {
+          return true;
+        }
       }
     }
 
-    if (lineIntersectsBufferedLine(polygon, line, radius)) return true;
+    if (lineIntersectsBufferedLine(polygon, line, radius)) {
+      return true;
+    }
   }
   return false;
 }
 
 function lineIntersectsBufferedLine(lineA, lineB, radius) {
   if (lineA.length > 1) {
-    if (lineIntersectsLine(lineA, lineB)) return true;
+    if (lineIntersectsLine(lineA, lineB)) {
+      return true;
+    }
 
     // Check whether any point in either line is within radius of the other line
     for (let j = 0; j < lineB.length; j++) {
-      if (pointIntersectsBufferedLine(lineB[j], lineA, radius)) return true;
+      if (pointIntersectsBufferedLine(lineB[j], lineA, radius)) {
+        return true;
+      }
     }
   }
 
   for (let k = 0; k < lineA.length; k++) {
-    if (pointIntersectsBufferedLine(lineA[k], lineB, radius)) return true;
+    if (pointIntersectsBufferedLine(lineA[k], lineB, radius)) {
+      return true;
+    }
   }
 
   return false;
 }
 
 function lineIntersectsLine(lineA, lineB) {
-  if (lineA.length === 0 || lineB.length === 0) return false;
+  if (lineA.length === 0 || lineB.length === 0) {
+    return false;
+  }
   for (let i = 0; i < lineA.length - 1; i++) {
     const a0 = lineA[i];
     const a1 = lineA[i + 1];
     for (let j = 0; j < lineB.length - 1; j++) {
       const b0 = lineB[j];
       const b1 = lineB[j + 1];
-      if (lineSegmentIntersectsLineSegment(a0, a1, b0, b1)) return true;
+      if (lineSegmentIntersectsLineSegment(a0, a1, b0, b1)) {
+        return true;
+      }
     }
   }
   return false;
@@ -109,25 +130,35 @@ function lineSegmentIntersectsLineSegment(a0, a1, b0, b1) {
 function pointIntersectsBufferedLine(p, line, radius) {
   const radiusSquared = radius * radius;
 
-  if (line.length === 1) return p.distSqr(line[0]) < radiusSquared;
+  if (line.length === 1) {
+    return p.distSqr(line[0]) < radiusSquared;
+  }
 
   for (let i = 1; i < line.length; i++) {
     // Find line segments that have a distance <= radius^2 to p
     // In that case, we treat the line as "containing point p".
     const v = line[i - 1];
     const w = line[i];
-    if (distToSegmentSquared(p, v, w) < radiusSquared) return true;
+    if (distToSegmentSquared(p, v, w) < radiusSquared) {
+      return true;
+    }
   }
   return false;
 }
 
 // Code from http://stackoverflow.com/a/1501725/331379.
-function distToSegmentSquared(p, v, w) {
+export function distToSegmentSquared(p, v, w) {
   const l2 = v.distSqr(w);
-  if (l2 === 0) return p.distSqr(v);
+  if (l2 === 0) {
+    return p.distSqr(v);
+  }
   const t = ((p.x - v.x) * (w.x - v.x) + (p.y - v.y) * (w.y - v.y)) / l2;
-  if (t < 0) return p.distSqr(v);
-  if (t > 1) return p.distSqr(w);
+  if (t < 0) {
+    return p.distSqr(v);
+  }
+  if (t > 1) {
+    return p.distSqr(w);
+  }
   return p.distSqr(w.sub(v)._mult(t)._add(v));
 }
 
@@ -163,23 +194,29 @@ function polygonContainsPoint(ring, p) {
   return c;
 }
 
-function polygonIntersectsBox(ring, boxX1, boxY1, boxX2, boxY2) {
+export function polygonIntersectsBox(ring, boxX1, boxY1, boxX2, boxY2) {
   for (const p of ring) {
-    if (boxX1 <= p.x && boxY1 <= p.y && boxX2 >= p.x && boxY2 >= p.y) return true;
+    if (boxX1 <= p.x && boxY1 <= p.y && boxX2 >= p.x && boxY2 >= p.y) {
+      return true;
+    }
   }
 
   const corners = [new Point(boxX1, boxY1), new Point(boxX1, boxY2), new Point(boxX2, boxY2), new Point(boxX2, boxY1)];
 
   if (ring.length > 2) {
     for (const corner of corners) {
-      if (polygonContainsPoint(ring, corner)) return true;
+      if (polygonContainsPoint(ring, corner)) {
+        return true;
+      }
     }
   }
 
   for (let i = 0; i < ring.length - 1; i++) {
     const p1 = ring[i];
     const p2 = ring[i + 1];
-    if (edgeIntersectsBox(p1, p2, corners)) return true;
+    if (edgeIntersectsBox(p1, p2, corners)) {
+      return true;
+    }
   }
 
   return false;
@@ -194,8 +231,9 @@ function edgeIntersectsBox(e1, e2, corners) {
     (e1.x > br.x && e2.x > br.x) ||
     (e1.y < tl.y && e2.y < tl.y) ||
     (e1.y > br.y && e2.y > br.y)
-  )
+  ) {
     return false;
+  }
 
   // check if all corners of the box are on the same side of the edge
   const dir = isCounterClockwise(e1, e2, corners[0]);

package/src/util/is_char_in_unicode_block.js

@@ -284,4 +284,4 @@ const unicodeBlockLookup = {
   // 'Supplementary Private Use Area-B': (char) => char >= 0x100000 && char <= 0x10FFFF,
 };
 
-module.exports = unicodeBlockLookup;
+export default unicodeBlockLookup;

package/src/util/key.js

@@ -0,0 +1,25 @@
+export default createKey;
+
+function stringify(obj) {
+  if (obj == null) {
+    return 'null';
+  }
+  const type = typeof obj;
+  if (type === 'number' || type === 'boolean' || type === 'string') {
+    return obj;
+  }
+
+  if (Array.isArray(obj)) {
+    return '[' + obj.map(val => stringify(val)).join(',') + ']';
+  }
+
+  const keys = Object.keys(obj).sort();
+  return '{' + keys.map(key => `${key}:${stringify(obj[key])}`).join(',') + '}';
+}
+
+/**
+ * Create a unique key for an based on its properties.
+ */
+function createKey(properties, object) {
+  return properties.map(k => stringify(object[k])).join('/');
+}

package/src/util/loader/image.js

@@ -1,4 +1,4 @@
-module.exports = image;
+export default image;
 
 function image(data) {
   if (!data) {

package/src/util/object.js

@@ -1,34 +1,3 @@
-/*
- * Polyfill for Object.values. Not fully spec compliant, but we don't
- * need it to be.
- *
- * @private
- */
-function values(obj) {
-  const result = [];
-  for (const k in obj) {
-    result.push(obj[k]);
-  }
-  return result;
-}
-
-/*
- * Compute the difference between the keys in one object and the keys
- * in another object.
- *
- * @returns keys difference
- * @private
- */
-function keysDifference(obj, other) {
-  const difference = [];
-  for (const i in obj) {
-    if (!(i in other)) {
-      difference.push(i);
-    }
-  }
-  return difference;
-}
-
 /**
  * Given an object and a number of properties as strings, return version
  * of that object with only those properties.
@@ -43,15 +12,9 @@ function keysDifference(obj, other) {
  * // justName = { name: 'Charlie' }
  * @private
  */
-function pick(src, properties) {
-  const result = {};
-  for (let i = 0; i < properties.length; i++) {
-    const k = properties[i];
-    if (k in src) {
-      result[k] = src[k];
-    }
-  }
-  return result;
+export function pick(src, properties) {
+  const entries = properties.filter(p => p in src).map(p => [p, src[p]]);
+  return Object.fromEntries(entries);
 }
 
 /**
@@ -75,7 +38,7 @@ function pick(src, properties) {
  * setTimeout(myClass.ontimer, 100);
  * @private
  */
-function bindAll(fns, context) {
+export function bindAll(fns, context) {
   fns.forEach(fn => {
     if (!context[fn]) {
       return;
@@ -90,12 +53,10 @@ function bindAll(fns, context) {
  *
  * @private
  */
-function mapObject(input, iterator, context) {
-  const output = {};
-  for (const key in input) {
-    output[key] = iterator.call(context || this, input[key], key, input);
-  }
-  return output;
+export function mapObject(input, iterator, context) {
+  context ??= this;
+  const entries = Object.entries(input).map(([k, v]) => [k, iterator.call(context, v, k, input)]);
+  return Object.fromEntries(entries);
 }
 
 /**
@@ -103,14 +64,10 @@ function mapObject(input, iterator, context) {
  *
  * @private
  */
-function filterObject(input, iterator, context) {
-  const output = {};
-  for (const key in input) {
-    if (iterator.call(context || this, input[key], key, input)) {
-      output[key] = input[key];
-    }
-  }
-  return output;
+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);
 }
 
 /**
@@ -118,20 +75,30 @@ function filterObject(input, iterator, context) {
  *
  * @private
  */
-function deepEqual(a, b) {
+export function deepEqual(a, b) {
   if (Array.isArray(a)) {
-    if (!Array.isArray(b) || a.length !== b.length) return false;
+    if (!Array.isArray(b) || a.length !== b.length) {
+      return false;
+    }
     for (let i = 0; i < a.length; i++) {
-      if (!deepEqual(a[i], b[i])) return false;
+      if (!deepEqual(a[i], b[i])) {
+        return false;
+      }
     }
     return true;
   }
   if (typeof a === 'object' && a !== null && b !== null) {
-    if (!(typeof b === 'object')) return false;
+    if (!(typeof b === 'object')) {
+      return false;
+    }
     const keys = Object.keys(a);
-    if (keys.length !== Object.keys(b).length) return false;
+    if (keys.length !== Object.keys(b).length) {
+      return false;
+    }
     for (const key in a) {
-      if (!deepEqual(a[key], b[key])) return false;
+      if (!deepEqual(a[key], b[key])) {
+        return false;
+      }
     }
     return true;
   }
@@ -143,7 +110,7 @@ function deepEqual(a, b) {
  *
  * @private
  */
-function clone(input) {
+export function clone(input) {
   if (Array.isArray(input)) {
     return input.map(clone);
   }
@@ -158,21 +125,11 @@ function clone(input) {
  *
  * @private
  */
-function arraysIntersect(a, b) {
+export function arraysIntersect(a, b) {
   for (let l = 0; l < a.length; l++) {
-    if (b.indexOf(a[l]) >= 0) return true;
+    if (b.indexOf(a[l]) >= 0) {
+      return true;
+    }
   }
   return false;
 }
-
-module.exports = {
-  values,
-  keysDifference,
-  pick,
-  bindAll,
-  mapObject,
-  filterObject,
-  deepEqual,
-  clone,
-  arraysIntersect
-};