dgeoutils 2.3.6 → 2.4.1

package/dist/cjs/DPolygonLoop.js

@@ -36,366 +36,361 @@ var LoopFunctions;
     LoopFunctions[LoopFunctions["metersToDegree"] = 30] = "metersToDegree";
     LoopFunctions[LoopFunctions["flipVertically"] = 31] = "flipVertically";
 })(LoopFunctions || (LoopFunctions = {}));
-var decodePoolRecord = function (a, _a) {
-    var functionName = _a.functionName, pointArg = _a.pointArg, numberPointArg = _a.numberPointArg, numberArg = _a.numberArg, setterArg = _a.setterArg;
-    var res = a;
+const decodePoolRecord = (a, { functionName, pointArg, numberPointArg, numberArg, setterArg }) => {
+    let res = a;
     switch (functionName) {
         case LoopFunctions.getTileFromCoords:
-            res = function (k) { return a(k)
-                .getTileFromCoords(numberArg); };
+            res = (k) => a(k)
+                .getTileFromCoords(numberArg);
             break;
         case LoopFunctions.getCoordsFromTile:
-            res = function (k) { return a(k)
-                .getCoordsFromTile(numberArg); };
+            res = (k) => a(k)
+                .getCoordsFromTile(numberArg);
             break;
         case LoopFunctions.height:
-            res = function (k) { return a(k)
-                .height(numberArg); };
+            res = (k) => a(k)
+                .height(numberArg);
             break;
         case LoopFunctions.setX:
-            res = function (k) { return a(k)
-                .setX(setterArg); };
+            res = (k) => a(k)
+                .setX(setterArg);
             break;
         case LoopFunctions.setY:
-            res = function (k) { return a(k)
-                .setY(setterArg); };
+            res = (k) => a(k)
+                .setY(setterArg);
             break;
         case LoopFunctions.setZ:
-            res = function (k) { return a(k)
-                .setZ(setterArg); };
+            res = (k) => a(k)
+                .setZ(setterArg);
             break;
         case LoopFunctions.rotate:
-            res = function (k) { return a(k)
-                .rotate(numberArg); };
+            res = (k) => a(k)
+                .rotate(numberArg);
             break;
         case LoopFunctions.rotate3dX:
-            res = function (k) { return a(k)
-                .rotate3dX(numberArg); };
+            res = (k) => a(k)
+                .rotate3dX(numberArg);
             break;
         case LoopFunctions.rotate3dY:
-            res = function (k) { return a(k)
-                .rotate3dY(numberArg); };
+            res = (k) => a(k)
+                .rotate3dY(numberArg);
             break;
         case LoopFunctions.rotate3dZ:
-            res = function (k) { return a(k)
-                .rotate3dZ(numberArg); };
+            res = (k) => a(k)
+                .rotate3dZ(numberArg);
             break;
         case LoopFunctions.move:
-            res = function (k) { return a(k)
-                .move(numberPointArg, numberArg); };
+            res = (k) => a(k)
+                .move(numberPointArg, numberArg);
             break;
         case LoopFunctions.round:
-            res = function (k) { return a(k)
-                .round(); };
+            res = (k) => a(k)
+                .round();
             break;
         case LoopFunctions.ceil:
-            res = function (k) { return a(k)
-                .ceil(); };
+            res = (k) => a(k)
+                .ceil();
             break;
         case LoopFunctions.floor:
-            res = function (k) { return a(k)
-                .floor(); };
+            res = (k) => a(k)
+                .floor();
             break;
         case LoopFunctions.toFixed:
-            res = function (k) { return a(k)
-                .toFixed(numberArg); };
+            res = (k) => a(k)
+                .toFixed(numberArg);
             break;
         case LoopFunctions.abs:
-            res = function (k) { return a(k)
-                .abs(); };
+            res = (k) => a(k)
+                .abs();
             break;
         case LoopFunctions.scale:
-            res = function (k) { return a(k)
-                .scale(numberPointArg, numberArg); };
+            res = (k) => a(k)
+                .scale(numberPointArg, numberArg);
             break;
         case LoopFunctions.divide:
-            res = function (k) { return a(k)
-                .divide(numberPointArg, numberArg); };
+            res = (k) => a(k)
+                .divide(numberPointArg, numberArg);
             break;
         case LoopFunctions.degreeToRadians:
-            res = function (k) { return a(k)
-                .degreeToRadians(); };
+            res = (k) => a(k)
+                .degreeToRadians();
             break;
         case LoopFunctions.radiansToDegrees:
-            res = function (k) { return a(k)
-                .radiansToDegrees(); };
+            res = (k) => a(k)
+                .radiansToDegrees();
             break;
         case LoopFunctions.radiansToMeters:
-            res = function (k) { return a(k)
-                .radiansToMeters(); };
+            res = (k) => a(k)
+                .radiansToMeters();
             break;
         case LoopFunctions.metersToRadians:
-            res = function (k) { return a(k)
-                .metersToRadians(); };
+            res = (k) => a(k)
+                .metersToRadians();
             break;
         case LoopFunctions.hipPoint:
-            res = function (k) { return a(k)
-                .hipPoint; };
+            res = (k) => a(k)
+                .hipPoint;
             break;
         case LoopFunctions.xPoint:
-            res = function (k) { return a(k)
-                .xPoint; };
+            res = (k) => a(k)
+                .xPoint;
             break;
         case LoopFunctions.yPoint:
-            res = function (k) { return a(k)
-                .yPoint; };
+            res = (k) => a(k)
+                .yPoint;
             break;
         case LoopFunctions.wPoint:
-            res = function (k) { return a(k)
-                .wPoint; };
+            res = (k) => a(k)
+                .wPoint;
             break;
         case LoopFunctions.hPoint:
-            res = function (k) { return a(k)
-                .hPoint; };
+            res = (k) => a(k)
+                .hPoint;
             break;
         case LoopFunctions.setIfLessThan:
-            res = function (k) { return a(k)
-                .setIfLessThan(pointArg); };
+            res = (k) => a(k)
+                .setIfLessThan(pointArg);
             break;
         case LoopFunctions.minus:
-            res = function (k) { return a(k)
-                .minus(); };
+            res = (k) => a(k)
+                .minus();
             break;
         case LoopFunctions.degreeToMeters:
-            res = function (k) { return a(k)
-                .degreeToMeters(); };
+            res = (k) => a(k)
+                .degreeToMeters();
             break;
         case LoopFunctions.metersToDegree:
-            res = function (k) { return a(k)
-                .metersToDegree(); };
+            res = (k) => a(k)
+                .metersToDegree();
             break;
         case LoopFunctions.flipVertically:
-            res = function (k) { return a(k)
-                .flipVertically(numberPointArg); };
+            res = (k) => a(k)
+                .flipVertically(numberPointArg);
             break;
     }
     return res;
 };
-var DPolygonLoop = (function () {
-    function DPolygonLoop(parent) {
+class DPolygonLoop {
+    constructor(parent) {
         this.parent = parent;
         this.pool = [];
     }
-    DPolygonLoop.prototype.getLoopFunction = function () {
-        return this.pool.reduce(decodePoolRecord, function (k) { return k; });
-    };
-    DPolygonLoop.prototype.run = function () {
+    getLoopFunction() {
+        return this.pool.reduce(decodePoolRecord, (k) => k);
+    }
+    run() {
         return this.parent.map(this.getLoopFunction());
-    };
-    DPolygonLoop.prototype.getTileFromCoords = function (zoom) {
+    }
+    getTileFromCoords(zoom) {
         this.pool.push({
             functionName: LoopFunctions.getTileFromCoords,
             numberArg: zoom
         });
         return this;
-    };
-    DPolygonLoop.prototype.getCoordsFromTile = function (zoom) {
+    }
+    getCoordsFromTile(zoom) {
         this.pool.push({
             functionName: LoopFunctions.getCoordsFromTile,
             numberArg: zoom
         });
         return this;
-    };
-    DPolygonLoop.prototype.height = function (z) {
+    }
+    height(z) {
         this.pool.push({
             functionName: LoopFunctions.height,
             numberArg: z
         });
         return this;
-    };
-    DPolygonLoop.prototype.setX = function (x) {
+    }
+    setX(x) {
         this.pool.push({
             functionName: LoopFunctions.setX,
             setterArg: x
         });
         return this;
-    };
-    DPolygonLoop.prototype.setY = function (y) {
+    }
+    setY(y) {
         this.pool.push({
             functionName: LoopFunctions.setY,
             setterArg: y
         });
         return this;
-    };
-    DPolygonLoop.prototype.setZ = function (z) {
+    }
+    setZ(z) {
         this.pool.push({
             functionName: LoopFunctions.setZ,
             setterArg: z
         });
         return this;
-    };
-    DPolygonLoop.prototype.rotate = function (a) {
+    }
+    rotate(a) {
         this.pool.push({
             functionName: LoopFunctions.rotate,
             numberArg: a
         });
         return this;
-    };
-    DPolygonLoop.prototype.rotate3dX = function (a) {
+    }
+    rotate3dX(a) {
         this.pool.push({
             functionName: LoopFunctions.rotate3dX,
             numberArg: a
         });
         return this;
-    };
-    DPolygonLoop.prototype.rotate3dY = function (a) {
+    }
+    rotate3dY(a) {
         this.pool.push({
             functionName: LoopFunctions.rotate3dY,
             numberArg: a
         });
         return this;
-    };
-    DPolygonLoop.prototype.rotate3dZ = function (a) {
+    }
+    rotate3dZ(a) {
         this.pool.push({
             functionName: LoopFunctions.rotate3dZ,
             numberArg: a
         });
         return this;
-    };
-    DPolygonLoop.prototype.move = function (x, y) {
-        if (y === void 0) { y = x; }
+    }
+    move(x, y = x) {
         this.pool.push({
             functionName: LoopFunctions.move,
             numberPointArg: x,
             numberArg: y
         });
         return this;
-    };
-    DPolygonLoop.prototype.round = function () {
+    }
+    round() {
         this.pool.push({
             functionName: LoopFunctions.round
         });
         return this;
-    };
-    DPolygonLoop.prototype.ceil = function () {
+    }
+    ceil() {
         this.pool.push({
             functionName: LoopFunctions.ceil
         });
         return this;
-    };
-    DPolygonLoop.prototype.floor = function () {
+    }
+    floor() {
         this.pool.push({
             functionName: LoopFunctions.floor
         });
         return this;
-    };
-    DPolygonLoop.prototype.toFixed = function (n) {
-        if (n === void 0) { n = 2; }
+    }
+    toFixed(n = 2) {
         this.pool.push({
             functionName: LoopFunctions.toFixed,
             numberArg: n
         });
         return this;
-    };
-    DPolygonLoop.prototype.abs = function () {
+    }
+    abs() {
         this.pool.push({
             functionName: LoopFunctions.abs
         });
         return this;
-    };
-    DPolygonLoop.prototype.scale = function (x, y) {
-        if (y === void 0) { y = x; }
+    }
+    scale(x, y = x) {
         this.pool.push({
             functionName: LoopFunctions.scale,
             numberPointArg: x,
             numberArg: y
         });
         return this;
-    };
-    DPolygonLoop.prototype.divide = function (x, y) {
+    }
+    divide(x, y) {
         this.pool.push({
             functionName: LoopFunctions.divide,
             numberPointArg: x,
             numberArg: y
         });
         return this;
-    };
-    DPolygonLoop.prototype.degreeToRadians = function () {
+    }
+    degreeToRadians() {
         this.pool.push({
             functionName: LoopFunctions.degreeToRadians
         });
         return this;
-    };
-    DPolygonLoop.prototype.radiansToDegrees = function () {
+    }
+    radiansToDegrees() {
         this.pool.push({
             functionName: LoopFunctions.radiansToDegrees
         });
         return this;
-    };
-    DPolygonLoop.prototype.radiansToMeters = function () {
+    }
+    radiansToMeters() {
         this.pool.push({
             functionName: LoopFunctions.radiansToMeters
         });
         return this;
-    };
-    DPolygonLoop.prototype.metersToRadians = function () {
+    }
+    metersToRadians() {
         this.pool.push({
             functionName: LoopFunctions.metersToRadians
         });
         return this;
-    };
-    DPolygonLoop.prototype.getHipPoint = function () {
+    }
+    getHipPoint() {
         this.pool.push({
             functionName: LoopFunctions.hipPoint
         });
         return this;
-    };
-    DPolygonLoop.prototype.getXPoint = function () {
+    }
+    getXPoint() {
         this.pool.push({
             functionName: LoopFunctions.xPoint
         });
         return this;
-    };
-    DPolygonLoop.prototype.getYPoint = function () {
+    }
+    getYPoint() {
         this.pool.push({
             functionName: LoopFunctions.yPoint
         });
         return this;
-    };
-    DPolygonLoop.prototype.getWPoint = function () {
+    }
+    getWPoint() {
         this.pool.push({
             functionName: LoopFunctions.wPoint
         });
         return this;
-    };
-    DPolygonLoop.prototype.getHPoint = function () {
+    }
+    getHPoint() {
         this.pool.push({
             functionName: LoopFunctions.hPoint
         });
         return this;
-    };
-    DPolygonLoop.prototype.setIfLessThan = function (p) {
+    }
+    setIfLessThan(p) {
         this.pool.push({
             functionName: LoopFunctions.setIfLessThan,
             pointArg: p
         });
         return this;
-    };
-    DPolygonLoop.prototype.minus = function () {
+    }
+    minus() {
         this.pool.push({
             functionName: LoopFunctions.minus
         });
         return this;
-    };
-    DPolygonLoop.prototype.degreeToMeters = function () {
+    }
+    degreeToMeters() {
         this.pool.push({
             functionName: LoopFunctions.degreeToMeters
         });
         return this;
-    };
-    DPolygonLoop.prototype.metersToDegree = function () {
+    }
+    metersToDegree() {
         this.pool.push({
             functionName: LoopFunctions.metersToDegree
         });
         return this;
-    };
-    DPolygonLoop.prototype.flipVertically = function (size) {
+    }
+    flipVertically(size) {
         this.pool.push({
             functionName: LoopFunctions.flipVertically,
             numberPointArg: size
         });
         return this;
-    };
-    return DPolygonLoop;
-}());
+    }
+}
 exports.DPolygonLoop = DPolygonLoop;

package/dist/cjs/FastSearch.js

@@ -1,45 +1,22 @@
 "use strict";
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FastSearch = void 0;
-var FastSearch = (function () {
-    function FastSearch() {
+class FastSearch {
+    constructor() {
         this.searchStore = {};
     }
-    FastSearch.prototype.add = function (points) {
-        var e_1, _a;
-        try {
-            for (var points_1 = __values(points), points_1_1 = points_1.next(); !points_1_1.done; points_1_1 = points_1.next()) {
-                var _b = points_1_1.value, x = _b.x, y = _b.y, z = _b.z;
-                if (!this.searchStore[x]) {
-                    this.searchStore[x] = {};
-                }
-                if (!this.searchStore[x][y]) {
-                    this.searchStore[x][y] = {};
-                }
-                this.searchStore[x][y][z || 'undefined'] = true;
+    add(points) {
+        for (const { x, y, z } of points) {
+            if (!this.searchStore[x]) {
+                this.searchStore[x] = {};
             }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (points_1_1 && !points_1_1.done && (_a = points_1.return)) _a.call(points_1);
+            if (!this.searchStore[x][y]) {
+                this.searchStore[x][y] = {};
             }
-            finally { if (e_1) throw e_1.error; }
+            this.searchStore[x][y][z || 'undefined'] = true;
         }
-    };
-    FastSearch.prototype.find = function (_a) {
-        var x = _a.x, y = _a.y, z = _a.z;
+    }
+    find({ x, y, z }) {
         if (!this.searchStore[x]) {
             return false;
         }
@@ -47,7 +24,6 @@ var FastSearch = (function () {
             return false;
         }
         return this.searchStore[x][y][z || 'undefined'];
-    };
-    return FastSearch;
-}());
+    }
+}
 exports.FastSearch = FastSearch;