@bitbybit-dev/base 0.19.7 → 0.19.8

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

@@ -1,7 +1,11 @@
+import * as Inputs from "../inputs";
+import { MathBitByBit } from "./math";
+
 export class Color {
-    constructor(math) {
-        this.math = math;
-    }
+
+
+    constructor(private readonly math: MathBitByBit) { }
+
     /**
      * Creates a hex color
      * @param inputs Color hex
@@ -10,9 +14,10 @@ export class Color {
      * @shortname color
      * @drawable false
      */
-    hexColor(inputs) {
+    hexColor(inputs: Inputs.Color.HexDto): Inputs.Base.Color {
         return inputs.color;
     }
+
     /**
      * Creates rgb color from hex
      * @param inputs Color hex
@@ -21,7 +26,7 @@ export class Color {
      * @shortname hex to rgb
      * @drawable false
      */
-    hexToRgb(inputs) {
+    hexToRgb(inputs: Inputs.Color.HexDto): Inputs.Base.ColorRGB {
         const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(inputs.color);
         return result ? {
             r: parseInt(result[1], 16),
@@ -29,6 +34,7 @@ export class Color {
             b: parseInt(result[3], 16)
         } : undefined;
     }
+
     /**
      * Creates hex color from rgb
      * @param inputs Color hext
@@ -37,10 +43,11 @@ export class Color {
      * @shortname rgb to hex
      * @drawable false
      */
-    rgbToHex(inputs) {
+    rgbToHex(inputs: Inputs.Color.RGBMinMaxDto): Inputs.Base.Color {
         let r = inputs.r;
         let g = inputs.g;
         let b = inputs.b;
+
         // sometimes rgb values are in 0 - 100 or 0 - 1 ranges
         // so we need to remap them to 0 - 255
         if (inputs.max !== 255) {
@@ -48,9 +55,13 @@ export class Color {
             g = Math.round(this.math.remap({ number: g, fromLow: inputs.min, fromHigh: inputs.max, toLow: 0, toHigh: 255 }));
             b = Math.round(this.math.remap({ number: b, fromLow: inputs.min, fromHigh: inputs.max, toLow: 0, toHigh: 255 }));
         }
+
         const s = `#${Number(0x1000000 + r * 0x10000 + g * 0x100 + b).toString(16).substring(1, 7)}`;
+
         return s;
     }
+
+
     /**
      * Creates hex color from rgb obj that contains {r, g, b} properties in certain range
      * @param inputs Color hext
@@ -59,9 +70,10 @@ export class Color {
      * @shortname rgb obj to hex
      * @drawable false
      */
-    rgbObjToHex(inputs) {
+    rgbObjToHex(inputs: Inputs.Color.RGBObjectMaxDto): Inputs.Base.Color {
         return this.rgbToHex({ r: inputs.rgb.r, g: inputs.rgb.g, b: inputs.rgb.b, min: inputs.min, max: inputs.max });
     }
+
     /**
      * Creates rgb color from hex and maps to different range if needed
      * @param inputs Color hext
@@ -70,7 +82,7 @@ export class Color {
      * @shortname hex to rgb mapped
      * @drawable false
      */
-    hexToRgbMapped(inputs) {
+    hexToRgbMapped(inputs: Inputs.Color.HexDtoMapped): Inputs.Base.ColorRGB {
         const rgb = this.hexToRgb(inputs);
         return {
             r: this.math.remap({ number: rgb.r, fromLow: 0, fromHigh: 255, toLow: inputs.from, toHigh: inputs.to }),
@@ -78,6 +90,7 @@ export class Color {
             b: this.math.remap({ number: rgb.b, fromLow: 0, fromHigh: 255, toLow: inputs.from, toHigh: inputs.to }),
         };
     }
+
     /**
      * Get red param
      * @param inputs Color hext
@@ -86,10 +99,11 @@ export class Color {
      * @shortname red
      * @drawable false
      */
-    getRedParam(inputs) {
+    getRedParam(inputs: Inputs.Color.HexDtoMapped): number {
         const rgb = this.hexToRgbMapped(inputs);
         return rgb.r;
     }
+
     /**
      * Get green param
      * @param inputs Color hext
@@ -98,10 +112,11 @@ export class Color {
      * @shortname green
      * @drawable false
      */
-    getGreenParam(inputs) {
+    getGreenParam(inputs: Inputs.Color.HexDtoMapped): number {
         const rgb = this.hexToRgbMapped(inputs);
         return rgb.g;
     }
+
     /**
      * Get blue param
      * @param inputs Color hext
@@ -110,10 +125,11 @@ export class Color {
      * @shortname blue
      * @drawable false
      */
-    getBlueParam(inputs) {
+    getBlueParam(inputs: Inputs.Color.HexDtoMapped): number {
         const rgb = this.hexToRgbMapped(inputs);
         return rgb.b;
     }
+
     /**
      * RGB to red
      * @param inputs Color rgb
@@ -122,9 +138,10 @@ export class Color {
      * @shortname red
      * @drawable false
      */
-    rgbToRed(inputs) {
+    rgbToRed(inputs: Inputs.Color.RGBObjectDto): number {
         return inputs.rgb.r;
     }
+
     /**
      * RGB to green
      * @param inputs Color rgb
@@ -133,9 +150,10 @@ export class Color {
      * @shortname green
      * @drawable false
      */
-    rgbToGreen(inputs) {
+    rgbToGreen(inputs: Inputs.Color.RGBObjectDto): number {
         return inputs.rgb.g;
     }
+
     /**
      * RGB to blue
      * @param inputs Color rgb
@@ -144,9 +162,10 @@ export class Color {
      * @shortname blue
      * @drawable false
      */
-    rgbToBlue(inputs) {
+    rgbToBlue(inputs: Inputs.Color.RGBObjectDto): number {
         return inputs.rgb.b;
     }
+
     /**
      * Invert color
      * @param inputs hex color and black and white option
@@ -155,7 +174,7 @@ export class Color {
      * @shortname invert color
      * @drawable false
      */
-    invert(inputs) {
+    invert(inputs: Inputs.Color.InvertHexDto): Inputs.Base.Color {
         const { r, g, b } = this.hexToRgbMapped({ color: inputs.color, from: 0, to: 255 });
         if (inputs.blackAndWhite) {
             return (r * 0.299 + g * 0.587 + b * 0.114) > 186

package/lib/api/services/{geometry-helper.js → geometry-helper.ts}

@@ -1,34 +1,41 @@
+import * as Inputs from "../inputs";
+
 export class GeometryHelper {
-    constructor() {
-        this.getArrayDepth = (value) => {
-            return Array.isArray(value) ?
-                1 + Math.max(...value.map(this.getArrayDepth)) :
-                0;
-        };
-    }
-    transformControlPoints(transformation, transformedControlPoints) {
+
+    transformControlPoints(transformation: number[][] | number[][][], transformedControlPoints: Inputs.Base.Point3[]): Inputs.Base.Point3[] {
         const transformationArrays = this.getFlatTransformations(transformation);
+
         transformationArrays.forEach(transform => {
+
             transformedControlPoints = this.transformPointsByMatrixArray(transformedControlPoints, transform);
         });
         return transformedControlPoints;
     }
-    getFlatTransformations(transformation) {
+
+    getFlatTransformations(transformation: number[][] | number[][][]): number[][] {
         let transformationArrays = [];
+
         if (this.getArrayDepth(transformation) === 3) {
             transformation.forEach(transform => {
                 transformationArrays.push(...transform);
             });
-        }
-        else {
+        } else {
             transformationArrays = transformation;
         }
         return transformationArrays;
-    }
-    transformPointsByMatrixArray(points, transform) {
+}
+
+    getArrayDepth = (value): number => {
+        return Array.isArray(value) ?
+            1 + Math.max(...value.map(this.getArrayDepth)) :
+            0;
+    };
+
+    transformPointsByMatrixArray(points: Inputs.Base.Point3[], transform: number[]): Inputs.Base.Point3[] {
         return this.transformPointsCoordinates(points, transform);
     }
-    transformPointsCoordinates(points, transform) {
+
+    transformPointsCoordinates(points: Inputs.Base.Point3[], transform: number[]): Inputs.Base.Point3[] {
         const transformedPoints = [];
         for (const pt of points) {
             const transformedVector = this.transformCoordinates(pt[0], pt[1], pt[2], transform);
@@ -36,9 +43,10 @@ export class GeometryHelper {
         }
         return transformedPoints;
     }
+
     // Algorithm works with arbitrary length numeric vectors. This algorithm is more costly for longer arrays of vectors
-    removeAllDuplicateVectors(vectors, tolerance = 1e-7) {
-        const cleanVectors = [];
+    removeAllDuplicateVectors(vectors: number[][], tolerance = 1e-7): number[][] {
+        const cleanVectors: number[][] = [];
         vectors.forEach(vector => {
             // when there are no vectors in cleanVectors array that match the current vector, push it in.
             if (!cleanVectors.some(s => this.vectorsTheSame(vector, s, tolerance))) {
@@ -47,9 +55,10 @@ export class GeometryHelper {
         });
         return cleanVectors;
     }
+
     // Algorithm works with arbitrary length numeric vectors. 
-    removeConsecutiveVectorDuplicates(vectors, checkFirstAndLast = true, tolerance = 1e-7) {
-        const vectorsRemaining = [];
+    removeConsecutiveVectorDuplicates(vectors: number[][], checkFirstAndLast = true, tolerance = 1e-7): number[][] {
+        const vectorsRemaining: number[][] = [];
         if (vectors.length > 1) {
             for (let i = 1; i < vectors.length; i++) {
                 const currentVector = vectors[i];
@@ -68,18 +77,17 @@ export class GeometryHelper {
                     vectorsRemaining.pop();
                 }
             }
-        }
-        else if (vectors.length === 1) {
+        } else if (vectors.length === 1) {
             vectorsRemaining.push(...vectors);
         }
         return vectorsRemaining;
     }
-    vectorsTheSame(vec1, vec2, tolerance) {
+
+    vectorsTheSame(vec1: number[], vec2: number[], tolerance: number) {
         let result = false;
         if (vec1.length !== vec2.length) {
             return result;
-        }
-        else {
+        } else {
             result = true;
             for (let i = 0; i < vec1.length; i++) {
                 if (!this.approxEq(vec1[i], vec2[i], tolerance)) {
@@ -90,11 +98,13 @@ export class GeometryHelper {
         }
         return result;
     }
-    approxEq(num1, num2, tolerance) {
+
+    approxEq(num1: number, num2: number, tolerance: number): boolean {
         const res = Math.abs(num1 - num2) < tolerance;
         return res;
     }
-    removeConsecutivePointDuplicates(points, checkFirstAndLast = true, tolerance = 1e-7) {
+
+    removeConsecutivePointDuplicates(points: Inputs.Base.Point3[], checkFirstAndLast = true, tolerance = 1e-7): Inputs.Base.Point3[] {
         const pointsRemaining = [];
         if (points.length > 1) {
             for (let i = 1; i < points.length; i++) {
@@ -114,21 +124,20 @@ export class GeometryHelper {
                     pointsRemaining.pop();
                 }
             }
-        }
-        else if (points.length === 1) {
+        } else if (points.length === 1) {
             pointsRemaining.push(...points);
         }
         return pointsRemaining;
     }
-    arePointsTheSame(pointA, pointB, tolerance) {
+
+    arePointsTheSame(pointA: Inputs.Base.Point3 | Inputs.Base.Point2, pointB: Inputs.Base.Point3 | Inputs.Base.Point2, tolerance: number): boolean {
         let result = false;
         if (pointA.length === 2 && pointB.length === 2) {
             if (this.approxEq(pointA[0], pointB[0], tolerance) &&
                 this.approxEq(pointA[1], pointB[1], tolerance)) {
                 result = true;
             }
-        }
-        else if (pointA.length === 3 && pointB.length === 3) {
+        } else if (pointA.length === 3 && pointB.length === 3) {
             if (this.approxEq(pointA[0], pointB[0], tolerance) &&
                 this.approxEq(pointA[1], pointB[1], tolerance) &&
                 this.approxEq(pointA[2], pointB[2], tolerance)) {
@@ -137,15 +146,18 @@ export class GeometryHelper {
         }
         return result;
     }
-    transformCoordinates(x, y, z, transformation) {
+
+    private transformCoordinates(x: number, y: number, z: number, transformation: number[]): Inputs.Base.Vector3 {
         const m = transformation;
         const rx = x * m[0] + y * m[4] + z * m[8] + m[12];
         const ry = x * m[1] + y * m[5] + z * m[9] + m[13];
         const rz = x * m[2] + y * m[6] + z * m[10] + m[14];
         const rw = 1 / (x * m[3] + y * m[7] + z * m[11] + m[15]);
+
         const newx = rx * rw;
         const newy = ry * rw;
         const newz = rz * rw;
         return [newx, newy, newz];
     }
+
 }

package/lib/api/services/{index.d.ts → index.ts}

@@ -6,4 +6,4 @@ export * from "./point";
 export * from "./text";
 export * from "./vector";
 export * from "./transforms";
-export * from "./geometry-helper";
+export * from "./geometry-helper";