@bitbybit-dev/base 0.19.8 → 0.19.9

package/lib/api/services/color.d.ts

@@ -0,0 +1,114 @@
+import * as Inputs from "../inputs";
+import { MathBitByBit } from "./math";
+export declare class Color {
+    private readonly math;
+    constructor(math: MathBitByBit);
+    /**
+     * Creates a hex color
+     * @param inputs Color hex
+     * @returns color string
+     * @group create
+     * @shortname color
+     * @drawable false
+     */
+    hexColor(inputs: Inputs.Color.HexDto): Inputs.Base.Color;
+    /**
+     * Creates rgb color from hex
+     * @param inputs Color hex
+     * @returns rgb color
+     * @group convert
+     * @shortname hex to rgb
+     * @drawable false
+     */
+    hexToRgb(inputs: Inputs.Color.HexDto): Inputs.Base.ColorRGB;
+    /**
+     * Creates hex color from rgb
+     * @param inputs Color hext
+     * @returns hex color
+     * @group convert
+     * @shortname rgb to hex
+     * @drawable false
+     */
+    rgbToHex(inputs: Inputs.Color.RGBMinMaxDto): Inputs.Base.Color;
+    /**
+     * Creates hex color from rgb obj that contains {r, g, b} properties in certain range
+     * @param inputs Color hext
+     * @returns hex color string
+     * @group convert
+     * @shortname rgb obj to hex
+     * @drawable false
+     */
+    rgbObjToHex(inputs: Inputs.Color.RGBObjectMaxDto): Inputs.Base.Color;
+    /**
+     * Creates rgb color from hex and maps to different range if needed
+     * @param inputs Color hext
+     * @returns rgb color
+     * @group convert
+     * @shortname hex to rgb mapped
+     * @drawable false
+     */
+    hexToRgbMapped(inputs: Inputs.Color.HexDtoMapped): Inputs.Base.ColorRGB;
+    /**
+     * Get red param
+     * @param inputs Color hext
+     * @returns rgb color
+     * @group hex to
+     * @shortname red
+     * @drawable false
+     */
+    getRedParam(inputs: Inputs.Color.HexDtoMapped): number;
+    /**
+     * Get green param
+     * @param inputs Color hext
+     * @returns rgb color
+     * @group hex to
+     * @shortname green
+     * @drawable false
+     */
+    getGreenParam(inputs: Inputs.Color.HexDtoMapped): number;
+    /**
+     * Get blue param
+     * @param inputs Color hext
+     * @returns blue param
+     * @group hex to
+     * @shortname blue
+     * @drawable false
+     */
+    getBlueParam(inputs: Inputs.Color.HexDtoMapped): number;
+    /**
+     * RGB to red
+     * @param inputs Color rgb
+     * @returns red param
+     * @group  rgb to
+     * @shortname red
+     * @drawable false
+     */
+    rgbToRed(inputs: Inputs.Color.RGBObjectDto): number;
+    /**
+     * RGB to green
+     * @param inputs Color rgb
+     * @returns green param
+     * @group rgb to
+     * @shortname green
+     * @drawable false
+     */
+    rgbToGreen(inputs: Inputs.Color.RGBObjectDto): number;
+    /**
+     * RGB to blue
+     * @param inputs Color rgb
+     * @returns blue param
+     * @group rgb to
+     * @shortname blue
+     * @drawable false
+     */
+    rgbToBlue(inputs: Inputs.Color.RGBObjectDto): number;
+    /**
+     * Invert color
+     * @param inputs hex color and black and white option
+     * @returns inverted color
+     * @group hex to
+     * @shortname invert color
+     * @drawable false
+     */
+    invert(inputs: Inputs.Color.InvertHexDto): Inputs.Base.Color;
+}

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

