dgeoutils 2.0.2 → 2.2.2

package/dist/DPolygonLoop.js

@@ -1,135 +1,353 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DPolygonLoop = void 0;
-const DPoint_1 = require("./DPoint");
+var LoopFunctions;
+(function (LoopFunctions) {
+    LoopFunctions[LoopFunctions["getTileFromCoords"] = 0] = "getTileFromCoords";
+    LoopFunctions[LoopFunctions["getCoordsFromTile"] = 1] = "getCoordsFromTile";
+    LoopFunctions[LoopFunctions["height"] = 2] = "height";
+    LoopFunctions[LoopFunctions["setX"] = 3] = "setX";
+    LoopFunctions[LoopFunctions["setY"] = 4] = "setY";
+    LoopFunctions[LoopFunctions["rotate"] = 5] = "rotate";
+    LoopFunctions[LoopFunctions["move"] = 6] = "move";
+    LoopFunctions[LoopFunctions["round"] = 7] = "round";
+    LoopFunctions[LoopFunctions["ceil"] = 8] = "ceil";
+    LoopFunctions[LoopFunctions["floor"] = 9] = "floor";
+    LoopFunctions[LoopFunctions["toFixed"] = 10] = "toFixed";
+    LoopFunctions[LoopFunctions["abs"] = 11] = "abs";
+    LoopFunctions[LoopFunctions["scale"] = 12] = "scale";
+    LoopFunctions[LoopFunctions["divide"] = 13] = "divide";
+    LoopFunctions[LoopFunctions["degreeToRadians"] = 14] = "degreeToRadians";
+    LoopFunctions[LoopFunctions["radiansToDegrees"] = 15] = "radiansToDegrees";
+    LoopFunctions[LoopFunctions["radiansToMeters"] = 16] = "radiansToMeters";
+    LoopFunctions[LoopFunctions["metersToRadians"] = 17] = "metersToRadians";
+    LoopFunctions[LoopFunctions["hipPoint"] = 18] = "hipPoint";
+    LoopFunctions[LoopFunctions["xPoint"] = 19] = "xPoint";
+    LoopFunctions[LoopFunctions["yPoint"] = 20] = "yPoint";
+    LoopFunctions[LoopFunctions["wPoint"] = 21] = "wPoint";
+    LoopFunctions[LoopFunctions["hPoint"] = 22] = "hPoint";
+    LoopFunctions[LoopFunctions["setIfLessThan"] = 23] = "setIfLessThan";
+    LoopFunctions[LoopFunctions["minus"] = 24] = "minus";
+    LoopFunctions[LoopFunctions["degreeToMeters"] = 25] = "degreeToMeters";
+    LoopFunctions[LoopFunctions["metersToDegree"] = 26] = "metersToDegree";
+    LoopFunctions[LoopFunctions["flipVertically"] = 27] = "flipVertically";
+})(LoopFunctions || (LoopFunctions = {}));
+// eslint-disable-next-line complexity
+const decodePoolRecord = (a, { functionName, pointArg, numberPointArg, numberArg, setterArg }) => {
+    let res = a;
+    switch (functionName) {
+        case LoopFunctions.getTileFromCoords:
+            res = (k) => a(k)
+                .getTileFromCoords(numberArg);
+            break;
+        case LoopFunctions.getCoordsFromTile:
+            res = (k) => a(k)
+                .getCoordsFromTile(numberArg);
+            break;
+        case LoopFunctions.height:
+            res = (k) => a(k)
+                .height(numberArg);
+            break;
+        case LoopFunctions.setX:
+            res = (k) => a(k)
+                .setX(setterArg);
+            break;
+        case LoopFunctions.setY:
+            res = (k) => a(k)
+                .setY(setterArg);
+            break;
+        case LoopFunctions.rotate:
+            res = (k) => a(k)
+                .rotate(numberArg);
+            break;
+        case LoopFunctions.move:
+            res = (k) => a(k)
+                .move(numberPointArg, numberArg);
+            break;
+        case LoopFunctions.round:
+            res = (k) => a(k)
+                .round();
+            break;
+        case LoopFunctions.ceil:
+            res = (k) => a(k)
+                .ceil();
+            break;
+        case LoopFunctions.floor:
+            res = (k) => a(k)
+                .floor();
+            break;
+        case LoopFunctions.toFixed:
+            res = (k) => a(k)
+                .toFixed(numberArg);
+            break;
+        case LoopFunctions.abs:
+            res = (k) => a(k)
+                .abs();
+            break;
+        case LoopFunctions.scale:
+            res = (k) => a(k)
+                .scale(numberPointArg, numberArg);
+            break;
+        case LoopFunctions.divide:
+            res = (k) => a(k)
+                .divide(numberPointArg, numberArg);
+            break;
+        case LoopFunctions.degreeToRadians:
+            res = (k) => a(k)
+                .degreeToRadians();
+            break;
+        case LoopFunctions.radiansToDegrees:
+            res = (k) => a(k)
+                .radiansToDegrees();
+            break;
+        case LoopFunctions.radiansToMeters:
+            res = (k) => a(k)
+                .radiansToMeters();
+            break;
+        case LoopFunctions.metersToRadians:
+            res = (k) => a(k)
+                .metersToRadians();
+            break;
+        case LoopFunctions.hipPoint:
+            res = (k) => a(k)
+                .hipPoint;
+            break;
+        case LoopFunctions.xPoint:
+            res = (k) => a(k)
+                .xPoint;
+            break;
+        case LoopFunctions.yPoint:
+            res = (k) => a(k)
+                .yPoint;
+            break;
+        case LoopFunctions.wPoint:
+            res = (k) => a(k)
+                .wPoint;
+            break;
+        case LoopFunctions.hPoint:
+            res = (k) => a(k)
+                .hPoint;
+            break;
+        case LoopFunctions.setIfLessThan:
+            res = (k) => a(k)
+                .setIfLessThan(pointArg);
+            break;
+        case LoopFunctions.minus:
+            res = (k) => a(k)
+                .minus();
+            break;
+        case LoopFunctions.degreeToMeters:
+            res = (k) => a(k)
+                .degreeToMeters();
+            break;
+        case LoopFunctions.metersToDegree:
+            res = (k) => a(k)
+                .metersToDegree();
+            break;
+        case LoopFunctions.flipVertically:
+            res = (k) => a(k)
+                .flipVertically(numberPointArg);
+            break;
+        default:
+    }
+    return res;
+};
 class DPolygonLoop {
     constructor(parent) {
-        this.f = (k) => k;
         this.parent = parent;
+        this.pool = [];
+    }
+    getLoopFunction() {
+        return this.pool.reduce(decodePoolRecord, (k) => k);
+    }
+    /**
+     * Run loop
+     */
+    run() {
+        return this.parent.map(this.getLoopFunction());
     }
     getTileFromCoords(zoom) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).getTileFromCoords(zoom);
