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

package/src/cut-by-grid.ts

@@ -1,15 +1,17 @@
 /* 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';
 
+import type {NumericArray} from '@math.gl/core';
+
 export type Polygon = {
-  positions: Array<number>;
-  holeIndices?: Array<number>;
-  vertexTypes?: Array<number>;
+  positions: number[];
+  holeIndices?: number[];
+  edgeTypes?: number[];
 };
 
 export function cutPolylineByGrid(
-  positions: Array<number>,
+  positions: NumericArray,
   options?: {
     size?: number;
     broken?: boolean;
@@ -18,7 +20,7 @@ export function cutPolylineByGrid(
     startIndex?: number;
     endIndex?: number;
   }
-): Array<number> | Array<Array<number>> {
+): number[] | number[][] {
   const {
     size = 2,
     broken = false,
@@ -28,13 +30,13 @@ export function cutPolylineByGrid(
     endIndex = positions.length
   } = 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++) {
@@ -73,7 +75,7 @@ export function cutPolylineByGrid(
 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]);
   }
@@ -81,30 +83,31 @@ function concatInPlace(arr1, arr2) {
 }
 
 export function cutPolygonByGrid(
-  positions: Array<number>,
-  holeIndices: Array<number> | null = null,
+  positions: number[],
+  holeIndices: number[] | null = null,
   options?: {
     size?: number;
     gridResolution?: number;
     gridOffset?: [number, number];
     edgeTypes?: boolean;
   }
-): Array<Polygon> {
+): Polygon[] {
   if (!positions.length) {
     // input is empty
     return [];
   }
   const {size = 2, gridResolution = 10, gridOffset = [0, 0], edgeTypes = false} = options || {};
-  const result = [];
-  const queue = [
+  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) {
@@ -113,7 +116,6 @@ export function cutPolygonByGrid(
     // Get the bounding box of the outer polygon
     getBoundingBox(pos, size, holes[0] || pos.length, bbox);
     cell = getGridCell(bbox[0], gridResolution, gridOffset, cell);
-    // @ts-expect-error
     const code = bitCode(bbox[1], cell);
 
     if (code) {
@@ -144,13 +146,11 @@ export function cutPolygonByGrid(
       }
     } else {
       // Polygon fits in a single cell, no more processing required
-      const polygon = {positions: pos};
+      const polygon: Polygon = {positions: pos};
       if (edgeTypes) {
-        // @ts-expect-error
         polygon.edgeTypes = types;
       }
       if (holes.length) {
-        // @ts-expect-error
         polygon.holeIndices = holes;
       }
 
@@ -164,17 +164,25 @@ export function cutPolygonByGrid(
 // 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 = [];
+  const resultLow: number[] = [];
+  const resultHigh: number[] = [];
+  const typesLow: number[] = [];
+  const typesHigh: number[] = [];
+  const scratchPoint: number[] = [];
 
-  let p;
-  let side;
-  let type;
+  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];
@@ -217,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];
@@ -225,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;
@@ -248,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.ts

@@ -1,20 +1,21 @@
 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: Array<number>,
+  positions: NumericArray,
   options?: {
     size?: number;
     startIndex?: number;
     endIndex?: number;
     normalize?: boolean;
   }
-): Array<number> {
+): number[][] {
   const {size = 2, startIndex = 0, endIndex = positions.length, normalize = true} = options || {};
 
   // Remap longitudes so that each segment takes the shorter path
@@ -26,7 +27,7 @@ export function cutPolylineByMercatorBounds(
     broken: true,
     gridResolution: 360,
     gridOffset: [-180, -180]
-  });
+  }) as number[][];
 
   if (normalize) {
     // Each part is guaranteed to be in a single copy of the world
@@ -35,25 +36,24 @@ export function cutPolylineByMercatorBounds(
       shiftLongitudesIntoRange(part, size);
     }
   }
-  // @ts-expect-error
   return parts;
 }
 
 /** https://user-images.githubusercontent.com/2059298/78465770-94241080-76ae-11ea-809a-6a8534dac1d9.png */
 export function cutPolygonByMercatorBounds(
-  positions: Array<number>,
-  holeIndices: Array<number> | null = null,
+  positions: number[],
+  holeIndices: number[] | null = null,
   options?: {
     size?: number;
     normalize?: boolean;
     maxLatitude?: number;
     edgeTypes?: boolean;
   }
-): Array<Polygon> {
+): 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;
 