@@ -1,11 +1,7 @@
-import * as Inputs from "../inputs";
-import { MathBitByBit } from "./math";
-
 export class Color {
-
-
-    constructor(private readonly math: MathBitByBit) { }
-
+    constructor(math) {
+        this.math = math;
+    }
     /**
      * Creates a hex color
      * @param inputs Color hex
@@ -14,10 +10,9 @@ export class Color {
      * @shortname color
      * @drawable false
      */
-    hexColor(inputs: Inputs.Color.HexDto): Inputs.Base.Color {
+    hexColor(inputs) {
         return inputs.color;
     }
-
     /**
      * Creates rgb color from hex
      * @param inputs Color hex
@@ -26,7 +21,7 @@ export class Color {
      * @shortname hex to rgb
      * @drawable false
      */
-    hexToRgb(inputs: Inputs.Color.HexDto): Inputs.Base.ColorRGB {
+    hexToRgb(inputs) {
         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),
@@ -34,7 +29,6 @@ export class Color {
             b: parseInt(result[3], 16)
         } : undefined;
     }
-
     /**
      * Creates hex color from rgb
      * @param inputs Color hext
@@ -43,11 +37,10 @@ export class Color {
      * @shortname rgb to hex
      * @drawable false
      */
-    rgbToHex(inputs: Inputs.Color.RGBMinMaxDto): Inputs.Base.Color {
+    rgbToHex(inputs) {
         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) {
@@ -55,13 +48,9 @@ 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
@@ -70,10 +59,9 @@ export class Color {
      * @shortname rgb obj to hex
      * @drawable false
      */
-    rgbObjToHex(inputs: Inputs.Color.RGBObjectMaxDto): Inputs.Base.Color {
+    rgbObjToHex(inputs) {
         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
@@ -82,7 +70,7 @@ export class Color {
      * @shortname hex to rgb mapped
      * @drawable false
      */
-    hexToRgbMapped(inputs: Inputs.Color.HexDtoMapped): Inputs.Base.ColorRGB {
+    hexToRgbMapped(inputs) {
         const rgb = this.hexToRgb(inputs);
         return {
             r: this.math.remap({ number: rgb.r, fromLow: 0, fromHigh: 255, toLow: inputs.from, toHigh: inputs.to }),
@@ -90,7 +78,6 @@ 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
@@ -99,11 +86,10 @@ export class Color {
      * @shortname red
      * @drawable false
      */
-    getRedParam(inputs: Inputs.Color.HexDtoMapped): number {
+    getRedParam(inputs) {
         const rgb = this.hexToRgbMapped(inputs);
         return rgb.r;
     }
-
     /**
      * Get green param
      * @param inputs Color hext
@@ -112,11 +98,10 @@ export class Color {
      * @shortname green
      * @drawable false
      */
-    getGreenParam(inputs: Inputs.Color.HexDtoMapped): number {
+    getGreenParam(inputs) {
         const rgb = this.hexToRgbMapped(inputs);
         return rgb.g;
     }
-
     /**
      * Get blue param
      * @param inputs Color hext
@@ -125,11 +110,10 @@ export class Color {
      * @shortname blue
      * @drawable false
      */
-    getBlueParam(inputs: Inputs.Color.HexDtoMapped): number {
+    getBlueParam(inputs) {
         const rgb = this.hexToRgbMapped(inputs);
         return rgb.b;
     }
-
     /**
      * RGB to red
      * @param inputs Color rgb
@@ -138,10 +122,9 @@ export class Color {
      * @shortname red
      * @drawable false
      */
-    rgbToRed(inputs: Inputs.Color.RGBObjectDto): number {
+    rgbToRed(inputs) {
         return inputs.rgb.r;
     }
-
     /**
      * RGB to green
      * @param inputs Color rgb
@@ -150,10 +133,9 @@ export class Color {
      * @shortname green
      * @drawable false
      */
-    rgbToGreen(inputs: Inputs.Color.RGBObjectDto): number {
+    rgbToGreen(inputs) {
         return inputs.rgb.g;
     }
-
     /**
      * RGB to blue
      * @param inputs Color rgb
@@ -162,10 +144,9 @@ export class Color {
      * @shortname blue
      * @drawable false
      */
-    rgbToBlue(inputs: Inputs.Color.RGBObjectDto): number {
+    rgbToBlue(inputs) {
         return inputs.rgb.b;
     }
-
     /**
      * Invert color
      * @param inputs hex color and black and white option
@@ -174,7 +155,7 @@ export class Color {
      * @shortname invert color
      * @drawable false
      */
-    invert(inputs: Inputs.Color.InvertHexDto): Inputs.Base.Color {
+    invert(inputs) {
         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.d.ts

@@ -0,0 +1,15 @@
+import * as Inputs from "../inputs";
+export declare class GeometryHelper {
+    transformControlPoints(transformation: number[][] | number[][][], transformedControlPoints: Inputs.Base.Point3[]): Inputs.Base.Point3[];
+    getFlatTransformations(transformation: number[][] | number[][][]): number[][];
+    getArrayDepth: (value: any) => number;
+    transformPointsByMatrixArray(points: Inputs.Base.Point3[], transform: number[]): Inputs.Base.Point3[];
+    transformPointsCoordinates(points: Inputs.Base.Point3[], transform: number[]): Inputs.Base.Point3[];
+    removeAllDuplicateVectors(vectors: number[][], tolerance?: number): number[][];
+    removeConsecutiveVectorDuplicates(vectors: number[][], checkFirstAndLast?: boolean, tolerance?: number): number[][];
+    vectorsTheSame(vec1: number[], vec2: number[], tolerance: number): boolean;
+    approxEq(num1: number, num2: number, tolerance: number): boolean;
+    removeConsecutivePointDuplicates(points: Inputs.Base.Point3[], checkFirstAndLast?: boolean, tolerance?: number): Inputs.Base.Point3[];
+    arePointsTheSame(pointA: Inputs.Base.Point3 | Inputs.Base.Point2, pointB: Inputs.Base.Point3 | Inputs.Base.Point2, tolerance: number): boolean;
+    private transformCoordinates;
+}

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

@@ -1,41 +1,34 @@
-import * as Inputs from "../inputs";
-
 export class GeometryHelper {
-
-    transformControlPoints(transformation: number[][] | number[][][], transformedControlPoints: Inputs.Base.Point3[]): Inputs.Base.Point3[] {
+    constructor() {
+        this.getArrayDepth = (value) => {
+            return Array.isArray(value) ?
+                1 + Math.max(...value.map(this.getArrayDepth)) :
+                0;
+        };
+    }
+    transformControlPoints(transformation, transformedControlPoints) {
         const transformationArrays = this.getFlatTransformations(transformation);
-
         transformationArrays.forEach(transform => {
-
             transformedControlPoints = this.transformPointsByMatrixArray(transformedControlPoints, transform);
         });
         return transformedControlPoints;
     }
-
-    getFlatTransformations(transformation: number[][] | number[][][]): number[][] {
+    getFlatTransformations(transformation) {
         let transformationArrays = [];
-
         if (this.getArrayDepth(transformation) === 3) {
             transformation.forEach(transform => {
                 transformationArrays.push(...transform);
             });
-        } else {
+        }
+        else {
             transformationArrays = transformation;
         }
         return transformationArrays;
-}
-
-    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[] {
+    }
+    transformPointsByMatrixArray(points, transform) {
         return this.transformPointsCoordinates(points, transform);
     }
-
-    transformPointsCoordinates(points: Inputs.Base.Point3[], transform: number[]): Inputs.Base.Point3[] {
+    transformPointsCoordinates(points, transform) {
         const transformedPoints = [];
         for (const pt of points) {
             const transformedVector = this.transformCoordinates(pt[0], pt[1], pt[2], transform);
@@ -43,10 +36,9 @@ export class GeometryHelper {
         }
         return transformedPoints;
     }
-
     // Algorithm works with arbitrary length numeric vectors. This algorithm is more costly for longer arrays of vectors
-    removeAllDuplicateVectors(vectors: number[][], tolerance = 1e-7): number[][] {
-        const cleanVectors: number[][] = [];
+    removeAllDuplicateVectors(vectors, tolerance = 1e-7) {
+        const cleanVectors = [];
         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))) {
@@ -55,10 +47,9 @@ export class GeometryHelper {
         });
         return cleanVectors;
     }
-
     // Algorithm works with arbitrary length numeric vectors. 
-    removeConsecutiveVectorDuplicates(vectors: number[][], checkFirstAndLast = true, tolerance = 1e-7): number[][] {
-        const vectorsRemaining: number[][] = [];
+    removeConsecutiveVectorDuplicates(vectors, checkFirstAndLast = true, tolerance = 1e-7) {
+        const vectorsRemaining = [];
         if (vectors.length > 1) {
             for (let i = 1; i < vectors.length; i++) {
                 const currentVector = vectors[i];
@@ -77,17 +68,18 @@ export class GeometryHelper {
                     vectorsRemaining.pop();
                 }
             }
-        } else if (vectors.length === 1) {
+        }
+        else if (vectors.length === 1) {
             vectorsRemaining.push(...vectors);
         }
         return vectorsRemaining;
     }
-
-    vectorsTheSame(vec1: number[], vec2: number[], tolerance: number) {
+    vectorsTheSame(vec1, vec2, tolerance) {
         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)) {
@@ -98,13 +90,11 @@ export class GeometryHelper {
         }
         return result;
     }
-
-    approxEq(num1: number, num2: number, tolerance: number): boolean {
+    approxEq(num1, num2, tolerance) {
         const res = Math.abs(num1 - num2) < tolerance;
         return res;
     }
-
-    removeConsecutivePointDuplicates(points: Inputs.Base.Point3[], checkFirstAndLast = true, tolerance = 1e-7): Inputs.Base.Point3[] {
+    removeConsecutivePointDuplicates(points, checkFirstAndLast = true, tolerance = 1e-7) {
         const pointsRemaining = [];
         if (points.length > 1) {
             for (let i = 1; i < points.length; i++) {
@@ -124,20 +114,21 @@ export class GeometryHelper {
                     pointsRemaining.pop();
                 }
             }
-        } else if (points.length === 1) {
+        }
+        else if (points.length === 1) {
             pointsRemaining.push(...points);
         }
         return pointsRemaining;
     }
-
-    arePointsTheSame(pointA: Inputs.Base.Point3 | Inputs.Base.Point2, pointB: Inputs.Base.Point3 | Inputs.Base.Point2, tolerance: number): boolean {
+    arePointsTheSame(pointA, pointB, tolerance) {
         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)) {
@@ -146,18 +137,15 @@ export class GeometryHelper {
         }
         return result;
     }
-
-    private transformCoordinates(x: number, y: number, z: number, transformation: number[]): Inputs.Base.Vector3 {
+    transformCoordinates(x, y, z, transformation) {
         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.ts → index.d.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";

package/lib/api/services/index.js

@@ -0,0 +1,9 @@
+export * from "./color";
+export * from "./lists";
+export * from "./logic";
+export * from "./math";
+export * from "./point";
+export * from "./text";
+export * from "./vector";
+export * from "./transforms";
+export * from "./geometry-helper";