@bitbybit-dev/base 0.19.0-alpha.0

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

@@ -0,0 +1,99 @@
+import * as Inputs from "../inputs/inputs";
+/**
+ * Contains various logic methods.
+ */
+export declare class Logic {
+    /**
+     * Creates a boolean value - true or false
+     * @param inputs a true or false boolean
+     * @returns boolean
+     * @group create
+     * @shortname boolean
+     * @drawable false
+     */
+    boolean(inputs: Inputs.Logic.BooleanDto): boolean;
+    /**
+     * Creates a random boolean list of predefined length
+     * @param inputs a length and a threshold for randomization of true values
+     * @returns booleans
+     * @group create
+     * @shortname random booleans
+     * @drawable false
+     */
+    randomBooleans(inputs: Inputs.Logic.RandomBooleansDto): boolean[];
+    /**
+     * 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
+     * @returns booleans
+     * @group create
+     * @shortname 2 threshold random gradient
+     * @drawable false
+     */
+    twoThresholdRandomGradient(inputs: Inputs.Logic.TwoThresholdRandomGradientDto): boolean[];
+    /**
+     * 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
+     * @returns booleans
+     * @group create
+     * @shortname threshold boolean list
+     * @drawable false
+     */
+    thresholdBooleanList(inputs: Inputs.Logic.ThresholdBooleanListDto): boolean[];
+    /**
+     * 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
+     * @returns booleans
+     * @group create
+     * @shortname threshold gaps boolean list
+     * @drawable false
+     */
+    thresholdGapsBooleanList(inputs: Inputs.Logic.ThresholdGapsBooleanListDto): boolean[];
+    /**
+     * Apply not operator on the boolean
+     * @param inputs a true or false boolean
+     * @returns boolean
+     * @group edit
+     * @shortname not
+     * @drawable false
+     */
+    not(inputs: Inputs.Logic.BooleanDto): boolean;
+    /**
+     * Apply not operator on a list of booleans
+     * @param inputs a list of true or false booleans
+     * @returns booleans
+     * @group edit
+     * @shortname not list
+     * @drawable false
+     */
+    notList(inputs: Inputs.Logic.BooleanListDto): boolean[];
+    /**
+     * Does comparison between first and second values
+     * @param inputs two values to be compared
+     * @returns Result of the comparison
+     * @group operations
+     * @shortname compare
+     * @drawable false
+     */
+    compare<T>(inputs: Inputs.Logic.ComparisonDto<T>): boolean;
+    /**
+     * Transmits a value if boolean provided is true and undefined if boolean provided is false
+     * @param inputs a value and a boolean value
+     * @returns value or undefined
+     * @group operations
+     * @shortname value gate
+     * @drawable false
+     */
+    valueGate<T>(inputs: Inputs.Logic.ValueGateDto<T>): T | undefined;
+    /**
+     * Returns first defined value out of two
+     * @param inputs two values
+     * @returns value or undefined
+     * @group operations
+     * @shortname first defined value gate
+     * @drawable false
+     */
+    firstDefinedValueGate<T, U>(inputs: Inputs.Logic.TwoValueGateDto<T, U>): T | U | undefined;
+}

package/lib/api/services/logic.js