+        this.pool.push({
+            functionName: LoopFunctions.getTileFromCoords,
+            numberArg: zoom
+        });
         return this;
     }
     getCoordsFromTile(zoom) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).getCoordsFromTile(zoom);
-        return this;
-    }
-    transform(from = DPoint_1.PSEUDO_MERCATOR, to = DPoint_1.WORLD_GEODETIC_SYSTEM) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).transform(from, to);
+        this.pool.push({
+            functionName: LoopFunctions.getCoordsFromTile,
+            numberArg: zoom
+        });
         return this;
     }
     height(z) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).height(z);
+        this.pool.push({
+            functionName: LoopFunctions.height,
+            numberArg: z
+        });
         return this;
     }
     setX(x) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).setX(x);
+        this.pool.push({
+            functionName: LoopFunctions.setX,
+            setterArg: x
+        });
         return this;
     }
     setY(y) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).setY(y);
+        this.pool.push({
+            functionName: LoopFunctions.setY,
+            setterArg: y
+        });
         return this;
     }
     rotate(a) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).rotate(a);
+        this.pool.push({
+            functionName: LoopFunctions.rotate,
+            numberArg: a
+        });
         return this;
     }
-    move(x = 0, y) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).move(x, y);
+    move(x = 0, y = x) {
+        this.pool.push({
+            functionName: LoopFunctions.move,
+            numberPointArg: x,
+            numberArg: y
+        });
         return this;
     }
     round() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).round();
+        this.pool.push({
+            functionName: LoopFunctions.round
+        });
         return this;
     }
     ceil() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).ceil();
+        this.pool.push({
+            functionName: LoopFunctions.ceil
+        });
         return this;
     }
     floor() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).floor();
+        this.pool.push({
+            functionName: LoopFunctions.floor
+        });
         return this;
     }
     toFixed(n = 2) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).toFixed(n);
+        this.pool.push({
+            functionName: LoopFunctions.toFixed,
+            numberArg: n
+        });
         return this;
     }
     abs() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).abs();
