@bitbybit-dev/base 0.19.0-alpha.0

package/lib/api/inputs/logic-inputs.d.ts

@@ -0,0 +1,163 @@
+import { Base } from "./base-inputs";
+export declare namespace Logic {
+    enum BooleanOperatorsEnum {
+        less = "<",
+        lessOrEqual = "<=",
+        greater = ">",
+        greaterOrEqual = ">=",
+        tripleEqual = "===",
+        tripleNotEqual = "!==",
+        equal = "==",
+        notEqual = "!="
+    }
+    class ComparisonDto<T> {
+        constructor(first?: T, second?: T, operator?: BooleanOperatorsEnum);
+        /**
+         * First item
+         * @default undefined
+         */
+        first: T;
+        /**
+         * Second item
+         * @default undefined
+         */
+        second: T;
+        /**
+         * Operator
+         * @default less
+         */
+        operator: BooleanOperatorsEnum;
+    }
+    class BooleanDto {
+        constructor(boolean?: boolean);
+        /**
+         * Boolean value
+         * @default false
+         */
+        boolean: boolean;
+    }
+    class BooleanListDto {
+        constructor(booleans?: boolean);
+        /**
+         * Boolean value
+         * @default undefined
+         */
+        booleans: any;
+    }
+    class ValueGateDto<T> {
+        constructor(value?: T, boolean?: boolean);
+        /**
+         * Value to transmit when gate will be released. When value is not released we will transmit undefined value
+         * @default undefined
+         */
+        value: T;
+        /**
+         * Boolean value to release the gate
+         * @default false
+         */
+        boolean: boolean;
+    }
+    class TwoValueGateDto<T, U> {
+        constructor(value1?: T, value2?: U);
+        /**
+         * First value to check
+         * @default undefined
+         * @optional true
+         */
+        value1?: T;
+        /**
+         * Second value to check
+         * @default undefined
+         * @optional true
+         */
+        value2?: U;
+    }
+    class RandomBooleansDto {
+        constructor(length?: number);
+        /**
+         * Length of the list
+         * @default 10
+         * @minimum 1
+         * @maximum Infinity
+         * @step 1
+         */
+        length: number;
+        /**
+         * Threshold for true value between 0 and 1. The closer the value is to 1 the more true values there will be in the list.
+         * @default 0.5
+         * @minimum 0
+         * @maximum 1
+         * @step 0.1
+         */
+        trueThreshold: number;
+    }
+    class TwoThresholdRandomGradientDto {
+        /**
+         * Numbers to remap to bools
+         * @default undefined
+         */
+        numbers: number[];
+        /**
+         * Threshold for the numeric value until which the output will be true
+         * @default 1
+         * @minimum 0
+         * @maximum Infinity
+         * @step 0.1
+         */
+        thresholdTotalTrue: number;
+        /**
+         * Threshold for the numeric value until which the output will be true
+         * @default 2
+         * @minimum 0
+         * @maximum Infinity
+         * @step 0.1
+         */
+        thresholdTotalFalse: number;
+        /**
+         * Number of levels to go through in between thresholds for gradient
+         * @default 10
+         * @minimum 0
+         * @maximum Infinity
+         * @step 1
+         */
+        nrLevels: number;
+    }
+    class ThresholdBooleanListDto {
+        /**
+         * Numbers to remap to bools based on threshold
+         * @default undefined
+         */
+        numbers: number[];
+        /**
+         * Threshold for the numeric value until which the output will be true.
+         * If number in the list is larger than this threshold it will become false if inverse stays false.
+         * @default 1
+         * @minimum 0
+         * @maximum Infinity
+         * @step 0.1
+         */
+        threshold: number;
+        /**
+         * True values become false and false values become true
+         * @default false
+         */
+        inverse: boolean;
+    }
+    class ThresholdGapsBooleanListDto {
+        /**
+         * Numbers to remap to bools based on threshold
+         * @default undefined
+         */
+        numbers: number[];
+        /**
+         * 2D arrays representing gaps of the thresholds on which numbers should be flipped from false to true if inverse is false.
+         * @default undefined
+         */
+        gapThresholds: Base.Vector2[];
+        /**
+         * True values become false and false values become true
+         * @default false
+         */
+        inverse: boolean;
+    }
+}

package/lib/api/inputs/logic-inputs.js

