@media-quest/engine 0.0.1 → 0.0.3

package/src/player/next-que.ts

@@ -0,0 +1,93 @@
+import { PageDto } from "../dto/SchemaDto";
+
+export class NextQue {
+    private originalOrder: ReadonlyArray<string> = [];
+    private allPages: PageDto[] = [];
+    private excludedTags = new Set<string>();
+    private excludedByPageId = new Set<string>();
+    private remaining: PageDto[] = [];
+    constructor(pages: PageDto[] = []) {
+        this.resetQue(pages);
+    }
+
+    /**
+     * Will reset que with the new pages.
+     * @param pages
+     */
+    resetQue(pages: PageDto[]) {
+        this.allPages = [...pages];
+        this.remaining = [...pages];
+        this.excludedTags = new Set();
+        this.excludedByPageId = new Set();
+        this.originalOrder = this.allPages.map((p) => p.id);
+    }
+
+    pop(): PageDto | false {
+        const next = this.remaining.shift();
+        // TODO CLONE??
+        return next ?? false;
+    }
+
+    peek(): PageDto | false {
+        const next = this.remaining[0];
+        return next ?? false;
+    }
+
+    jumpToPageById(pageId: string): boolean {
+        const index = this.remaining.findIndex((p) => p.id === pageId);
+        if (index < 0) {
+            return false;
+        }
+        this.remaining = this.remaining.slice(index);
+        return true;
+    }
+
+    removeByTag(tag: string | string[]) {
+        if (Array.isArray(tag)) {
+            tag.forEach((tag) => {
+                this.excludedTags.add(tag);
+            });
+        } else {
+            this.excludedTags.add(tag);
+        }
+        this.filterRemaining();
+    }
+
+    /**
+     * Will not be included
+     * @param pages
+     */
+    insertAsNextByForce(pages: PageDto[]) {
+        this.remaining.unshift(...pages);
+    }
+
+    removeByPageId(pageId: string | string[]) {
+        if (Array.isArray(pageId)) {
+            pageId.forEach((id) => {
+                this.excludedByPageId.add(id);
+            });
+        } else {
+            this.excludedByPageId.add(pageId);
+        }
+        this.filterRemaining();
+        // this.excludedByPageId.add(pageId);
+    }
+
+    private filterRemaining() {
+        this.remaining = this.remaining.filter((p) => {
+            const tags = p.tags ?? [];
+            const isIncluededByTag = !tags.some((tag) => this.excludedTags.has(tag));
+            const isIncludedByPageId = !this.excludedByPageId.has(p.id);
+            return isIncludedByPageId && isIncluededByTag;
+        });
+    }
+    get isEmpty(): boolean {
+        return this.remaining.length === 0;
+    }
+    get size(): number {
+        return this.remaining.length;
+    }
+    get pageCount(): number {
+        return this.originalOrder.length;
+    }
+}

package/src/public-api.ts

@@ -1,5 +1,18 @@
-export const createEngine = () => {
-  const engine = document.createElement("div");
-  engine.innerText = "ENGINE";
-  return engine;
-}
+export { SchemaEngine } from "./engine/SchemaEngine";
+export * from "./dto/SchemaDto";
+export * from "./dto/AnimationDto";
+export * from "./dto/DElement.dto";
+export * from "./event-handlers/DEventHandler";
+export * from "./commands/DCommand";
+export * from "./events/DEvents";
+export * from "./rules/rule";
+export * from "./rules/fact";
+export * from "./rules/rule-engine";
+export * from "./rules/condition";
+export * from "./state/boolean-property";
+export * from "./state/Dstate";
+export * from "./Delement/DStyle";
+export * from "./Delement/DAuto-play";
+export * from "./Delement/css";
+
+export * from "./utils/DUtil";

package/src/rules/__test__/complex-condition.spec.ts

@@ -0,0 +1,15 @@
+import { Condition } from '../condition';
+describe('Rule validations', () => {
+  // beforeEach(() => {
+  // });
+
+  it('isCondition -> true', () => {
+    const d: Condition.Complex = {
+      kind: 'complex-condition',
+      name: 'test-name',
+      all: [],
+      some: [],
+    };
+    expect(Condition.isEmpty(d)).toBe(true);
+  });
+});

package/src/rules/__test__/conditon.spec.ts

