@media-quest/engine 0.0.3 → 0.0.4

package/dist/public-api.d.mts

@@ -380,7 +380,7 @@ interface DAudioDto {
 }
 
 interface Rule<OnSuccessAction, OnFailureAction> {
-    readonly id: string;
+    readonly id?: string;
     readonly description: string;
     readonly all: ReadonlyArray<Condition>;
     readonly some: ReadonlyArray<Condition>;

package/dist/public-api.d.ts

@@ -380,7 +380,7 @@ interface DAudioDto {
 }
 
 interface Rule<OnSuccessAction, OnFailureAction> {
-    readonly id: string;
+    readonly id?: string;
     readonly description: string;
     readonly all: ReadonlyArray<Condition>;
     readonly some: ReadonlyArray<Condition>;

package/dist/public-api.js

@@ -1032,7 +1032,7 @@ var RuleEngine = class {
       } else if (Rule.solve(rule, facts)) {
         const match = {
           ruleDescription: rule.description,
-          matchingRuleId: rule.id,
+          matchingRuleId: rule.id ?? "no-id-given",
           actionList: [...rule.onSuccess]
         };
         matching.push(match);

package/dist/public-api.mjs

@@ -996,7 +996,7 @@ var RuleEngine = class {
       } else if (Rule.solve(rule, facts)) {
         const match = {
           ruleDescription: rule.description,
-          matchingRuleId: rule.id,
+          matchingRuleId: rule.id ?? "no-id-given",
           actionList: [...rule.onSuccess]
         };
         matching.push(match);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@media-quest/engine",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Rendering engine for media-quest schemas.",
   "main": "dist/public-api.js",
   "module": "dist/public-api.mjs",

package/src/commands/DCommandBus.ts

@@ -2,59 +2,59 @@ import { DCommand } from "./DCommand";
 import { DTimestamp } from "../common/DTimestamp";
 
 export interface DCommandStore {
-    subscribe(callback: () => void, subscriberId: string): void;
+  subscribe(callback: () => void, subscriberId: string): void;
 }
 
 export interface DCommandDispatcher {
-    emit(command: DCommand): void;
+  emit(command: DCommand): void;
 }
 
 interface CommandSubscriberData {
-    readonly subscriberId: string;
-    readonly callback: (command: DCommand) => void;
+  readonly subscriberId: string;
+  readonly callback: (command: DCommand) => void;
 }
 export class DCommandBus implements DCommandStore, DCommandDispatcher {
-    private readonly TAG = "[ COMMAND_BUS ] ";
-    logCommands = false;
-    private readonly commandLog: Array<DCommand & { timestamp: DTimestamp }> = [];
-    readonly subscribers = new Set<CommandSubscriberData>();
-    // readonly sub
-
-    subscribe(cb: (command: DCommand) => void, subscriberId: string) {
-        const sub: CommandSubscriberData = {
-            subscriberId,
-            callback: cb,
-        };
-
-        this.subscribers.add(sub);
-        return () => {
-            this.subscribers.delete(sub);
-        };
-    }
-
-    emit(command: DCommand) {
-        const timestamp = DTimestamp.now();
-        this.commandLog.push({ ...command, timestamp });
-        if (this.logCommands) {
-            this.logCommand(command);
-        }
-        this.subscribers.forEach((subscriber) => {
-            subscriber.callback(command);
-        });
-    }
-
-    getStats() {
-        return {
-            commands: [...this.commandLog],
-            subscribers: [...this.subscribers],
-            subscribersCount: this.subscribers.size,
-        };
-    }
-
-    private logCommand(command: DCommand) {
-        console.groupCollapsed(this.TAG + " " + command.kind);
-        console.log("TargetID : " + command.targetId);
-        console.log(command.payload);
-        console.groupEnd();
+  private readonly TAG = "[ COMMAND_BUS ] ";
+  logCommands = false;
+  private readonly commandLog: Array<DCommand & { timestamp: DTimestamp }> = [];
+  readonly subscribers = new Set<CommandSubscriberData>();
+  // readonly sub
+
+  subscribe(cb: (command: DCommand) => void, subscriberId: string) {
+    const sub: CommandSubscriberData = {
+      subscriberId,
+      callback: cb,
+    };
+
+    this.subscribers.add(sub);
+    return () => {
+      this.subscribers.delete(sub);
+    };
+  }
+
+  emit(command: DCommand) {
+    const timestamp = DTimestamp.now();
+    this.commandLog.push({ ...command, timestamp });
+    if (this.logCommands) {
+      this.logCommand(command);
     }
+    this.subscribers.forEach((subscriber) => {
+      subscriber.callback(command);
+    });
+  }
+
+  getStats() {
+    return {
+      commands: [...this.commandLog],
+      subscribers: [...this.subscribers],
+      subscribersCount: this.subscribers.size,
+    };
+  }
+
+  private logCommand(command: DCommand) {
+    console.groupCollapsed(this.TAG + " " + command.kind);
+    console.log("TargetID : " + command.targetId);
+    console.log(command.payload);
+    console.groupEnd();
+  }
 }

package/src/rules/rule-engine.ts

@@ -1,46 +1,45 @@
 import { Fact } from "./fact";
 import { Rule } from "./rule";
-import { PageQueCommand } from "../commands/DCommand";
 
 export interface SolveResult<S, F> {
-    matching: ReadonlyArray<Match<S, F>>;
-    errors: ReadonlyArray<RuleEngineError>;
+  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>;
+  readonly matchingRuleId: string;
+  readonly ruleDescription: string;
+  readonly actionList: ReadonlyArray<S> | ReadonlyArray<F>;
 }
 
 export interface RuleEngineError {
-    readonly kind?: string;
-    readonly message: string;
+  readonly kind?: string;
+  readonly message: string;
 }
 
 export class RuleEngine<S, F> {
-    constructor() {}
+  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,
-                    actionList: [...rule.onSuccess],
-                };
-                matching.push(match);
-            }
-        });
-        return { matching, errors };
-    }
+  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);
-    }
+  solve(rule: Rule<S, F>, facts: Fact[]): boolean {
+    // TODO Validate, and Return result
+    return Rule.solve(rule, facts);
+  }
 }

package/src/rules/rule.ts

@@ -3,38 +3,38 @@ 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>;
+  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
-     */
+  /**
+   * 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 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;
-        }
+  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 someSolved = rule.some.map((condition) => Condition.evaluate(condition, facts));
 
-        const someResult = someSolved.length === 0 || someSolved.some(DUtil.isTrue);
+    const someResult = someSolved.length === 0 || someSolved.some(DUtil.isTrue);
 
-        const allSolved = rule.all.map((condition) => Condition.evaluate(condition, facts)).every(DUtil.isTrue);
+    const allSolved = rule.all.map((condition) => Condition.evaluate(condition, facts)).every(DUtil.isTrue);
 
-        return allSolved && someResult;
-    };
+    return allSolved && someResult;
+  };
 }