@bitbybit-dev/base 0.19.6 → 0.19.8

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

@@ -1,8 +1,10 @@
 import * as Inputs from "../inputs";
+
 /**
  * Contains various math methods.
  */
 export class MathBitByBit {
+
     /**
      * Creates a number
      * @param inputs a number to be created
@@ -11,9 +13,10 @@ export class MathBitByBit {
      * @shortname number
      * @drawable false
      */
-    number(inputs) {
+    number(inputs: Inputs.Math.NumberDto): number {
         return inputs.number;
     }
+
     /**
      * Does basic math operations
      * @param inputs two numbers and operator
@@ -22,7 +25,7 @@ export class MathBitByBit {
      * @shortname two numbers
      * @drawable false
      */
-    twoNrOperation(inputs) {
+    twoNrOperation(inputs: Inputs.Math.ActionOnTwoNumbersDto): number {
         let result;
         switch (inputs.operation) {
             case Inputs.Math.mathTwoNrOperatorEnum.add:
@@ -48,6 +51,7 @@ export class MathBitByBit {
         }
         return result;
     }
+
     /**
      * Does modulus operation
      * @param inputs two numbers and operator
@@ -56,9 +60,10 @@ export class MathBitByBit {
      * @shortname modulus
      * @drawable false
      */
-    modulus(inputs) {
+    modulus(inputs: Inputs.Math.ModulusDto): number {
         return this.twoNrOperation({ first: inputs.number, second: inputs.modulus, operation: Inputs.Math.mathTwoNrOperatorEnum.modulus });
     }
+
     /**
      * Does rounding to decimals
      * @param inputs a number and decimal places
@@ -67,9 +72,10 @@ export class MathBitByBit {
      * @shortname round to decimals
      * @drawable false
      */
-    roundToDecimals(inputs) {
+    roundToDecimals(inputs: Inputs.Math.RoundToDecimalsDto): number {
         return Math.round(inputs.number * Math.pow(10, inputs.decimalPlaces)) / Math.pow(10, inputs.decimalPlaces);
     }
+
     /**
      * Does basic math operations on one number
      * @param inputs one number and operator action
@@ -78,7 +84,7 @@ export class MathBitByBit {
      * @shortname one number
      * @drawable false
      */
-    oneNrOperation(inputs) {
+    oneNrOperation(inputs: Inputs.Math.ActionOnOneNumberDto): number {
         let result;
         switch (inputs.operation) {
             case Inputs.Math.mathOneNrOperatorEnum.absolute:
@@ -143,6 +149,7 @@ export class MathBitByBit {
         }
         return result;
     }
+
     /**
     * Remaps a number from one range to another
     * @param inputs one number and operator action
@@ -151,9 +158,10 @@ export class MathBitByBit {
     * @shortname remap
     * @drawable false
     */
-    remap(inputs) {
+    remap(inputs: Inputs.Math.RemapNumberDto): number {
         return (inputs.number - inputs.fromLow) * (inputs.toHigh - inputs.toLow) / (inputs.fromHigh - inputs.fromLow) + inputs.toLow;
     }
+
     /**
     * Creates a random number between 0 and 1
     * @returns A random number between 0 and 1
@@ -161,9 +169,10 @@ export class MathBitByBit {
     * @shortname random 0 - 1
     * @drawable false
     */
-    random() {
+    random(): number {
         return Math.random();
     }
+
     /**
     * Creates a random number between low and high value
     * @param inputs low and high numbers
@@ -172,9 +181,10 @@ export class MathBitByBit {
     * @shortname random number
     * @drawable false
     */
-    randomNumber(inputs) {
+    randomNumber(inputs: Inputs.Math.RandomNumberDto): number {
         return Math.random() * (inputs.high - inputs.low) + inputs.low;
     }
+
     /**
     * Creates random numbers between low and high values
     * @param inputs low and high numbers
@@ -183,13 +193,14 @@ export class MathBitByBit {
     * @shortname random numbers
     * @drawable false
     */
-    randomNumbers(inputs) {
+    randomNumbers(inputs: Inputs.Math.RandomNumbersDto): number[] {
         const result = [];
         for (let i = 0; i < inputs.count; i++) {
             result.push(this.randomNumber(inputs));
         }
         return result;
     }
+
     /**
     * Creates a PI number
     * @returns A number PI
@@ -197,9 +208,10 @@ export class MathBitByBit {
     * @shortname π
     * @drawable false
     */
-    pi() {
+    pi(): number {
         return Math.PI;
     }
+
     /**
      * Rounds the number to decimal places
      * @param inputs a number to be rounded to decimal places
@@ -208,9 +220,10 @@ export class MathBitByBit {
      * @shortname to fixed
      * @drawable false
      */
-    toFixed(inputs) {
+    toFixed(inputs: Inputs.Math.ToFixedDto): string {
         return inputs.number.toFixed(inputs.decimalPlaces);
     }
+
     /**
      * Adds two numbers
      * @param inputs two numbers
@@ -219,9 +232,10 @@ export class MathBitByBit {
      * @shortname add
      * @drawable false
      */
-    add(inputs) {
+    add(inputs: Inputs.Math.TwoNumbersDto): number {
         return inputs.first + inputs.second;
     }
+
     /**
      * Subtracts two numbers
      * @param inputs two numbers
@@ -230,9 +244,10 @@ export class MathBitByBit {
      * @shortname subtract
      * @drawable false
      */
-    subtract(inputs) {
+    subtract(inputs: Inputs.Math.TwoNumbersDto): number {
         return inputs.first - inputs.second;
     }
+
     /**
      * Multiplies two numbers
      * @param inputs two numbers
@@ -241,9 +256,10 @@ export class MathBitByBit {
      * @shortname multiply
      * @drawable false
      */
-    multiply(inputs) {
+    multiply(inputs: Inputs.Math.TwoNumbersDto): number {
         return inputs.first * inputs.second;
     }
+
     /**
      * Divides two numbers
      * @param inputs two numbers
@@ -252,9 +268,10 @@ export class MathBitByBit {
      * @shortname divide
      * @drawable false
      */
-    divide(inputs) {
+    divide(inputs: Inputs.Math.TwoNumbersDto): number {
         return inputs.first / inputs.second;
     }
+
     /**
      * Powers a number
      * @param inputs two numbers
@@ -263,9 +280,10 @@ export class MathBitByBit {
      * @shortname power
      * @drawable false
      */
-    power(inputs) {
+    power(inputs: Inputs.Math.TwoNumbersDto): number {
         return Math.pow(inputs.first, inputs.second);
     }
+
     /**
      * Gets the square root of a number
      * @param inputs a number
@@ -274,9 +292,10 @@ export class MathBitByBit {
      * @shortname sqrt
      * @drawable false
      */
-    sqrt(inputs) {
+    sqrt(inputs: Inputs.Math.NumberDto): number {
         return Math.sqrt(inputs.number);
     }
+
     /**
      * Gets the absolute value of a number
      * @param inputs a number
@@ -285,9 +304,10 @@ export class MathBitByBit {
      * @shortname abs
      * @drawable false
      */
-    abs(inputs) {
+    abs(inputs: Inputs.Math.NumberDto): number {
         return Math.abs(inputs.number);
     }
+
     /**
      * Rounds a number
      * @param inputs a number
@@ -296,9 +316,10 @@ export class MathBitByBit {
      * @shortname round
      * @drawable false
      */
-    round(inputs) {
+    round(inputs: Inputs.Math.NumberDto): number {
         return Math.round(inputs.number);
     }
+
     /**
      * Floors a number
      * @param inputs a number
@@ -307,9 +328,10 @@ export class MathBitByBit {
      * @shortname floor
      * @drawable false
      */
-    floor(inputs) {
+    floor(inputs: Inputs.Math.NumberDto): number {
         return Math.floor(inputs.number);
     }
+
     /**
      * Ceils a number
      * @param inputs a number
@@ -318,9 +340,10 @@ export class MathBitByBit {
      * @shortname ceil
      * @drawable false
      */
-    ceil(inputs) {
+    ceil(inputs: Inputs.Math.NumberDto): number {
         return Math.ceil(inputs.number);
     }
+
     /**
      * Negates a number
      * @param inputs a number
@@ -329,9 +352,10 @@ export class MathBitByBit {
      * @shortname negate
      * @drawable false
      */
-    negate(inputs) {
+    negate(inputs: Inputs.Math.NumberDto): number {
         return -inputs.number;
     }
+
     /**
      * Gets the natural logarithm of a number
      * @param inputs a number
@@ -340,9 +364,10 @@ export class MathBitByBit {
      * @shortname ln
      * @drawable false
      */
-    ln(inputs) {
+    ln(inputs: Inputs.Math.NumberDto): number {
         return Math.log(inputs.number);
     }
+
     /**
      * Gets the base 10 logarithm of a number
      * @param inputs a number
@@ -351,9 +376,10 @@ export class MathBitByBit {
      * @shortname log10
      * @drawable false
      */
-    log10(inputs) {
+    log10(inputs: Inputs.Math.NumberDto): number {
         return Math.log10(inputs.number);
     }
+
     /**
      * Raises 10 to the power of a number
      * @param inputs a number
@@ -362,9 +388,10 @@ export class MathBitByBit {
      * @shortname ten pow
      * @drawable false
      */
-    tenPow(inputs) {
+    tenPow(inputs: Inputs.Math.NumberDto): number {
         return Math.pow(10, inputs.number);
     }
+
     /**
      * Gets the sine of a number
      * @param inputs a number
@@ -373,9 +400,10 @@ export class MathBitByBit {
      * @shortname sin
      * @drawable false
      */
-    sin(inputs) {
+    sin(inputs: Inputs.Math.NumberDto): number {
         return Math.sin(inputs.number);
     }
+
     /**
      * Gets the cosine of a number
      * @param inputs a number
@@ -384,9 +412,10 @@ export class MathBitByBit {
      * @shortname cos
      * @drawable false
      */
-    cos(inputs) {
+    cos(inputs: Inputs.Math.NumberDto): number {
         return Math.cos(inputs.number);
     }
+
     /**
      * Gets the tangent of a number
      * @param inputs a number
@@ -395,9 +424,10 @@ export class MathBitByBit {
      * @shortname tan
      * @drawable false
      */
-    tan(inputs) {
+    tan(inputs: Inputs.Math.NumberDto): number {
         return Math.tan(inputs.number);
     }
+
     /**
      * Gets the arcsine of a number
      * @param inputs a number
@@ -406,9 +436,10 @@ export class MathBitByBit {
      * @shortname asin
      * @drawable false
      */
-    asin(inputs) {
+    asin(inputs: Inputs.Math.NumberDto): number {
         return Math.asin(inputs.number);
     }
+
     /**
      * Gets the arccosine of a number
      * @param inputs a number
@@ -417,9 +448,10 @@ export class MathBitByBit {
      * @shortname acos
      * @drawable false
      */
-    acos(inputs) {
+    acos(inputs: Inputs.Math.NumberDto): number {
         return Math.acos(inputs.number);
     }
+
     /**
      * Gets the arctangent of a number
      * @param inputs a number
@@ -428,9 +460,10 @@ export class MathBitByBit {
      * @shortname atan
      * @drawable false
      */
-    atan(inputs) {
+    atan(inputs: Inputs.Math.NumberDto): number {
         return Math.atan(inputs.number);
     }
+
     /**
      * Gets the natural exponent of a number
      * @param inputs a number
@@ -439,9 +472,10 @@ export class MathBitByBit {
      * @shortname exp
      * @drawable false
      */
-    exp(inputs) {
+    exp(inputs: Inputs.Math.NumberDto): number {
         return Math.exp(inputs.number);
     }
+
     /**
      * Converts degrees to radians
      * @param inputs a number in degrees
@@ -450,9 +484,10 @@ export class MathBitByBit {
      * @shortname deg to rad
      * @drawable false
      */
-    degToRad(inputs) {
+    degToRad(inputs: Inputs.Math.NumberDto): number {
         return inputs.number * Math.PI / 180;
     }
+
     /**
      * Converts radians to degrees
      * @param inputs a number in radians
@@ -461,9 +496,10 @@ export class MathBitByBit {
      * @shortname rad to deg
      * @drawable false
      */
-    radToDeg(inputs) {
+    radToDeg(inputs: Inputs.Math.NumberDto): number {
         return inputs.number * 180 / Math.PI;
     }
+
     /**
      * Eases a number by providing x parameter 0-1 and a range of output values
      * @param inputs a number, min and max values, and ease type
@@ -472,66 +508,85 @@ export class MathBitByBit {
      * @shortname ease
      * @drawable false
      */
-    ease(inputs) {
+    ease(inputs: Inputs.Math.EaseDto) {
         const x = inputs.x;
         const min = inputs.min;
         const max = inputs.max;
+
         const y = this[inputs.ease](x);
         const res = this.remap({ number: y, fromLow: 0, fromHigh: 1, toLow: min, toHigh: max });
         return res;
     }
-    easeInSine(x) {
+
+    private easeInSine(x: number): number {
         return 1 - Math.cos((x * Math.PI) / 2);
     }
-    easeOutSine(x) {
+
+    private easeOutSine(x: number): number {
         return Math.sin((x * Math.PI) / 2);
     }
-    easeInOutSine(x) {
+
+    private easeInOutSine(x: number): number {
         return -(Math.cos(Math.PI * x) - 1) / 2;
     }
-    easeInQuad(x) {
+
+    private easeInQuad(x: number): number {
         return x * x;
     }
-    easeOutQuad(x) {
+
+    private easeOutQuad(x: number): number {
         return 1 - (1 - x) * (1 - x);
     }
-    easeInOutQuad(x) {
+
+    private easeInOutQuad(x: number): number {
         return x < 0.5 ? 2 * x * x : 1 - Math.pow(-2 * x + 2, 2) / 2;
     }
-    easeInCubic(x) {
+
+    private easeInCubic(x: number): number {
         return x * x * x;
     }
-    easeOutCubic(x) {
+
+    private easeOutCubic(x: number): number {
         return 1 - Math.pow(1 - x, 3);
     }
-    easeInOutCubic(x) {
+
+    private easeInOutCubic(x: number): number {
         return x < 0.5 ? 4 * x * x * x : 1 - Math.pow(-2 * x + 2, 3) / 2;
     }
-    easeInQuart(x) {
+
+    private easeInQuart(x: number): number {
         return x * x * x * x;
     }
-    easeOutQuart(x) {
+
+    private easeOutQuart(x: number): number {
         return 1 - Math.pow(1 - x, 4);
     }
-    easeInOutQuart(x) {
+
+    private easeInOutQuart(x: number): number {
         return x < 0.5 ? 8 * x * x * x * x : 1 - Math.pow(-2 * x + 2, 4) / 2;
     }
-    easeInQuint(x) {
+
+    private easeInQuint(x: number): number {
         return x * x * x * x * x;
     }
-    easeOutQuint(x) {
+
+    private easeOutQuint(x: number): number {
         return 1 - Math.pow(1 - x, 5);
     }
-    easeInOutQuint(x) {
+
+    private easeInOutQuint(x: number): number {
         return x < 0.5 ? 16 * x * x * x * x * x : 1 - Math.pow(-2 * x + 2, 5) / 2;
     }
-    easeInExpo(x) {
+
+    private easeInExpo(x: number): number {
         return x === 0 ? 0 : Math.pow(2, 10 * x - 10);
     }
-    easeOutExpo(x) {
+
+    private easeOutExpo(x: number): number {
         return x === 1 ? 1 : 1 - Math.pow(2, -10 * x);
     }
-    easeInOutExpo(x) {
+
+    private easeInOutExpo(x: number): number {
         return x === 0
             ? 0
             : x === 1
@@ -540,35 +595,42 @@ export class MathBitByBit {
                     ? Math.pow(2, 20 * x - 10) / 2
                     : (2 - Math.pow(2, -20 * x + 10)) / 2;
     }
-    easeInCirc(x) {
+
+    private easeInCirc(x: number): number {
         return 1 - Math.sqrt(1 - x * x);
     }
-    easeOutCirc(x) {
+
+    private easeOutCirc(x: number): number {
         return Math.sqrt(1 - Math.pow(x - 1, 2));
     }
-    easeInOutCirc(x) {
+
+    private easeInOutCirc(x: number): number {
         return x < 0.5
             ? (1 - Math.sqrt(1 - Math.pow(2 * x, 2))) / 2
             : (Math.sqrt(1 - Math.pow(-2 * x + 2, 2)) + 1) / 2;
     }
-    easeInBack(x) {
+
+    private easeInBack(x: number): number {
         const c1 = 1.70158;
         const c3 = c1 + 1;
         return c3 * x * x * x - c1 * x * x;
     }
-    easeOutBack(x) {
+
+    private easeOutBack(x: number): number {
         const c1 = 1.70158;
         const c3 = c1 + 1;
         return 1 + c3 * Math.pow(x - 1, 3) + c1 * Math.pow(x - 1, 2);
     }
-    easeInOutBack(x) {
+
+    private easeInOutBack(x: number): number {
         const c1 = 1.70158;
         const c2 = c1 * 1.525;
         return x < 0.5
             ? (Math.pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2)) / 2
             : (Math.pow(2 * x - 2, 2) * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2;
     }
-    easeInElastic(x) {
+
+    private easeInElastic(x: number): number {
         const c4 = (2 * Math.PI) / 3;
         return x === 0
             ? 0
@@ -576,7 +638,8 @@ export class MathBitByBit {
                 ? 1
                 : -Math.pow(2, 10 * x - 10) * Math.sin((x * 10 - 10.75) * c4);
     }
-    easeOutElastic(x) {
+
+    private easeOutElastic(x: number): number {
         const c4 = (2 * Math.PI) / 3;
         return x === 0
             ? 0
@@ -584,7 +647,8 @@ export class MathBitByBit {
                 ? 1
                 : Math.pow(2, -10 * x) * Math.sin((x * 10 - 0.75) * c4) + 1;
     }
-    easeInOutElastic(x) {
+
+    private easeInOutElastic(x: number): number {
         const c5 = (2 * Math.PI) / 4.5;
         return x === 0
             ? 0
@@ -594,28 +658,29 @@ export class MathBitByBit {
                     ? -(Math.pow(2, 20 * x - 10) * Math.sin((20 * x - 11.125) * c5)) / 2
                     : (Math.pow(2, -20 * x + 10) * Math.sin((20 * x - 11.125) * c5)) / 2 + 1;
     }
-    easeInBounce(x) {
+
+    private easeInBounce(x: number): number {
         return 1 - this.easeOutBounce(1 - x);
     }
-    easeOutBounce(x) {
+
+    private easeOutBounce(x: number): number {
         const n1 = 7.5625;
         const d1 = 2.75;
         if (x < 1 / d1) {
             return n1 * x * x;
-        }
-        else if (x < 2 / d1) {
+        } else if (x < 2 / d1) {
             return n1 * (x -= 1.5 / d1) * x + 0.75;
-        }
-        else if (x < 2.5 / d1) {
+        } else if (x < 2.5 / d1) {
             return n1 * (x -= 2.25 / d1) * x + 0.9375;
-        }
-        else {
+        } else {
             return n1 * (x -= 2.625 / d1) * x + 0.984375;
         }
     }
-    easeInOutBounce(x) {
+
+    private easeInOutBounce(x: number): number {
         return x < 0.5
             ? (1 - this.easeOutBounce(1 - 2 * x)) / 2
             : (1 + this.easeOutBounce(2 * x - 1)) / 2;
     }
+
 }