@@ -0,0 +1,203 @@
+/**
+ * Contains various logic methods.
+ */
+export class Logic {
+    /**
+     * Creates a boolean value - true or false
+     * @param inputs a true or false boolean
+     * @returns boolean
+     * @group create
+     * @shortname boolean
+     * @drawable false
+     */
+    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
+     * @returns booleans
+     * @group create
+     * @shortname random booleans
+     * @drawable false
+     */
+    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,
+     * 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
+     * @returns booleans
+     * @group create
+     * @shortname 2 threshold random gradient
+     * @drawable false
+     */
+    twoThresholdRandomGradient(inputs) {
+        const booleans = [];
+        inputs.numbers.forEach(n => {
+            if (n < inputs.thresholdTotalTrue) {
+                booleans.push(true);
+            }
+            else if (n > inputs.thresholdTotalFalse) {
+                booleans.push(false);
+            }
+            else {
+                const leveledNr = n - inputs.thresholdTotalTrue;
+                const step = (inputs.thresholdTotalFalse - inputs.thresholdTotalTrue) / inputs.nrLevels;
+                const whichCat = Math.ceil(leveledNr / step);
+                const bound = whichCat / inputs.nrLevels;
+                const random = Math.random();
+                if (random > bound) {
+                    booleans.push(true);
+                }
+                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
+     * @returns booleans
+     * @group create
+     * @shortname threshold boolean list
+     * @drawable false
+     */
+    thresholdBooleanList(inputs) {
+        const booleans = [];
+        inputs.numbers.forEach(n => {
+            if (n < inputs.threshold) {
+                booleans.push(true);
+            }
+            else {
+                booleans.push(false);
+            }
+        });
+        if (inputs.inverse) {
+            return booleans.map(b => !b);
+        }
+        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
+     * @returns booleans
+     * @group create
+     * @shortname threshold gaps boolean list
+     * @drawable false
+     */
+    thresholdGapsBooleanList(inputs) {
+        const booleans = [];
+        inputs.numbers.forEach(n => {
+            let foundInThresholds = false;
+            inputs.gapThresholds.forEach(t => {
+                const min = t[0];
+                const max = t[1];
+                if (n >= min && n <= max) {
+                    booleans.push(true);
+                    foundInThresholds = true;
+                }
+            });
+            if (!foundInThresholds) {
+                booleans.push(false);
+            }
+        });
+        if (inputs.inverse) {
+            return booleans.map(b => !b);
+        }
+        return booleans;
+    }
+    /**
+     * Apply not operator on the boolean
+     * @param inputs a true or false boolean
+     * @returns boolean
+     * @group edit
+     * @shortname not
+     * @drawable false
+     */
+    not(inputs) {
+        return !inputs.boolean;
+    }
+    /**
+     * Apply not operator on a list of booleans
+     * @param inputs a list of true or false booleans
+     * @returns booleans
+     * @group edit
+     * @shortname not list
+     * @drawable false
+     */
+    notList(inputs) {
+        return inputs.booleans.map(b => !b);
+    }
+    /**
+     * Does comparison between first and second values
+     * @param inputs two values to be compared
+     * @returns Result of the comparison
+     * @group operations
+     * @shortname compare
+     * @drawable false
+     */
+    compare(inputs) {
+        switch (inputs.operator) {
+            case "==":
+                return inputs.first == inputs.second;
+            case "!=":
+                return inputs.first != inputs.second;
+            case "===":
+                return inputs.first === inputs.second;
+            case "!==":
+                return inputs.first !== inputs.second;
+            case "<":
+                return inputs.first < inputs.second;
+            case "<=":
+                return inputs.first <= inputs.second;
+            case ">":
+                return inputs.first > inputs.second;
+            case ">=":
+                return inputs.first >= inputs.second;
+            default:
+                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
+     * @returns value or undefined
+     * @group operations
+     * @shortname value gate
+     * @drawable false
+     */
+    valueGate(inputs) {
+        return inputs.boolean ? inputs.value : undefined;
+    }
+    /**
+     * Returns first defined value out of two
+     * @param inputs two values
+     * @returns value or undefined
+     * @group operations
+     * @shortname first defined value gate
+     * @drawable false
+     */
+    firstDefinedValueGate(inputs) {
+        let res;
+        if (inputs.value1 !== undefined) {
+            res = inputs.value1;
+        }
+        else if (inputs.value2 !== undefined) {
+            res = inputs.value2;
+        }
+        else {
+            res = undefined;
+        }
+        return res;
+    }
+}

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

@@ -0,0 +1,349 @@
+import * as Inputs from "../inputs/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;
+}