@media-quest/engine 0.0.22 → 0.0.24

package/src/rules/condition.ts

@@ -1,191 +1,191 @@
-import { Fact } from "./fact";
-import { DUtil } from "../utils/DUtil";
-export type Condition = Condition.String | Condition.Numeric | Condition.Complex;
-
-export namespace Condition {
-    export type StringOperator = "eq" | "not-eq" | "longer-then" | "shorter-then";
-
-    export type NumericOperator =
-        | "eq"
-        | "not-eq"
-        | "greater-then"
-        | "less-then"
-        | "greater-then-inclusive"
-        | "less-then-inclusive";
-
-    export interface Numeric {
-        readonly referenceId: string;
-        readonly referenceLabel: string;
-        readonly valueLabel: string;
-        readonly kind: "numeric-condition";
-        readonly operator: NumericOperator;
-        readonly value: number;
-    }
-    export interface String {
-        readonly referenceId: string;
-        readonly referenceLabel: string;
-        readonly valueLabel: string;
-        readonly kind: "string-condition";
-        readonly operator: StringOperator;
-        readonly value: string;
-    }
-
-    export interface Complex {
-        readonly kind: "complex-condition";
-        readonly name: string;
-        readonly all: ReadonlyArray<Condition.Simple>;
-        readonly some: ReadonlyArray<Condition.Simple>;
-    }
-
-    export type Simple = Condition.String | Condition.Numeric;
-
-    /**
-     * An empty condition will evaluate to false,
-     * @param condition: Condition.Any
-     * @param facts
-     */
-    export const evaluate = (condition: Condition, facts: ReadonlyArray<Fact>) => {
-        let result: boolean = false;
-        switch (condition.kind) {
-            case "string-condition":
-                result = evaluateSimple(condition, facts);
-                break;
-            case "numeric-condition":
-                result = evaluateSimple(condition, facts);
-                break;
-            case "complex-condition":
-                result = evaluateComplex(condition, facts);
-                break;
-            default:
-                const check: never = condition;
-        }
-        return result;
-    };
-
-    const evaluateComplex = (condition: Condition.Complex, facts: ReadonlyArray<Fact>): boolean => {
-        if (condition.some.length === 0 && condition.all.length === 0) {
-            return false;
-        }
-        const allSolved = condition.all.map((condition) => {
-            return evaluateSimple(condition, facts);
-        });
-
-        const someEvaluated = condition.some.map((condition) => {
-            return evaluateSimple(condition, facts);
-        });
-        const allResult = allSolved.every(DUtil.isTrue);
-        const someResult = someEvaluated.length === 0 || someEvaluated.some(DUtil.isTrue);
-        return someResult && allResult;
-    };
-
-    const evaluateSimple = (condition: Condition.Simple, facts: ReadonlyArray<Fact>): boolean => {
-        const fact = facts.find((f) => f.referenceId === condition.referenceId);
-        if (!fact) {
-            return false;
-        }
-        let res = false;
-        switch (condition.kind) {
-            case "numeric-condition":
-                if (fact.kind === "numeric-fact") {
-                    res = evaluateNumeric(condition, fact.value);
-                }
-                break;
-            case "string-condition":
-                if (fact.kind === "string-fact") {
-                    res = evaluateString(condition, fact.value);
-                }
-                break;
-            default:
-                const check: never = condition;
-        }
-        return res;
-    };
-
-    export const isEmpty = (complex: Complex) => {
-        return complex.all.length === 0 && complex.some.length === 0;
-    };
-
-    const evaluateString = (condition: Readonly<Condition.String>, value: string): boolean => {
-        const operator = condition.operator;
-        let result = false;
-        switch (operator) {
-            case "eq":
-                result = condition.value === value;
-                break;
-            case "not-eq":
-                result = condition.value !== value;
-                break;
-            case "shorter-then":
-                result = condition.value !== value;
-                break;
-            case "longer-then":
-                result = condition.value !== value;
-                break;
-            default:
-                const check: never = operator;
-        }
-        return result;
-    };
-
-    const evaluateNumeric = (condition: Numeric, value: number): boolean => {
-        const op = condition.operator;
-        const conditionValue = condition.value;
-        let result = false;
-        switch (op) {
-            case "eq":
-                result = value === conditionValue;
-                break;
-            case "not-eq":
-                result = value !== conditionValue;
-                break;
-            case "greater-then":
-                result = value > conditionValue;
-                break;
-            case "greater-then-inclusive":
-                result = value >= conditionValue;
-                break;
-            case "less-then":
-                result = value < conditionValue;
-                break;
-            case "less-then-inclusive":
-                result = value <= conditionValue;
-                break;
-            default:
-                const check: never = op;
-        }
-        return result;
-    };
-
-    const _getAllSimple = (condition: Condition): ReadonlyArray<Condition.Simple> => {
-        const simple: Array<Condition.Simple> = [];
-        switch (condition.kind) {
-            case "complex-condition":
-                simple.push(...condition.all);
-                simple.push(...condition.some);
-                break;
-            case "numeric-condition":
-                simple.push(condition);
-                break;
-            case "string-condition":
-                simple.push(condition);
-                break;
-            default:
-                DUtil.neverCheck(condition);
-        }
-        return simple;
-    };
-
-    export const getAllSimpleConditions = (
-        condition: Condition | Array<Condition>
-    ): ReadonlyArray<Condition.Simple> => {
-        const simple: Array<Condition.Simple> = [];
-        if (Array.isArray(condition)) {
-            condition.forEach((c) => {
-                simple.push(..._getAllSimple(c));
-            });
-        } else {
-            simple.push(..._getAllSimple(condition));
-        }
-        return simple;
-    };
-}
+import { Fact } from "./fact";
+import { DUtil } from "../utils/DUtil";
+export type Condition = Condition.String | Condition.Numeric | Condition.Complex;
+
+export namespace Condition {
+    export type StringOperator = "eq" | "not-eq" | "longer-then" | "shorter-then";
+
+    export type NumericOperator =
+        | "eq"
+        | "not-eq"
+        | "greater-then"
+        | "less-then"
+        | "greater-then-inclusive"
+        | "less-then-inclusive";
+
+    export interface Numeric {
+        readonly referenceId: string;
+        readonly referenceLabel: string;
+        readonly valueLabel: string;
+        readonly kind: "numeric-condition";
+        readonly operator: NumericOperator;
+        readonly value: number;
+    }
+    export interface String {
+        readonly referenceId: string;
+        readonly referenceLabel: string;
+        readonly valueLabel: string;
+        readonly kind: "string-condition";
+        readonly operator: StringOperator;
+        readonly value: string;
+    }
+
+    export interface Complex {
+        readonly kind: "complex-condition";
+        readonly name: string;
+        readonly all: ReadonlyArray<Condition.Simple>;
+        readonly some: ReadonlyArray<Condition.Simple>;
+    }
+
+    export type Simple = Condition.String | Condition.Numeric;
+
+    /**
+     * An empty condition will evaluate to false,
+     * @param condition: Condition.Any
+     * @param facts
+     */
+    export const evaluate = (condition: Condition, facts: ReadonlyArray<Fact>) => {
+        let result: boolean = false;
+        switch (condition.kind) {
+            case "string-condition":
+                result = evaluateSimple(condition, facts);
+                break;
+            case "numeric-condition":
+                result = evaluateSimple(condition, facts);
+                break;
+            case "complex-condition":
+                result = evaluateComplex(condition, facts);
+                break;
+            default:
+                const check: never = condition;
+        }
+        return result;
+    };
+
+    const evaluateComplex = (condition: Condition.Complex, facts: ReadonlyArray<Fact>): boolean => {
+        if (condition.some.length === 0 && condition.all.length === 0) {
+            return false;
+        }
+        const allSolved = condition.all.map((condition) => {
+            return evaluateSimple(condition, facts);
+        });
+
+        const someEvaluated = condition.some.map((condition) => {
+            return evaluateSimple(condition, facts);
+        });
+        const allResult = allSolved.every(DUtil.isTrue);
+        const someResult = someEvaluated.length === 0 || someEvaluated.some(DUtil.isTrue);
+        return someResult && allResult;
+    };
+
+    const evaluateSimple = (condition: Condition.Simple, facts: ReadonlyArray<Fact>): boolean => {
+        const fact = facts.find((f) => f.referenceId === condition.referenceId);
+        if (!fact) {
+            return false;
+        }
+        let res = false;
+        switch (condition.kind) {
+            case "numeric-condition":
+                if (fact.kind === "numeric-fact") {
+                    res = evaluateNumeric(condition, fact.value);
+                }
+                break;
+            case "string-condition":
+                if (fact.kind === "string-fact") {
+                    res = evaluateString(condition, fact.value);
+                }
+                break;
+            default:
+                const check: never = condition;
+        }
+        return res;
+    };
+
+    export const isEmpty = (complex: Complex) => {
+        return complex.all.length === 0 && complex.some.length === 0;
+    };
+
+    const evaluateString = (condition: Readonly<Condition.String>, value: string): boolean => {
+        const operator = condition.operator;
+        let result = false;
+        switch (operator) {
+            case "eq":
+                result = condition.value === value;
+                break;
+            case "not-eq":
+                result = condition.value !== value;
+                break;
+            case "shorter-then":
+                result = condition.value !== value;
+                break;
+            case "longer-then":
+                result = condition.value !== value;
+                break;
+            default:
+                const check: never = operator;
+        }
+        return result;
+    };
+
+    const evaluateNumeric = (condition: Numeric, value: number): boolean => {
+        const op = condition.operator;
+        const conditionValue = condition.value;
+        let result = false;
+        switch (op) {
+            case "eq":
+                result = value === conditionValue;
+                break;
+            case "not-eq":
+                result = value !== conditionValue;
+                break;
+            case "greater-then":
+                result = value > conditionValue;
+                break;
+            case "greater-then-inclusive":
+                result = value >= conditionValue;
+                break;
+            case "less-then":
+                result = value < conditionValue;
+                break;
+            case "less-then-inclusive":
+                result = value <= conditionValue;
+                break;
+            default:
+                const check: never = op;
+        }
+        return result;
+    };
+
+    const _getAllSimple = (condition: Condition): ReadonlyArray<Condition.Simple> => {
+        const simple: Array<Condition.Simple> = [];
+        switch (condition.kind) {
+            case "complex-condition":
+                simple.push(...condition.all);
+                simple.push(...condition.some);
+                break;
+            case "numeric-condition":
+                simple.push(condition);
+                break;
+            case "string-condition":
+                simple.push(condition);
+                break;
+            default:
+                DUtil.neverCheck(condition);
+        }
+        return simple;
+    };
+
+    export const getAllSimpleConditions = (
+        condition: Condition | Array<Condition>
+    ): ReadonlyArray<Condition.Simple> => {
+        const simple: Array<Condition.Simple> = [];
+        if (Array.isArray(condition)) {
+            condition.forEach((c) => {
+                simple.push(..._getAllSimple(c));
+            });
+        } else {
+            simple.push(..._getAllSimple(condition));
+        }
+        return simple;
+    };
+}

