@turf/polygonize 6.4.0 → 7.0.0-alpha.0

package/README.md

@@ -13,17 +13,18 @@ noded, i.e., they must only meet at their endpoints.
 
 The implementation correctly handles:
 
--   Dangles: edges which have one or both ends which are not incident on another edge endpoint.
--   Cut Edges (bridges): edges that are connected at both ends but which do not form part of a polygon.
+*   Dangles: edges which have one or both ends which are not incident on another edge endpoint.
+*   Cut Edges (bridges): edges that are connected at both ends but which do not form part of a polygon.
 
-**Parameters**
+### Parameters
 
--   `geoJson` **([FeatureCollection][3] \| [Geometry][4] \| [Feature][5]<([LineString][6] \| [MultiLineString][7])>)** Lines in order to polygonize
+*   `geoJson` **([FeatureCollection][3] | [Geometry][4] | [Feature][5]<([LineString][6] | [MultiLineString][7])>)** Lines in order to polygonize
 
+<!---->
 
--   Throws **[Error][8]** if geoJson is invalid.
+*   Throws **[Error][8]** if geoJson is invalid.
 
-Returns **[FeatureCollection][3]&lt;[Polygon][9]>** Polygons created
+Returns **[FeatureCollection][3]<[Polygon][9]>** Polygons created
 
 [1]: https://tools.ietf.org/html/rfc7946#section-3.1.4
 

package/dist/es/index.js

@@ -20,27 +20,27 @@ import EdgeRing from "./lib/EdgeRing.js";
  * @throws {Error} if geoJson is invalid.
  */
 export default function polygonize(geoJson) {
-    var graph = Graph.fromGeoJson(geoJson);
+    const graph = Graph.fromGeoJson(geoJson);
     // 1. Remove dangle node
     graph.deleteDangles();
     // 2. Remove cut-edges (bridge edges)
     graph.deleteCutEdges();
     // 3. Get all holes and shells
-    var holes = [], shells = [];
+    const holes = [], shells = [];
     graph
         .getEdgeRings()
-        .filter(function (edgeRing) { return edgeRing.isValid(); })
-        .forEach(function (edgeRing) {
+        .filter((edgeRing) => edgeRing.isValid())
+        .forEach((edgeRing) => {
         if (edgeRing.isHole())
             holes.push(edgeRing);
         else
             shells.push(edgeRing);
     });
     // 4. Assign Holes to Shells
-    holes.forEach(function (hole) {
+    holes.forEach((hole) => {
         if (EdgeRing.findEdgeRingContaining(hole, shells))
             shells.push(hole);
     });
     // 5. EdgeRings to Polygons
-    return featureCollection(shells.map(function (shell) { return shell.toPolygon(); }));
+    return featureCollection(shells.map((shell) => shell.toPolygon()));
 }

package/dist/es/lib/Edge.js

@@ -3,12 +3,12 @@ import { orientationIndex } from "./util.js";
 /**
  * This class is inspired by GEOS's geos::operation::polygonize::PolygonizeDirectedEdge
  */
-var Edge = /** @class */ (function () {
+export default 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
@@ -23,20 +23,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.
      *
@@ -45,20 +45,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 lineString([this.from.coordinates, this.to.coordinates]);
-    };
+    }
     /**
      * Comparator of two edges.
      *
@@ -69,9 +69,7 @@ var Edge = /** @class */ (function () {
      *          0 if the Edges are colinear,
      *          1 otherwise
      */
-    Edge.prototype.compareTo = function (edge) {
+    compareTo(edge) {
         return orientationIndex(edge.from.coordinates, edge.to.coordinates, this.to.coordinates);
-    };
-    return Edge;
-}());
-export default Edge;
+    }
+}

package/dist/es/lib/EdgeRing.js

@@ -9,8 +9,8 @@ import booleanPointInPolygon from "@turf/boolean-point-in-polygon";
  *
  * This class is inspired in GEOS's geos::operation::polygonize::EdgeRing
  */
-var EdgeRing = /** @class */ (function () {
-    function EdgeRing() {
+export default class EdgeRing {
+    constructor() {
         this.edges = [];
         this.polygon = undefined; //< Caches Polygon representation
         this.envelope = undefined; //< Caches Envelope representation
@@ -21,12 +21,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.
      *
@@ -34,31 +32,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.
      *
@@ -66,9 +60,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.
      *
@@ -76,9 +70,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.
      *
@@ -89,10 +83,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.
      *
@@ -102,12 +96,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 = orientationIndex(this.edges[iPrev].from.coordinates, this.edges[hiIndex].from.coordinates, this.edges[iNext].from.coordinates);
@@ -115,40 +108,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 multiPoint(this.edges.map(function (edge) { return edge.from.coordinates; }));
-    };
+    toMultiPoint() {
+        return 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 = 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(this.toPolygon()));
-    };
+    }
     /**
      * `geos::operation::polygonize::EdgeRing::findEdgeRingContaining`
      *
@@ -157,22 +150,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 (envelopeIsEqual(tryEnvelope, testEnvelope))
                 return;
             if (envelopeContains(tryEnvelope, testEnvelope)) {
-                var testPoint = testEdgeRing
-                    .map(function (edge) { return edge.from.coordinates; })
-                    .find(function (pt) {
-                    return !shell.some(function (edge) { return coordinatesEqual(pt, edge.from.coordinates); });
-                });
+                const testEdgeRingCoordinates = testEdgeRing.map((edge) => edge.from.coordinates);
+                let testPoint;
+                for (const pt of testEdgeRingCoordinates) {
+                    if (!shell.some((edge) => coordinatesEqual(pt, edge.from.coordinates))) {
+                        testPoint = pt;
+                    }
+                }
                 if (testPoint && shell.inside(point(testPoint))) {
                     if (!minShell || envelopeContains(minEnvelope, tryEnvelope))
                         minShell = shell;
@@ -180,16 +175,14 @@ 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 booleanPointInPolygon(pt, this.toPolygon());
-    };
-    return EdgeRing;
-}());
-export default EdgeRing;
+    }
+}