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

package/dist/lineclip.js

@@ -0,0 +1,178 @@
+/*
+  Adapted from https://github.com/mapbox/lineclip to work with flat arrays
+  and 3d positions
+
+  ISC License
+
+  Copyright (c) 2015, Mapbox
+
+  Permission to use, copy, modify, and/or distribute this software for any purpose
+  with or without fee is hereby granted, provided that the above copyright notice
+  and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+  OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+  TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+  THIS SOFTWARE.
+
+ */
+/* 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 || {};
+    const numPoints = (endIndex - startIndex) / size;
+    const result = [];
+    let part = [];
+    let a;
+    let b;
+    let codeA = -1;
+    let codeB;
+    let lastCode;
+    for (let i = 1; i < numPoints; i++) {
+        a = getPointAtIndex(positions, i - 1, size, startIndex, a);
+        b = getPointAtIndex(positions, i, size, startIndex, b);
+        if (codeA < 0) {
+            codeA = bitCode(a, bbox);
+        }
+        codeB = lastCode = bitCode(b, bbox);
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            if (!(codeA | codeB)) {
+                // accept
+                push(part, a);
+                if (codeB !== lastCode) {
+                    // segment went outside
+                    push(part, b);
+                    if (i < numPoints - 1) {
+                        // start a new line
+                        result.push(part);
+                        part = [];
+                    }
+                }
+                else if (i === numPoints - 1) {
+                    push(part, b);
+                }
+                break;
+            }
+            else if (codeA & codeB) {
+                // trivial reject
+                break;
+            }
+            else if (codeA) {
+                // a outside, intersect with clip edge
+                intersect(a, b, codeA, bbox, a);
+                codeA = bitCode(a, bbox);
+            }
+            else {
+                // b outside
+                intersect(a, b, codeB, bbox, b);
+                codeB = bitCode(b, bbox);
+            }
+        }
+        codeA = lastCode;
+    }
+    if (part.length)
+        result.push(part);
+    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 || {};
+    let numPoints = (endIndex - startIndex) / size;
+    let result;
+    let p;
+    let prev;
+    let inside;
+    let prevInside;
+    // clip against each side of the clip rectangle
+    for (let edge = 1; edge <= 8; edge *= 2) {
+        result = [];
+        prev = getPointAtIndex(positions, numPoints - 1, size, startIndex, prev);
+        prevInside = !(bitCode(prev, bbox) & edge);
+        for (let i = 0; i < numPoints; i++) {
+            p = getPointAtIndex(positions, i, size, startIndex, p);
+            inside = !(bitCode(p, bbox) & edge);
+            // if segment goes through the clip window, add an intersection
+            if (inside !== prevInside)
+                push(result, intersect(prev, p, edge, bbox));
+            if (inside)
+                push(result, p); // add a point if it's inside
+            copy(prev, p);
+            prevInside = inside;
+        }
+        // close loop
+        positions = result;
+        startIndex = 0;
+        numPoints = result.length / size;
+        if (!numPoints)
+            break;
+    }
+    return result;
+}
+/** intersect a segment against one of the 4 lines that make up the bbox */
+export function intersect(a, b, edge, bbox, out = []) {
+    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;
+    if (edge & 8) {
+        // top
+        t = (bbox[3] - a[1]) / (b[1] - a[1]);
+        snap = 3;
+    }
+    else if (edge & 4) {
+        // bottom
+        t = (bbox[1] - a[1]) / (b[1] - a[1]);
+        snap = 1;
+    }
+    else if (edge & 2) {
+        // right
+        t = (bbox[2] - a[0]) / (b[0] - a[0]);
+        snap = 2;
+    }
+    else if (edge & 1) {
+        // left
+        t = (bbox[0] - a[0]) / (b[0] - a[0]);
+        snap = 0;
+    }
+    else {
+        return null;
+    }
+    for (let i = 0; i < a.length; i++) {
+        out[i] = (snap & 1) === i ? bbox[snap] : t * (b[i] - a[i]) + a[i];
+    }
+    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) {
+    let code = 0;
+    if (p[0] < bbox[0])
+        code |= 1;
+    // left
+    else if (p[0] > bbox[2])
+        code |= 2; // right
+    if (p[1] < bbox[1])
+        code |= 4;
+    // bottom
+    else if (p[1] > bbox[3])
+        code |= 8; // top
+    return code;
+}

