@media-quest/engine 0.0.1 → 0.0.3

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

@@ -0,0 +1,140 @@
+import { Rule } from "../rule";
+import { Fact } from "../fact";
+import { Condition } from "../condition";
+
+const xIs = (value: number): Fact.Numeric => ({
+    referenceId: "x",
+    referenceLabel: "x-label",
+    label: "label for x",
+    value,
+    kind: "numeric-fact",
+});
+
+const yIs = (value: number): Fact.Numeric => ({
+    kind: "numeric-fact",
+    referenceId: "y",
+    referenceLabel: "y-label",
+    label: "value-label-y",
+    // valueLabel: 'value-label-y',
+    value,
+});
+
+const conditionFactory =
+    (factId: string) =>
+    (op: Condition.NumericOperator) =>
+    (value: number): Condition.Numeric => ({
+        kind: "numeric-condition",
+        referenceId: factId,
+        operator: op,
+        value,
+        referenceLabel: "fact-label",
+        valueLabel: "value-label",
+    });
+
+// Conditon helpers
+const xConditionFactory = conditionFactory("x");
+const xEq = xConditionFactory("eq");
+const xLessThan = xConditionFactory("less-then");
+const xGreaterThan = xConditionFactory("greater-then");
+
+const yConditionFactory = conditionFactory("y");
+const yEq = yConditionFactory("eq");
+const yLessThan = yConditionFactory("less-then");
+const yGreaterThan = yConditionFactory("greater-then");
+
+const con = {
+    xEq,
+    xLessThan,
+    xGreaterThan,
+    yEq,
+    yLessThan,
+    yGreaterThan,
+} as const;
+
+const complex = (all: ReadonlyArray<Condition.Simple>, some: ReadonlyArray<Condition.Simple>): Condition.Complex => ({
+    name: "test-name",
+    kind: "complex-condition",
+    all,
+    some,
+});
+
+const createRule = (all: ReadonlyArray<Condition>, some: ReadonlyArray<Condition>): Rule<any, any> => {
+    const rule: Rule<any, any> = {
+        id: "xyz",
+        description: "",
+        some,
+        all,
+        onSuccess: [],
+        onFailure: [],
+    };
+    return rule;
+};
+
+describe("Rule-evaluation works", () => {
+    it("A empty rule is not valid, and will always return false", () => {
+        expect(Rule.solve(createRule([], []), [])).toBe(false);
+    });
+
+    it("One all condition is true => true", () => {
+        const all: ReadonlyArray<Condition> = [con.xEq(0)];
+        const some: ReadonlyArray<Condition> = [];
+        const facts: ReadonlyArray<Fact> = [xIs(0)];
+        const rule = createRule(all, some);
+        expect(Rule.solve(rule, facts)).toEqual(true);
+    });
+
+    it("one some condition is true => true", () => {
+        const all: ReadonlyArray<Condition> = [];
+        const some: ReadonlyArray<Condition> = [con.xEq(0)];
+        const facts: ReadonlyArray<Fact> = [xIs(0)];
+        const rule = createRule(all, some);
+        expect(Rule.solve(rule, facts)).toEqual(true);
+    });
+
+    it("one some condition is true, but all condition is false => false", () => {
+        const all: ReadonlyArray<Condition> = [con.xEq(6)];
+        const some: ReadonlyArray<Condition> = [con.xEq(0)];
+        const facts: ReadonlyArray<Fact> = [xIs(0)];
+        const rule = createRule(all, some);
+        expect(Rule.solve(rule, facts)).toEqual(false);
+    });
+
+    it("some is empty, and all is not all true => false", () => {
+        const all: ReadonlyArray<Condition> = [con.xEq(6), con.xEq(0)];
+        const some: ReadonlyArray<Condition> = [];
+        const facts: ReadonlyArray<Fact> = [xIs(0)];
+        const rule = createRule(all, some);
+        expect(Rule.solve(rule, facts)).toEqual(false);
+    });
+
+    it("some is false, and all is not all true => false", () => {
+        const all: ReadonlyArray<Condition> = [con.xEq(6), con.xEq(0)];
+        const some: ReadonlyArray<Condition> = [con.xLessThan(-2)];
+        const facts: ReadonlyArray<Fact> = [xIs(0)];
+        const rule = createRule(all, some);
+        expect(Rule.solve(rule, facts)).toEqual(false);
+    });
+    it("If one all-condition is true -> true", () => {
+        const all: ReadonlyArray<Condition> = [con.xEq(0)];
+        const some: ReadonlyArray<Condition> = [];
+        const facts: ReadonlyArray<Fact> = [xIs(0)];
+        const rule = createRule(all, some);
+        expect(Rule.solve(rule, facts)).toBe(true);
+    });
+
+    it("All all-condition is true, and some is empty -> true", () => {
+        const all: ReadonlyArray<Condition> = [con.xEq(0), con.xLessThan(8), con.xGreaterThan(-1)];
+        const some: ReadonlyArray<Condition> = [];
+        const facts: ReadonlyArray<Fact> = [xIs(0)];
+        const rule = createRule(all, some);
+        expect(Rule.solve(rule, facts)).toBe(true);
+    });
+
+    it("All all-condition is true, and none in some is true -> false", () => {
+        const all: ReadonlyArray<Condition> = [con.xEq(0), con.xLessThan(8), con.xGreaterThan(-1), con.yEq(9)];
+        const some: ReadonlyArray<Condition> = [con.yLessThan(9)];
+        const facts: ReadonlyArray<Fact> = [xIs(0), yIs(9)];
+        const rule = createRule(all, some);
+        expect(Rule.solve(rule, facts)).toBe(false);
+    });
+});

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