package/src/rules/fact.ts

@@ -1,18 +1,18 @@
-export type Fact = Fact.Numeric | Fact.String;
-export namespace Fact {
-    export interface Numeric {
-        readonly kind: "numeric-fact";
-        readonly value: number;
-        readonly label: string;
-        readonly referenceId: string;
-        readonly referenceLabel: string;
-    }
-
-    export interface String {
-        readonly kind: "string-fact";
-        readonly label: string;
-        readonly value: string;
-        readonly referenceId: string;
-        readonly referenceLabel: string;
-    }
-}
+export type Fact = Fact.Numeric | Fact.String;
+export namespace Fact {
+    export interface Numeric {
+        readonly kind: "numeric-fact";
+        readonly value: number;
+        readonly label: string;
+        readonly referenceId: string;
+        readonly referenceLabel: string;
+    }
+
+    export interface String {
+        readonly kind: "string-fact";
+        readonly label: string;
+        readonly value: string;
+        readonly referenceId: string;
+        readonly referenceLabel: string;
+    }
+}

package/src/rules/rule-engine.ts

@@ -1,45 +1,45 @@
-import { Fact } from "./fact";
-import { Rule } from "./rule";
-
-export interface SolveResult<S, F> {
-  matching: ReadonlyArray<Match<S, F>>;
-  errors: ReadonlyArray<RuleEngineError>;
-}
-
-export interface Match<S, F> {
-  readonly matchingRuleId: string;
-  readonly ruleDescription: string;
-  readonly actionList: ReadonlyArray<S> | ReadonlyArray<F>;
-}
-
-export interface RuleEngineError {
-  readonly kind?: string;
-  readonly message: string;
-}
-
-export class RuleEngine<S, F> {
-  constructor() {}
-
-  solveAll(rules: Rule<S, F>[], facts: Fact[]): SolveResult<S, F> {
-    const errors: RuleEngineError[] = [];
-    const matching: Match<S, F>[] = [];
-    rules.forEach((rule) => {
-      if (Rule.isEmpty(rule)) {
-        errors.push({ message: "Empty rule: " + rule.id });
-      } else if (Rule.solve(rule, facts)) {
-        const match: Match<S, F> = {
-          ruleDescription: rule.description,
-          matchingRuleId: rule.id ?? "no-id-given",
-          actionList: [...rule.onSuccess],
-        };
-        matching.push(match);
-      }
-    });
-    return { matching, errors };
-  }
-
-  solve(rule: Rule<S, F>, facts: Fact[]): boolean {
-    // TODO Validate, and Return result
-    return Rule.solve(rule, facts);
-  }
-}
+import { Fact } from "./fact";
+import { Rule } from "./rule";
+
+export interface SolveResult<S, F> {
+  matching: ReadonlyArray<Match<S, F>>;
+  errors: ReadonlyArray<RuleEngineError>;
+}
+
+export interface Match<S, F> {
+  readonly matchingRuleId: string;
+  readonly ruleDescription: string;
+  readonly actionList: ReadonlyArray<S> | ReadonlyArray<F>;
+}
+
+export interface RuleEngineError {
+  readonly kind?: string;
+  readonly message: string;
+}
+
+export class RuleEngine<S, F> {
+  constructor() {}
+
+  solveAll(rules: Rule<S, F>[], facts: Fact[]): SolveResult<S, F> {
+    const errors: RuleEngineError[] = [];
+    const matching: Match<S, F>[] = [];
+    rules.forEach((rule) => {
+      if (Rule.isEmpty(rule)) {
+        errors.push({ message: "Empty rule: " + rule.id });
+      } else if (Rule.solve(rule, facts)) {
+        const match: Match<S, F> = {
+          ruleDescription: rule.description,
+          matchingRuleId: rule.id ?? "no-id-given",
+          actionList: [...rule.onSuccess],
+        };
+        matching.push(match);
+      }
+    });
+    return { matching, errors };
+  }
+
+  solve(rule: Rule<S, F>, facts: Fact[]): boolean {
+    // TODO Validate, and Return result
+    return Rule.solve(rule, facts);
+  }
+}

