dgeoutils 2.1.0 → 2.2.3

package/dist/DPolygonLoop.js

@@ -1,155 +1,358 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DPolygonLoop = void 0;
+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(f = this.f) {
-        return this.parent.map(f);
+    run() {
+        return this.parent.map(this.getLoopFunction());
     }
+    /**
+     * @param zoom default value would be `z` of point
+     */
     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;
     }
+    /**
+     * @param zoom default value would be `z` of point
+     */
     getCoordsFromTile(zoom) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).getCoordsFromTile(zoom);
+        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, 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, 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);
+    divide(x, y) {
+        this.pool.push({
+            functionName: LoopFunctions.divide,
+            numberPointArg: x,
+            numberArg: y
+        });
         return this;
     }
     degreeToRadians() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).degreeToRadians();
+        this.pool.push({
+            functionName: LoopFunctions.degreeToRadians
+        });
         return this;
     }
     radiansToDegrees() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).radiansToDegrees();
+        this.pool.push({
+            functionName: LoopFunctions.radiansToDegrees
+        });
         return this;
     }
     radiansToMeters() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).radiansToMeters();
+        this.pool.push({
+            functionName: LoopFunctions.radiansToMeters
+        });
         return this;
     }
     metersToRadians() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).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;
     }
     degreeToMeters() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).degreeToMeters();
+        this.pool.push({
+            functionName: LoopFunctions.degreeToMeters
+        });
         return this;
     }
     metersToDegree() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).metersToDegree();
+        this.pool.push({
+            functionName: LoopFunctions.metersToDegree
+        });
         return this;
     }
     flipVertically(size) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).flipVertically(size);
+        this.pool.push({
+            functionName: LoopFunctions.flipVertically,
+            numberPointArg: size
+        });
         return this;
     }
 }

package/dist/TraceMatrix.js

@@ -4,10 +4,7 @@ exports.TraceMatrix = exports.TraceMatrixValues = void 0;
 const DPoint_1 = require("./DPoint");
 const DPolygon_1 = require("./DPolygon");
 const FastSearch_1 = require("./FastSearch");
-const createArray = (v = 0) => new Array(v + 1)
-    .join(' ')
-    .split('')
-    .map((r, i) => i);
+const utils_1 = require("./utils");
 var TraceMatrixValues;
 (function (TraceMatrixValues) {
     TraceMatrixValues[TraceMatrixValues["f"] = 0] = "f";
@@ -36,7 +33,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 +87,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]));
@@ -201,7 +198,8 @@ class TraceMatrix {
         return res;
     }
     static createMatrix(size, f = () => TraceMatrixValues.f) {
-        return createArray(size.h).map((i) => createArray(size.w).map((j) => f(new DPoint_1.DPoint(j, i))));
+        return (0, utils_1.createArray)(size.h)
+            .map((v, i) => (0, utils_1.createArray)(size.w).map((v2, j) => f(new DPoint_1.DPoint(j, i))));
     }
 }
 exports.TraceMatrix = TraceMatrix;

package/dist/utils.d.ts

@@ -12,4 +12,5 @@ interface CheckFunction {
     checkArgument: (argName: string) => CheckArgument;
 }
 export declare const checkFunction: (funcName: string) => CheckFunction;
+export declare const createArray: (v: number) => number[];
 export {};

package/dist/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkFunction = exports.warn = void 0;
+exports.createArray = exports.checkFunction = exports.warn = void 0;
 const index_1 = require("./index");
 const DPoint_1 = require("./DPoint");
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -21,7 +21,7 @@ const shouldBeInt = (scope, funcName, argName) => (p) => {
 };
 const shouldBeUInt = (scope, funcName, argName) => (p) => {
     if (!p.clone().round()
-        .equal(p) || !p.gtOrEqual(DPoint_1.DPoint.Zero())) {
+        .equal(p) || !p.gtOrEqual(DPoint_1.DPoint.zero())) {
         (0, exports.warn)(`"${funcName}" -> "${argName}" should be UInt!`);
     }
     return scope;
@@ -66,3 +66,5 @@ const checkFunction = (funcName) => ({
     }
 });
 exports.checkFunction = checkFunction;
+const createArray = (v) => new Array(v).fill(0);
+exports.createArray = createArray;

package/package.json

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