@bitbybit-dev/base 0.19.6 → 0.19.8

package/lib/api/services/{point.js → point.ts}

@@ -1,13 +1,17 @@
+import { GeometryHelper } from "./geometry-helper";
+import * as Inputs from "../inputs";
+import { Transforms } from "./transforms";
+
 /**
  * Contains various methods for points. Point in bitbybit is simply an array containing 3 numbers for [x, y, z].
  * Because of this form Point can be interchanged with Vector, which also is an array in [x, y, z] form.
  * When creating 2D points, z coordinate is simply set to 0 - [x, y, 0].
  */
+
 export class Point {
-    constructor(geometryHelper, transforms) {
-        this.geometryHelper = geometryHelper;
-        this.transforms = transforms;
-    }
+
+    constructor(private readonly geometryHelper: GeometryHelper, private readonly transforms: Transforms) { }
+
     /**
      * Transforms the single point
      * @param inputs Contains a point and the transformations to apply
@@ -16,12 +20,13 @@ export class Point {
      * @shortname transform point
      * @drawable true
      */
-    transformPoint(inputs) {
+    transformPoint(inputs: Inputs.Point.TransformPointDto): Inputs.Base.Point3 {
         const transformation = inputs.transformation;
         let transformedControlPoints = [inputs.point];
         transformedControlPoints = this.geometryHelper.transformControlPoints(transformation, transformedControlPoints);
         return transformedControlPoints[0];
     }
+
     /**
      * Transforms multiple points
      * @param inputs Contains points and the transformations to apply
@@ -30,9 +35,10 @@ export class Point {
      * @shortname transform points
      * @drawable true
      */
-    transformPoints(inputs) {
+    transformPoints(inputs: Inputs.Point.TransformPointsDto): Inputs.Base.Point3[] {
         return this.geometryHelper.transformControlPoints(inputs.transformation, inputs.points);
     }
+
     /**
      * Transforms multiple points by multiple transformations
      * @param inputs Contains points and the transformations to apply
@@ -41,7 +47,7 @@ export class Point {
      * @shortname transforms for points
      * @drawable true
      */
-    transformsForPoints(inputs) {
+    transformsForPoints(inputs: Inputs.Point.TransformsForPointsDto): Inputs.Base.Point3[] {
         if (inputs.points.length !== inputs.transformation.length) {
             throw new Error("You must provide equal nr of points and transformations");
         }
@@ -49,6 +55,7 @@ export class Point {
             return this.geometryHelper.transformControlPoints(inputs.transformation[index], [pt])[0];
         });
     }
+
     /**
      * Translate multiple points
      * @param inputs Contains points and the translation vector
@@ -57,10 +64,11 @@ export class Point {
      * @shortname translate points
      * @drawable true
      */
-    translatePoints(inputs) {
+    translatePoints(inputs: Inputs.Point.TranslatePointsDto): Inputs.Base.Point3[] {
         const translationTransform = this.transforms.translationXYZ({ translation: inputs.translation });
         return this.geometryHelper.transformControlPoints(translationTransform, inputs.points);
     }
+
     /**
      * Translate multiple points
      * @param inputs Contains points and the translation vector
@@ -69,7 +77,7 @@ export class Point {
      * @shortname translate points with vectors
      * @drawable true
      */
-    translatePointsWithVectors(inputs) {
+    translatePointsWithVectors(inputs: Inputs.Point.TranslatePointsWithVectorsDto): Inputs.Base.Point3[] {
         if (inputs.points.length !== inputs.translations.length) {
             throw new Error("You must provide equal nr of points and translations");
         }
@@ -78,6 +86,7 @@ export class Point {
             return this.geometryHelper.transformControlPoints(translationTransforms[index], [pt])[0];
         });
     }
+
     /**
      * Translate multiple points by x, y, z values provided
      * @param inputs Contains points and the translation in x y and z
@@ -86,10 +95,11 @@ export class Point {
      * @shortname translate xyz points
      * @drawable true
      */
-    translateXYZPoints(inputs) {
+    translateXYZPoints(inputs: Inputs.Point.TranslateXYZPointsDto): Inputs.Base.Point3[] {
         const translationTransform = this.transforms.translationXYZ({ translation: [inputs.x, inputs.y, inputs.z] });
         return this.geometryHelper.transformControlPoints(translationTransform, inputs.points);
     }
+
     /**
      * Scale multiple points by providing center point and x, y, z scale factors
      * @param inputs Contains points, center point and scale factors
@@ -98,10 +108,11 @@ export class Point {
      * @shortname scale points on center
      * @drawable true
      */
-    scalePointsCenterXYZ(inputs) {
+    scalePointsCenterXYZ(inputs: Inputs.Point.ScalePointsCenterXYZDto): Inputs.Base.Point3[] {
         const scaleTransforms = this.transforms.scaleCenterXYZ({ center: inputs.center, scaleXyz: inputs.scaleXyz });
         return this.geometryHelper.transformControlPoints(scaleTransforms, inputs.points);
     }
+
     /**
      * Rotate multiple points by providing center point, axis and degrees of rotation
      * @param inputs Contains points, axis, center point and angle of rotation
@@ -110,10 +121,11 @@ export class Point {
      * @shortname rotate points center axis
      * @drawable true
      */
-    rotatePointsCenterAxis(inputs) {
+    rotatePointsCenterAxis(inputs: Inputs.Point.RotatePointsCenterAxisDto): Inputs.Base.Point3[] {
         const rotationTransforms = this.transforms.rotationCenterAxis({ center: inputs.center, axis: inputs.axis, angle: inputs.angle });
         return this.geometryHelper.transformControlPoints(rotationTransforms, inputs.points);
     }
+
     /**
      * Measures the closest distance between a point and a collection of points
      * @param inputs Point from which to measure and points to measure the distance against
@@ -122,9 +134,10 @@ export class Point {
      * @shortname distance to closest pt
      * @drawable false
      */
-    closestPointFromPointsDistance(inputs) {
+    closestPointFromPointsDistance(inputs: Inputs.Point.ClosestPointFromPointsDto): number {
         return this.closestPointFromPointData(inputs).distance;
     }
+
     /**
      * Finds the closest point index between a point and a collection of points. Caution, index is not 0 based, it starts with 1.
      * @param inputs Point from which to find the index in a collection of points
@@ -133,9 +146,10 @@ export class Point {
      * @shortname index of closest pt
      * @drawable false
      */
-    closestPointFromPointsIndex(inputs) {
+    closestPointFromPointsIndex(inputs: Inputs.Point.ClosestPointFromPointsDto): number {
         return this.closestPointFromPointData(inputs).index;
     }
+
     /**
      * Finds the closest point in a collection
      * @param inputs Point and points collection to find the closest point in
@@ -144,9 +158,10 @@ export class Point {
      * @shortname closest pt
      * @drawable true
      */
-    closestPointFromPoints(inputs) {
-        return this.closestPointFromPointData(inputs).point;
+    closestPointFromPoints(inputs: Inputs.Point.ClosestPointFromPointsDto): Inputs.Base.Point3 {
+        return this.closestPointFromPointData(inputs).point as Inputs.Base.Point3;
     }
+
     /**
      * Finds the distance between two points
      * @param inputs Coordinates of start and end points
@@ -155,12 +170,13 @@ export class Point {
      * @shortname distance
      * @drawable false
      */
-    distance(inputs) {
+    distance(inputs: Inputs.Point.StartEndPointsDto): number {
         const x = inputs.endPoint[0] - inputs.startPoint[0];
         const y = inputs.endPoint[1] - inputs.startPoint[1];
         const z = inputs.endPoint[2] - inputs.startPoint[2];
         return Math.sqrt(x * x + y * y + z * z);
     }
+
     /**
      * Finds the distances between the start point and multiple end points
      * @param inputs Coordinates of start and end points
@@ -169,11 +185,12 @@ export class Point {
      * @shortname distances to points
      * @drawable false
      */
-    distancesToPoints(inputs) {
+    distancesToPoints(inputs: Inputs.Point.StartEndPointsListDto): number[] {
         return inputs.endPoints.map(pt => {
             return this.distance({ startPoint: inputs.startPoint, endPoint: pt });
         });
     }
+
     /**
      * Multiply point by a specified amount
      * @param inputs The point to be multiplied and the amount of points to create
@@ -182,13 +199,14 @@ export class Point {
      * @shortname multiply point
      * @drawable true
      */
-    multiplyPoint(inputs) {
+    multiplyPoint(inputs: Inputs.Point.MultiplyPointDto): Inputs.Base.Point3[] {
         const points = [];
         for (let i = 0; i < inputs.amountOfPoints; i++) {
             points.push([inputs.point[0], inputs.point[1], inputs.point[2]]);
         }
         return points;
     }
+
     /**
      * Get x coordinate of the point
      * @param inputs The point
@@ -197,9 +215,10 @@ export class Point {
      * @shortname x coord
      * @drawable false
      */
-    getX(inputs) {
+    getX(inputs: Inputs.Point.PointDto): number {
         return inputs.point[0];
     }
+
     /**
      * Get y coordinate of the point
      * @param inputs The point
@@ -208,9 +227,10 @@ export class Point {
      * @shortname y coord
      * @drawable false
      */
-    getY(inputs) {
+    getY(inputs: Inputs.Point.PointDto): number {
         return inputs.point[1];
     }
+
     /**
      * Get z coordinate of the point
      * @param inputs The point
@@ -219,9 +239,10 @@ export class Point {
      * @shortname z coord
      * @drawable false
      */
-    getZ(inputs) {
+    getZ(inputs: Inputs.Point.PointDto): number {
         return inputs.point[2];
     }
+
     /**
      * Get average point of points
      * @param inputs The points
@@ -230,21 +251,24 @@ export class Point {
      * @shortname average point
      * @drawable true
      */
-    averagePoint(inputs) {
+    averagePoint(inputs: Inputs.Point.PointsDto): Inputs.Base.Point3 {
         const xVals = [];
         const yVals = [];
         const zVals = [];
+
         inputs.points.forEach(pt => {
             xVals.push(pt[0]);
             yVals.push(pt[1]);
             zVals.push(pt[2]);
         });
+
         return [
             xVals.reduce((p, c) => p + c, 0) / inputs.points.length,
             yVals.reduce((p, c) => p + c, 0) / inputs.points.length,
             zVals.reduce((p, c) => p + c, 0) / inputs.points.length,
         ];
     }
+
     /**
      * Creates the xyz point
      * @param inputs xyz information
@@ -253,9 +277,10 @@ export class Point {
      * @shortname point xyz
      * @drawable true
      */
-    pointXYZ(inputs) {
+    pointXYZ(inputs: Inputs.Point.PointXYZDto): Inputs.Base.Point3 {
         return [inputs.x, inputs.y, inputs.z];
     }
+
     /**
      * Creates the xy point
      * @param inputs xy information
@@ -264,9 +289,10 @@ export class Point {
      * @shortname point xy
      * @drawable false
      */
-    pointXY(inputs) {
+    pointXY(inputs: Inputs.Point.PointXYDto): Inputs.Base.Point2 {
         return [inputs.x, inputs.y];
     }
+
     /**
      * Creates the spiral out of multiple points
      * @param inputs Spiral information
@@ -275,7 +301,7 @@ export class Point {
      * @shortname spiral
      * @drawable true
      */
-    spiral(inputs) {
+    spiral(inputs: Inputs.Point.SpiralDto): Inputs.Base.Point3[] {
         const phi = inputs.phi;
         const b = Math.log(phi) / (Math.PI / inputs.widening);
         const spiral = [];
@@ -288,6 +314,7 @@ export class Point {
         }
         return spiral;
     }
+
     /**
      * Creates a flat point grid on XY plane. This grid contains center points for hexagons of the given radius.
      * Be aware that we control only the nr of hexagons to be made and not the length and width of the grid.
@@ -297,7 +324,7 @@ export class Point {
      * @shortname hex grid
      * @drawable true
      */
-    hexGrid(inputs) {
+    hexGrid(inputs: Inputs.Point.HexGridCentersDto): Inputs.Base.Point3[] {
         const xLength = Math.sqrt(Math.pow(inputs.radiusHexagon, 2) - Math.pow(inputs.radiusHexagon / 2, 2));
         const points = [];
         for (let ix = 0; ix < inputs.nrHexagonsX; ix++) {
@@ -308,6 +335,7 @@ export class Point {
                 points.push([adjustX, coordY, 0]);
             }
         }
+
         if (inputs.orientOnCenter) {
             const compensateX = points[points.length - 1][0] / 2;
             const compensateY = points[points.length - 1][1] / 2;
@@ -315,13 +343,16 @@ export class Point {
                 points[index] = [p[0] - compensateX, p[1] - compensateY, 0];
             });
         }
+
         if (inputs.pointsOnGround) {
             points.forEach((p, index) => {
                 points[index] = [p[0], 0, p[1]];
             });
         }
+
         return points;
     }
+
     /**
      * Removes consecutive duplicates from the point array with tolerance
      * @param inputs points, tolerance and check first and last
@@ -330,22 +361,26 @@ export class Point {
      * @shortname remove duplicates
      * @drawable true
      */
-    removeConsecutiveDuplicates(inputs) {
+    removeConsecutiveDuplicates(inputs: Inputs.Point.RemoveConsecutiveDuplicatesDto): Inputs.Base.Point3[] {
         return this.geometryHelper.removeConsecutivePointDuplicates(inputs.points, inputs.checkFirstAndLast, inputs.tolerance);
     }
-    closestPointFromPointData(inputs) {
+
+    private closestPointFromPointData(inputs: Inputs.Point.ClosestPointFromPointsDto): {
+        index: number, point: Inputs.Base.Point3, distance: number
+    } {
         let distance = Number.MAX_SAFE_INTEGER;
-        let closestPointIndex;
-        let point;
+        let closestPointIndex: number;
+        let point: Inputs.Base.Point3;
         for (let i = 0; i < inputs.points.length; i++) {
             const pt = inputs.points[i];
             const currentDist = this.distance({ startPoint: inputs.point, endPoint: pt });
             if (currentDist < distance) {
                 distance = currentDist;
                 closestPointIndex = i;
-                point = pt;
+                point = pt as Inputs.Base.Point3;
             }
         }
         return { index: closestPointIndex + 1, distance, point };
     }
+
 }

package/lib/api/services/text.test.ts

@@ -0,0 +1,55 @@
+import { TextBitByBit } from "./text";
+
+describe("Text unit tests", () => {
+    let text: TextBitByBit;
+
+    beforeAll(async () => {
+        text = new TextBitByBit();
+    });
+
+    it("should create a text", async () => {
+        const result = text.create({ text: "Hello World, Matas" });
+        expect(result).toEqual("Hello World, Matas");
+    });
+
+    it("should split text", async () => {
+        const result = text.split({ text: "Hello World, Matas, Ubarevicius", separator: "," });
+        expect(result).toEqual(["Hello World", " Matas", " Ubarevicius"]);
+    });
+
+    it("should replace all in text", async () => {
+        const result = text.replaceAll({ text: "Hello World, Matas, Ubarevicius", search: ",", replaceWith: "-" });
+        expect(result).toEqual("Hello World- Matas- Ubarevicius");
+    });
+
+    it("should join all items", async () => {
+        const result = text.join({ list: ["Hello World", " Matas", " Ubarevicius"], separator: "," });
+        expect(result).toEqual("Hello World, Matas, Ubarevicius");
+    });
+
+    it("should convert to string item", async () => {
+        const result = text.toString({ item: [0, 0, 0] });
+        expect(result).toEqual("0,0,0");
+    });
+
+    it("should convert to string items", async () => {
+        const result = text.toStringEach({ list: [0, 1, 2] });
+        expect(result).toEqual(["0", "1", "2"]);
+    });
+
+    it("should format string", () => {
+        const result = text.format({ text: "Hello {0}, {1}", values: ["World", "Matas"] });
+        expect(result).toEqual("Hello World, Matas");
+    });
+
+    it("should not format string if there are no values", () => {
+        const result = text.format({ text: "Hello {0}, {1}", values: [] });
+        expect(result).toEqual("Hello {0}, {1}");
+    });
+
+    it("should not format string if there are no placeholders", () => {
+        const result = text.format({ text: "Hello World, Matas", values: ["dada"] });
+        expect(result).toEqual("Hello World, Matas");
+    });
+});
+

package/lib/api/services/{text.js → text.ts}

@@ -1,7 +1,10 @@
+import * as Inputs from "../inputs";
+
 /**
  * Contains various text methods.
  */
 export class TextBitByBit {
+
     /**
      * Creates a text
      * @param inputs a text
@@ -10,9 +13,10 @@ export class TextBitByBit {
      * @shortname text
      * @drawable false
      */
-    create(inputs) {
+    create(inputs: Inputs.Text.TextDto): string {
         return inputs.text;
     }
+
     /**
     * Split the text to multiple pieces by a separator
     * @param inputs a text
@@ -21,9 +25,10 @@ export class TextBitByBit {
     * @shortname split
     * @drawable false
     */
-    split(inputs) {
+    split(inputs: Inputs.Text.TextSplitDto): string[] {
         return inputs.text.split(inputs.separator);
     }
+
     /**
     * Replace all occurrences of a text by another text
     * @param inputs a text
@@ -32,9 +37,10 @@ export class TextBitByBit {
     * @shortname replaceAll
     * @drawable false
     */
-    replaceAll(inputs) {
+    replaceAll(inputs: Inputs.Text.TextReplaceDto): string {
         return inputs.text.split(inputs.search).join(inputs.replaceWith);
     }
+
     /**
     * Join multiple items by a separator into text
     * @param inputs a list of items
@@ -43,9 +49,10 @@ export class TextBitByBit {
     * @shortname join
     * @drawable false
     */
-    join(inputs) {
+    join(inputs: Inputs.Text.TextJoinDto): string {
         return inputs.list.join(inputs.separator);
     }
+
     /**
     * Transform any item to text
     * @param inputs any item
@@ -54,9 +61,10 @@ export class TextBitByBit {
     * @shortname to string
     * @drawable false
     */
-    toString(inputs) {
+    toString<T>(inputs: Inputs.Text.ToStringDto<T>): string {
         return inputs.item.toString();
     }
+
     /**
     * Transform each item in list to text
     * @param inputs list of items
@@ -65,9 +73,10 @@ export class TextBitByBit {
     * @shortname to strings
     * @drawable false
     */
-    toStringEach(inputs) {
+    toStringEach<T>(inputs: Inputs.Text.ToStringEachDto<T>): string[] {
         return inputs.list.map(i => i.toString());
     }
+
     /**
      * Format a text with values
      * @param inputs a text and values
@@ -76,9 +85,10 @@ export class TextBitByBit {
      * @shortname format
      * @drawable false
      */
-    format(inputs) {
+    format(inputs: Inputs.Text.TextFormatDto): string {
         return inputs.text.replace(/{(\d+)}/g, (match, number) => {
             return typeof inputs.values[number] !== "undefined" ? inputs.values[number] : match;
         });
     }
+
 }