@@ -0,0 +1,41 @@
+import { Condition } from "../condition";
+import { Fact } from "../fact";
+
+const helloWorldString = "hello-world";
+const eqHelloWorld: Condition.String = {
+    operator: "eq",
+    referenceId: "not-important",
+    value: helloWorldString,
+    kind: "string-condition",
+    referenceLabel: "fact-label",
+    valueLabel: "value-label",
+};
+
+const strFact = (str: string): [Fact.String] => [
+    {
+        kind: "string-fact",
+        value: str,
+        label: "asdf",
+        referenceId: "not-important",
+        referenceLabel: "not-important-label",
+    },
+    // Fact.string('not-important', 'var-label-' + str, str, 'value-label-' + str),
+];
+const notEqHelloWorld: Condition.String = {
+    ...eqHelloWorld,
+    operator: "not-eq",
+};
+
+describe("string-conditions test-suite", () => {
+    // beforeEach(() => {});
+
+    it("string eq works", () => {
+        expect(Condition.evaluate(eqHelloWorld, strFact(helloWorldString))).toBe(true);
+        expect(Condition.evaluate(eqHelloWorld, strFact("not-hello-world"))).toBe(false);
+    });
+
+    it("string not-eq works", () => {
+        expect(Condition.evaluate(eqHelloWorld, strFact("not-hello-world"))).toBe(false);
+        expect(Condition.evaluate(eqHelloWorld, strFact(helloWorldString))).toBe(true);
+    });
+});

package/src/rules/condition.ts

@@ -0,0 +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;
+    };
+}

package/src/rules/fact.ts

@@ -0,0 +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;
+    }
+}

package/src/rules/rule-engine.ts

@@ -0,0 +1,46 @@
+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>;
+}
+
+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,
+                    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

@@ -0,0 +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;
+    };
+}

package/src/services/DMedia-manager.spec.ts