@@ -0,0 +1,111 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+// tslint:disable-next-line: no-namespace
+export var Logic;
+(function (Logic) {
+    let BooleanOperatorsEnum;
+    (function (BooleanOperatorsEnum) {
+        BooleanOperatorsEnum["less"] = "<";
+        BooleanOperatorsEnum["lessOrEqual"] = "<=";
+        BooleanOperatorsEnum["greater"] = ">";
+        BooleanOperatorsEnum["greaterOrEqual"] = ">=";
+        BooleanOperatorsEnum["tripleEqual"] = "===";
+        BooleanOperatorsEnum["tripleNotEqual"] = "!==";
+        BooleanOperatorsEnum["equal"] = "==";
+        BooleanOperatorsEnum["notEqual"] = "!=";
+    })(BooleanOperatorsEnum = Logic.BooleanOperatorsEnum || (Logic.BooleanOperatorsEnum = {}));
+    class ComparisonDto {
+        constructor(first, second, operator) {
+            if (first !== undefined) {
+                this.first = first;
+            }
+            if (second !== undefined) {
+                this.second = second;
+            }
+            if (operator !== undefined) {
+                this.operator = operator;
+            }
+        }
+    }
+    Logic.ComparisonDto = ComparisonDto;
+    class BooleanDto {
+        constructor(boolean) {
+            /**
+             * Boolean value
+             * @default false
+             */
+            this.boolean = false;
+            if (boolean !== undefined) {
+                this.boolean = boolean;
+            }
+        }
+    }
+    Logic.BooleanDto = BooleanDto;
+    class BooleanListDto {
+        constructor(booleans) {
+            if (booleans !== undefined) {
+                this.booleans = booleans;
+            }
+        }
+    }
+    Logic.BooleanListDto = BooleanListDto;
+    class ValueGateDto {
+        constructor(value, boolean) {
+            /**
+             * Boolean value to release the gate
+             * @default false
+             */
+            this.boolean = false;
+            if (value !== undefined) {
+                this.value = value;
+            }
+            if (boolean !== undefined) {
+                this.boolean = boolean;
+            }
+        }
+    }
+    Logic.ValueGateDto = ValueGateDto;
+    class TwoValueGateDto {
+        constructor(value1, value2) {
+            if (value1 !== undefined) {
+                this.value1 = value1;
+            }
+            if (value2 !== undefined) {
+                this.value2 = value2;
+            }
+        }
+    }
+    Logic.TwoValueGateDto = TwoValueGateDto;
+    class RandomBooleansDto {
+        constructor(length) {
+            /**
+             * Length of the list
+             * @default 10
+             * @minimum 1
+             * @maximum Infinity
+             * @step 1
+             */
+            this.length = 10;
+            /**
+             * Threshold for true value between 0 and 1. The closer the value is to 1 the more true values there will be in the list.
+             * @default 0.5
+             * @minimum 0
+             * @maximum 1
+             * @step 0.1
+             */
+            this.trueThreshold = 0.5;
+            if (length !== undefined) {
+                this.length = length;
+            }
+        }
+    }
+    Logic.RandomBooleansDto = RandomBooleansDto;
+    class TwoThresholdRandomGradientDto {
+    }
+    Logic.TwoThresholdRandomGradientDto = TwoThresholdRandomGradientDto;
+    class ThresholdBooleanListDto {
+    }
+    Logic.ThresholdBooleanListDto = ThresholdBooleanListDto;
+    class ThresholdGapsBooleanListDto {
+    }
+    Logic.ThresholdGapsBooleanListDto = ThresholdGapsBooleanListDto;
+})(Logic || (Logic = {}));

package/lib/api/inputs/math-inputs.d.ts

