@mapwhit/tilerenderer 0.47.1

package/src/util/tile_cover.js

@@ -0,0 +1,114 @@
+const { OverscaledTileID } = require('../source/tile_id');
+
+module.exports = tileCover;
+
+function tileCover(z, bounds, actualZ, renderWorldCopies) {
+  if (renderWorldCopies === undefined) {
+    renderWorldCopies = true;
+  }
+  const tiles = 1 << z;
+  const t = {};
+
+  function scanLine(x0, x1, y) {
+    let x;
+    let w;
+    let wx;
+    let coord;
+    if (y >= 0 && y <= tiles) {
+      for (x = x0; x < x1; x++) {
+        w = Math.floor(x / tiles);
+        wx = ((x % tiles) + tiles) % tiles;
+        if (w === 0 || renderWorldCopies === true) {
+          coord = new OverscaledTileID(actualZ, w, z, wx, y);
+          t[coord.key] = coord;
+        }
+      }
+    }
+  }
+
+  // Divide the screen up in two triangles and scan each of them:
+  // +---/
+  // | / |
+  // /---+
+  scanTriangle(bounds[0], bounds[1], bounds[2], 0, tiles, scanLine);
+  scanTriangle(bounds[2], bounds[3], bounds[0], 0, tiles, scanLine);
+
+  return Object.keys(t).map(id => {
+    return t[id];
+  });
+}
+
+// Taken from polymaps src/Layer.js
+// https://github.com/simplegeo/polymaps/blob/master/src/Layer.js#L333-L383
+
+function edge(a, b) {
+  if (a.row > b.row) {
+    const t = a;
+    a = b;
+    b = t;
+  }
+  return {
+    x0: a.column,
+    y0: a.row,
+    x1: b.column,
+    y1: b.row,
+    dx: b.column - a.column,
+    dy: b.row - a.row
+  };
+}
+
+function scanSpans(e0, e1, ymin, ymax, scanLine) {
+  const y0 = Math.max(ymin, Math.floor(e1.y0));
+  const y1 = Math.min(ymax, Math.ceil(e1.y1));
+
+  // sort edges by x-coordinate
+  if (
+    e0.x0 === e1.x0 && e0.y0 === e1.y0
+      ? e0.x0 + (e1.dy / e0.dy) * e0.dx < e1.x1
+      : e0.x1 - (e1.dy / e0.dy) * e0.dx < e1.x0
+  ) {
+    const t = e0;
+    e0 = e1;
+    e1 = t;
+  }
+
+  // scan lines!
+  const m0 = e0.dx / e0.dy;
+  const m1 = e1.dx / e1.dy;
+  const d0 = e0.dx > 0; // use y + 1 to compute x0
+  const d1 = e1.dx < 0; // use y + 1 to compute x1
+  for (let y = y0; y < y1; y++) {
+    const x0 = m0 * Math.max(0, Math.min(e0.dy, y + d0 - e0.y0)) + e0.x0;
+    const x1 = m1 * Math.max(0, Math.min(e1.dy, y + d1 - e1.y0)) + e1.x0;
+    scanLine(Math.floor(x1), Math.ceil(x0), y);
+  }
+}
+
+function scanTriangle(a, b, c, ymin, ymax, scanLine) {
+  let ab = edge(a, b);
+  let bc = edge(b, c);
+  let ca = edge(c, a);
+
+  let t;
+
+  // sort edges by y-length
+  if (ab.dy > bc.dy) {
+    t = ab;
+    ab = bc;
+    bc = t;
+  }
+  if (ab.dy > ca.dy) {
+    t = ab;
+    ab = ca;
+    ca = t;
+  }
+  if (bc.dy > ca.dy) {
+    t = bc;
+    bc = ca;
+    ca = t;
+  }
+
+  // scan span! scan span!
+  if (ab.dy) scanSpans(ca, ab, ymin, ymax, scanLine);
+  if (bc.dy) scanSpans(ca, bc, ymin, ymax, scanLine);
+}

package/src/util/token.js

@@ -0,0 +1,13 @@
+module.exports = resolveTokens;
+
+/**
+ * Replace tokens in a string template with values in an object
+ *
+ * @param properties a key/value relationship between tokens and replacements
+ * @param text the template string
+ * @returns the template with tokens replaced
+ * @private
+ */
+function resolveTokens(properties, text) {
+  return text.replace(/{([^{}]+)}/g, (match, key) => String(properties[key] ?? ''));
+}

package/src/util/unique_id.js

@@ -0,0 +1,12 @@
+let id = 1;
+
+/**
+ * Return a unique numeric id, starting at 1 and incrementing with
+ * each call.
+ *
+ * @returns unique numeric id.
+ * @private
+ */
+module.exports = function uniqueId() {
+  return id++;
+};