@@ -105,7 +105,12 @@ export function cutPolygonByMercatorBounds(
 /* 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) {
@@ -128,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];
@@ -153,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;
@@ -166,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.ts

@@ -22,7 +22,7 @@
 
  */
 
-/* eslint-disable complexity, max-params, max-statements, max-depth, no-continue, no-shadow */
+/* eslint-disable */
 
 import {getPolygonSignedArea} from './polygon-utils';
 

package/src/lineclip.ts

@@ -24,7 +24,7 @@
 
 import {push, copy, getPointAtIndex} from './utils';
 
-type BoundingBox = [number, number, number, number];
+export type BoundingBox = [number, number, number, number];
 
 /**
  * Cohen-Sutherland line clipping algorithm, adapted to efficiently
@@ -41,13 +41,13 @@ export function clipPolyline(
 ): 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);
@@ -114,11 +114,11 @@ export function clipPolygon(
   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) {
@@ -163,7 +163,7 @@ export function intersect(
   // 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]);

package/src/polygon-utils.ts

@@ -132,7 +132,10 @@ export function forEachSegmentInPolygon(
   }
 }
 
-function reversePolygon(points, options) {
+function reversePolygon(
+  points: NumericArray,
+  options: {start?: number; end?: number; size?: number}
+): void {
   const {start = 0, end = points.length, size = 2} = options;
 
   const numPoints = (end - start) / size;

package/src/polygon.ts

@@ -1,6 +1,7 @@
 /* eslint-disable no-undef, no-console */
 import {isArray} from '@math.gl/core';
 import type {SegmentVisitorPoints} from './polygon-utils';
+import type {NumericArray} from '@math.gl/core';
 
 import {
   getPolygonSignedArea,
@@ -19,11 +20,11 @@ export type PolygonOptions = {
 };
 
 export default class Polygon {
-  points; // : number[];
+  points: NumericArray | number[][];
   isFlatArray: boolean;
   options: PolygonOptions;
 
-  constructor(points /* : number[] */, options: PolygonOptions = {}) {
+  constructor(points: NumericArray | number[][], options: PolygonOptions = {}) {
     this.points = points;
     this.isFlatArray = !isArray(points[0]);
 
@@ -42,9 +43,9 @@ export default class Polygon {
    * @returns Signed area of the polygon.
    */
   getSignedArea(): number {
-    if (this.isFlatArray) return getPolygonSignedArea(this.points, this.options);
+    if (this.isFlatArray) return getPolygonSignedArea(this.points as NumericArray, this.options);
 
-    return getPolygonSignedAreaPoints(this.points, this.options);
+    return getPolygonSignedAreaPoints(this.points as number[][], this.options);
   }
 
   /**
@@ -70,7 +71,7 @@ export default class Polygon {
   forEachSegment(visitor: SegmentVisitorPoints): void {
     if (this.isFlatArray) {
       forEachSegmentInPolygon(
-        this.points,
+        this.points as NumericArray,
         // eslint-disable-next-line max-params
         (x1, y1, x2, y2, i1, i2) => {
           // TODO @igorDykhta original visitor uses arrays for each point, but with flat arrays performance degrades if we allocate points for each segment
@@ -79,7 +80,7 @@ export default class Polygon {
         this.options
       );
     } else {
-      forEachSegmentInPolygonPoints(this.points, visitor, this.options);
+      forEachSegmentInPolygonPoints(this.points as number[][], visitor, this.options);
     }
   }
 
@@ -90,8 +91,8 @@ export default class Polygon {
    */
   modifyWindingDirection(direction: number): boolean {
     if (this.isFlatArray) {
-      return modifyPolygonWindingDirection(this.points, direction, this.options);
+      return modifyPolygonWindingDirection(this.points as NumericArray, direction, this.options);
     }
-    return modifyPolygonWindingDirectionPoints(this.points, direction, this.options);
+    return modifyPolygonWindingDirectionPoints(this.points as number[][], direction, this.options);
   }
 }

package/src/utils.ts

@@ -1,4 +1,6 @@
-export function push(target, source) {
+import type {NumericArray} from '@math.gl/core';
+
+export function push(target: number[], source: number[]): boolean {
   const size = source.length;
   const startIndex = target.length;
 
@@ -22,14 +24,20 @@ export function push(target, source) {
   return true;
 }
 
-export function copy(target, source) {
+export function copy(target: number[], source: Readonly<NumericArray>): void {
   const size = source.length;
   for (let i = 0; i < size; i++) {
     target[i] = source[i];
   }
 }
 
-export function getPointAtIndex(positions, index, size, offset, out = []) {
+export function getPointAtIndex(
+  positions: NumericArray,
+  index: number,
+  size: number,
+  offset: number,
+  out: number[] = []
+): number[] {
   const startI = offset + index * size;
   for (let i = 0; i < size; i++) {
     out[i] = positions[startI + i];