@turf/polygonize 6.5.0 → 7.0.0-alpha.0

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,10 +24,10 @@ var EdgeRing = /** @class */ (function () {
      * @memberof EdgeRing
      * @param {Edge} edge - Edge to be inserted
      */
-    EdgeRing.prototype.push = function (edge) {
+    push(edge) {
         this.edges.push(edge);
         this.polygon = this.envelope = undefined;
-    };
+    }
     /**
      * Get Edge.
      *
@@ -37,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.
      *
@@ -69,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.
      *
@@ -79,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.
      *
@@ -92,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.
      *
@@ -105,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);
@@ -118,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`
      *
@@ -160,27 +153,23 @@ 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 testEdgeRingCoordinates = testEdgeRing.map(function (edge) { return edge.from.coordinates; });
-                var testPoint = void 0;
-                var _loop_1 = function (pt) {
-                    if (!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;
                     }
-                };
-                for (var _i = 0, testEdgeRingCoordinates_1 = testEdgeRingCoordinates; _i < testEdgeRingCoordinates_1.length; _i++) {
-                    var pt = testEdgeRingCoordinates_1[_i];
-                    _loop_1(pt);
                 }
                 if (testPoint && shell.inside(helpers_1.point(testPoint))) {
                     if (!minShell || util_1.envelopeContains(minEnvelope, tryEnvelope))
@@ -189,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.
  *

package/dist/js/lib/Graph.js

@@ -1,13 +1,11 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var Node_1 = __importDefault(require("./Node"));
-var Edge_1 = __importDefault(require("./Edge"));
-var EdgeRing_1 = __importDefault(require("./EdgeRing"));
-var meta_1 = require("@turf/meta");
-var invariant_1 = require("@turf/invariant");
+const tslib_1 = require("tslib");
+const Node_1 = tslib_1.__importDefault(require("./Node"));
+const Edge_1 = tslib_1.__importDefault(require("./Edge"));
+const EdgeRing_1 = tslib_1.__importDefault(require("./EdgeRing"));
+const meta_1 = require("@turf/meta");
+const invariant_1 = require("@turf/invariant");
 /**
  * Validates the geoJson.
  *
@@ -22,7 +20,7 @@ function validateGeoJson(geoJson) {
         geoJson.type !== "MultiLineString" &&
         geoJson.type !== "LineString" &&
         geoJson.type !== "Feature")
-        throw new Error("Invalid input type '" + geoJson.type + "'. Geojson must be FeatureCollection, GeometryCollection, LineString, MultiLineString or Feature");
+        throw new Error(`Invalid input type '${geoJson.type}'. Geojson must be FeatureCollection, GeometryCollection, LineString, MultiLineString or Feature`);
 }
 /**
  * Represents a planar graph of edges and nodes that can be used to compute a polygonization.
@@ -33,8 +31,8 @@ function validateGeoJson(geoJson) {
  *
  * This graph is directed (both directions are created)
  */
-var Graph = /** @class */ (function () {
-    function Graph() {
+class Graph {
+    constructor() {
         this.edges = []; //< {Edge[]} dirEdges
         // The key is the `id` of the Node (ie: coordinates.join(','))
         this.nodes = {};
@@ -46,35 +44,35 @@ var Graph = /** @class */ (function () {
      * @returns {Graph} - The newly created graph
      * @throws {Error} if geoJson is invalid.
      */
-    Graph.fromGeoJson = function (geoJson) {
+    static fromGeoJson(geoJson) {
         validateGeoJson(geoJson);
-        var graph = new Graph();
-        meta_1.flattenEach(geoJson, function (feature) {
+        const graph = new Graph();
+        meta_1.flattenEach(geoJson, (feature) => {
             invariant_1.featureOf(feature, "LineString", "Graph::fromGeoJson");
             // When a LineString if formed by many segments, split them
-            meta_1.coordReduce(feature, function (prev, cur) {
+            meta_1.coordReduce(feature, (prev, cur) => {
                 if (prev) {
-                    var start = graph.getNode(prev), end = graph.getNode(cur);
+                    const start = graph.getNode(prev), end = graph.getNode(cur);
                     graph.addEdge(start, end);
                 }
                 return cur;
             });
         });
         return graph;
-    };
+    }
     /**
      * Creates or get a Node.
      *
      * @param {number[]} coordinates - Coordinates of the node
      * @returns {Node} - The created or stored node
      */
-    Graph.prototype.getNode = function (coordinates) {
-        var id = Node_1.default.buildId(coordinates);
-        var node = this.nodes[id];
+    getNode(coordinates) {
+        const id = Node_1.default.buildId(coordinates);
+        let node = this.nodes[id];
         if (!node)
             node = this.nodes[id] = new Node_1.default(coordinates);
         return node;
-    };
+    }
     /**
      * Adds an Edge and its symetricall.
      *
@@ -83,20 +81,19 @@ var Graph = /** @class */ (function () {
      * @param {Node} from - Node which starts the Edge
      * @param {Node} to - Node which ends the Edge
      */
-    Graph.prototype.addEdge = function (from, to) {
-        var edge = new Edge_1.default(from, to), symetricEdge = edge.getSymetric();
+    addEdge(from, to) {
+        const edge = new Edge_1.default(from, to), symetricEdge = edge.getSymetric();
         this.edges.push(edge);
         this.edges.push(symetricEdge);
-    };
+    }
     /**
      * Removes Dangle Nodes (nodes with grade 1).
      */
-    Graph.prototype.deleteDangles = function () {
-        var _this = this;
+    deleteDangles() {
         Object.keys(this.nodes)
-            .map(function (id) { return _this.nodes[id]; })
-            .forEach(function (node) { return _this._removeIfDangle(node); });
-    };
+            .map((id) => this.nodes[id])
+            .forEach((node) => this._removeIfDangle(node));
+    }
     /**
      * Check if node is dangle, if so, remove it.
      *
@@ -104,15 +101,14 @@ var Graph = /** @class */ (function () {
      *
      * @param {Node} node - Node to check if it's a dangle
      */
-    Graph.prototype._removeIfDangle = function (node) {
-        var _this = this;
+    _removeIfDangle(node) {
         // As edges are directed and symetrical, we count only innerEdges
         if (node.innerEdges.length <= 1) {
-            var outerNodes = node.getOuterEdges().map(function (e) { return e.to; });
+            const outerNodes = node.getOuterEdges().map((e) => e.to);
             this.removeNode(node);
-            outerNodes.forEach(function (n) { return _this._removeIfDangle(n); });
+            outerNodes.forEach((n) => this._removeIfDangle(n));
         }
-    };
+    }
     /**
      * Delete cut-edges (bridge edges).
      *
@@ -120,18 +116,17 @@ var Graph = /** @class */ (function () {
      * in which they are. (The label is a number incremented by 1). Edges with the same
      * label are cut-edges.
      */
-    Graph.prototype.deleteCutEdges = function () {
-        var _this = this;
+    deleteCutEdges() {
         this._computeNextCWEdges();
         this._findLabeledEdgeRings();
         // Cut-edges (bridges) are edges where both edges have the same label
-        this.edges.forEach(function (edge) {
+        this.edges.forEach((edge) => {
             if (edge.label === edge.symetric.label) {
-                _this.removeEdge(edge.symetric);
-                _this.removeEdge(edge);
+                this.removeEdge(edge.symetric);
+                this.removeEdge(edge);
             }
         });
-    };
+    }
     /**
      * Set the `next` property of each Edge.
      *
@@ -140,19 +135,16 @@ var Graph = /** @class */ (function () {
      *
      * @param {Node} [node] - If no node is passed, the function calls itself for every node in the Graph
      */
-    Graph.prototype._computeNextCWEdges = function (node) {
-        var _this = this;
+    _computeNextCWEdges(node) {
         if (typeof node === "undefined") {
-            Object.keys(this.nodes).forEach(function (id) {
-                return _this._computeNextCWEdges(_this.nodes[id]);
-            });
+            Object.keys(this.nodes).forEach((id) => this._computeNextCWEdges(this.nodes[id]));
         }
         else {
-            node.getOuterEdges().forEach(function (edge, i) {
+            node.getOuterEdges().forEach((edge, i) => {
                 node.getOuterEdge((i === 0 ? node.getOuterEdges().length : i) - 1).symetric.next = edge;
             });
         }
-    };
+    }
     /**
      * Computes the next edge pointers going CCW around the given node, for the given edgering label.
      *
@@ -164,11 +156,11 @@ var Graph = /** @class */ (function () {
      * @param {Node} node - Node
      * @param {number} label - Ring's label
      */
-    Graph.prototype._computeNextCCWEdges = function (node, label) {
-        var edges = node.getOuterEdges();
-        var firstOutDE, prevInDE;
-        for (var i = edges.length - 1; i >= 0; --i) {
-            var de = edges[i], sym = de.symetric, outDE = void 0, inDE = void 0;
+    _computeNextCCWEdges(node, label) {
+        const edges = node.getOuterEdges();
+        let firstOutDE, prevInDE;
+        for (let i = edges.length - 1; i >= 0; --i) {
+            let de = edges[i], sym = de.symetric, outDE, inDE;
             if (de.label === label)
                 outDE = de;
             if (sym.label === label)
@@ -189,7 +181,7 @@ var Graph = /** @class */ (function () {
         }
         if (prevInDE)
             prevInDE.next = firstOutDE;
-    };
+    }
     /**
      * Finds rings and labels edges according to which rings are.
      *
@@ -197,14 +189,14 @@ var Graph = /** @class */ (function () {
      *
      * @returns {Edge[]} edges that start rings
      */
-    Graph.prototype._findLabeledEdgeRings = function () {
-        var edgeRingStarts = [];
-        var label = 0;
-        this.edges.forEach(function (edge) {
+    _findLabeledEdgeRings() {
+        const edgeRingStarts = [];
+        let label = 0;
+        this.edges.forEach((edge) => {
             if (edge.label >= 0)
                 return;
             edgeRingStarts.push(edge);
-            var e = edge;
+            let e = edge;
             do {
                 e.label = label;
                 e = e.next;
@@ -212,96 +204,90 @@ var Graph = /** @class */ (function () {
             label++;
         });
         return edgeRingStarts;
-    };
+    }
     /**
      * Computes the EdgeRings formed by the edges in this graph.
      *
      * @returns {EdgeRing[]} - A list of all the EdgeRings in the graph.
      */
-    Graph.prototype.getEdgeRings = function () {
-        var _this = this;
+    getEdgeRings() {
         this._computeNextCWEdges();
         // Clear labels
-        this.edges.forEach(function (edge) {
+        this.edges.forEach((edge) => {
             edge.label = undefined;
         });
-        this._findLabeledEdgeRings().forEach(function (edge) {
+        this._findLabeledEdgeRings().forEach((edge) => {
             // convertMaximalToMinimalEdgeRings
-            _this._findIntersectionNodes(edge).forEach(function (node) {
-                _this._computeNextCCWEdges(node, edge.label);
+            this._findIntersectionNodes(edge).forEach((node) => {
+                this._computeNextCCWEdges(node, edge.label);
             });
         });
-        var edgeRingList = [];
+        const edgeRingList = [];
         // find all edgerings
-        this.edges.forEach(function (edge) {
+        this.edges.forEach((edge) => {
             if (edge.ring)
                 return;
-            edgeRingList.push(_this._findEdgeRing(edge));
+            edgeRingList.push(this._findEdgeRing(edge));
         });
         return edgeRingList;
-    };
+    }
     /**
      * Find all nodes in a Maxima EdgeRing which are self-intersection nodes.
      *
      * @param {Node} startEdge - Start Edge of the Ring
      * @returns {Node[]} - intersection nodes
      */
-    Graph.prototype._findIntersectionNodes = function (startEdge) {
-        var intersectionNodes = [];
-        var edge = startEdge;
-        var _loop_1 = function () {
+    _findIntersectionNodes(startEdge) {
+        const intersectionNodes = [];
+        let edge = startEdge;
+        do {
             // getDegree
-            var degree = 0;
-            edge.from.getOuterEdges().forEach(function (e) {
+            let degree = 0;
+            edge.from.getOuterEdges().forEach((e) => {
                 if (e.label === startEdge.label)
                     ++degree;
             });
             if (degree > 1)
                 intersectionNodes.push(edge.from);
             edge = edge.next;
-        };
-        do {
-            _loop_1();
         } while (!startEdge.isEqual(edge));
         return intersectionNodes;
-    };
+    }
     /**
      * Get the edge-ring which starts from the provided Edge.
      *
      * @param {Edge} startEdge - starting edge of the edge ring
      * @returns {EdgeRing} - EdgeRing which start Edge is the provided one.
      */
-    Graph.prototype._findEdgeRing = function (startEdge) {
-        var edge = startEdge;
-        var edgeRing = new EdgeRing_1.default();
+    _findEdgeRing(startEdge) {
+        let edge = startEdge;
+        const edgeRing = new EdgeRing_1.default();
         do {
             edgeRing.push(edge);
             edge.ring = edgeRing;
             edge = edge.next;
         } while (!startEdge.isEqual(edge));
         return edgeRing;
-    };
+    }
     /**
      * Removes a node from the Graph.
      *
      * It also removes edges asociated to that node
      * @param {Node} node - Node to be removed
      */
-    Graph.prototype.removeNode = function (node) {
-        var _this = this;
-        node.getOuterEdges().forEach(function (edge) { return _this.removeEdge(edge); });
-        node.innerEdges.forEach(function (edge) { return _this.removeEdge(edge); });
+    removeNode(node) {
+        node.getOuterEdges().forEach((edge) => this.removeEdge(edge));
+        node.innerEdges.forEach((edge) => this.removeEdge(edge));
         delete this.nodes[node.id];
-    };
+    }
     /**
      * Remove edge from the graph and deletes the edge.
      *
      * @param {Edge} edge - Edge to be removed
      */
-    Graph.prototype.removeEdge = function (edge) {
-        this.edges = this.edges.filter(function (e) { return !e.isEqual(edge); });
+    removeEdge(edge) {
+        this.edges = this.edges.filter((e) => !e.isEqual(edge));
         edge.deleteEdge();
-    };
-    return Graph;
-}());
+    }
+}
 exports.default = Graph;