@@ -0,0 +1,311 @@
+export declare namespace Math {
+    enum mathTwoNrOperatorEnum {
+        add = "add",
+        subtract = "subtract",
+        multiply = "multiply",
+        divide = "divide",
+        power = "power",
+        modulus = "modulus"
+    }
+    enum mathOneNrOperatorEnum {
+        absolute = "absolute",
+        negate = "negate",
+        ln = "ln",
+        log10 = "log10",
+        tenPow = "tenPow",
+        round = "round",
+        floor = "floor",
+        ceil = "ceil",
+        sqrt = "sqrt",
+        sin = "sin",
+        cos = "cos",
+        tan = "tan",
+        asin = "asin",
+        acos = "acos",
+        atan = "atan",
+        log = "log",
+        exp = "exp",
+        radToDeg = "radToDeg",
+        degToRad = "degToRad"
+    }
+    enum easeEnum {
+        easeInSine = "easeInSine",
+        easeOutSine = "easeOutSine",
+        easeInOutSine = "easeInOutSine",
+        easeInQuad = "easeInQuad",
+        easeOutQuad = "easeOutQuad",
+        easeInOutQuad = "easeInOutQuad",
+        easeInCubic = "easeInCubic",
+        easeOutCubic = "easeOutCubic",
+        easeInOutCubic = "easeInOutCubic",
+        easeInQuart = "easeInQuart",
+        easeOutQuart = "easeOutQuart",
+        easeInOutQuart = "easeInOutQuart",
+        easeInQuint = "easeInQuint",
+        easeOutQuint = "easeOutQuint",
+        easeInOutQuint = "easeInOutQuint",
+        easeInExpo = "easeInExpo",
+        easeOutExpo = "easeOutExpo",
+        easeInOutExpo = "easeInOutExpo",
+        easeInCirc = "easeInCirc",
+        easeOutCirc = "easeOutCirc",
+        easeInOutCirc = "easeInOutCirc",
+        easeInElastic = "easeInElastic",
+        easeOutElastic = "easeOutElastic",
+        easeInOutElastic = "easeInOutElastic",
+        easeInBack = "easeInBack",
+        easeOutBack = "easeOutBack",
+        easeInOutBack = "easeInOutBack",
+        easeInBounce = "easeInBounce",
+        easeOutBounce = "easeOutBounce",
+        easeInOutBounce = "easeInOutBounce"
+    }
+    class ModulusDto {
+        constructor(number?: number, modulus?: number);
+        /**
+         * Number
+         * @default 1
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        number: number;
+        /**
+         * Modulus
+         * @default 1
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        modulus: number;
+    }
+    class NumberDto {
+        constructor(number?: number);
+        /**
+         * Number
+         * @default 1
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        number: number;
+    }
+    class EaseDto {
+        constructor(x?: number);
+        /**
+         * X value param between 0-1
+         * @default 0.5
+         * @minimum 0
+         * @maximum 1
+         * @step 0.1
+         */
+        x: number;
+        /**
+         * Minimum value
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        min: number;
+        /**
+         * Maximum value
+         * @default 1
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        max: number;
+        /**
+         * Ease function
+         * @default easeInSine
+         */
+        ease: easeEnum;
+    }
+    class RoundToDecimalsDto {
+        constructor(number?: number, decimalPlaces?: number);
+        /**
+         * Number to round
+         * @default 1.123456
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        number: number;
+        /**
+         * Number of decimal places
+         * @default 2
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 1
+         */
+        decimalPlaces: number;
+    }
+    class ActionOnTwoNumbersDto {
+        constructor(first?: number, second?: number, operation?: mathTwoNrOperatorEnum);
+        /**
+         * First number
+         * @default 1
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        first: number;
+        /**
+         * Second number
+         * @default 1
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        second: number;
+        /**
+         * Point
+         * @default add
+         */
+        operation: mathTwoNrOperatorEnum;
+    }
+    class TwoNumbersDto {
+        constructor(first?: number, second?: number);
+        /**
+         * First number
+         * @default 1
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        first: number;
+        /**
+         * Second number
+         * @default 2
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        second: number;
+    }
+    class ActionOnOneNumberDto {
+        constructor(number?: number, operation?: mathOneNrOperatorEnum);
+        /**
+         * First number
+         * @default 1
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        number: number;
+        /**
+         * Point
+         * @default absolute
+         */
+        operation: mathOneNrOperatorEnum;
+    }
+    class RemapNumberDto {
+        constructor(number?: number, fromLow?: number, fromHigh?: number, toLow?: number, toHigh?: number);
+        /**
+         * Number to remap
+         * @default 0.5
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        number: number;
+        /**
+         * First number range min
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        fromLow: number;
+        /**
+        * Map to range min
+        * @default 1
+        * @minimum -Infinity
+        * @maximum Infinity
+        * @step 0.1
+        */
+        fromHigh: number;
+        /**
+         * First number range max
+         * @default 1
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        toLow: number;
+        /**
+         * Map to range max
+         * @default 2
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        toHigh: number;
+    }
+    class RandomNumberDto {
+        constructor(low?: number, high?: number);
+        /**
+         * Low range of random value
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        low: number;
+        /**
+         * High range of random value
+         * @default 1
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        high: number;
+    }
+    class RandomNumbersDto {
+        constructor(low?: number, high?: number, count?: number);
+        /**
+         * Low range of random value
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        low: number;
+        /**
+         * High range of random value
+         * @default 1
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        high: number;
+        /**
+         * Number of produced random values
+         * @default 10
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 1
+         */
+        count: number;
+    }
+    class ToFixedDto {
+        constructor(number?: number, decimalPlaces?: number);
+        /**
+         * Number to round
+         * @default undefined
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        number: number;
+        /**
+         * Number of decimal places
+         * @default 2
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 1
+         */
+        decimalPlaces: number;
+    }
+}