@@ -0,0 +1,27 @@
+import { DMediaManager } from "./DMedia-manager";
+import { EventBus } from "../events/event-bus";
+import { ScaleService } from "../engine/scale";
+import { DCommandBus } from "../commands/DCommandBus";
+import { ResourceProvider } from "./resource-provider";
+
+describe("Media-manager to work", () => {
+    test("Can be instanciated", () => {
+        const host = document.createElement("div");
+        const eventBus = new EventBus();
+        const commandBus = new DCommandBus();
+        const scale = new ScaleService({
+            baseHeight: 1300,
+            baseWidth: 1024,
+            containerHeight: 650,
+            containerWidth: 600,
+        });
+
+        const resourceProvider = new ResourceProvider({
+            videos: [],
+            audio: [],
+        });
+        const mm = new DMediaManager(host, commandBus, eventBus, resourceProvider, scale);
+        // const pageDto: PageDto = {id}
+        expect(host.children.length).toBe(1);
+    });
+});

package/src/services/DMedia-manager.ts

@@ -0,0 +1,182 @@
+import { PageDto } from "../dto/SchemaDto";
+import { VideoContainer } from "../Delement/VideoContainer";
+import { AudioContainer } from "../Delement/AudioContainer";
+import { AutoPlayElement, DAutoPlaySequence } from "../Delement/DAuto-play";
+import { DCommandBus } from "../commands/DCommandBus";
+import { DCommand } from "../commands/DCommand";
+import { DTimestamp } from "../common/DTimestamp";
+import { EventBus } from "../events/event-bus";
+import { ScaleService } from "../engine/scale";
+import { ResourceProvider } from "./resource-provider";
+import { AutoplayTask, SequenceManager } from "./sequence-manager";
+
+export interface IMediaManager {
+    setPage(page: PageDto): void;
+    destroy(): void;
+}
+
+export class DMediaManager implements IMediaManager {
+    private static INSTANCE_COUNT = 0;
+    private readonly instanceNumber: number;
+    private readonly TAG = "[ MEDIA_MANAGER ] : ";
+    private readonly videoContainer: VideoContainer;
+    private readonly audioContainer: AudioContainer;
+    private pageEnter: DTimestamp;
+    private sincePageEnter: DTimestamp.Diff;
+    private currentPage: PageDto | null = null;
+    private readonly unsubscribeCommands: () => void;
+    private readonly tickerRef: number;
+    private readonly sequenceManager: SequenceManager | false = false;
+    constructor(
+        private hostEl: HTMLDivElement,
+        private readonly commandBus: DCommandBus,
+        private readonly eventBus: EventBus,
+        private readonly resourceProvider: ResourceProvider,
+        private readonly scale: ScaleService
+    ) {
+        DMediaManager.INSTANCE_COUNT = DMediaManager.INSTANCE_COUNT + 1;
+        this.instanceNumber = DMediaManager.INSTANCE_COUNT;
+        const videoEl = document.createElement("video");
+        this.hostEl.append(videoEl);
+        this.videoContainer = new VideoContainer(videoEl, eventBus, this.scale);
+        this.audioContainer = new AudioContainer(this.eventBus);
+        this.tick = this.tick.bind(this);
+        this.videoContainer.setStyle({ visibility: "hidden" });
+        const now = DTimestamp.now();
+        this.pageEnter = now;
+        this.sincePageEnter = DTimestamp.diff(now, now);
+        this.unsubscribeCommands = this.commandBus.subscribe((action) => {
+            this.commandHandler(action);
+        }, this.TAG);
+
+        this.tickerRef = window.setInterval(() => {}, 1000);
+    }
+
+    /**
+     * Stop all media that is playing
+     */
+    clearAllMedia() {
+        this.videoContainer.pause();
+        this.audioContainer.pause();
+    }
+    destroy() {
+        console.log("TODO DESTROY ALL MEDIA");
+        this.unsubscribeCommands();
+        // console.log(this.tickerRef);
+        window.clearInterval(this.tickerRef);
+        this.audioContainer.destroy();
+        this.videoContainer.destroy();
+    }
+
+    setPage(page: PageDto) {
+        // TODO STOP VIDEO/AUDIO THAT MIGHT BE PLAYING IN THE DOM??
+        this.currentPage = page;
+        this.videoContainer.pause();
+        this.pageEnter = DTimestamp.now();
+        // TODO THis might be a bug if someone
+
+        const seq = page.autoPlaySequence;
+        // this.sequence = seq ? [...seq.items] : [];
+        const { mainVideoId, audio } = page;
+        const audioElements = page.audio;
+
+        if (mainVideoId) {
+            const dto = this.resourceProvider.getVideoById(mainVideoId);
+            if (dto) {
+                this.videoContainer.setDto(dto);
+                this.videoContainer.setStyle({ ...dto.style, visibility: "visible" });
+            }
+            // this.videoContainer.playToEnd();
+        } else {
+            this.videoContainer.setStyle({ visibility: "hidden" });
+            // HIDE?
+        }
+        if (audioElements) {
+            const first = audioElements[0];
+            if (first) {
+                this.audioContainer.setAudio(first);
+            }
+        }
+        if (seq) {
+            this.playSequence(seq);
+        }
+        // const hasVideo =
+    }
+
+    private commandHandler(command: DCommand) {
+        if (command.kind === "VIDEO_PLAY_COMMAND") {
+            const video = command.targetId;
+            const dto = this.videoContainer.getCurrentDto();
+
+            if (dto && dto.id === command.targetId) {
+                console.log(video);
+                this.videoContainer.play(dto.url);
+            }
+        }
+        if (command.kind === "VIDEO_PAUSE_COMMAND") {
+            this.videoContainer.pause();
+        }
+        if (command.kind === "AUDIO_PLAY_COMMAND") {
+            this.audioContainer
+                .playToEnd()
+                .then(() => {})
+                .catch()
+                .finally(() => {});
+        }
+
+        if (command.kind === "AUDIO_PAUSE_COMMAND") {
+            // this.audioContainer.
+        }
+    }
+
+    private async playSequence(seq: DAutoPlaySequence) {
+        console.log(this.TAG + "SEQUENCE STARTED -- TODO EVENT FOR THIS??");
+        console.log(this.TAG + "SEQUENCE STARTED -- TODO EVENT FOR THIS??");
+        console.log(this.TAG + "SEQUENCE STARTED -- TODO EVENT FOR THIS??");
+        console.log(this.TAG + "SEQUENCE STARTED -- TODO EVENT FOR THIS??");
+
+        const elements = seq.items;
+        const testClone = [...elements];
+        const first = testClone.pop();
+
+        if (!first) {
+            return false;
+        }
+        const now = DTimestamp.now();
+        seq.startCommands.forEach((c) => {
+            console.log(c);
+            this.commandBus.emit(c);
+        });
+        // this.commandBus.emit(DStateProps.mediaBlockedBySequence.setTrueCommand);
+        // if (seq.blockUserInput) {
+        //     this.commandBus.emit(DStateProps.inputBlockingBySequence.getSetTrueCommand());
+        // }
+        for (let i = 0; i < elements.length; i++) {
+            const item = elements[i];
+            if (item.kind === "autoplay-video") {
+                const dto = this.resourceProvider.getVideoById(item.videoId);
+                if (dto) this.videoContainer.setDto(dto);
+                await this.videoContainer.playToEnd();
+            }
+            if (item.kind === "autoplay-audio") {
+                console.log(item);
+                const dto = this.resourceProvider.getAudioById(item.audioId);
+                if (dto) this.audioContainer.setAudio(dto);
+                await this.audioContainer.playToEnd();
+            }
+        }
+        seq.endCommands.forEach((c) => {
+            this.commandBus.emit(c);
+        });
+        // this.actionService.emit(DStateProps.mediaBlockedBySequence.setFalseCommand);
+        // this.actionService.emit(DStateProps.inputBlockingBySequence.setFalseCommand);
+        console.log(this.TAG + "SEQUENCE ENDED");
+        return true;
+    }
+
+    // setPage()
+
+    private tick() {
+        // console.log(this.video1.getStats());
+    }
+}