@bitbybit-dev/base 0.19.7 → 0.19.8

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

@@ -0,0 +1,187 @@
+import { Logic } from "./logic";
+import * as Inputs from "../inputs";
+
+describe("Logic unit tests", () => {
+    let logic: Logic;
+    beforeAll(() => {
+        logic = new Logic();
+    });
+
+    it("should create boolean true", () => {
+        const res = logic.boolean({ boolean: true });
+        expect(res).toBe(true);
+    });
+
+    it("should create boolean false", () => {
+        const res = logic.boolean({ boolean: false });
+        expect(res).toBe(false);
+    });
+
+    it("should create reandom list of boolean values", () => {
+        const res = logic.randomBooleans({ length: 10, trueThreshold: 0.5 });
+        expect(res.length).toBe(10);
+    });
+
+    it("should create reandom list of boolean values with true threshold on 1", () => {
+        const res = logic.randomBooleans({ length: 10, trueThreshold: 1 });
+        expect(res).toEqual([true, true, true, true, true, true, true, true, true, true]);
+    });
+
+    it("should create reandom list of boolean values with true threshold on 0", () => {
+        const res = logic.randomBooleans({ length: 10, trueThreshold: 0 });
+        expect(res).toEqual([false, false, false, false, false, false, false, false, false, false]);
+    });
+
+    it("should create threshold boolean list", () => {
+        const res = logic.thresholdBooleanList({ numbers: [0.1, 0.2, 0.3], threshold: 0.2, inverse: false });
+        expect(res).toEqual([true, false, false]);
+    });
+
+    it("should create inverted threshold boolean list", () => {
+        const res = logic.thresholdBooleanList({ numbers: [0.1, 0.2, 0.3], threshold: 0.2, inverse: true });
+        expect(res).toEqual([false, true, true]);
+    });
+
+    it("should create two threshold random gradient", () => {
+        const res = logic.twoThresholdRandomGradient({ numbers: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23], thresholdTotalTrue: 5, thresholdTotalFalse: 21, nrLevels: 10 });
+        expect(res.length).toEqual(23);
+        expect(res.filter(r => r === true).length).toBeGreaterThan(5);
+        expect(res.filter(r => r === false).length).toBeGreaterThan(3);
+    });
+
+    it("should create boolean list based on gap thresholds", () => {
+        const res = logic.thresholdGapsBooleanList({ numbers: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], gapThresholds: [[2, 4], [6, 8]], inverse: false });
+        expect(res).toEqual([
+            false, true, true,
+            true, false, true,
+            true, true, false,
+            false
+        ]);
+    });
+
+    it("should create inverted boolean list based on gap thresholds", () => {
+        const res = logic.thresholdGapsBooleanList({ numbers: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], gapThresholds: [[2, 4], [6, 8]], inverse: true });
+        expect(res).toEqual([
+            true, false, false,
+            false, true, false,
+            false, false, true,
+            true
+        ]);
+    });
+
+    it("should invert true value with not", () => {
+        const res = logic.not({ boolean: true });
+        expect(res).toEqual(false);
+    });
+
+    it("should invert false value with not", () => {
+        const res = logic.not({ boolean: false });
+        expect(res).toEqual(true);
+    });
+
+    it("should invert a boolean list", () => {
+        const res = logic.notList({ booleans: [false, false, true, false, true] });
+        expect(res).toEqual([true, true, false, true, false]);
+    });
+
+    it("should compare two unequal values", () => {
+        const res = logic.compare({ first: false, second: true, operator: Inputs.Logic.BooleanOperatorsEnum.equal });
+        expect(res).toBe(false);
+    });
+
+    it("should compare two unequal values as equal without strict mode", () => {
+        const res = logic.compare({ first: "1", second: 1 as any, operator: Inputs.Logic.BooleanOperatorsEnum.equal });
+        expect(res).toBe(true);
+    });
+
+    it("should compare two unequal values as not equal without strict mode", () => {
+        const res = logic.compare({ first: "1", second: 1 as any, operator: Inputs.Logic.BooleanOperatorsEnum.notEqual });
+        expect(res).toBe(false);
+    });
+
+    it("should compare two unequal values as equal with strict mode", () => {
+        const res = logic.compare({ first: "1", second: 1 as any, operator: Inputs.Logic.BooleanOperatorsEnum.tripleEqual });
+        expect(res).toBe(false);
+    });
+
+    it("should compare two unequal values as not equal with strict mode", () => {
+        const res = logic.compare({ first: "1", second: 1 as any, operator: Inputs.Logic.BooleanOperatorsEnum.tripleNotEqual });
+        expect(res).toBe(true);
+    });
+
+    it("should compare two unequal values", () => {
+        const res = logic.compare({ first: false, second: true, operator: Inputs.Logic.BooleanOperatorsEnum.notEqual });
+        expect(res).toBe(true);
+    });
+
+    it("should compare two equal values", () => {
+        const res = logic.compare({ first: false, second: false, operator: Inputs.Logic.BooleanOperatorsEnum.equal });
+        expect(res).toBe(true);
+    });
+
+    it("should compare two equal values", () => {
+        const res = logic.compare({ first: false, second: false, operator: Inputs.Logic.BooleanOperatorsEnum.notEqual });
+        expect(res).toBe(false);
+    });
+
+    it("should check if 4 is less than 5", () => {
+        const res = logic.compare({ first: 4, second: 5, operator: Inputs.Logic.BooleanOperatorsEnum.less });
+        expect(res).toBe(true);
+    });
+
+    it("should check if 4 is greater than 5", () => {
+        const res = logic.compare({ first: 4, second: 5, operator: Inputs.Logic.BooleanOperatorsEnum.greater });
+        expect(res).toBe(false);
+    });
+
+    it("should check if 4 is less or equal to 5", () => {
+        const res = logic.compare({ first: 5, second: 5, operator: Inputs.Logic.BooleanOperatorsEnum.lessOrEqual });
+        expect(res).toBe(true);
+    });
+
+    it("should check if 5 is less or equal to 5", () => {
+        const res = logic.compare({ first: 5, second: 5, operator: Inputs.Logic.BooleanOperatorsEnum.lessOrEqual });
+        expect(res).toBe(true);
+    });
+
+    it("should check if 5 is greater or equal to 5", () => {
+        const res = logic.compare({ first: 5, second: 5, operator: Inputs.Logic.BooleanOperatorsEnum.greaterOrEqual });
+        expect(res).toBe(true);
+    });
+
+    it("should check if 6 is greater or equal to 5", () => {
+        const res = logic.compare({ first: 5, second: 5, operator: Inputs.Logic.BooleanOperatorsEnum.greaterOrEqual });
+        expect(res).toBe(true);
+    });
+
+    it("should return false if unknown operator is provided", () => {
+        const res = logic.compare({ first: 5, second: 5, operator: "whatever" as any });
+        expect(res).toBe(false);
+    });
+
+    it("should return value through the gate if boolean is true", () => {
+        const res = logic.valueGate({ value: { d: "a" }, boolean: true });
+        expect(res).toEqual({ d: "a" });
+    });
+
+    it("should not return value through the gate if boolean is false", () => {
+        const res = logic.valueGate({ value: { d: "a" }, boolean: false });
+        expect(res).toEqual(undefined);
+    });
+
+    it("should return first defined value", () => {
+        const res = logic.firstDefinedValueGate({ value1: { d: "a" }, value2: { c: "x" } });
+        expect(res).toEqual({ d: "a" });
+    });
+
+    it("should return first defined value", () => {
+        const res = logic.firstDefinedValueGate({ value1: undefined, value2: { c: "x" } });
+        expect(res).toEqual({ c: "x" });
+    });
+
+    it("should not return defined value if no values are defined", () => {
+        const res = logic.firstDefinedValueGate({ value1: undefined, value2: undefined });
+        expect(res).toEqual(undefined);
+    });
+});
+

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

