@math.gl/polygon 3.5.6 → 3.6.0-alpha.2

package/src/{cut-by-grid.js → cut-by-grid.ts}

@@ -1,8 +1,26 @@
 /* eslint-disable max-statements, max-depth, complexity, no-unused-expressions */
-import {bitCode, intersect} from './lineclip';
+import {bitCode, intersect, BoundingBox} from './lineclip';
 import {getPointAtIndex, copy, push} from './utils';
 
-export function cutPolylineByGrid(positions, options = {}) {
+import type {NumericArray} from '@math.gl/core';
+
+export type Polygon = {
+  positions: number[];
+  holeIndices?: number[];
+  edgeTypes?: number[];
+};
+
+export function cutPolylineByGrid(
+  positions: NumericArray,
+  options?: {
+    size?: number;
+    broken?: boolean;
+    gridResolution?: number;
+    gridOffset?: [number, number];
+    startIndex?: number;
+    endIndex?: number;
+  }
+): number[] | number[][] {
   const {
     size = 2,
     broken = false,
@@ -10,15 +28,15 @@ export function cutPolylineByGrid(positions, options = {}) {
     gridOffset = [0, 0],
     startIndex = 0,
     endIndex = positions.length
-  } = options;
+  } = options || {};
   const numPoints = (endIndex - startIndex) / size;
-  let part = [];
-  const result = [part];
-  const a = getPointAtIndex(positions, 0, size, startIndex);
-  let b;
-  let codeB;
-  const cell = getGridCell(a, gridResolution, gridOffset, []);
-  const scratchPoint = [];
+  let part: number[] = [];
+  const result: number[][] = [part];
+  const a: number[] = getPointAtIndex(positions, 0, size, startIndex);
+  let b: number[];
+  let codeB: number;
+  const cell: BoundingBox = getGridCell(a, gridResolution, gridOffset, []);
+  const scratchPoint: number[] = [];
   push(part, a);
 
   for (let i = 1; i < numPoints; i++) {
@@ -57,29 +75,39 @@ export function cutPolylineByGrid(positions, options = {}) {
 const TYPE_INSIDE = 0;
 const TYPE_BORDER = 1;
 
-function concatInPlace(arr1, arr2) {
+function concatInPlace(arr1: number[], arr2: number[]): number[] {
   for (let i = 0; i < arr2.length; i++) {
     arr1.push(arr2[i]);
   }
   return arr1;
 }
 
-export function cutPolygonByGrid(positions, holeIndices, options = {}) {
+export function cutPolygonByGrid(
+  positions: number[],
+  holeIndices: number[] | null = null,
+  options?: {
+    size?: number;
+    gridResolution?: number;
+    gridOffset?: [number, number];
+    edgeTypes?: boolean;
+  }
+): Polygon[] {
   if (!positions.length) {
     // input is empty
     return [];
   }
-  const {size = 2, gridResolution = 10, gridOffset = [0, 0], edgeTypes = false} = options;
-  const result = [];
-  const queue = [
+  const {size = 2, gridResolution = 10, gridOffset = [0, 0], edgeTypes = false} = options || {};
+  const result: Polygon[] = [];
+  const queue: {pos: number[]; types: number[]; holes: number[]}[] = [
     {
       pos: positions,
-      types: edgeTypes && new Array(positions.length / size).fill(TYPE_BORDER),
+      types: edgeTypes ? (new Array(positions.length / size).fill(TYPE_BORDER) as number[]) : null,
       holes: holeIndices || []
     }
   ];
-  const bbox = [[], []];
-  let cell = [];
+  const bbox: number[][] = [[], []];
+  // @ts-ignore
+  let cell: BoundingBox = [];
 
   // Recursively bisect polygon until every part fit in a single grid cell
   while (queue.length) {
@@ -118,7 +146,7 @@ export function cutPolygonByGrid(positions, holeIndices, options = {}) {
       }
     } else {
       // Polygon fits in a single cell, no more processing required
-      const polygon = {positions: pos};
+      const polygon: Polygon = {positions: pos};
       if (edgeTypes) {
         polygon.edgeTypes = types;
       }
@@ -136,17 +164,25 @@ export function cutPolygonByGrid(positions, holeIndices, options = {}) {
 // TYPE_BORDER - edge from the original polygon
 // TYPE_INSIDE - inside the original polygon
 // eslint-disable-next-line max-params
-function bisectPolygon(positions, edgeTypes, size, startIndex, endIndex, bbox, edge) {
+function bisectPolygon(
+  positions: NumericArray,
+  edgeTypes: number[] | undefined,
+  size: number,
+  startIndex: number,
+  endIndex: number,
+  bbox: BoundingBox,
+  edge: number
+) {
   const numPoints = (endIndex - startIndex) / size;
-  const resultLow = [];
-  const resultHigh = [];
-  const typesLow = [];
-  const typesHigh = [];
-  const scratchPoint = [];
-
-  let p;
-  let side;
-  let type;
+  const resultLow: number[] = [];
+  const resultHigh: number[] = [];
+  const typesLow: number[] = [];
+  const typesHigh: number[] = [];
+  const scratchPoint: number[] = [];
+
+  let p: number[];
+  let side: number;
+  let type: number;
   const prev = getPointAtIndex(positions, numPoints - 1, size, startIndex);
   let prevSide = Math.sign(edge & 8 ? prev[1] - bbox[3] : prev[0] - bbox[2]);
   let prevType = edgeTypes && edgeTypes[numPoints - 1];
@@ -189,7 +225,12 @@ function bisectPolygon(positions, edgeTypes, size, startIndex, endIndex, bbox, e
   ];
 }
 
-function getGridCell(p, gridResolution, gridOffset, out) {
+function getGridCell(
+  p: number[],
+  gridResolution: number,
+  gridOffset: [number, number],
+  out: number[]
+): BoundingBox {
   const left = Math.floor((p[0] - gridOffset[0]) / gridResolution) * gridResolution + gridOffset[0];
   const bottom =
     Math.floor((p[1] - gridOffset[1]) / gridResolution) * gridResolution + gridOffset[1];
@@ -197,10 +238,10 @@ function getGridCell(p, gridResolution, gridOffset, out) {
   out[1] = bottom;
   out[2] = left + gridResolution;
   out[3] = bottom + gridResolution;
-  return out;
+  return out as BoundingBox;
 }
 
-function moveToNeighborCell(cell, gridResolution, edge) {
+function moveToNeighborCell(cell: number[], gridResolution: number, edge: number): void {
   if (edge & 8) {
     // top
     cell[1] += gridResolution;
@@ -220,7 +261,12 @@ function moveToNeighborCell(cell, gridResolution, edge) {
   }
 }
 
-function getBoundingBox(positions, size, endIndex, out) {
+function getBoundingBox(
+  positions: NumericArray,
+  size: number,
+  endIndex: number,
+  out: number[][]
+): number[][] {
   let minX = Infinity;
   let maxX = -Infinity;
   let minY = Infinity;

package/src/{cut-by-mercator-bounds.js → cut-by-mercator-bounds.ts}

@@ -1,12 +1,22 @@
 import {cutPolylineByGrid, cutPolygonByGrid} from './cut-by-grid';
 import {getPointAtIndex, push} from './utils';
+import type {Polygon} from './cut-by-grid';
+import type {NumericArray} from '@math.gl/core';
 
 // https://en.wikipedia.org/wiki/Web_Mercator_projection
 const DEFAULT_MAX_LATITUDE = 85.051129;
 
-// https://user-images.githubusercontent.com/2059298/78465769-938b7a00-76ae-11ea-9b95-1f4c26425ab9.png
-export function cutPolylineByMercatorBounds(positions, options = {}) {
-  const {size = 2, startIndex = 0, endIndex = positions.length, normalize = true} = options;
+/** https://user-images.githubusercontent.com/2059298/78465769-938b7a00-76ae-11ea-9b95-1f4c26425ab9.png */
+export function cutPolylineByMercatorBounds(
+  positions: NumericArray,
+  options?: {
+    size?: number;
+    startIndex?: number;
+    endIndex?: number;
+    normalize?: boolean;
+  }
+): number[][] {
+  const {size = 2, startIndex = 0, endIndex = positions.length, normalize = true} = options || {};
 
   // Remap longitudes so that each segment takes the shorter path
   const newPositions = positions.slice(startIndex, endIndex);
@@ -17,7 +27,7 @@ export function cutPolylineByMercatorBounds(positions, options = {}) {
     broken: true,
     gridResolution: 360,
     gridOffset: [-180, -180]
-  });
+  }) as number[][];
 
   if (normalize) {
     // Each part is guaranteed to be in a single copy of the world
@@ -29,12 +39,21 @@ export function cutPolylineByMercatorBounds(positions, options = {}) {
   return parts;
 }
 
-// https://user-images.githubusercontent.com/2059298/78465770-94241080-76ae-11ea-809a-6a8534dac1d9.png
-export function cutPolygonByMercatorBounds(positions, holeIndices, options = {}) {
-  const {size = 2, normalize = true, edgeTypes = false} = options;
+/** https://user-images.githubusercontent.com/2059298/78465770-94241080-76ae-11ea-809a-6a8534dac1d9.png */
+export function cutPolygonByMercatorBounds(
+  positions: number[],
+  holeIndices: number[] | null = null,
+  options?: {
+    size?: number;
+    normalize?: boolean;
+    maxLatitude?: number;
+    edgeTypes?: boolean;
+  }
+): Polygon[] {
+  const {size = 2, normalize = true, edgeTypes = false} = options || {};
   holeIndices = holeIndices || [];
-  const newPositions = [];
-  const newHoleIndices = [];
+  const newPositions: number[] = [];
+  const newHoleIndices: number[] = [];
   let srcStartIndex = 0;
   let targetIndex = 0;
 
@@ -59,7 +78,7 @@ export function cutPolygonByMercatorBounds(positions, holeIndices, options = {})
     wrapLongitudesForShortestPath(newPositions, size, targetStartIndex, targetIndex);
 
     // Handle the case when the ring contains a pole
-    insertPoleVertices(newPositions, size, targetStartIndex, targetIndex, options.maxLatitude);
+    insertPoleVertices(newPositions, size, targetStartIndex, targetIndex, options?.maxLatitude);
 
     srcStartIndex = srcEndIndex;
     newHoleIndices[ringIndex] = targetIndex;
@@ -86,7 +105,12 @@ export function cutPolygonByMercatorBounds(positions, holeIndices, options = {})
 /* Helpers */
 
 // See comments for insertPoleVertices
-function findSplitIndex(positions, size, startIndex, endIndex) {
+function findSplitIndex(
+  positions: number[],
+  size: number,
+  startIndex: number,
+  endIndex: number
+): number {
   let maxLat = -1;
   let pointIndex = -1;
   for (let i = startIndex + 1; i < endIndex; i += size) {
@@ -109,12 +133,12 @@ function findSplitIndex(positions, size, startIndex, endIndex) {
 // intersect with the ring itself. This is ensured by findSplitIndex, which returns the
 // vertex closest to the pole.
 function insertPoleVertices(
-  positions,
-  size,
-  startIndex,
-  endIndex,
-  maxLatitude = DEFAULT_MAX_LATITUDE
-) {
+  positions: number[],
+  size: number,
+  startIndex: number,
+  endIndex: number,
+  maxLatitude: number = DEFAULT_MAX_LATITUDE
+): void {
   // Check if the ring contains a pole
   const firstLng = positions[startIndex];
   const lastLng = positions[endIndex - size];
@@ -134,9 +158,14 @@ function insertPoleVertices(
   }
 }
 
-function wrapLongitudesForShortestPath(positions, size, startIndex, endIndex) {
-  let prevLng = positions[0];
-  let lng;
+function wrapLongitudesForShortestPath(
+  positions: NumericArray,
+  size: number,
+  startIndex: number,
+  endIndex: number
+): void {
+  let prevLng: number = positions[0];
+  let lng: number;
   for (let i = startIndex; i < endIndex; i += size) {
     lng = positions[i];
     const delta = lng - prevLng;
@@ -147,8 +176,8 @@ function wrapLongitudesForShortestPath(positions, size, startIndex, endIndex) {
   }
 }
 
-function shiftLongitudesIntoRange(positions, size) {
-  let refLng;
+function shiftLongitudesIntoRange(positions: NumericArray, size: number): void {
+  let refLng: number;
   const pointCount = positions.length / size;
 
   // Find a longitude that is not on the edge of a world

package/src/{earcut.js → earcut.ts}

@@ -22,16 +22,28 @@
 
  */
 
-/* eslint-disable complexity, max-params, max-statements, max-depth, no-continue, no-shadow */
+/* eslint-disable */
 
 import {getPolygonSignedArea} from './polygon-utils';
 
-export function earcut(data, holeIndices, dim, areas) {
-  dim = dim || 2;
-
+/**
+ * Computes a triangulation of a polygon
+ * @param positions a flat array of the vertex positions that define the polygon.
+ * @param holeIndices an array of hole indices if any (e.g. [5, 8] for a 12-vertex input would mean one hole with vertices 5–7 and another with 8–11).
+ * @param dim the number of elements in each vertex. Size `2` will interpret `positions` as `[x0, y0, x1, y1, ...]` and size `3` will interpret `positions` as `[x0, y0, z0, x1, y1, z1, ...]`. Default `2`.
+ * @param areas areas of outer polygon and holes as computed by `getPolygonSignedArea()`. Can be optionally supplied to speed up triangulation
+ * @returns array of indices into the `positions` array that describes the triangulation of the polygon
+ * Adapted from https://github.com/mapbox/earcut
+ */
+export function earcut(
+  positions: number[],
+  holeIndices?: number[],
+  dim: number = 2,
+  areas?: number[]
+): number[] {
   const hasHoles = holeIndices && holeIndices.length;
-  const outerLen = hasHoles ? holeIndices[0] * dim : data.length;
-  let outerNode = linkedList(data, 0, outerLen, dim, true, areas && areas[0]);
+  const outerLen = hasHoles ? holeIndices[0] * dim : positions.length;
+  let outerNode = linkedList(positions, 0, outerLen, dim, true, areas && areas[0]);
   const triangles = [];
 
   if (!outerNode || outerNode.next === outerNode.prev) return triangles;
@@ -44,16 +56,16 @@ export function earcut(data, holeIndices, dim, areas) {
   let x;
   let y;
 
-  if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim, areas);
+  if (hasHoles) outerNode = eliminateHoles(positions, holeIndices, outerNode, dim, areas);
 
   // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
-  if (data.length > 80 * dim) {
-    minX = maxX = data[0];
-    minY = maxY = data[1];
+  if (positions.length > 80 * dim) {
+    minX = maxX = positions[0];
+    minY = maxY = positions[1];
 
     for (let i = dim; i < outerLen; i += dim) {
-      x = data[i];
-      y = data[i + 1];
+      x = positions[i];
+      y = positions[i + 1];
       if (x < minX) minX = x;
       if (y < minY) minY = y;
       if (x > maxX) maxX = x;
@@ -96,7 +108,7 @@ function linkedList(data, start, end, dim, clockwise, area) {
 }
 
 // eliminate colinear or duplicate points
-function filterPoints(start, end) {
+function filterPoints(start, end?) {
   if (!start) return start;
   if (!end) end = start;
 
@@ -119,7 +131,7 @@ function filterPoints(start, end) {
 }
 
 // main ear slicing loop which triangulates a polygon (given as a linked list)
-function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
+function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass?) {
   if (!ear) return;
 
   // interlink polygon nodes in z-order

package/src/{lineclip.js → lineclip.ts}

@@ -20,22 +20,34 @@
 
  */
 
-/* eslint-disable max-statements, max-depth */
+/* eslint-disable max-statements, max-depth, complexity */
 
 import {push, copy, getPointAtIndex} from './utils';
 
-// Cohen-Sutherland line clipping algorithm, adapted to efficiently
-// handle polylines rather than just segments
-export function clipPolyline(positions, bbox, options = {}) {
-  const {size = 2, startIndex = 0, endIndex = positions.length} = options;
+export type BoundingBox = [number, number, number, number];
+
+/**
+ * Cohen-Sutherland line clipping algorithm, adapted to efficiently
+ * handle polylines rather than just segments
+ */
+export function clipPolyline(
+  positions: number[],
+  bbox: BoundingBox,
+  options?: {
+    size?: number;
+    startIndex?: number;
+    endIndex?: number;
+  }
+): number[][] {
+  const {size = 2, startIndex = 0, endIndex = positions.length} = options || {};
   const numPoints = (endIndex - startIndex) / size;
-  const result = [];
-  let part = [];
-  let a;
-  let b;
-  let codeA = -1;
-  let codeB;
-  let lastCode;
+  const result: number[][] = [];
+  let part: number[] = [];
+  let a: number[];
+  let b: number[];
+  let codeA: number = -1;
+  let codeB: number;
+  let lastCode: number;
 
   for (let i = 1; i < numPoints; i++) {
     a = getPointAtIndex(positions, i - 1, size, startIndex, a);
@@ -86,17 +98,27 @@ export function clipPolyline(positions, bbox, options = {}) {
   return result;
 }
 
-// Sutherland-Hodgeman polygon clipping algorithm
-// polygon must be closed (first vertex == last vertex)
-export function clipPolygon(positions, bbox, options = {}) {
-  const {size = 2, endIndex = positions.length} = options;
-  let {startIndex = 0} = options;
+/**
+ * Sutherland-Hodgeman polygon clipping algorithm
+ * polygon must be closed (first vertex == last vertex)
+ */
+export function clipPolygon(
+  positions: number[],
+  bbox: BoundingBox,
+  options?: {
+    size?: number;
+    startIndex?: number;
+    endIndex?: number;
+  }
+): number[] {
+  const {size = 2, endIndex = positions.length} = options || {};
+  let {startIndex = 0} = options || {};
   let numPoints = (endIndex - startIndex) / size;
-  let result;
-  let p;
-  let prev;
-  let inside;
-  let prevInside;
+  let result: number[];
+  let p: number[];
+  let prev: number[];
+  let inside: boolean;
+  let prevInside: boolean;
 
   // clip against each side of the clip rectangle
   for (let edge = 1; edge <= 8; edge *= 2) {
@@ -128,14 +150,20 @@ export function clipPolygon(positions, bbox, options = {}) {
   return result;
 }
 
-// intersect a segment against one of the 4 lines that make up the bbox
+/** intersect a segment against one of the 4 lines that make up the bbox */
 
-export function intersect(a, b, edge, bbox, out = []) {
+export function intersect(
+  a: number[],
+  b: number[],
+  edge: number,
+  bbox: BoundingBox,
+  out: number[] = []
+): number[] {
   let t;
   // Forces out[snapI] to be on the bbox edge
   // Interpolation introduces precision issue which may cause lineclip to be
   // stuck in an infinite loop
-  let snap;
+  let snap: number;
   if (edge & 8) {
     // top
     t = (bbox[3] - a[1]) / (b[1] - a[1]);
@@ -161,14 +189,14 @@ export function intersect(a, b, edge, bbox, out = []) {
   return out;
 }
 
-// bit code reflects the point position relative to the bbox:
-
-//         left  mid  right
-//    top  1001  1000  1010
-//    mid  0001  0000  0010
-// bottom  0101  0100  0110
-
-export function bitCode(p, bbox) {
+/**
+ * bit code reflects the point position relative to the bbox:
+ *         left  mid  right
+ *    top  1001  1000  1010
+ *    mid  0001  0000  0010
+ * bottom  0101  0100  0110
+ */
+export function bitCode(p: number[], bbox: BoundingBox): number {
   let code = 0;
 
   if (p[0] < bbox[0]) code |= 1;