package/src/util/util.js

@@ -0,0 +1,192 @@
+const UnitBezier = require('@mapbox/unitbezier');
+
+const Coordinate = require('../geo/coordinate');
+
+/**
+ * @module util
+ * @private
+ */
+
+/**
+ * Given a value `t` that varies between 0 and 1, return
+ * an interpolation function that eases between 0 and 1 in a pleasing
+ * cubic in-out fashion.
+ *
+ * @private
+ */
+function easeCubicInOut(t) {
+  if (t <= 0) return 0;
+  if (t >= 1) return 1;
+  const t2 = t * t;
+  const t3 = t2 * t;
+  return 4 * (t < 0.5 ? t3 : 3 * (t - t2) + t3 - 0.75);
+}
+
+/**
+ * Given given (x, y), (x1, y1) control points for a bezier curve,
+ * return a function that interpolates along that curve.
+ *
+ * @param p1x control point 1 x coordinate
+ * @param p1y control point 1 y coordinate
+ * @param p2x control point 2 x coordinate
+ * @param p2y control point 2 y coordinate
+ * @private
+ */
+function bezier(p1x, p1y, p2x, p2y) {
+  const bezier = new UnitBezier(p1x, p1y, p2x, p2y);
+  return function (t) {
+    return bezier.solve(t);
+  };
+}
+
+/**
+ * A default bezier-curve powered easing function with
+ * control points (0.25, 0.1) and (0.25, 1)
+ *
+ * @private
+ */
+const ease = bezier(0.25, 0.1, 0.25, 1);
+
+/**
+ * constrain n to the given range via min + max
+ *
+ * @param n value
+ * @param min the minimum value to be returned
+ * @param max the maximum value to be returned
+ * @returns the clamped value
+ * @private
+ */
+function clamp(n, min, max) {
+  return Math.min(max, Math.max(min, n));
+}
+
+/**
+ * constrain n to the given range, excluding the minimum, via modular arithmetic
+ *
+ * @param n value
+ * @param min the minimum value to be returned, exclusive
+ * @param max the maximum value to be returned, inclusive
+ * @returns constrained number
+ * @private
+ */
+function wrap(n, min, max) {
+  const d = max - min;
+  const w = ((((n - min) % d) + d) % d) + min;
+  return w === min ? max : w;
+}
+
+/**
+ * Given a list of coordinates, get their center as a coordinate.
+ *
+ * @returns centerpoint
+ * @private
+ */
+function getCoordinatesCenter(coords) {
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+
+  for (let i = 0; i < coords.length; i++) {
+    minX = Math.min(minX, coords[i].column);
+    minY = Math.min(minY, coords[i].row);
+    maxX = Math.max(maxX, coords[i].column);
+    maxY = Math.max(maxY, coords[i].row);
+  }
+
+  const dx = maxX - minX;
+  const dy = maxY - minY;
+  const dMax = Math.max(dx, dy);
+  const zoom = Math.max(0, Math.floor(-Math.log(dMax) / Math.LN2));
+  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/
+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
+ */
+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
+ */
+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.
+ *
+ * @private
+ * @param spherical Spherical coordinates, in [radial, azimuthal, polar]
+ * @return cartesian coordinates in [x, y, z]
+ */
+
+function sphericalToCartesian([r, azimuthal, polar]) {
+  // We abstract "north"/"up" (compass-wise) to be 0° when really this is 90° (π/2):
+  // correct for that here
+  azimuthal += 90;
+
+  // Convert azimuthal and polar angles to radians
+  azimuthal *= Math.PI / 180;
+  polar *= Math.PI / 180;
+
+  return {
+    x: r * Math.cos(azimuthal) * Math.sin(polar),
+    y: r * Math.sin(azimuthal) * Math.sin(polar),
+    z: r * Math.cos(polar)
+  };
+}
+
+module.exports = {
+  easeCubicInOut,
+  bezier,
+  ease,
+  clamp,
+  wrap,
+  getCoordinatesCenter,
+  isCounterClockwise,
+  calculateSignedArea,
+  isClosedPolygon,
+  sphericalToCartesian
+};

package/src/util/vectortile_to_geojson.js

@@ -0,0 +1,44 @@
+class Feature {
+  constructor(vectorTileFeature, z, x, y) {
+    this.type = 'Feature';
+
+    this._vectorTileFeature = vectorTileFeature;
+    vectorTileFeature._z = z;
+    vectorTileFeature._x = x;
+    vectorTileFeature._y = y;
+
+    this.properties = vectorTileFeature.properties;
+
+    if (vectorTileFeature.id != null) {
+      this.id = vectorTileFeature.id;
+    }
+  }
+
+  get geometry() {
+    if (this._geometry === undefined) {
+      this._geometry = this._vectorTileFeature.toGeoJSON(
+        this._vectorTileFeature._x,
+        this._vectorTileFeature._y,
+        this._vectorTileFeature._z
+      ).geometry;
+    }
+    return this._geometry;
+  }
+
+  set geometry(g) {
+    this._geometry = g;
+  }
+
+  toJSON() {
+    const json = {
+      geometry: this.geometry
+    };
+    for (const i in this) {
+      if (i === '_geometry' || i === '_vectorTileFeature') continue;
+      json[i] = this[i];
+    }
+    return json;
+  }
+}
+
+module.exports = Feature;

package/src/util/verticalize_punctuation.js

@@ -0,0 +1,112 @@
+const { charHasRotatedVerticalOrientation } = require('./script_detection');
+
+const verticalizedCharacterMap = {
+  '!': '︕',
+  '#': '＃',
+  $: '＄',
+  '%': '％',
+  '&': '＆',
+  '(': '︵',
+  ')': '︶',
+  '*': '＊',
+  '+': '＋',
+  ',': '︐',
+  '-': '︲',
+  '.': '・',
+  '/': '／',
+  ':': '︓',
+  ';': '︔',
+  '<': '︿',
+  '=': '＝',
+  '>': '﹀',
+  '?': '︖',
+  '@': '＠',
+  '[': '﹇',
+  '\\': '＼',
+  ']': '﹈',
+  '^': '＾',
+  _: '︳',
+  '`': '｀',
+  '{': '︷',
+  '|': '―',
+  '}': '︸',
+  '~': '～',
+  '¢': '￠',
+  '£': '￡',
+  '¥': '￥',
+  '¦': '￤',
+  '¬': '￢',
+  '¯': '￣',
+  '–': '︲',
+  '—': '︱',
+  '‘': '﹃',
+  '’': '﹄',
+  '“': '﹁',
+  '”': '﹂',
+  '…': '︙',
+  '‧': '・',
+  '₩': '￦',
+  '、': '︑',
+  '。': '︒',
+  '〈': '︿',
+  '〉': '﹀',
+  '《': '︽',
+  '》': '︾',
+  '「': '﹁',
+  '」': '﹂',
+  '『': '﹃',
+  '』': '﹄',
+  '【': '︻',
+  '】': '︼',
+  '〔': '︹',
+  '〕': '︺',
+  '〖': '︗',
+  '〗': '︘',
+  '！': '︕',
+  '（': '︵',
+  '）': '︶',
+  '，': '︐',
+  '－': '︲',
+  '．': '・',
+  '：': '︓',
+  '；': '︔',
+  '＜': '︿',
+  '＞': '﹀',
+  '？': '︖',
+  '［': '﹇',
+  '］': '﹈',
+  '＿': '︳',
+  '｛': '︷',
+  '｜': '―',
+  '｝': '︸',
+  '｟': '︵',
+  '｠': '︶',
+  '｡': '︒',
+  '｢': '﹁',
+  '｣': '﹂'
+};
+
+function verticalizePunctuation(input) {
+  let output = '';
+
+  for (let i = 0; i < input.length; i++) {
+    const nextCharCode = input.charCodeAt(i + 1) || null;
+    const prevCharCode = input.charCodeAt(i - 1) || null;
+
+    const canReplacePunctuation =
+      (!nextCharCode || !charHasRotatedVerticalOrientation(nextCharCode) || verticalizedCharacterMap[input[i + 1]]) &&
+      (!prevCharCode || !charHasRotatedVerticalOrientation(prevCharCode) || verticalizedCharacterMap[input[i - 1]]);
+
+    if (canReplacePunctuation && verticalizedCharacterMap[input[i]]) {
+      output += verticalizedCharacterMap[input[i]];
+    } else {
+      output += input[i];
+    }
+  }
+
+  return output;
+}
+
+verticalizePunctuation.verticalizedCharacterMap = verticalizedCharacterMap;
+
+module.exports = verticalizePunctuation;

package/src/util/warn.js

@@ -0,0 +1,21 @@
+/**
+ * Print a warning message to the console and ensure duplicate warning messages
+ * are not printed.
+ *
+ * @private
+ */
+const warnOnceHistory = {};
+
+function once(message) {
+  if (!warnOnceHistory[message]) {
+    console.warn(message);
+    warnOnceHistory[message] = true;
+  }
+}
+
+function noop() {}
+
+// console isn't defined in some WebWorkers, see #2558
+module.exports = {
+  once: typeof console !== 'undefined' ? once : noop
+};

package/src/util/web_worker.js

@@ -0,0 +1,5 @@
+const config = require('./config');
+
+module.exports = function () {
+  return new window.Worker(config.WORKER_URL);
+};