@mapwhit/tilerenderer 1.0.0 → 1.1.0

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

@@ -1,9 +1,13 @@
-module.exports = createKey;
+export default createKey;
 
 function stringify(obj) {
-  if (obj == null) return 'null';
+  if (obj == null) {
+    return 'null';
+  }
   const type = typeof obj;
-  if (type === 'number' || type === 'boolean' || type === 'string') return obj;
+  if (type === 'number' || type === 'boolean' || type === 'string') {
+    return obj;
+  }
 
   if (Array.isArray(obj)) {
     return '[' + obj.map(val => stringify(val)).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

@@ -12,7 +12,7 @@
  * // justName = { name: 'Charlie' }
  * @private
  */
-function pick(src, properties) {
+export function pick(src, properties) {
   const entries = properties.filter(p => p in src).map(p => [p, src[p]]);
   return Object.fromEntries(entries);
 }
@@ -38,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;
@@ -53,7 +53,7 @@ function bindAll(fns, context) {
  *
  * @private
  */
-function mapObject(input, iterator, context) {
+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);
@@ -64,7 +64,7 @@ function mapObject(input, iterator, context) {
  *
  * @private
  */
-function filterObject(input, iterator, context) {
+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);
@@ -75,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;
   }
@@ -100,7 +110,7 @@ function deepEqual(a, b) {
  *
  * @private
  */
-function clone(input) {
+export function clone(input) {
   if (Array.isArray(input)) {
     return input.map(clone);
   }
@@ -115,19 +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 = {
-  pick,
-  bindAll,
-  mapObject,
-  filterObject,
-  deepEqual,
-  clone,
-  arraysIntersect
-};