package/src/rules/rule.ts

@@ -1,40 +1,40 @@
-import { Condition } from "./condition";
-import { Fact } from "./fact";
-import { DUtil } from "../utils/DUtil";
-
-export interface Rule<OnSuccessAction, OnFailureAction> {
-  readonly id?: string;
-  readonly description: string;
-  readonly all: ReadonlyArray<Condition>;
-  readonly some: ReadonlyArray<Condition>;
-  readonly onSuccess: ReadonlyArray<OnSuccessAction>;
-  readonly onFailure: ReadonlyArray<OnFailureAction>;
-}
-
-export namespace Rule {
-  /**
-   * Validates that the rule is valid.
-   * @param rule
-   */
-
-  export const isEmpty = (rule: Rule<any, any>): boolean => {
-    const emptyConditions = rule.all.length === 0 && rule.some.length === 0;
-    const emptyActions = rule.onSuccess.length === 0 && rule.onFailure.length === 0;
-    return emptyConditions || emptyActions;
-  };
-
-  export const solve = (rule: Rule<any, any>, facts: ReadonlyArray<Fact>): boolean => {
-    if (rule.some.length === 0 && rule.all.length === 0) {
-      // TODO RETURN WARNING? OR LOGGING ?
-      return false;
-    }
-
-    const someSolved = rule.some.map((condition) => Condition.evaluate(condition, facts));
-
-    const someResult = someSolved.length === 0 || someSolved.some(DUtil.isTrue);
-
-    const allSolved = rule.all.map((condition) => Condition.evaluate(condition, facts)).every(DUtil.isTrue);
-
-    return allSolved && someResult;
-  };
-}
+import { Condition } from "./condition";
+import { Fact } from "./fact";
+import { DUtil } from "../utils/DUtil";
+
+export interface Rule<OnSuccessAction, OnFailureAction> {
+  readonly id?: string;
+  readonly description: string;
+  readonly all: ReadonlyArray<Condition>;
+  readonly some: ReadonlyArray<Condition>;
+  readonly onSuccess: ReadonlyArray<OnSuccessAction>;
+  readonly onFailure: ReadonlyArray<OnFailureAction>;
+}
+
+export namespace Rule {
+  /**
+   * Validates that the rule is valid.
+   * @param rule
+   */
+
+  export const isEmpty = (rule: Rule<any, any>): boolean => {
+    const emptyConditions = rule.all.length === 0 && rule.some.length === 0;
+    const emptyActions = rule.onSuccess.length === 0 && rule.onFailure.length === 0;
+    return emptyConditions || emptyActions;
+  };
+
+  export const solve = (rule: Rule<any, any>, facts: ReadonlyArray<Fact>): boolean => {
+    if (rule.some.length === 0 && rule.all.length === 0) {
+      // TODO RETURN WARNING? OR LOGGING ?
+      return false;
+    }
+
+    const someSolved = rule.some.map((condition) => Condition.evaluate(condition, facts));
+
+    const someResult = someSolved.length === 0 || someSolved.some(DUtil.isTrue);
+
+    const allSolved = rule.all.map((condition) => Condition.evaluate(condition, facts)).every(DUtil.isTrue);
+
+    return allSolved && someResult;
+  };
+}