@@ -0,0 +1,124 @@
+import { Condition } from "../condition";
+import { Fact } from "../fact";
+
+const xEqCondition = (value: number): Condition.Numeric => {
+    const numericCondition: Condition.Numeric = {
+        kind: "numeric-condition",
+        value,
+        valueLabel: "value-label",
+        operator: "eq",
+        referenceId: "x",
+        referenceLabel: "fact-label",
+    };
+    return numericCondition;
+};
+const exq1: Fact.Numeric = {
+    label: "",
+    referenceId: "x",
+    referenceLabel: "x-label",
+    value: 1,
+    kind: "numeric-fact",
+};
+
+const exq2: Fact.Numeric = {
+    label: "",
+    referenceId: "x",
+    referenceLabel: "x-label",
+    value: 2,
+    kind: "numeric-fact",
+};
+const f = {
+    xeq1: exq1,
+    xeq2: exq2,
+} as const;
+const con = {
+    xeq1: xEqCondition(1),
+    xeq2: xEqCondition(2),
+    xeq3: xEqCondition(3),
+} as const;
+
+const complex = (all: Condition.Simple[], some: Condition.Simple[]): Condition.Complex => ({
+    kind: "complex-condition",
+    all,
+    some,
+    name: "test-name",
+});
+
+const validNumericCondition: Condition.Numeric = {
+    kind: "numeric-condition",
+    value: 1,
+    referenceId: "x",
+    referenceLabel: "fact-label",
+    valueLabel: "value-label",
+    operator: "not-eq",
+};
+
+const inValidFactId: Condition.Numeric = {
+    kind: "numeric-condition",
+    value: 1,
+    referenceId: "",
+    referenceLabel: "fact-label",
+    valueLabel: "value-label",
+    operator: "not-eq",
+};
+
+const undefinedCondition = undefined as unknown as Condition;
+
+const validStringCondition: Condition.String = {
+    kind: "string-condition",
+    value: "hello",
+    referenceId: "asdf",
+    referenceLabel: "fact-label",
+    valueLabel: "value-label",
+    operator: "not-eq",
+};
+
+describe("Can pick all simple conditions from Complex.", () => {
+    const complex: Condition.Complex = {
+        kind: "complex-condition",
+        name: "test-condition",
+        all: [validStringCondition, validNumericCondition],
+        some: [inValidFactId, validNumericCondition, inValidFactId],
+    };
+    it("empty condition will always be false", () => {
+        expect(Condition.getAllSimpleConditions(complex).length).toBe(5);
+        expect(Condition.getAllSimpleConditions([complex, complex, validNumericCondition, inValidFactId]).length).toBe(
+            12
+        );
+    });
+});
+
+describe("condition validation", () => {
+    it("empty condition will always be false", () => {
+        expect(Condition.evaluate(complex([], []), [f.xeq1])).toBe(false);
+    });
+});
+
+describe("condition evaluation", () => {
+    it("If 1 in some is true -> true", () => {
+        const all: Condition.Simple[] = [];
+        const some: Condition.Simple[] = [con.xeq1, con.xeq3];
+        const facts: Fact[] = [f.xeq1];
+        expect(Condition.evaluate(complex(all, some), facts)).toBe(true);
+    });
+    it("If not all is true (empty some) -> false", () => {
+        const all: Condition.Simple[] = [con.xeq1, con.xeq3];
+        const some: Condition.Simple[] = [];
+        const facts: Fact[] = [f.xeq1];
+        expect(Condition.evaluate(complex(all, some), facts)).toBe(false);
+    });
+
+    it("If not all is true (non empty some) -> false", () => {
+        const all: Condition.Simple[] = [con.xeq1, con.xeq3];
+        const some: Condition.Simple[] = [con.xeq3];
+        const facts: Fact[] = [f.xeq1];
+        expect(Condition.evaluate(complex(all, some), facts)).toBe(false);
+    });
+
+    it("If not all is true (non empty some) -> false", () => {
+        const all: Condition.Simple[] = [con.xeq1, con.xeq3];
+        const some: Condition.Simple[] = [con.xeq3];
+        const facts: Fact[] = [f.xeq1];
+        expect(Condition.evaluate(complex(all, some), facts)).toBe(false);
+    });
+});

package/src/rules/__test__/numeric-condition.spec.ts