@@ -1,7 +1,10 @@
+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
@@ -10,9 +13,10 @@ export class Logic {
      * @shortname boolean
      * @drawable false
      */
-    boolean(inputs) {
+    boolean(inputs: Inputs.Logic.BooleanDto): boolean {
         return inputs.boolean;
     }
+
     /**
      * Creates a random boolean list of predefined length
      * @param inputs a length and a threshold for randomization of true values
@@ -21,16 +25,17 @@ export class Logic {
      * @shortname random booleans
      * @drawable false
      */
-    randomBooleans(inputs) {
+    randomBooleans(inputs: Inputs.Logic.RandomBooleansDto): boolean[] {
         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
@@ -39,16 +44,14 @@ export class Logic {
      * @shortname 2 threshold random gradient
      * @drawable false
      */
-    twoThresholdRandomGradient(inputs) {
+    twoThresholdRandomGradient(inputs: Inputs.Logic.TwoThresholdRandomGradientDto): boolean[] {
         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);
@@ -56,14 +59,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
@@ -72,13 +75,12 @@ export class Logic {
      * @shortname threshold boolean list
      * @drawable false
      */
-    thresholdBooleanList(inputs) {
+    thresholdBooleanList(inputs: Inputs.Logic.ThresholdBooleanListDto): boolean[] {
         const booleans = [];
         inputs.numbers.forEach(n => {
             if (n < inputs.threshold) {
                 booleans.push(true);
-            }
-            else {
+            } else {
                 booleans.push(false);
             }
         });
@@ -87,6 +89,7 @@ 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
@@ -95,8 +98,9 @@ export class Logic {
      * @shortname threshold gaps boolean list
      * @drawable false
      */
-    thresholdGapsBooleanList(inputs) {
+    thresholdGapsBooleanList(inputs: Inputs.Logic.ThresholdGapsBooleanListDto): boolean[] {
         const booleans = [];
+
         inputs.numbers.forEach(n => {
             let foundInThresholds = false;
             inputs.gapThresholds.forEach(t => {
@@ -116,6 +120,7 @@ export class Logic {
         }
         return booleans;
     }
+
     /**
      * Apply not operator on the boolean
      * @param inputs a true or false boolean
@@ -124,9 +129,10 @@ export class Logic {
      * @shortname not
      * @drawable false
      */
-    not(inputs) {
+    not(inputs: Inputs.Logic.BooleanDto): boolean {
         return !inputs.boolean;
     }
+
     /**
      * Apply not operator on a list of booleans
      * @param inputs a list of true or false booleans
@@ -135,9 +141,10 @@ export class Logic {
      * @shortname not list
      * @drawable false
      */
-    notList(inputs) {
+    notList(inputs: Inputs.Logic.BooleanListDto): boolean[] {
         return inputs.booleans.map(b => !b);
     }
+
     /**
      * Does comparison between first and second values
      * @param inputs two values to be compared
@@ -146,7 +153,7 @@ export class Logic {
      * @shortname compare
      * @drawable false
      */
-    compare(inputs) {
+    compare<T>(inputs: Inputs.Logic.ComparisonDto<T>): boolean {
         switch (inputs.operator) {
             case "==":
                 return inputs.first == inputs.second;
@@ -168,6 +175,7 @@ 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
@@ -176,9 +184,10 @@ export class Logic {
      * @shortname value gate
      * @drawable false
      */
-    valueGate(inputs) {
+    valueGate<T>(inputs: Inputs.Logic.ValueGateDto<T>): T | undefined {
         return inputs.boolean ? inputs.value : undefined;
     }
+
     /**
      * Returns first defined value out of two
      * @param inputs two values
@@ -187,17 +196,16 @@ export class Logic {
      * @shortname first defined value gate
      * @drawable false
      */
-    firstDefinedValueGate(inputs) {
+    firstDefinedValueGate<T, U>(inputs: Inputs.Logic.TwoValueGateDto<T, U>): T | U | undefined {
         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;
     }
+
 }