package/dist/{es5/polygon-utils.d.ts → polygon-utils.d.ts}

@@ -1,34 +1,21 @@
-import {NumberArray} from '@math.gl/core/';
-
-export const WINDING: {
-  CLOCKWISE: number;
-  COUNTER_CLOCKWISE: number;
+import type { NumericArray } from '@math.gl/core';
+export declare enum WINDING {
+    CLOCKWISE = 1,
+    COUNTER_CLOCKWISE = -1
+}
+/** Polygon representation where each point is represented as a separate array of positions. */
+declare type PointsArray = NumericArray[];
+/** Segment visitor callback type for polygons defined with flat arrays, */
+declare type SegmentVisitorFlat = (p1x: number, p1y: number, p2x: number, p2y: number, i1: number, i2: number) => void;
+/** Segment visitor callback type for polygons defined with array of points. */
+export declare type SegmentVisitorPoints = (p1: NumericArray, p2: NumericArray, i1: number, i2: number) => void;
+/** Parameters of a polygon. */
+declare type PolygonParams = {
+    start?: number;
+    end?: number;
+    size?: number;
+    isClosed?: boolean;
 };
-
-// Polygon representation where each point is represented as a separate array of positions.
-type PointsArray = NumberArray[];
-
-// Segment visitor callback type for polygons defined with flat arrays,
-type SegmentVisitorFlat = (
-  p1x: number,
-  p1y: number,
-  p2x: number,
-  p2y: number,
-  i1: number,
-  i2: number
-) => void;
-
-// Segment visitor callback type for polygons defined with array of points.
-export type SegmentVisitorPoints = (p1: NumberArray, p2: NumberArray, i1: number, i2: number) => void;
-
-// Parameters of a polygon.
-type PolygonParams = {
-  start?: number; // Start index of the polygon in the array of positions. Defaults to 0.
-  end?: number; // End index of the polygon in the array of positions. Defaults to number of positions.
-  size?: number; // Size of a point, 2 (XZ) or 3 (XYZ). Defaults to 2. Affects only polygons stored in flat arrays.
-  isClosed?: boolean; // Indicates that the first point of the polygon is equal to the last point, and additional checks should be ommited.
-};
-
 /**
  * Checks winding direction of the polygon and reverses the polygon in case of opposite winding direction.
  * Note: points are modified in-place.
@@ -37,40 +24,29 @@ type PolygonParams = {
  * @param options Parameters of the polygon.
  * @return Returns true if the winding direction was changed.
  */
-export function modifyPolygonWindingDirection(
-  points: NumberArray,
-  direction: number,
-  options?: PolygonParams
-): boolean;
-
+export declare function modifyPolygonWindingDirection(points: NumericArray, direction: number, options?: PolygonParams): boolean;
 /**
  * Returns winding direction of the polygon.
  * @param points An array that represents points of the polygon.
  * @param options Parameters of the polygon.
  * @returns Winding direction of the polygon.
  */
-export function getPolygonWindingDirection(points: NumberArray, options?: PolygonParams): number;
-
+export declare function getPolygonWindingDirection(points: NumericArray, options?: PolygonParams): number;
 /**
  * Returns signed area of the polygon.
  * @param points An array that represents points of the polygon.
  * @param options Parameters of the polygon.
  * @returns Signed area of the polygon.
+ * https://en.wikipedia.org/wiki/Shoelace_formula
  */
-export function getPolygonSignedArea(points: NumberArray, options?: PolygonParams): number;
-
+export declare function getPolygonSignedArea(points: NumericArray, options?: PolygonParams): number;
 /**
  * Calls the visitor callback for each segment in the polygon.
  * @param points An array that represents points of the polygon
  * @param visitor A callback to call for each segment.
  * @param options Parameters of the polygon.
  */
-export function forEachSegmentInPolygon(
-  points: NumberArray,
-  visitor: SegmentVisitorFlat,
-  options?: PolygonParams
-): void;
-
+export declare function forEachSegmentInPolygon(points: NumericArray, visitor: SegmentVisitorFlat, options?: PolygonParams): void;
 /**
  * Checks winding direction of the polygon and reverses the polygon in case of opposite winding direction.
  * Note: points are modified in-place.
@@ -79,39 +55,27 @@ export function forEachSegmentInPolygon(
  * @param options Parameters of the polygon.
  * @return Returns true if the winding direction was changed.
  */
-export function modifyPolygonWindingDirectionPoints(
-  points: PointsArray,
-  direction: number,
-  options?: PolygonParams
-): boolean;
-
+export declare function modifyPolygonWindingDirectionPoints(points: PointsArray, direction: number, options?: PolygonParams): boolean;
 /**
  * Returns winding direction of the polygon.
  * @param points Array of points that represent the polygon.
  * @param options Parameters of the polygon.
  * @returns Winding direction of the polygon.
  */
-export function getPolygonWindingDirectionPoints(
-  points: PointsArray,
-  options?: PolygonParams
-): number;
-
+export declare function getPolygonWindingDirectionPoints(points: PointsArray, options?: PolygonParams): number;
 /**
  * Returns signed area of the polygon.
  * @param points Array of points that represent the polygon.
  * @param options Parameters of the polygon.
  * @returns Signed area of the polygon.
  */
-export function getPolygonSignedAreaPoints(points: PointsArray, options?: PolygonParams): number;
-
+export declare function getPolygonSignedAreaPoints(points: PointsArray, options?: PolygonParams): number;
 /**
  * Calls visitor callback for each segment in the polygon.
  * @param points Array of points that represent the polygon.
  * @param visitor A callback to call for each segment.
  * @param options Parameters of the polygon.
  */
-export function forEachSegmentInPolygonPoints(
-  points: PointsArray,
-  visitor: SegmentVisitorPoints,
-  options?: PolygonParams
-): void;
+export declare function forEachSegmentInPolygonPoints(points: PointsArray, visitor: SegmentVisitorPoints, options?: PolygonParams): void;
+export {};
+//# sourceMappingURL=polygon-utils.d.ts.map

package/dist/polygon-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon-utils.d.ts","sourceRoot":"","sources":["../src/polygon-utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAEhD,oBAAY,OAAO;IACjB,SAAS,IAAI;IACb,iBAAiB,KAAK;CACvB;AAED,+FAA+F;AAC/F,aAAK,WAAW,GAAG,YAAY,EAAE,CAAC;AAElC,2EAA2E;AAC3E,aAAK,kBAAkB,GAAG,CACxB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,KACP,IAAI,CAAC;AAEV,+EAA+E;AAC/E,oBAAY,oBAAoB,GAAG,CACjC,EAAE,EAAE,YAAY,EAChB,EAAE,EAAE,YAAY,EAChB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,KACP,IAAI,CAAC;AAEV,+BAA+B;AAC/B,aAAK,aAAa,GAAG;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,YAAY,EACpB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAOT;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,YAAY,EACpB,OAAO,GAAE,aAAkB,GAC1B,MAAM,CAER;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,CAS9F;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,kBAAkB,EAC3B,OAAO,GAAE,aAAkB,GAC1B,IAAI,CA+BN;AAqBD;;;;;;;GAOG;AACH,wBAAgB,mCAAmC,CACjD,MAAM,EAAE,WAAW,EACnB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAOT;AAED;;;;;GAKG;AACH,wBAAgB,gCAAgC,CAC9C,MAAM,EAAE,WAAW,EACnB,OAAO,GAAE,aAAkB,GAC1B,MAAM,CAER;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,WAAW,EACnB,OAAO,GAAE,aAAkB,GAC1B,MAAM,CASR;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,oBAAoB,EAC7B,OAAO,GAAE,aAAkB,GAC1B,IAAI,CAUN"}

package/dist/polygon-utils.js

@@ -0,0 +1,140 @@
+/* eslint-disable max-statements, max-depth, complexity, no-unused-expressions */
+import { equals } from '@math.gl/core';
+export var WINDING;
+(function (WINDING) {
+    WINDING[WINDING["CLOCKWISE"] = 1] = "CLOCKWISE";
+    WINDING[WINDING["COUNTER_CLOCKWISE"] = -1] = "COUNTER_CLOCKWISE";
+})(WINDING || (WINDING = {}));
+/**
+ * Checks winding direction of the polygon and reverses the polygon in case of opposite winding direction.
+ * Note: points are modified in-place.
+ * @param points An array that represents points of the polygon.
+ * @param direction Requested winding direction. 1 is for clockwise, -1 for counterclockwise winding direction.
+ * @param options Parameters of the polygon.
+ * @return Returns true if the winding direction was changed.
+ */
+export function modifyPolygonWindingDirection(points, direction, options = {}) {
+    const windingDirection = getPolygonWindingDirection(points, options);
+    if (windingDirection !== direction) {
+        reversePolygon(points, options);
+        return true;
+    }
+    return false;
+}
+/**
+ * Returns winding direction of the polygon.
+ * @param points An array that represents points of the polygon.
+ * @param options Parameters of the polygon.
+ * @returns Winding direction of the polygon.
+ */
+export function getPolygonWindingDirection(points, options = {}) {
+    return Math.sign(getPolygonSignedArea(points, options));
+}
+/**
+ * Returns signed area of the polygon.
+ * @param points An array that represents points of the polygon.
+ * @param options Parameters of the polygon.
+ * @returns Signed area of the polygon.
+ * https://en.wikipedia.org/wiki/Shoelace_formula
+ */
+export function getPolygonSignedArea(points, options = {}) {
+    const { start = 0, end = points.length } = options;
+    const dim = options.size || 2;
+    let area = 0;
+    for (let i = start, j = end - dim; i < end; i += dim) {
+        area += (points[i] - points[j]) * (points[i + 1] + points[j + 1]);
+        j = i;
+    }
+    return area / 2;
+}
+/**
+ * Calls the visitor callback for each segment in the polygon.
+ * @param points An array that represents points of the polygon
+ * @param visitor A callback to call for each segment.
+ * @param options Parameters of the polygon.
+ */
+export function forEachSegmentInPolygon(points, visitor, options = {}) {
+    const { start = 0, end = points.length, size = 2, isClosed } = options;
+    const numPoints = (end - start) / size;
+    for (let i = 0; i < numPoints - 1; ++i) {
+        visitor(points[start + i * size], points[start + i * size + 1], points[start + (i + 1) * size], points[start + (i + 1) * size + 1], i, i + 1);
+    }
+    const endPointIndex = start + (numPoints - 1) * size;
+    const isClosedEx = isClosed ||
+        (equals(points[start], points[endPointIndex]) &&
+            equals(points[start + 1], points[endPointIndex + 1]));
+    if (!isClosedEx) {
+        visitor(points[endPointIndex], points[endPointIndex + 1], points[start], points[start + 1], numPoints - 1, 0);
+    }
+}
+function reversePolygon(points, options) {
+    const { start = 0, end = points.length, size = 2 } = options;
+    const numPoints = (end - start) / size;
+    const numSwaps = Math.floor(numPoints / 2);
+    for (let i = 0; i < numSwaps; ++i) {
+        const b1 = start + i * size;
+        const b2 = start + (numPoints - 1 - i) * size;
+        for (let j = 0; j < size; ++j) {
+            const tmp = points[b1 + j];
+            points[b1 + j] = points[b2 + j];
+            points[b2 + j] = tmp;
+        }
+    }
+}
+/**
+ * Checks winding direction of the polygon and reverses the polygon in case of opposite winding direction.
+ * Note: points are modified in-place.
+ * @param points Array of points that represent the polygon.
+ * @param direction Requested winding direction. 1 is for clockwise, -1 for counterclockwise winding direction.
+ * @param options Parameters of the polygon.
+ * @return Returns true if the winding direction was changed.
+ */
+export function modifyPolygonWindingDirectionPoints(points, direction, options = {}) {
+    const currentDirection = getPolygonWindingDirectionPoints(points, options);
+    if (currentDirection !== direction) {
+        points.reverse();
+        return true;
+    }
+    return false;
+}
+/**
+ * Returns winding direction of the polygon.
+ * @param points Array of points that represent the polygon.
+ * @param options Parameters of the polygon.
+ * @returns Winding direction of the polygon.
+ */
+export function getPolygonWindingDirectionPoints(points, options = {}) {
+    return Math.sign(getPolygonSignedAreaPoints(points, options));
+}
+/**
+ * Returns signed area of the polygon.
+ * @param points Array of points that represent the polygon.
+ * @param options Parameters of the polygon.
+ * @returns Signed area of the polygon.
+ */
+export function getPolygonSignedAreaPoints(points, options = {}) {
+    // https://en.wikipedia.org/wiki/Shoelace_formula
+    const { start = 0, end = points.length } = options;
+    let area = 0;
+    for (let i = start, j = end - 1; i < end; ++i) {
+        area += (points[i][0] - points[j][0]) * (points[i][1] + points[j][1]);
+        j = i;
+    }
+    return area / 2;
+}
+/**
+ * Calls visitor callback for each segment in the polygon.
+ * @param points Array of points that represent the polygon.
+ * @param visitor A callback to call for each segment.
+ * @param options Parameters of the polygon.
+ */
+export function forEachSegmentInPolygonPoints(points, visitor, options = {}) {
+    const { start = 0, end = points.length, isClosed } = options;
+    for (let i = start; i < end - 1; ++i) {
+        visitor(points[i], points[i + 1], i, i + 1);
+    }
+    const isClosedEx = isClosed || equals(points[end - 1], points[0]);
+    if (!isClosedEx) {
+        visitor(points[end - 1], points[0], end - 1, 0);
+    }
+}

package/dist/polygon.d.ts

@@ -0,0 +1,41 @@
+import type { SegmentVisitorPoints } from './polygon-utils';
+import type { NumericArray } from '@math.gl/core';
+export declare type PolygonOptions = {
+    start?: number;
+    end?: number;
+    size?: number;
+    isClosed?: boolean;
+};
+export default class Polygon {
+    points: NumericArray | number[][];
+    isFlatArray: boolean;
+    options: PolygonOptions;
+    constructor(points: NumericArray | number[][], options?: PolygonOptions);
+    /**
+     * Returns signed area of the polygon.
+     * @returns Signed area of the polygon.
+     */
+    getSignedArea(): number;
+    /**
+     * Returns absolute area of the polygon.
+     * @returns Absolute area of the polygon.
+     */
+    getArea(): number;
+    /**
+     * Returns winding direction of the polygon.
+     * @returns Winding direction of the polygon. 1 is for clockwise, -1 for counterclockwise winding direction.
+     */
+    getWindingDirection(): number;
+    /**
+     * Calls the visitor callback for each segment in the polygon.
+     * @param visitor A callback to call for each segment.
+     */
+    forEachSegment(visitor: SegmentVisitorPoints): void;
+    /**
+     * Checks winding direction of the polygon and reverses the polygon in case of opposite winding direction.
+     * @param direction Requested winding direction. 1 is for clockwise, -1 for counterclockwise winding direction.
+     * @return Returns true if the winding direction was changed.
+     */
+    modifyWindingDirection(direction: number): boolean;
+}
+//# sourceMappingURL=polygon.d.ts.map

package/dist/polygon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon.d.ts","sourceRoot":"","sources":["../src/polygon.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,iBAAiB,CAAC;AAC1D,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAWhD,oBAAY,cAAc,GAAG;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,OAAO;IAC1B,MAAM,EAAE,YAAY,GAAG,MAAM,EAAE,EAAE,CAAC;IAClC,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,cAAc,CAAC;gBAEZ,MAAM,EAAE,YAAY,GAAG,MAAM,EAAE,EAAE,EAAE,OAAO,GAAE,cAAmB;IAc3E;;;OAGG;IACH,aAAa,IAAI,MAAM;IAMvB;;;OAGG;IACH,OAAO,IAAI,MAAM;IAIjB;;;OAGG;IACH,mBAAmB,IAAI,MAAM;IAI7B;;;OAGG;IACH,cAAc,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI;IAgBnD;;;;OAIG;IACH,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;CAMnD"}

package/dist/polygon.js

@@ -0,0 +1,67 @@
+/* eslint-disable no-undef, no-console */
+import { isArray } from '@math.gl/core';
+import { getPolygonSignedArea, forEachSegmentInPolygon, modifyPolygonWindingDirection, getPolygonSignedAreaPoints, forEachSegmentInPolygonPoints, modifyPolygonWindingDirectionPoints } from './polygon-utils';
+export default class Polygon {
+    constructor(points, options = {}) {
+        this.points = points;
+        this.isFlatArray = !isArray(points[0]);
+        this.options = {
+            start: options.start || 0,
+            end: options.end || points.length,
+            size: options.size || 2,
+            isClosed: options.isClosed
+        };
+        Object.freeze(this);
+    }
+    /**
+     * Returns signed area of the polygon.
+     * @returns Signed area of the polygon.
+     */
+    getSignedArea() {
+        if (this.isFlatArray)
+            return getPolygonSignedArea(this.points, this.options);
+        return getPolygonSignedAreaPoints(this.points, this.options);
+    }
+    /**
+     * Returns absolute area of the polygon.
+     * @returns Absolute area of the polygon.
+     */
+    getArea() {
+        return Math.abs(this.getSignedArea());
+    }
+    /**
+     * Returns winding direction of the polygon.
+     * @returns Winding direction of the polygon. 1 is for clockwise, -1 for counterclockwise winding direction.
+     */
+    getWindingDirection() {
+        return Math.sign(this.getSignedArea());
+    }
+    /**
+     * Calls the visitor callback for each segment in the polygon.
+     * @param visitor A callback to call for each segment.
+     */
+    forEachSegment(visitor) {
+        if (this.isFlatArray) {
+            forEachSegmentInPolygon(this.points, 
+            // 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
+                visitor([x1, y1], [x2, y2], i1, i2);
+            }, this.options);
+        }
+        else {
+            forEachSegmentInPolygonPoints(this.points, visitor, this.options);
+        }
+    }
+    /**
+     * Checks winding direction of the polygon and reverses the polygon in case of opposite winding direction.
+     * @param direction Requested winding direction. 1 is for clockwise, -1 for counterclockwise winding direction.
+     * @return Returns true if the winding direction was changed.
+     */
+    modifyWindingDirection(direction) {
+        if (this.isFlatArray) {
+            return modifyPolygonWindingDirection(this.points, direction, this.options);
+        }
+        return modifyPolygonWindingDirectionPoints(this.points, direction, this.options);
+    }
+}