@@ -0,0 +1,84 @@
+import { Condition } from "../condition";
+import { Fact } from "../fact";
+const numFact = (n: number): [Fact.Numeric] => [
+    {
+        kind: "numeric-fact",
+        value: n,
+        label: "Label-for " + n,
+        referenceId: "test-fact",
+        referenceLabel: "test-fact-label",
+    },
+];
+const eq0: Condition.Numeric = {
+    kind: "numeric-condition",
+    referenceId: "test-fact",
+    operator: "eq",
+    value: 0,
+    referenceLabel: "fact-label",
+    valueLabel: "value-label",
+};
+
+const notEq0: Condition.Numeric = {
+    ...eq0,
+    operator: "not-eq",
+};
+
+const lessThen0: Condition.Numeric = {
+    ...eq0,
+    operator: "less-then",
+};
+
+const greaterThen0: Condition.Numeric = {
+    ...eq0,
+    operator: "greater-then",
+};
+const greaterThen0Inclusive: Condition.Numeric = {
+    ...eq0,
+    operator: "greater-then-inclusive",
+};
+
+const lessThen0Inclusive: Condition.Numeric = {
+    ...eq0,
+    operator: "less-then-inclusive",
+};
+
+describe("Numeric conditions", () => {
+    // beforeEach(() => {});
+
+    it("eq works", () => {
+        const equals = Condition.evaluate(eq0, numFact(0));
+        const notEquals = Condition.evaluate(eq0, numFact(1));
+        expect(equals).toBe(true);
+        expect(notEquals).toBe(false);
+    });
+
+    it("not-eq works", () => {
+        expect(Condition.evaluate(notEq0, numFact(1))).toBe(true);
+        expect(Condition.evaluate(notEq0, numFact(-1))).toBe(true);
+        expect(Condition.evaluate(notEq0, numFact(0))).toBe(false);
+    });
+
+    it("less than works", () => {
+        expect(Condition.evaluate(lessThen0, numFact(-1))).toBe(true);
+        expect(Condition.evaluate(lessThen0, numFact(0))).toBe(false);
+        expect(Condition.evaluate(lessThen0, numFact(1))).toBe(false);
+    });
+
+    it("less than inclusive works", () => {
+        expect(Condition.evaluate(lessThen0Inclusive, numFact(-1))).toBe(true);
+        expect(Condition.evaluate(lessThen0Inclusive, numFact(0))).toBe(true);
+        expect(Condition.evaluate(lessThen0Inclusive, numFact(1))).toBe(false);
+    });
+
+    it("greater than works", () => {
+        expect(Condition.evaluate(greaterThen0, numFact(-1))).toBe(false);
+        expect(Condition.evaluate(greaterThen0, numFact(0))).toBe(false);
+        expect(Condition.evaluate(greaterThen0, numFact(1))).toBe(true);
+    });
+
+    it("greater than inclusive works", () => {
+        expect(Condition.evaluate(greaterThen0Inclusive, numFact(-1))).toBe(false);
+        expect(Condition.evaluate(greaterThen0Inclusive, numFact(0))).toBe(true);
+        expect(Condition.evaluate(greaterThen0Inclusive, numFact(1))).toBe(true);
+    });
+});

package/src/rules/__test__/rule-engine.spec.ts

