@bitbybit-dev/base 0.19.8 → 0.20.0

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

@@ -1,10 +1,7 @@
-import * as Inputs from "../inputs";
-
 /**
  * Contains various logic methods.
  */
 export class Logic {
-
     /**
      * Creates a boolean value - true or false
      * @param inputs a true or false boolean
@@ -13,10 +10,9 @@ export class Logic {
      * @shortname boolean
      * @drawable false
      */
-    boolean(inputs: Inputs.Logic.BooleanDto): boolean {
+    boolean(inputs) {
         return inputs.boolean;
     }
-
     /**
      * Creates a random boolean list of predefined length
      * @param inputs a length and a threshold for randomization of true values
@@ -25,17 +21,16 @@ export class Logic {
      * @shortname random booleans
      * @drawable false
      */
-    randomBooleans(inputs: Inputs.Logic.RandomBooleansDto): boolean[] {
+    randomBooleans(inputs) {
         const booleans = [];
         for (let i = 0; i < inputs.length; i++) {
             booleans.push(Math.random() < inputs.trueThreshold);
         }
         return booleans;
     }
-
     /**
-     * Creates a random boolean list of true and false values based on a list of numbers. 
-     * All values between true threshold will be true, all values above false threshold will be false, 
+     * Creates a random boolean list of true and false values based on a list of numbers.
+     * All values between true threshold will be true, all values above false threshold will be false,
      * and the rest will be distributed between true and false based on the number of levels in a gradient pattern.
      * That means that the closer the number gets to the false threshold the bigger the chance will be to get random false value.
      * @param inputs a length and a threshold for randomization of true values
@@ -44,14 +39,16 @@ export class Logic {
      * @shortname 2 threshold random gradient
      * @drawable false
      */
-    twoThresholdRandomGradient(inputs: Inputs.Logic.TwoThresholdRandomGradientDto): boolean[] {
+    twoThresholdRandomGradient(inputs) {
         const booleans = [];
         inputs.numbers.forEach(n => {
             if (n < inputs.thresholdTotalTrue) {
                 booleans.push(true);
-            } else if (n > inputs.thresholdTotalFalse) {
+            }
+            else if (n > inputs.thresholdTotalFalse) {
                 booleans.push(false);
-            } else {
+            }
+            else {
                 const leveledNr = n - inputs.thresholdTotalTrue;
                 const step = (inputs.thresholdTotalFalse - inputs.thresholdTotalTrue) / inputs.nrLevels;
                 const whichCat = Math.ceil(leveledNr / step);
@@ -59,14 +56,14 @@ export class Logic {
                 const random = Math.random();
                 if (random > bound) {
                     booleans.push(true);
-                } else {
+                }
+                else {
                     booleans.push(false);
                 }
             }
         });
         return booleans;
     }
-
     /**
      * Creates a boolean list based on a list of numbers and a threshold.
      * @param inputs a length and a threshold for randomization of true values
@@ -75,12 +72,13 @@ export class Logic {
      * @shortname threshold boolean list
      * @drawable false
      */
-    thresholdBooleanList(inputs: Inputs.Logic.ThresholdBooleanListDto): boolean[] {
+    thresholdBooleanList(inputs) {
         const booleans = [];
         inputs.numbers.forEach(n => {
             if (n < inputs.threshold) {
                 booleans.push(true);
-            } else {
+            }
+            else {
                 booleans.push(false);
             }
         });
@@ -89,7 +87,6 @@ export class Logic {
         }
         return booleans;
     }
-
     /**
      * Creates a boolean list based on a list of numbers and a gap thresholds. Gap thresholds are pairs of numbers that define a range of numbers that will be true.
      * @param inputs a length and a threshold for randomization of true values
@@ -98,9 +95,8 @@ export class Logic {
      * @shortname threshold gaps boolean list
      * @drawable false
      */
-    thresholdGapsBooleanList(inputs: Inputs.Logic.ThresholdGapsBooleanListDto): boolean[] {
+    thresholdGapsBooleanList(inputs) {
         const booleans = [];
-
         inputs.numbers.forEach(n => {
             let foundInThresholds = false;
             inputs.gapThresholds.forEach(t => {
@@ -120,7 +116,6 @@ export class Logic {
         }
         return booleans;
     }
-
     /**
      * Apply not operator on the boolean
      * @param inputs a true or false boolean
@@ -129,10 +124,9 @@ export class Logic {
      * @shortname not
      * @drawable false
      */
-    not(inputs: Inputs.Logic.BooleanDto): boolean {
+    not(inputs) {
         return !inputs.boolean;
     }
-
     /**
      * Apply not operator on a list of booleans
      * @param inputs a list of true or false booleans
@@ -141,10 +135,9 @@ export class Logic {
      * @shortname not list
      * @drawable false
      */
-    notList(inputs: Inputs.Logic.BooleanListDto): boolean[] {
+    notList(inputs) {
         return inputs.booleans.map(b => !b);
     }
-
     /**
      * Does comparison between first and second values
      * @param inputs two values to be compared
@@ -153,7 +146,7 @@ export class Logic {
      * @shortname compare
      * @drawable false
      */
-    compare<T>(inputs: Inputs.Logic.ComparisonDto<T>): boolean {
+    compare(inputs) {
         switch (inputs.operator) {
             case "==":
                 return inputs.first == inputs.second;
@@ -175,7 +168,6 @@ export class Logic {
                 return false;
         }
     }
-
     /**
      * Transmits a value if boolean provided is true and undefined if boolean provided is false
      * @param inputs a value and a boolean value
@@ -184,10 +176,9 @@ export class Logic {
      * @shortname value gate
      * @drawable false
      */
-    valueGate<T>(inputs: Inputs.Logic.ValueGateDto<T>): T | undefined {
+    valueGate(inputs) {
         return inputs.boolean ? inputs.value : undefined;
     }
-
     /**
      * Returns first defined value out of two
      * @param inputs two values
@@ -196,16 +187,17 @@ export class Logic {
      * @shortname first defined value gate
      * @drawable false
      */
-    firstDefinedValueGate<T, U>(inputs: Inputs.Logic.TwoValueGateDto<T, U>): T | U | undefined {
+    firstDefinedValueGate(inputs) {
         let res;
         if (inputs.value1 !== undefined) {
             res = inputs.value1;
-        } else if (inputs.value2 !== undefined) {
+        }
+        else if (inputs.value2 !== undefined) {
             res = inputs.value2;
-        } else {
+        }
+        else {
             res = undefined;
         }
         return res;
     }
-
 }

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

@@ -0,0 +1,349 @@
+import * as Inputs from "../inputs";
+/**
+ * Contains various math methods.
+ */
+export declare class MathBitByBit {
+    /**
+     * Creates a number
+     * @param inputs a number to be created
+     * @returns number
+     * @group create
+     * @shortname number
+     * @drawable false
+     */
+    number(inputs: Inputs.Math.NumberDto): number;
+    /**
+     * Does basic math operations
+     * @param inputs two numbers and operator
+     * @returns Result of math operation action
+     * @group operations
+     * @shortname two numbers
+     * @drawable false
+     */
+    twoNrOperation(inputs: Inputs.Math.ActionOnTwoNumbersDto): number;
+    /**
+     * Does modulus operation
+     * @param inputs two numbers and operator
+     * @returns Result of modulus operation
+     * @group operations
+     * @shortname modulus
+     * @drawable false
+     */
+    modulus(inputs: Inputs.Math.ModulusDto): number;
+    /**
+     * Does rounding to decimals
+     * @param inputs a number and decimal places
+     * @returns Result of rounding
+     * @group operations
+     * @shortname round to decimals
+     * @drawable false
+     */
+    roundToDecimals(inputs: Inputs.Math.RoundToDecimalsDto): number;
+    /**
+     * Does basic math operations on one number
+     * @param inputs one number and operator action
+     * @returns Result of math operation
+     * @group operations
+     * @shortname one number
+     * @drawable false
+     */
+    oneNrOperation(inputs: Inputs.Math.ActionOnOneNumberDto): number;
+    /**
+    * Remaps a number from one range to another
+    * @param inputs one number and operator action
+    * @returns Result of mapping
+    * @group operations
+    * @shortname remap
+    * @drawable false
+    */
+    remap(inputs: Inputs.Math.RemapNumberDto): number;
+    /**
+    * Creates a random number between 0 and 1
+    * @returns A random number between 0 and 1
+    * @group generate
+    * @shortname random 0 - 1
+    * @drawable false
+    */
+    random(): number;
+    /**
+    * Creates a random number between low and high value
+    * @param inputs low and high numbers
+    * @returns A random number
+    * @group generate
+    * @shortname random number
+    * @drawable false
+    */
+    randomNumber(inputs: Inputs.Math.RandomNumberDto): number;
+    /**
+    * Creates random numbers between low and high values
+    * @param inputs low and high numbers
+    * @returns A list of random numbers
+    * @group generate
+    * @shortname random numbers
+    * @drawable false
+    */
+    randomNumbers(inputs: Inputs.Math.RandomNumbersDto): number[];
+    /**
+    * Creates a PI number
+    * @returns A number PI
+    * @group generate
+    * @shortname π
+    * @drawable false
+    */
+    pi(): number;
+    /**
+     * Rounds the number to decimal places
+     * @param inputs a number to be rounded to decimal places
+     * @returns number
+     * @group operations
+     * @shortname to fixed
+     * @drawable false
+     */
+    toFixed(inputs: Inputs.Math.ToFixedDto): string;
+    /**
+     * Adds two numbers
+     * @param inputs two numbers
+     * @returns number
+     * @group basics
+     * @shortname add
+     * @drawable false
+     */
+    add(inputs: Inputs.Math.TwoNumbersDto): number;
+    /**
+     * Subtracts two numbers
+     * @param inputs two numbers
+     * @returns number
+     * @group basics
+     * @shortname subtract
+     * @drawable false
+     */
+    subtract(inputs: Inputs.Math.TwoNumbersDto): number;
+    /**
+     * Multiplies two numbers
+     * @param inputs two numbers
+     * @returns number
+     * @group basics
+     * @shortname multiply
+     * @drawable false
+     */
+    multiply(inputs: Inputs.Math.TwoNumbersDto): number;
+    /**
+     * Divides two numbers
+     * @param inputs two numbers
+     * @returns number
+     * @group basics
+     * @shortname divide
+     * @drawable false
+     */
+    divide(inputs: Inputs.Math.TwoNumbersDto): number;
+    /**
+     * Powers a number
+     * @param inputs two numbers
+     * @returns number
+     * @group basics
+     * @shortname power
+     * @drawable false
+     */
+    power(inputs: Inputs.Math.TwoNumbersDto): number;
+    /**
+     * Gets the square root of a number
+     * @param inputs a number
+     * @returns number
+     * @group basics
+     * @shortname sqrt
+     * @drawable false
+     */
+    sqrt(inputs: Inputs.Math.NumberDto): number;
+    /**
+     * Gets the absolute value of a number
+     * @param inputs a number
+     * @returns number
+     * @group basics
+     * @shortname abs
+     * @drawable false
+     */
+    abs(inputs: Inputs.Math.NumberDto): number;
+    /**
+     * Rounds a number
+     * @param inputs a number
+     * @returns number
+     * @group basics
+     * @shortname round
+     * @drawable false
+     */
+    round(inputs: Inputs.Math.NumberDto): number;
+    /**
+     * Floors a number
+     * @param inputs a number
+     * @returns number
+     * @group basics
+     * @shortname floor
+     * @drawable false
+     */
+    floor(inputs: Inputs.Math.NumberDto): number;
+    /**
+     * Ceils a number
+     * @param inputs a number
+     * @returns number
+     * @group basics
+     * @shortname ceil
+     * @drawable false
+     */
+    ceil(inputs: Inputs.Math.NumberDto): number;
+    /**
+     * Negates a number
+     * @param inputs a number
+     * @returns number
+     * @group basics
+     * @shortname negate
+     * @drawable false
+     */
+    negate(inputs: Inputs.Math.NumberDto): number;
+    /**
+     * Gets the natural logarithm of a number
+     * @param inputs a number
+     * @returns number
+     * @group basics
+     * @shortname ln
+     * @drawable false
+     */
+    ln(inputs: Inputs.Math.NumberDto): number;
+    /**
+     * Gets the base 10 logarithm of a number
+     * @param inputs a number
+     * @returns number
+     * @group basics
+     * @shortname log10
+     * @drawable false
+     */
+    log10(inputs: Inputs.Math.NumberDto): number;
+    /**
+     * Raises 10 to the power of a number
+     * @param inputs a number
+     * @returns number
+     * @group basics
+     * @shortname ten pow
+     * @drawable false
+     */
+    tenPow(inputs: Inputs.Math.NumberDto): number;
+    /**
+     * Gets the sine of a number
+     * @param inputs a number
+     * @returns number
+     * @group basics
+     * @shortname sin
+     * @drawable false
+     */
+    sin(inputs: Inputs.Math.NumberDto): number;
+    /**
+     * Gets the cosine of a number
+     * @param inputs a number
+     * @returns number
+     * @group basics
+     * @shortname cos
+     * @drawable false
+     */
+    cos(inputs: Inputs.Math.NumberDto): number;
+    /**
+     * Gets the tangent of a number
+     * @param inputs a number
+     * @returns number
+     * @group basics
+     * @shortname tan
+     * @drawable false
+     */
+    tan(inputs: Inputs.Math.NumberDto): number;
+    /**
+     * Gets the arcsine of a number
+     * @param inputs a number
+     * @returns number
+     * @group basics
+     * @shortname asin
+     * @drawable false
+     */
+    asin(inputs: Inputs.Math.NumberDto): number;
+    /**
+     * Gets the arccosine of a number
+     * @param inputs a number
+     * @returns number
+     * @group basics
+     * @shortname acos
+     * @drawable false
+     */
+    acos(inputs: Inputs.Math.NumberDto): number;
+    /**
+     * Gets the arctangent of a number
+     * @param inputs a number
+     * @returns number
+     * @group basics
+     * @shortname atan
+     * @drawable false
+     */
+    atan(inputs: Inputs.Math.NumberDto): number;
+    /**
+     * Gets the natural exponent of a number
+     * @param inputs a number
+     * @returns number
+     * @group basics
+     * @shortname exp
+     * @drawable false
+     */
+    exp(inputs: Inputs.Math.NumberDto): number;
+    /**
+     * Converts degrees to radians
+     * @param inputs a number in degrees
+     * @returns number
+     * @group basics
+     * @shortname deg to rad
+     * @drawable false
+     */
+    degToRad(inputs: Inputs.Math.NumberDto): number;
+    /**
+     * Converts radians to degrees
+     * @param inputs a number in radians
+     * @returns number
+     * @group basics
+     * @shortname rad to deg
+     * @drawable false
+     */
+    radToDeg(inputs: Inputs.Math.NumberDto): number;
+    /**
+     * 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
+     * @returns number
+     * @group operations
+     * @shortname ease
+     * @drawable false
+     */
+    ease(inputs: Inputs.Math.EaseDto): number;
+    private easeInSine;
+    private easeOutSine;
+    private easeInOutSine;
+    private easeInQuad;
+    private easeOutQuad;
+    private easeInOutQuad;
+    private easeInCubic;
+    private easeOutCubic;
+    private easeInOutCubic;
+    private easeInQuart;
+    private easeOutQuart;
+    private easeInOutQuart;
+    private easeInQuint;
+    private easeOutQuint;
+    private easeInOutQuint;
+    private easeInExpo;
+    private easeOutExpo;
+    private easeInOutExpo;
+    private easeInCirc;
+    private easeOutCirc;
+    private easeInOutCirc;
+    private easeInBack;
+    private easeOutBack;
+    private easeInOutBack;
+    private easeInElastic;
+    private easeOutElastic;
+    private easeInOutElastic;
+    private easeInBounce;
+    private easeOutBounce;
+    private easeInOutBounce;
+}