@turf/polygonize 6.4.0 → 7.0.0-alpha.0

package/dist/js/lib/Edge.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var helpers_1 = require("@turf/helpers");
-var util_1 = require("./util");
+const helpers_1 = require("@turf/helpers");
+const util_1 = require("./util");
 /**
  * This class is inspired by GEOS's geos::operation::polygonize::PolygonizeDirectedEdge
  */
-var Edge = /** @class */ (function () {
+class Edge {
     /**
      * @param {Node} from - start node of the Edge
      * @param {Node} to - end node of the edge
      */
-    function Edge(from, to) {
+    constructor(from, to) {
         this.from = from; //< start
         this.to = to; //< End
         this.next = undefined; //< The edge to be computed after
@@ -25,20 +25,20 @@ var Edge = /** @class */ (function () {
      *
      * @returns {Edge} - Symetric Edge.
      */
-    Edge.prototype.getSymetric = function () {
+    getSymetric() {
         if (!this.symetric) {
             this.symetric = new Edge(this.to, this.from);
             this.symetric.symetric = this;
         }
         return this.symetric;
-    };
+    }
     /**
      * Removes edge from from and to nodes.
      */
-    Edge.prototype.deleteEdge = function () {
+    deleteEdge() {
         this.from.removeOuterEdge(this);
         this.to.removeInnerEdge(this);
-    };
+    }
     /**
      * Compares Edge equallity.
      *
@@ -47,20 +47,20 @@ var Edge = /** @class */ (function () {
      * @param {Edge} edge - Another Edge
      * @returns {boolean} - True if Edges are equal, False otherwise
      */
-    Edge.prototype.isEqual = function (edge) {
+    isEqual(edge) {
         return this.from.id === edge.from.id && this.to.id === edge.to.id;
-    };
-    Edge.prototype.toString = function () {
-        return "Edge { " + this.from.id + " -> " + this.to.id + " }";
-    };
+    }
+    toString() {
+        return `Edge { ${this.from.id} -> ${this.to.id} }`;
+    }
     /**
      * Returns a LineString representation of the Edge
      *
      * @returns {Feature<LineString>} - LineString representation of the Edge
      */
-    Edge.prototype.toLineString = function () {
+    toLineString() {
         return helpers_1.lineString([this.from.coordinates, this.to.coordinates]);
-    };
+    }
     /**
      * Comparator of two edges.
      *
@@ -71,9 +71,8 @@ var Edge = /** @class */ (function () {
      *          0 if the Edges are colinear,
      *          1 otherwise
      */
-    Edge.prototype.compareTo = function (edge) {
+    compareTo(edge) {
         return util_1.orientationIndex(edge.from.coordinates, edge.to.coordinates, this.to.coordinates);
-    };
-    return Edge;
-}());
+    }
+}
 exports.default = Edge;

package/dist/js/lib/EdgeRing.d.ts

@@ -1,4 +1,4 @@
-import { Polygon, Feature } from "@turf/helpers";
+import { Polygon, Feature, Point } from "geojson";
 import Edge from "./Edge";
 /**
  * Ring of edges which form a polygon.
@@ -9,8 +9,8 @@ import Edge from "./Edge";
  */
 export default class EdgeRing {
     private edges;
-    private polygon;
-    private envelope;
+    private polygon?;
+    private envelope?;
     constructor();
     /**
      * Add an edge to the ring, inserting it in the last position.
@@ -18,7 +18,7 @@ export default class EdgeRing {
      * @memberof EdgeRing
      * @param {Edge} edge - Edge to be inserted
      */
-    push(edge: any): void;
+    push(edge: Edge): void;
     /**
      * Get Edge.
      *
@@ -26,7 +26,7 @@ export default class EdgeRing {
      * @param {number} i - Index
      * @returns {Edge} - Edge in the i position
      */
-    get(i: any): Edge;
+    get(i: number): Edge;
     /**
      * Getter of length property.
      *
@@ -40,7 +40,7 @@ export default class EdgeRing {
      * @memberof EdgeRing
      * @param {Function} f - The same function to be passed to Array.prototype.forEach
      */
-    forEach(f: any): void;
+    forEach(f: (edge: Edge, index: number, array: Edge[]) => void): void;
     /**
      * Similar to Array.prototype.map for the list of Edges in the EdgeRing.
      *
@@ -48,7 +48,7 @@ export default class EdgeRing {
      * @param {Function} f - The same function to be passed to Array.prototype.map
      * @returns {Array} - The mapped values in the function
      */
-    map(f: any): unknown[];
+    map<T>(f: (edge: Edge, index: number, array: Edge[]) => T): T[];
     /**
      * Similar to Array.prototype.some for the list of Edges in the EdgeRing.
      *
@@ -56,7 +56,7 @@ export default class EdgeRing {
      * @param {Function} f - The same function to be passed to Array.prototype.some
      * @returns {boolean} - True if an Edge check the condition
      */
-    some(f: any): boolean;
+    some(f: (edge: Edge, index: number, array: Edge[]) => boolean): boolean;
     /**
      * Check if the ring is valid in geomtry terms.
      *
@@ -84,9 +84,7 @@ export default class EdgeRing {
      * @memberof EdgeRing
      * @returns {Feature<MultiPoint>} - Multipoint representation of the EdgeRing
      */
-    toMultiPoint(): Feature<import("@turf/helpers").MultiPoint, {
-        [name: string]: any;
-    }>;
+    toMultiPoint(): Feature<import("geojson").MultiPoint, import("geojson").GeoJsonProperties>;
     /**
      * Creates a Polygon representing the EdgeRing.
      *
@@ -113,12 +111,12 @@ export default class EdgeRing {
      *
      * @returns {EdgeRing} - EdgeRing which contains the testEdgeRing
      */
-    static findEdgeRingContaining(testEdgeRing: any, shellList: any): any;
+    static findEdgeRingContaining(testEdgeRing: EdgeRing, shellList: EdgeRing[]): EdgeRing | undefined;
     /**
      * Checks if the point is inside the edgeRing
      *
      * @param {Feature<Point>} pt - Point to check if it is inside the edgeRing
      * @returns {boolean} - True if it is inside, False otherwise
      */
-    inside(pt: any): boolean;
+    inside(pt: Feature<Point>): boolean;
 }

package/dist/js/lib/EdgeRing.js

@@ -1,12 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var util_1 = require("./util");
-var helpers_1 = require("@turf/helpers");
-var envelope_1 = __importDefault(require("@turf/envelope"));
-var boolean_point_in_polygon_1 = __importDefault(require("@turf/boolean-point-in-polygon"));
+const tslib_1 = require("tslib");
+const util_1 = require("./util");
+const helpers_1 = require("@turf/helpers");
+const envelope_1 = tslib_1.__importDefault(require("@turf/envelope"));
+const boolean_point_in_polygon_1 = tslib_1.__importDefault(require("@turf/boolean-point-in-polygon"));
 /**
  * Ring of edges which form a polygon.
  *
@@ -14,8 +12,8 @@ var boolean_point_in_polygon_1 = __importDefault(require("@turf/boolean-point-in
  *
  * This class is inspired in GEOS's geos::operation::polygonize::EdgeRing
  */
-var EdgeRing = /** @class */ (function () {
-    function EdgeRing() {
+class EdgeRing {
+    constructor() {
         this.edges = [];
         this.polygon = undefined; //< Caches Polygon representation
         this.envelope = undefined; //< Caches Envelope representation
@@ -26,12 +24,10 @@ var EdgeRing = /** @class */ (function () {
      * @memberof EdgeRing
      * @param {Edge} edge - Edge to be inserted
      */
-    EdgeRing.prototype.push = function (edge) {
-        // Emulate Array getter ([]) behaviour
-        this[this.edges.length] = edge;
+    push(edge) {
         this.edges.push(edge);
         this.polygon = this.envelope = undefined;
-    };
+    }
     /**
      * Get Edge.
      *
@@ -39,31 +35,27 @@ var EdgeRing = /** @class */ (function () {
      * @param {number} i - Index
      * @returns {Edge} - Edge in the i position
      */
-    EdgeRing.prototype.get = function (i) {
+    get(i) {
         return this.edges[i];
-    };
-    Object.defineProperty(EdgeRing.prototype, "length", {
-        /**
-         * Getter of length property.
-         *
-         * @memberof EdgeRing
-         * @returns {number} - Length of the edge ring.
-         */
-        get: function () {
-            return this.edges.length;
-        },
-        enumerable: true,
-        configurable: true
-    });
+    }
+    /**
+     * Getter of length property.
+     *
+     * @memberof EdgeRing
+     * @returns {number} - Length of the edge ring.
+     */
+    get length() {
+        return this.edges.length;
+    }
     /**
      * Similar to Array.prototype.forEach for the list of Edges in the EdgeRing.
      *
      * @memberof EdgeRing
      * @param {Function} f - The same function to be passed to Array.prototype.forEach
      */
-    EdgeRing.prototype.forEach = function (f) {
+    forEach(f) {
         this.edges.forEach(f);
-    };
+    }
     /**
      * Similar to Array.prototype.map for the list of Edges in the EdgeRing.
      *
@@ -71,9 +63,9 @@ var EdgeRing = /** @class */ (function () {
      * @param {Function} f - The same function to be passed to Array.prototype.map
      * @returns {Array} - The mapped values in the function
      */
-    EdgeRing.prototype.map = function (f) {
+    map(f) {
         return this.edges.map(f);
-    };
+    }
     /**
      * Similar to Array.prototype.some for the list of Edges in the EdgeRing.
      *
@@ -81,9 +73,9 @@ var EdgeRing = /** @class */ (function () {
      * @param {Function} f - The same function to be passed to Array.prototype.some
      * @returns {boolean} - True if an Edge check the condition
      */
-    EdgeRing.prototype.some = function (f) {
+    some(f) {
         return this.edges.some(f);
-    };
+    }
     /**
      * Check if the ring is valid in geomtry terms.
      *
@@ -94,10 +86,10 @@ var EdgeRing = /** @class */ (function () {
      * @memberof EdgeRing
      * @returns {boolean} - Validity of the EdgeRing
      */
-    EdgeRing.prototype.isValid = function () {
+    isValid() {
         // TODO: stub
         return true;
-    };
+    }
     /**
      * Tests whether this ring is a hole.
      *
@@ -107,12 +99,11 @@ var EdgeRing = /** @class */ (function () {
      * @memberof EdgeRing
      * @returns {boolean} - true: if it is a hole
      */
-    EdgeRing.prototype.isHole = function () {
-        var _this = this;
+    isHole() {
         // XXX: Assuming Ring is valid
         // Find highest point
-        var hiIndex = this.edges.reduce(function (high, edge, i) {
-            if (edge.from.coordinates[1] > _this.edges[high].from.coordinates[1])
+        const hiIndex = this.edges.reduce((high, edge, i) => {
+            if (edge.from.coordinates[1] > this.edges[high].from.coordinates[1])
                 high = i;
             return high;
         }, 0), iPrev = (hiIndex === 0 ? this.length : hiIndex) - 1, iNext = (hiIndex + 1) % this.length, disc = util_1.orientationIndex(this.edges[iPrev].from.coordinates, this.edges[hiIndex].from.coordinates, this.edges[iNext].from.coordinates);
@@ -120,40 +111,40 @@ var EdgeRing = /** @class */ (function () {
             return (this.edges[iPrev].from.coordinates[0] >
                 this.edges[iNext].from.coordinates[0]);
         return disc > 0;
-    };
+    }
     /**
      * Creates a MultiPoint representing the EdgeRing (discarts edges directions).
      *
      * @memberof EdgeRing
      * @returns {Feature<MultiPoint>} - Multipoint representation of the EdgeRing
      */
-    EdgeRing.prototype.toMultiPoint = function () {
-        return helpers_1.multiPoint(this.edges.map(function (edge) { return edge.from.coordinates; }));
-    };
+    toMultiPoint() {
+        return helpers_1.multiPoint(this.edges.map((edge) => edge.from.coordinates));
+    }
     /**
      * Creates a Polygon representing the EdgeRing.
      *
      * @memberof EdgeRing
      * @returns {Feature<Polygon>} - Polygon representation of the Edge Ring
      */
-    EdgeRing.prototype.toPolygon = function () {
+    toPolygon() {
         if (this.polygon)
             return this.polygon;
-        var coordinates = this.edges.map(function (edge) { return edge.from.coordinates; });
+        const coordinates = this.edges.map((edge) => edge.from.coordinates);
         coordinates.push(this.edges[0].from.coordinates);
         return (this.polygon = helpers_1.polygon([coordinates]));
-    };
+    }
     /**
      * Calculates the envelope of the EdgeRing.
      *
      * @memberof EdgeRing
      * @returns {Feature<Polygon>} - envelope
      */
-    EdgeRing.prototype.getEnvelope = function () {
+    getEnvelope() {
         if (this.envelope)
             return this.envelope;
         return (this.envelope = envelope_1.default(this.toPolygon()));
-    };
+    }
     /**
      * `geos::operation::polygonize::EdgeRing::findEdgeRingContaining`
      *
@@ -162,22 +153,24 @@ var EdgeRing = /** @class */ (function () {
      *
      * @returns {EdgeRing} - EdgeRing which contains the testEdgeRing
      */
-    EdgeRing.findEdgeRingContaining = function (testEdgeRing, shellList) {
-        var testEnvelope = testEdgeRing.getEnvelope();
-        var minEnvelope, minShell;
-        shellList.forEach(function (shell) {
-            var tryEnvelope = shell.getEnvelope();
+    static findEdgeRingContaining(testEdgeRing, shellList) {
+        const testEnvelope = testEdgeRing.getEnvelope();
+        let minEnvelope, minShell;
+        shellList.forEach((shell) => {
+            const tryEnvelope = shell.getEnvelope();
             if (minShell)
                 minEnvelope = minShell.getEnvelope();
             // the hole envelope cannot equal the shell envelope
             if (util_1.envelopeIsEqual(tryEnvelope, testEnvelope))
                 return;
             if (util_1.envelopeContains(tryEnvelope, testEnvelope)) {
-                var testPoint = testEdgeRing
-                    .map(function (edge) { return edge.from.coordinates; })
-                    .find(function (pt) {
-                    return !shell.some(function (edge) { return util_1.coordinatesEqual(pt, edge.from.coordinates); });
-                });
+                const testEdgeRingCoordinates = testEdgeRing.map((edge) => edge.from.coordinates);
+                let testPoint;
+                for (const pt of testEdgeRingCoordinates) {
+                    if (!shell.some((edge) => util_1.coordinatesEqual(pt, edge.from.coordinates))) {
+                        testPoint = pt;
+                    }
+                }
                 if (testPoint && shell.inside(helpers_1.point(testPoint))) {
                     if (!minShell || util_1.envelopeContains(minEnvelope, tryEnvelope))
                         minShell = shell;
@@ -185,16 +178,15 @@ var EdgeRing = /** @class */ (function () {
             }
         });
         return minShell;
-    };
+    }
     /**
      * Checks if the point is inside the edgeRing
      *
      * @param {Feature<Point>} pt - Point to check if it is inside the edgeRing
      * @returns {boolean} - True if it is inside, False otherwise
      */
-    EdgeRing.prototype.inside = function (pt) {
+    inside(pt) {
         return boolean_point_in_polygon_1.default(pt, this.toPolygon());
-    };
-    return EdgeRing;
-}());
+    }
+}
 exports.default = EdgeRing;

package/dist/js/lib/Graph.d.ts

@@ -1,7 +1,7 @@
 import Node from "./Node";
 import Edge from "./Edge";
 import EdgeRing from "./EdgeRing";
-import { FeatureCollection, LineString, MultiLineString, Feature } from "@turf/helpers";
+import { FeatureCollection, LineString, MultiLineString, Feature } from "geojson";
 /**
  * Represents a planar graph of edges and nodes that can be used to compute a polygonization.
  *
@@ -87,20 +87,20 @@ export default class Graph {
      *
      * @returns {Edge[]} edges that start rings
      */
-    _findLabeledEdgeRings(): any[];
+    _findLabeledEdgeRings(): Edge[];
     /**
      * Computes the EdgeRings formed by the edges in this graph.
      *
      * @returns {EdgeRing[]} - A list of all the EdgeRings in the graph.
      */
-    getEdgeRings(): any[];
+    getEdgeRings(): EdgeRing[];
     /**
      * Find all nodes in a Maxima EdgeRing which are self-intersection nodes.
      *
      * @param {Node} startEdge - Start Edge of the Ring
      * @returns {Node[]} - intersection nodes
      */
-    _findIntersectionNodes(startEdge: Edge): any[];
+    _findIntersectionNodes(startEdge: Edge): Node[];
     /**
      * Get the edge-ring which starts from the provided Edge.
      *