package/dist/utils.d.ts

@@ -0,0 +1,5 @@
+import type { NumericArray } from '@math.gl/core';
+export declare function push(target: number[], source: number[]): boolean;
+export declare function copy(target: number[], source: Readonly<NumericArray>): void;
+export declare function getPointAtIndex(positions: NumericArray, index: number, size: number, offset: number, out?: number[]): number[];
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAEhD,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAsBhE;AAED,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI,CAK3E;AAED,wBAAgB,eAAe,CAC7B,SAAS,EAAE,YAAY,EACvB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,GAAG,GAAE,MAAM,EAAO,GACjB,MAAM,EAAE,CAMV"}

package/dist/utils.js

@@ -0,0 +1,34 @@
+export function push(target, source) {
+    const size = source.length;
+    const startIndex = target.length;
+    // dedupe, if source is the same point as the last vertex
+    if (startIndex > 0) {
+        let isDuplicate = true;
+        for (let i = 0; i < size; i++) {
+            if (target[startIndex - size + i] !== source[i]) {
+                isDuplicate = false;
+                break;
+            }
+        }
+        if (isDuplicate) {
+            return false;
+        }
+    }
+    for (let i = 0; i < size; i++) {
+        target[startIndex + i] = source[i];
+    }
+    return true;
+}
+export function copy(target, source) {
+    const size = source.length;
+    for (let i = 0; i < size; i++) {
+        target[i] = source[i];
+    }
+}
+export function getPointAtIndex(positions, index, size, offset, out = []) {
+    const startI = offset + index * size;
+    for (let i = 0; i < size; i++) {
+        out[i] = positions[startI + i];
+    }
+    return out;
+}

package/package.json

@@ -5,7 +5,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.5.6",
+  "version": "3.6.0-alpha.2",
   "keywords": [
     "webgl",
     "javascript",
@@ -17,6 +17,7 @@
     "type": "git",
     "url": "https://github.com/uber-web/math.gl.git"
   },
+  "types": "dist/index.d.ts",
   "main": "dist/es5/index.js",
   "module": "dist/esm/index.js",
   "files": [
@@ -24,7 +25,7 @@
     "src"
   ],
   "dependencies": {
-    "@math.gl/core": "3.5.6"
+    "@math.gl/core": "3.6.0-alpha.2"
   },
-  "gitHead": "0e69c70ff2e6373fed84d303cbf8198a6972944f"
+  "gitHead": "ea7dc265c98b68af56218302d1d42b7d65f74ccb"
 }