@bitbybit-dev/base 0.19.6 → 0.19.8

package/lib/api/inputs/{transforms-inputs.d.ts → transforms-inputs.ts}

@@ -1,7 +1,14 @@
+/* eslint-disable @typescript-eslint/no-namespace */
 import { Base } from "./base-inputs";
-export declare namespace Transforms {
-    class RotationCenterAxisDto {
-        constructor(angle?: number, axis?: Base.Vector3, center?: Base.Point3);
+
+export namespace Transforms {
+
+    export class RotationCenterAxisDto {
+        constructor(angle?: number, axis?: Base.Vector3, center?: Base.Point3) {
+            if (angle !== undefined) { this.angle = angle; }
+            if (axis !== undefined) { this.axis = axis; }
+            if (center !== undefined) { this.center = center; }
+        }
         /**
          * Angle of rotation in degrees
          * @default 90
@@ -9,20 +16,23 @@ export declare namespace Transforms {
          * @maximum Infinity
          * @step 1
          */
-        angle: number;
+        angle = 90;
         /**
          * Axis vector for rotation
          * @default [0, 1, 0]
          */
-        axis: Base.Vector3;
+        axis: Base.Vector3 = [0, 1, 0];
         /**
          * The center from which the axis is pointing
          * @default [0, 0, 0]
          */
-        center: Base.Point3;
+        center: Base.Point3 = [0, 0, 0];
     }
-    class RotationCenterDto {
-        constructor(angle?: number, center?: Base.Point3);
+    export class RotationCenterDto {
+        constructor(angle?: number, center?: Base.Point3) {
+            if (angle !== undefined) { this.angle = angle; }
+            if (center !== undefined) { this.center = center; }
+        }
         /**
          * Angle of rotation in degrees
          * @default 90
@@ -30,15 +40,20 @@ export declare namespace Transforms {
          * @maximum Infinity
          * @step 1
          */
-        angle: number;
+        angle = 90;
         /**
          * The center from which the axis is pointing
          * @default [0, 0, 0]
          */
-        center: Base.Point3;
+        center: Base.Point3 = [0, 0, 0];
     }
-    class RotationCenterYawPitchRollDto {
-        constructor(yaw?: number, pitch?: number, roll?: number, center?: Base.Point3);
+    export class RotationCenterYawPitchRollDto {
+        constructor(yaw?: number, pitch?: number, roll?: number, center?: Base.Point3) {
+            if (yaw !== undefined) { this.yaw = yaw; }
+            if (pitch !== undefined) { this.pitch = pitch; }
+            if (roll !== undefined) { this.roll = roll; }
+            if (center !== undefined) { this.center = center; }
+        }
         /**
          * Yaw angle (Rotation around X) in degrees
          * @default 0
@@ -46,7 +61,7 @@ export declare namespace Transforms {
          * @maximum Infinity
          * @step 1
          */
-        yaw: number;
+        yaw = 0;
         /**
          * Pitch angle (Rotation around Y) in degrees
          * @default 0
@@ -54,7 +69,7 @@ export declare namespace Transforms {
          * @maximum Infinity
          * @step 1
          */
-        pitch: number;
+        pitch = 0;
         /**
          * Roll angle (Rotation around Z) in degrees
          * @default 0
@@ -62,36 +77,43 @@ export declare namespace Transforms {
          * @maximum Infinity
          * @step 1
          */
-        roll: number;
+        roll = 0;
         /**
          * The center from which the rotations are applied
          * @default [0, 0, 0]
          */
-        center: Base.Point3;
+        center: Base.Point3 = [0, 0, 0];
     }
-    class ScaleXYZDto {
-        constructor(scaleXyz?: Base.Vector3);
+    export class ScaleXYZDto {
+        constructor(scaleXyz?: Base.Vector3) {
+            if (scaleXyz !== undefined) { this.scaleXyz = scaleXyz; }
+        }
         /**
          * Scaling factors for each axis [1, 2, 1] means that Y axis will be scaled 200% and both x and z axis will remain on 100%
          * @default [1, 1, 1]
          */
-        scaleXyz: Base.Vector3;
+        scaleXyz: Base.Vector3 = [1, 1, 1];
     }
-    class ScaleCenterXYZDto {
-        constructor(center?: Base.Point3, scaleXyz?: Base.Vector3);
+    export class ScaleCenterXYZDto {
+        constructor(center?: Base.Point3, scaleXyz?: Base.Vector3) {
+            if (center !== undefined) { this.center = center; }
+            if (scaleXyz !== undefined) { this.scaleXyz = scaleXyz; }
+        }
         /**
          * The center from which the scaling is applied
          * @default [0, 0, 0]
          */
-        center: Base.Point3;
+        center: Base.Point3 = [0, 0, 0];
         /**
          * Scaling factors for each axis [1, 2, 1] means that Y axis will be scaled 200% and both x and z axis will remain on 100%
          * @default [1, 1, 1]
          */
-        scaleXyz: Base.Vector3;
+        scaleXyz: Base.Vector3 = [1, 1, 1];
     }
-    class UniformScaleDto {
-        constructor(scale?: number);
+    export class UniformScaleDto {
+        constructor(scale?: number) {
+            if (scale !== undefined) { this.scale = scale; }
+        }
         /**
          * Uniform scale factor for all x, y, z directions. 1 will keep everything on original size, 2 will scale 200%;
          * @default 1
@@ -99,10 +121,13 @@ export declare namespace Transforms {
          * @maximum Infinity
          * @step 0.1
          */
-        scale: number;
+        scale = 1;
     }
-    class UniformScaleFromCenterDto {
-        constructor(scale?: number, center?: Base.Point3);
+    export class UniformScaleFromCenterDto {
+        constructor(scale?: number, center?: Base.Point3) {
+            if (scale !== undefined) { this.scale = scale; }
+            if (center !== undefined) { this.center = center; }
+        }
         /**
          * Scale factor for all x, y, z directions. 1 will keep everything on original size, 2 will scale 200%;
          * @default 1
@@ -110,23 +135,27 @@ export declare namespace Transforms {
          * @maximum Infinity
          * @step 0.1
          */
-        scale: number;
+        scale = 1;
         /**
          * Center position of the scaling
          * @default [0, 0, 0]
          */
-        center: Base.Point3;
+        center: Base.Point3 = [0, 0, 0];
     }
-    class TranslationXYZDto {
-        constructor(translation?: Base.Vector3);
+    export class TranslationXYZDto {
+        constructor(translation?: Base.Vector3) {
+            if (translation !== undefined) { this.translation = translation; }
+        }
         /**
          * Translation vector with [x, y, z] distances
          * @default [0, 0, 0]
          */
-        translation: Base.Vector3;
+        translation: Base.Vector3 = [0, 0, 0];
     }
-    class TranslationsXYZDto {
-        constructor(translations?: Base.Vector3[]);
+    export class TranslationsXYZDto {
+        constructor(translations?: Base.Vector3[]) {
+            if (translations !== undefined) { this.translations = translations; }
+        }
         /**
          * Translation vectors with [x, y, z] distances
          * @default undefined

package/lib/api/inputs/{vector-inputs.d.ts → vector-inputs.ts}

@@ -1,8 +1,14 @@
+/* eslint-disable @typescript-eslint/no-namespace */
 import { Base } from "./base-inputs";
 import { Math } from "./inputs";
-export declare namespace Vector {
-    class TwoVectorsDto {
-        constructor(first?: number[], second?: number[]);
+
+export namespace Vector {
+
+    export class TwoVectorsDto {
+        constructor(first?: number[], second?: number[]) {
+            if (first !== undefined) { this.first = first; }
+            if (second !== undefined) { this.second = second; }
+        }
         /**
          * First vector
          * @default undefined
@@ -14,16 +20,21 @@ export declare namespace Vector {
          */
         second: number[];
     }
-    class VectorBoolDto {
-        constructor(vector?: boolean[]);
+    export class VectorBoolDto {
+        constructor(vector?: boolean[]) {
+            if (vector !== undefined) { this.vector = vector; }
+        }
         /**
          * Vector of booleans
          * @default undefined
          */
         vector: boolean[];
     }
-    class RemoveAllDuplicateVectorsDto {
-        constructor(vectors?: number[][], tolerance?: number);
+    export class RemoveAllDuplicateVectorsDto {
+        constructor(vectors?: number[][], tolerance?: number) {
+            if (vectors !== undefined) { this.vectors = vectors; }
+            if (tolerance !== undefined) { this.tolerance = tolerance; }
+        }
         /**
          * Vectors array
          * @default undefined
@@ -35,10 +46,14 @@ export declare namespace Vector {
          * @minimum 0
          * @maximum Infinity
          */
-        tolerance: number;
+        tolerance = 1e-7;
     }
-    class RemoveConsecutiveDuplicateVectorsDto {
-        constructor(vectors?: number[][], checkFirstAndLast?: boolean, tolerance?: number);
+    export class RemoveConsecutiveDuplicateVectorsDto {
+        constructor(vectors?: number[][], checkFirstAndLast?: boolean, tolerance?: number) {
+            if (vectors !== undefined) { this.vectors = vectors; }
+            if (checkFirstAndLast !== undefined) { this.checkFirstAndLast = checkFirstAndLast; }
+            if (tolerance !== undefined) { this.tolerance = tolerance; }
+        }
         /**
          * Vectors array
          * @default undefined
@@ -48,25 +63,29 @@ export declare namespace Vector {
          * Check first and last vectors
          * @default false
          */
-        checkFirstAndLast: boolean;
+        checkFirstAndLast = false;
         /**
          * Tolerance value
          * @default 1e-7
          * @minimum 0
          * @maximum Infinity
          */
-        tolerance: number;
+        tolerance = 1e-7;
     }
-    class VectorDto {
-        constructor(vector?: number[]);
+    export class VectorDto {
+        constructor(vector?: number[]) {
+            if (vector !== undefined) { this.vector = vector; }
+        }
         /**
          * Vector array of numbers
          * @default undefined
          */
         vector: number[];
     }
-    class RangeMaxDto {
-        constructor(max?: number);
+    export class RangeMaxDto {
+        constructor(max?: number) {
+            if (max !== undefined) { this.max = max; }
+        }
         /**
          * Maximum range boundary
          * @default 10
@@ -76,8 +95,12 @@ export declare namespace Vector {
          */
         max: number;
     }
-    class VectorXYZDto {
-        constructor(x?: number, y?: number, z?: number);
+    export class VectorXYZDto {
+        constructor(x?: number, y?: number, z?: number) {
+            if (x !== undefined) { this.x = x; }
+            if (y !== undefined) { this.y = y; }
+            if (z !== undefined) { this.z = z; }
+        }
         /**
          * X value of vector
          * @default 0
@@ -103,8 +126,11 @@ export declare namespace Vector {
          */
         z: number;
     }
-    class VectorXYDto {
-        constructor(x?: number, y?: number);
+    export class VectorXYDto {
+        constructor(x?: number, y?: number) {
+            if (x !== undefined) { this.x = x; }
+            if (y !== undefined) { this.y = y; }
+        }
         /**
          * X value of vector
          * @default 0
@@ -122,8 +148,12 @@ export declare namespace Vector {
          */
         y: number;
     }
-    class SpanDto {
-        constructor(step?: number, min?: number, max?: number);
+    export class SpanDto {
+        constructor(step?: number, min?: number, max?: number) {
+            if (step !== undefined) { this.step = step; }
+            if (min !== undefined) { this.min = min; }
+            if (max !== undefined) { this.max = max; }
+        }
         /**
          * Step of the span
          * @default 0.1
@@ -131,7 +161,7 @@ export declare namespace Vector {
          * @maximum Infinity
          * @step 0.1
          */
-        step: number;
+        step = 0.1;
         /**
         * Min value of the span
         * @default 0
@@ -139,7 +169,7 @@ export declare namespace Vector {
         * @maximum Infinity
         * @step 1
         */
-        min: number;
+        min = 0;
         /**
         * Max value of the span
         * @default 1
@@ -147,10 +177,15 @@ export declare namespace Vector {
         * @maximum Infinity
         * @step 1
         */
-        max: number;
+        max = 1;
     }
-    class SpanEaseItemsDto {
-        constructor(nrItems?: number, min?: number, max?: number, ease?: Math.easeEnum);
+    export class SpanEaseItemsDto {
+        constructor(nrItems?: number, min?: number, max?: number, ease?: Math.easeEnum) {
+            if (nrItems !== undefined) { this.nrItems = nrItems; }
+            if (min !== undefined) { this.min = min; }
+            if (max !== undefined) { this.max = max; }
+            if (ease !== undefined) { this.ease = ease; }
+        }
         /**
          * Nr of items in the span
          * @default 100
@@ -158,7 +193,7 @@ export declare namespace Vector {
          * @maximum Infinity
          * @step 1
          */
-        nrItems: number;
+        nrItems = 100;
         /**
         * Min value of the span
         * @default 0
@@ -166,7 +201,7 @@ export declare namespace Vector {
         * @maximum Infinity
         * @step 1
         */
-        min: number;
+        min = 0;
         /**
         * Max value of the span
         * @default 1
@@ -174,20 +209,24 @@ export declare namespace Vector {
         * @maximum Infinity
         * @step 1
         */
-        max: number;
+        max = 1;
         /**
         * Ease type
         * @default easeInSine
         */
-        ease: Math.easeEnum;
+        ease: Math.easeEnum = Math.easeEnum.easeInSine;
         /**
          * Indicates wether only intervals should be outputed. This will output step lengths between the values.
          * @default false
          */
-        intervals: boolean;
+        intervals = false;
     }
-    class SpanLinearItemsDto {
-        constructor(nrItems?: number, min?: number, max?: number);
+    export class SpanLinearItemsDto {
+        constructor(nrItems?: number, min?: number, max?: number) {
+            if (nrItems !== undefined) { this.nrItems = nrItems; }
+            if (min !== undefined) { this.min = min; }
+            if (max !== undefined) { this.max = max; }
+        }
         /**
          * Nr of items in the span
          * @default 100
@@ -195,7 +234,7 @@ export declare namespace Vector {
          * @maximum Infinity
          * @step 1
          */
-        nrItems: number;
+        nrItems = 100;
         /**
         * Min value of the span
         * @default 0
@@ -203,7 +242,7 @@ export declare namespace Vector {
         * @maximum Infinity
         * @step 1
         */
-        min: number;
+        min = 0;
         /**
         * Max value of the span
         * @default 1
@@ -211,10 +250,14 @@ export declare namespace Vector {
         * @maximum Infinity
         * @step 1
         */
-        max: number;
+        max = 1;
     }
-    class RayPointDto {
-        constructor(point?: Base.Point3, distance?: number, vector?: number[]);
+    export class RayPointDto {
+        constructor(point?: Base.Point3, distance?: number, vector?: number[]) {
+            if (point !== undefined) { this.point = point; }
+            if (distance !== undefined) { this.distance = distance; }
+            if (vector !== undefined) { this.vector = vector; }
+        }
         /**
          * Origin location of the ray
          * @default undefined
@@ -234,16 +277,22 @@ export declare namespace Vector {
          */
         vector: number[];
     }
-    class VectorsDto {
-        constructor(vectors?: number[][]);
+    export class VectorsDto {
+        constructor(vectors?: number[][]) {
+            if (vectors !== undefined) { this.vectors = vectors; }
+        }
         /**
          * Vectors array
          * @default undefined
          */
         vectors: number[][];
     }
-    class FractionTwoVectorsDto {
-        constructor(fraction?: number, first?: Base.Vector3, second?: Base.Vector3);
+    export class FractionTwoVectorsDto {
+        constructor(fraction?: number, first?: Base.Vector3, second?: Base.Vector3) {
+            if (fraction !== undefined) { this.fraction = fraction; }
+            if (first !== undefined) { this.first = first; }
+            if (second !== undefined) { this.second = second; }
+        }
         /**
          * Fraction number
          * @default 0.5
@@ -251,7 +300,7 @@ export declare namespace Vector {
          * @maximum Infinity
          * @step 0.1
          */
-        fraction: number;
+        fraction = 0.5;
         /**
          * First vector
          * @default undefined
@@ -263,8 +312,11 @@ export declare namespace Vector {
          */
         second: Base.Vector3;
     }
-    class VectorScalarDto {
-        constructor(scalar?: number, vector?: number[]);
+    export class VectorScalarDto {
+        constructor(scalar?: number, vector?: number[]) {
+            if (scalar !== undefined) { this.scalar = scalar; }
+            if (vector !== undefined) { this.vector = vector; }
+        }
         /**
          * Scalar number
          * @default 1
@@ -279,8 +331,12 @@ export declare namespace Vector {
          */
         vector: number[];
     }
-    class TwoVectorsReferenceDto {
-        constructor(reference?: number[], first?: Base.Vector3, second?: Base.Vector3);
+    export class TwoVectorsReferenceDto {
+        constructor(reference?: number[], first?: Base.Vector3, second?: Base.Vector3) {
+            if (reference !== undefined) { this.reference = reference; }
+            if (first !== undefined) { this.first = first; }
+            if (second !== undefined) { this.second = second; }
+        }
         /**
          * Reference vector
          * @default undefined

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

@@ -0,0 +1,86 @@
+import { Color } from "./color";
+import { MathBitByBit } from "./math";
+
+describe("Color unit tests", () => {
+    let color: Color;
+
+    beforeAll(async () => {
+        const math = new MathBitByBit();
+        color = new Color(math);
+    });
+
+    it("should create hex color", () => {
+        const res = color.hexColor({ color: "#ff0000" });
+        expect(res).toEqual("#ff0000");
+    });
+
+    it("should convert hex to rgb", () => {
+        const res = color.hexToRgb({ color: "#ff0000" });
+        expect(res).toEqual({ r: 255, g: 0, b: 0 });
+    });
+
+    it("should convert hex to rgb mapped", () => {
+        const res = color.hexToRgbMapped({ color: "#ff0000", from: 0, to: 1 });
+        expect(res).toEqual({ r: 1, g: 0, b: 0 });
+    });
+
+    it("should get red param", () => {
+        const res = color.getRedParam({ color: "#ff0000", from: 0, to: 1 });
+        expect(res).toEqual(1);
+    });
+
+    it("should get green param", () => {
+        const res = color.getGreenParam({ color: "#00ff00", from: 0, to: 1 });
+        expect(res).toEqual(1);
+    });
+
+    it("should get blue param", () => {
+        const res = color.getBlueParam({ color: "#0000ff", from: 0, to: 1 });
+        expect(res).toEqual(1);
+    });
+
+    it("should convert rgb to hex", () => {
+        const res = color.rgbToHex({ r: 255, g: 150, b: 23, min: 0, max: 255 });
+        expect(res).toEqual("#ff9617");
+    });
+
+    it("should convert rgb to hex", () => {
+        const res = color.rgbToHex({ r: 1, g: 0.3, b: 0.6, min: 0, max: 1 });
+        expect(res).toEqual("#ff4d99");
+    });
+
+    it("should convert rgb obj to hex", () => {
+        const res = color.rgbObjToHex({ rgb: { r: 1, g: 0.3, b: 0.6 }, min: 0, max: 1 });
+        expect(res).toEqual("#ff4d99");
+    });
+
+    it("should get R from rgb obj", () => {
+        const res = color.rgbToRed({ rgb: { r: 1, g: 0.3, b: 0.6 } });
+        expect(res).toEqual(1);
+    });
+
+    it("should get G from rgb obj", () => {
+        const res = color.rgbToGreen({ rgb: { r: 1, g: 0.3, b: 0.6 } });
+        expect(res).toEqual(0.3);
+    });
+
+    it("should get B from rgb obj", () => {
+        const res = color.rgbToBlue({ rgb: { r: 1, g: 0.3, b: 0.6 } });
+        expect(res).toEqual(0.6);
+    });
+
+    it("should invert colors", () => {
+        const res = color.invert({ color: "#ff4d99", blackAndWhite: false });
+        expect(res).toEqual("#00b266");
+    });
+
+    it("should invert colors to black and white", () => {
+        const res = color.invert({ color: "#ff4d99", blackAndWhite: true });
+        expect(res).toEqual("#ffffff");
+    });
+
+    it("should invert colors to black and white", () => {
+        const res = color.invert({ color: "#ffeeaa", blackAndWhite: true });
+        expect(res).toEqual("#000000");
+    });
+});