@@ -0,0 +1,354 @@
+import { RuleEngine } from "../rule-engine";
+import { Rule } from "../rule";
+import { Fact } from "../fact";
+import { Condition } from "../condition";
+import { PageQueCommand } from "../../commands/DCommand";
+
+const excludeById = (ids: string[]): PageQueCommand => {
+    return {
+        kind: "PAGE_QUE_EXCLUDE_BY_PAGE_ID_COMMAND",
+        target: "PAGE_QUE",
+        targetId: "PAGE_QUE",
+        payload: { pageIds: ids },
+    };
+};
+
+const excludeByTag = (id: string): PageQueCommand => ({
+    kind: "PAGE_QUE_EXCLUDE_BY_TAG_COMMAND",
+    target: "PAGE_QUE",
+    targetId: "PAGE_QUE",
+    payload: { tagIds: [id] },
+});
+
+let engine = new RuleEngine();
+// const x = 'x';
+// const y = 'y';
+
+const xIs = (value: number): Fact.Numeric => ({
+    referenceId: "x",
+    referenceLabel: "x-label",
+    label: "value-label x",
+    value,
+    kind: "numeric-fact",
+});
+
+const yIs = (value: number): Fact.Numeric => ({
+    kind: "numeric-fact",
+    referenceId: "y",
+    referenceLabel: "y-label",
+    label: "var-label y",
+    // valueLabel: 'value-label y',
+    value,
+});
+
+const xCondition = (operator: Condition.NumericOperator, value: number): Condition.Numeric => ({
+    kind: "numeric-condition",
+    referenceId: "x",
+    referenceLabel: "",
+    operator,
+    value,
+    valueLabel: "",
+});
+
+const trueIf_0_conditions: Condition.Numeric[] = [
+    xCondition("eq", 0),
+    xCondition("not-eq", 2),
+    xCondition("less-then", 1),
+    xCondition("less-then-inclusive", 0),
+    xCondition("greater-then", -1),
+    xCondition("greater-then-inclusive", 0),
+];
+
+const falseIf_0_conditions: Condition.Numeric[] = [
+    xCondition("eq", 10),
+    xCondition("not-eq", 0),
+    xCondition("less-then", -5),
+    xCondition("less-then-inclusive", -1),
+    xCondition("greater-then", 0),
+    xCondition("greater-then-inclusive", 1),
+];
+
+const trueIf_0_simple: Condition.Complex[] = [
+    {
+        kind: "complex-condition",
+        name: "test-name",
+        all: [...trueIf_0_conditions],
+        some: [...trueIf_0_conditions, ...falseIf_0_conditions],
+    },
+];
+
+const falseIf_0_simple: Condition.Complex[] = [
+    {
+        kind: "complex-condition",
+        name: "test-name",
+        all: [...trueIf_0_conditions, ...falseIf_0_conditions],
+        some: [...falseIf_0_conditions],
+    },
+];
+
+describe("Rule-engine spec", () => {
+    beforeEach(() => {
+        engine = new RuleEngine();
+    });
+
+    it("Empty rule => one error, no actions", () => {
+        const rule: Rule<any, any> = {
+            id: "id123",
+            description: "",
+            some: [],
+            all: [],
+            onFailure: [],
+            onSuccess: [],
+        };
+        const result = engine.solveAll([rule], []);
+        expect(result.matching.length).toBe(0);
+        expect(result.errors.length).toBe(1);
+    });
+
+    it("Empty facts => no actions, no errors.", () => {
+        const hideAs1 = excludeById(["as1"]);
+        const rule: Rule<any, any> = {
+            id: "id123",
+            description: "",
+            some: [],
+            all: [...trueIf_0_conditions],
+            onFailure: [],
+            onSuccess: [hideAs1],
+        };
+        const facts = [yIs(1)];
+        const rules = [rule];
+        // engine.addRule(rule);
+        // engine.addFact(yIs(1)); // X is now missing.
+        const result = engine.solveAll(rules, facts);
+
+        expect(result.matching.length).toBe(0);
+        expect(result.errors.length).toBe(0);
+    });
+
+    it("and-rule 0=0 true -> 2 Actions in ruleMatch", () => {
+        const rule: Rule<any, any> = {
+            id: "id123",
+            description: "",
+            some: [],
+            all: [...trueIf_0_conditions],
+            onFailure: [],
+            onSuccess: [excludeById(["as3", "as6"])],
+        };
+        const f1 = xIs(0);
+        const rules = [rule];
+        const result = engine.solveAll(rules, [f1]);
+        const firstMatch = result.matching[0];
+        expect(firstMatch.actionList.length).toBe(1);
+        expect(result.matching.length).toBe(1);
+        expect(result.errors.length).toBe(0);
+    });
+
+    it("and-rule 0=1 false", () => {
+        const facts = [xIs(1)];
+        const rule: Rule<any, any> = {
+            id: "id123",
+
+            description: "",
+            some: [],
+            all: [xCondition("eq", 0)],
+            onFailure: [],
+            onSuccess: [excludeById(["abx", "dfg"])],
+        };
+        expect(engine.solve(rule, facts)).toEqual(false);
+        const results = engine.solveAll([rule], facts);
+        expect(results.matching.length).toBe(0);
+        expect(results.errors.length).toBe(0);
+    });
+
+    it("One true some-rule gives true", () => {
+        const facts = [xIs(6)];
+        const rule: Rule<any, any> = {
+            id: "id123",
+            description: "",
+            some: [xCondition("eq", 6)],
+            all: [],
+            onFailure: [],
+            onSuccess: [excludeById(["abcf"])],
+        };
+        expect(engine.solve(rule, facts)).toBe(true);
+        const result = engine.solveAll([rule], facts);
+        expect(result.matching.length).toBe(1);
+    });
+
+    it("One false some-rule gives false", () => {
+        const facts = [xIs(6)];
+        const rule: Rule<any, any> = {
+            id: "id123",
+
+            description: "",
+            some: [xCondition("eq", 5)],
+            all: [],
+            onFailure: [],
+            onSuccess: [],
+        };
+        expect(engine.solve(rule, facts)).toBe(false);
+    });
+
+    it("All true all-rules, and one true some-rule -> true", () => {
+        const facts = [xIs(9)];
+        const rule: Rule<any, any> = {
+            id: "id123",
+
+            description: "",
+            some: [xCondition("eq", 5), xCondition("greater-then", 3)],
+            all: [xCondition("greater-then", 5), xCondition("eq", 9)],
+            onFailure: [],
+            onSuccess: [],
+        };
+        expect(engine.solve(rule, facts)).toBe(true);
+    });
+
+    it("Can solve complex rule [some-2 -> true]", () => {
+        const facts = [xIs(9)];
+        const rule: Rule<any, any> = {
+            id: "id123",
+
+            description: "",
+            some: [
+                {
+                    kind: "complex-condition",
+                    name: "test-name",
+                    all: [],
+                    some: [xCondition("eq", 5), xCondition("greater-then", 3)],
+                },
+            ],
+            all: [],
+            onFailure: [],
+            onSuccess: [excludeByTag("asdf")],
+        };
+        expect(engine.solve(rule, facts)).toBe(true);
+        const result = engine.solveAll([rule], facts);
+        expect(result.matching.length).toBe(1);
+    });
+    it("Can solve complex rule [some-1 -> false]", () => {
+        const facts = [xIs(0)];
+        const rule: Rule<any, any> = {
+            id: "id123",
+
+            description: "",
+            some: [
+                {
+                    kind: "complex-condition",
+                    name: "test-name",
+                    all: [],
+                    some: [xCondition("eq", 5)],
+                },
+            ],
+            all: [],
+            onFailure: [],
+            onSuccess: [excludeByTag("xbj")],
+        };
+        expect(engine.solve(rule, facts)).toBe(false);
+        const result = engine.solveAll([rule], facts);
+        expect(result.matching.length).toBe(0);
+        expect(result.errors.length).toBe(0);
+    });
+
+    it("Can solve complex rule [some-1-true -> true]", () => {
+        const facts = [xIs(0)];
+        const rule: Rule<any, any> = {
+            id: "id123",
+
+            description: "",
+            some: [
+                {
+                    kind: "complex-condition",
+                    name: "test-name",
+                    all: [],
+                    some: [xCondition("greater-then", -5)],
+                },
+            ],
+            all: [],
+            onFailure: [],
+            onSuccess: [],
+        };
+        expect(engine.solve(rule, facts)).toBe(true);
+    });
+
+    it("Empty some (nested) returns false (not valid condition)", () => {
+        const rule: Rule<any, any> = {
+            id: "id123",
+
+            description: "",
+            some: [
+                {
+                    kind: "complex-condition",
+                    name: "test-name",
+                    all: [],
+                    some: [],
+                },
+            ],
+            all: [],
+            onFailure: [],
+            onSuccess: [],
+        };
+        expect(engine.solve(rule, [])).toBe(false);
+    });
+
+    it("Empty complex -> false", () => {
+        const rule: Rule<any, any> = {
+            id: "id123",
+
+            description: "",
+            some: [],
+            all: [],
+            onFailure: [],
+            onSuccess: [],
+        };
+        expect(engine.solve(rule, [])).toBe(false);
+    });
+
+    it("Complex all 6 true conditions -> true", () => {
+        const facts = [xIs(0)];
+        const action = excludeById(["as1"]);
+        const rule: Rule<any, any> = {
+            id: "id123",
+
+            description: "",
+            some: [...falseIf_0_simple, ...trueIf_0_simple],
+            all: [...trueIf_0_conditions, ...trueIf_0_simple],
+            onFailure: [],
+            onSuccess: [action],
+        };
+        // CAN SOLVE
+        expect(engine.solve(rule, facts)).toBe(true);
+        // engine.addRule(rule);
+        // expect(engine.getRules().length).toBe(1);
+
+        // const lastAction = engine.actionState?.lastAction as HidePageAction;
+        // expect(lastAction?.pageId).toBe('as1');
+    });
+
+    it("True some, but false all -> true", () => {
+        const facts = [xIs(0)];
+        const rule: Rule<any, any> = {
+            id: "id123",
+
+            description: "",
+            some: [...falseIf_0_simple, ...trueIf_0_simple],
+            all: [...trueIf_0_conditions, ...trueIf_0_simple, ...falseIf_0_simple],
+            onFailure: [],
+            onSuccess: [],
+        };
+        expect(engine.solve(rule, facts)).toBe(false);
+    });
+
+    it("Empty some && true all -> true", () => {
+        const facts = [xIs(0)];
+        const rule: Rule<any, any> = {
+            id: "id123",
+
+            description: "",
+            some: [],
+            all: [...trueIf_0_conditions, ...trueIf_0_simple],
+            onFailure: [],
+            onSuccess: [],
+        };
+        expect(engine.solve(rule, facts)).toBe(true);
+    });
+});