+        this.pool.push({
+            functionName: LoopFunctions.abs
+        });
         return this;
     }
-    scale(x = 0, y) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).scale(x, y);
+    scale(x = 0, y = x) {
+        this.pool.push({
+            functionName: LoopFunctions.scale,
+            numberPointArg: x,
+            numberArg: y
+        });
         return this;
     }
     divide(x = 0, y) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).divide(x, y);
+        this.pool.push({
+            functionName: LoopFunctions.divide,
+            numberPointArg: x,
+            numberArg: y
+        });
+        return this;
+    }
+    degreeToRadians() {
+        this.pool.push({
+            functionName: LoopFunctions.degreeToRadians
+        });
         return this;
     }
-    asRadians() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).asRadians();
+    radiansToDegrees() {
+        this.pool.push({
+            functionName: LoopFunctions.radiansToDegrees
+        });
         return this;
     }
-    asDegrees() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).asDegrees();
+    radiansToMeters() {
+        this.pool.push({
+            functionName: LoopFunctions.radiansToMeters
+        });
+        return this;
+    }
+    metersToRadians() {
+        this.pool.push({
+            functionName: LoopFunctions.metersToRadians
+        });
         return this;
     }
     getHipPoint() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).hipPoint;
+        this.pool.push({
+            functionName: LoopFunctions.hipPoint
+        });
         return this;
     }
     getXPoint() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).xPoint;
+        this.pool.push({
+            functionName: LoopFunctions.xPoint
+        });
         return this;
     }
     getYPoint() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).yPoint;
+        this.pool.push({
+            functionName: LoopFunctions.yPoint
+        });
         return this;
     }
     getWPoint() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).wPoint;
+        this.pool.push({
+            functionName: LoopFunctions.wPoint
+        });
         return this;
     }
     getHPoint() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).hPoint;
+        this.pool.push({
+            functionName: LoopFunctions.hPoint
+        });
         return this;
     }
     setIfLessThan(p) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).setIfLessThan(p);
+        this.pool.push({
+            functionName: LoopFunctions.setIfLessThan,
+            pointArg: p
+        });
         return this;
     }
     minus() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).minus();
+        this.pool.push({
+            functionName: LoopFunctions.minus
+        });
         return this;
     }
-    run() {
-        this.parent.points = this.parent.points.map(this.f);
-        return this.parent;
+    degreeToMeters() {
+        this.pool.push({
+            functionName: LoopFunctions.degreeToMeters
+        });
+        return this;
+    }
+    metersToDegree() {
+        this.pool.push({
+            functionName: LoopFunctions.metersToDegree
+        });
+        return this;
+    }
+    flipVertically(size) {
+        this.pool.push({
+            functionName: LoopFunctions.flipVertically,
+            numberPointArg: size
+        });
+        return this;
     }
 }
 exports.DPolygonLoop = DPolygonLoop;

package/dist/TraceMatrix.js

@@ -36,7 +36,7 @@ class TraceMatrix {
                 const marked = TraceMatrix.createMatrix(this.size, () => TraceMatrixValues.f);
                 setByPosition(marked, s, TraceMatrixValues.t);
                 while (startIndex < res.length) {
-                    const r = res.p(startIndex);
+                    const r = res.at(startIndex);
                     for (let i = -1; i < 2; i++) {
                         for (let j = -1; j < 2; j++) {
                             const t = new DPoint_1.DPoint(r.x + i, r.y + j);
@@ -90,14 +90,14 @@ class TraceMatrix {
             const left = (d) => (d + traceDirections.length + 1) % traceDirections.length;
             const right = (d) => (d + traceDirections.length - 1) % traceDirections.length;
             if (group.length < 2) {
-                const t = group.p(0).clone();
+                const t = group.at(0).clone();
                 return new DPolygon_1.DPolygon([t, t, t]);
             }
             const points = new DPolygon_1.DPolygon();
             let direction = 0;
             let prevDirection = Infinity;
-            let p = group.p(0);
-            while (!p.equal(group.p(0)) || points.length < 2) {
+            let p = group.at(0);
+            while (!p.equal(group.at(0)) || points.length < 2) {
                 // eslint-disable-next-line no-constant-condition
                 while (true) {
                     const nextValue = getByPosition(m, p.clone().move(traceDirections[direction]));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dgeoutils",
-  "version": "2.0.2",
+  "version": "2.2.2",
   "description": "",
   "scripts": {
     "build": "node_modules/.bin/tsc",