@bitbybit-dev/base 0.19.8 → 0.19.9

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

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