@media-quest/engine 0.0.1 → 0.0.2

package/src/services/resource-provider.ts

@@ -0,0 +1,33 @@
+import { DAudioDto, DImgDto, DVideoDto } from "../dto/DElement.dto";
+
+export class ResourceProvider {
+    private readonly TAG = "[ RESOURCE_PROVIDER ]: ";
+    private readonly videoMap = new Map<string, DVideoDto>();
+    private readonly audioMap = new Map<string, DAudioDto>();
+    constructor(data: { videos: ReadonlyArray<DVideoDto>; audio: ReadonlyArray<DAudioDto> }) {
+        // console.log(this.TAG + "VIDEO_COUNT " + data.videos.length);
+        // console.log(this.TAG + "AUDIO_COUNT " + data.audio.length);
+        data.videos.forEach((video) => {
+            this.videoMap.set(video.id, video);
+        });
+        data.audio.forEach((audio) => {
+            this.audioMap.set(audio.id, audio);
+        });
+    }
+
+    getAudioById(id: string): DAudioDto | false {
+        const maybeAudio = this.audioMap.get(id);
+        if (!maybeAudio) {
+            console.error(this.TAG + "Audio by id " + id + " dont exist");
+        }
+        return maybeAudio ?? false;
+    }
+
+    getVideoById(id: string): DVideoDto | false {
+        const maybeVideo = this.videoMap.get(id);
+        if (!maybeVideo) {
+            console.error(this.TAG + "Video by id " + id + " dont exist");
+        }
+        return maybeVideo ?? false;
+    }
+}

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

@@ -0,0 +1,168 @@
+import { AudioTask, DelayTask, NoopTask, SequenceManager, VideoTask } from "./sequence-manager";
+import { DTimestamp } from "../common/DTimestamp";
+
+const delayTask = (duration: number): DelayTask => {
+    return { kind: "delay-task", duration };
+};
+const createTimestamps = () => {
+    const t0 = DTimestamp.now();
+    const add = (ms: number) => DTimestamp.addMills(t0, ms);
+    return {
+        t0,
+        t100: add(100),
+        t500: add(500),
+        t600: add(600),
+        t900: add(900),
+        t1000: add(1000),
+        t1020: add(1020),
+        t1100: add(1100),
+        t1200: add(1200),
+        t1500: add(1500),
+        t2000: add(2000),
+        t2100: add(2100),
+        t2500: add(2500),
+        t3000: add(3000),
+        t3001: add(3001),
+        t5000: add(5000),
+        t6000: add(6000),
+        t7000: add(7000),
+        t8000: add(8000),
+        t8500: add(8500),
+        t9000: add(9000),
+        t9500: add(9500),
+    };
+};
+const audioTask = (url: string): AudioTask => {
+    return { kind: "autoplay-audio-task", url, audioId: "id_" + url };
+};
+const videoTask = (url: string): VideoTask => {
+    return { kind: "autoplay-video-task", url, videoId: "id_" + url };
+};
+
+const noopTask: NoopTask = { kind: "noop-task" };
+const delay1000 = delayTask(1000);
+const delay2000 = delayTask(2000);
+const video1 = videoTask("video_1_url");
+const audio1 = audioTask("audio_1_url");
+const sequence1 = [delay1000, video1, delay2000, audio1];
+const manager = (tasks: Array<DelayTask | AudioTask | VideoTask>) => new SequenceManager(tasks);
+describe("Media manager state", () => {
+    test("Empty task array is completed at once:", () => {
+        const m = manager([]);
+        expect(m.isCompleted).toBeTruthy();
+    });
+
+    test("Non empty task-array will be running at creation-time", () => {
+        const m = manager([delayTask(1000), audioTask("url1")]);
+        expect(m.isRunning).toBeTruthy();
+    });
+
+    test("After abort the task", () => {
+        const sm = manager(sequence1);
+        expect(sm.isRunning).toBeTruthy();
+        sm.abort();
+        const nextTask = sm.nextTask(DTimestamp.now());
+        expect(sm.isRunning).toBeFalsy();
+        expect(nextTask).toStrictEqual(noopTask);
+    });
+    test("Fist task will be returned after construction", () => {
+        const sm = manager([video1]);
+        const firstTask = sm.nextTask(DTimestamp.now());
+        expect(firstTask).toStrictEqual(video1);
+        // expect(firstTask).toStrictEqual(noopTask);
+    });
+    test("A task will only be returned once!", () => {
+        const sm = manager([video1, audio1]);
+        const firstTask = sm.nextTask(DTimestamp.now());
+
+        expect(sm.isRunning);
+        expect(firstTask).toStrictEqual(video1);
+        const secondTask = sm.nextTask(DTimestamp.now());
+        expect(secondTask).toStrictEqual(noopTask);
+        expect(sm.isRunning);
+    });
+    test("A delayTask will block other tasks from running.", () => {
+        const t = createTimestamps();
+        const sm = manager([delayTask(1000), video1, audio1]);
+        expect(sm.isRunning);
+        const task0 = sm.nextTask(DTimestamp.now());
+        expect(task0).toStrictEqual(noopTask);
+
+        expect(sm.nextTask(t.t500)).toStrictEqual(noopTask);
+        expect(sm.nextTask(t.t600)).toStrictEqual(noopTask);
+        expect(sm.nextTask(t.t900)).toStrictEqual(noopTask);
+
+        // AFTER DELAY
+        expect(sm.nextTask(t.t1020)).toStrictEqual(video1);
+        expect(sm.nextTask(t.t5000)).toStrictEqual(noopTask);
+    });
+    test("A video-task can ble completed.", () => {
+        const t = createTimestamps();
+        const sm = manager([video1, audio1]);
+        expect(sm.isRunning);
+        expect(sm.nextTask(t.t100)).toStrictEqual(video1);
+        expect(sm.nextTask(t.t500)).toStrictEqual(noopTask);
+        expect(sm.nextTask(t.t2100)).toStrictEqual(noopTask);
+        sm.videoCompleted({ videoId: video1.videoId, url: video1.url });
+        const after = sm.nextTask(t.t3001);
+        expect(after).toStrictEqual(audio1);
+    });
+    test("Many delays can be placed and block on every step.", () => {
+        const t = createTimestamps();
+        const sm = manager([delayTask(1000), video1, delay2000, audio1]);
+        expect(sm.isRunning);
+
+        // FIRST DELAY.
+        expect(sm.nextTask(t.t100)).toStrictEqual(noopTask);
+        expect(sm.nextTask(t.t600)).toStrictEqual(noopTask);
+        expect(sm.nextTask(t.t900)).toStrictEqual(noopTask);
+        expect(sm.nextTask(t.t1020)).toStrictEqual(video1);
+        expect(sm.nextTask(t.t1100)).toStrictEqual(noopTask);
+        expect(sm.nextTask(t.t1500)).toStrictEqual(noopTask);
+
+        // DELAY 2 -> start at approximately 1500
+        sm.videoCompleted({ videoId: video1.videoId, url: video1.url });
+        expect(sm.nextTask(t.t2100)).toStrictEqual(noopTask);
+        expect(sm.nextTask(t.t3000)).toStrictEqual(noopTask);
+        expect(sm.nextTask(t.t5000)).toStrictEqual(audio1);
+        expect(sm.nextTask(t.t6000)).toStrictEqual(noopTask);
+        expect(sm.nextTask(t.t7000)).toStrictEqual(noopTask);
+        expect(sm.isCompleted).toStrictEqual(false);
+        sm.audioCompleted({ audioId: audio1.audioId, url: audio1.url });
+        expect(sm.isCompleted).toStrictEqual(true);
+    });
+    test("Can complete audio", () => {
+        const t = createTimestamps();
+        const sm = manager([audio1]);
+        expect(sm.isRunning);
+        // FIRST DELAY.
+        expect(sm.nextTask(t.t100)).toStrictEqual(audio1);
+        expect(sm.nextTask(t.t500)).toStrictEqual(noopTask);
+        expect(sm.nextTask(t.t600)).toStrictEqual(noopTask);
+        expect(sm.isCompleted).toStrictEqual(false);
+        sm.audioCompleted({ audioId: audio1.audioId, url: audio1.url });
+        expect(sm.isCompleted).toStrictEqual(true);
+    });
+    test("Can only complete audio with correct url.", () => {
+        const t = createTimestamps();
+        const sm = manager([audio1]);
+        expect(sm.isRunning);
+        // FIRST DELAY.
+        const first = sm.nextTask(t.t100);
+        expect(first).toStrictEqual(audio1);
+        expect(sm.isCompleted).toStrictEqual(false);
+        sm.audioCompleted({ audioId: "bullshit", url: "bullshit" });
+        expect(sm.isCompleted).toStrictEqual(false);
+    });
+    test("Can only complete video with correct url.", () => {
+        const t = createTimestamps();
+        const sm = manager([video1]);
+        expect(sm.isRunning);
+        // FIRST DELAY.
+        const first = sm.nextTask(t.t100);
+        expect(first).toStrictEqual(video1);
+        expect(sm.isCompleted).toStrictEqual(false);
+        sm.videoCompleted({ videoId: "bullshit", url: "bullshit" });
+        expect(sm.isCompleted).toStrictEqual(false);
+    });
+});

package/src/services/sequence-manager.ts

@@ -0,0 +1,132 @@
+import { DTimestamp } from "../common/DTimestamp";
+
+export interface DelayTask {
+    readonly kind: "delay-task";
+    readonly duration: number;
+}
+
+export interface NoopTask {
+    readonly kind: "noop-task";
+}
+
+export interface AudioTask {
+    readonly kind: "autoplay-audio-task";
+    readonly url: string;
+    readonly audioId: string;
+}
+
+export interface VideoTask {
+    readonly kind: "autoplay-video-task";
+    readonly url: string;
+    readonly videoId: string;
+}
+
+export type AutoplayTask = VideoTask | AudioTask | DelayTask;
+type TaskHistory = {
+    readonly startedAt: DTimestamp;
+    readonly completedAt: DTimestamp;
+    readonly task: AutoplayTask;
+};
+class SequenceHistory {
+    private taskHistory: Array<TaskHistory> = [];
+    constructor(private readonly startedAt: DTimestamp) {}
+
+    add(task: TaskHistory) {
+        this.taskHistory.push(task);
+    }
+}
+export class SequenceManager {
+    private runningTask: { task: AutoplayTask; startedAt: DTimestamp } | false;
+    private taskList: Array<DelayTask | AudioTask | VideoTask>;
+    private readonly t0: DTimestamp;
+    private readonly history: SequenceHistory;
+
+    constructor(private readonly tasks: ReadonlyArray<AudioTask | DelayTask | VideoTask>) {
+        this.t0 = DTimestamp.now();
+        const [first, ...rest] = tasks;
+        if (first && first.kind === "delay-task") {
+            this.runningTask = { task: first, startedAt: this.t0 };
+            this.taskList = [...rest];
+        } else {
+            this.runningTask = false;
+            this.taskList = [...tasks];
+        }
+        this.history = new SequenceHistory(this.t0);
+    }
+
+    audioCompleted(audio: { audioId: string; url: string }) {
+        const curr = this.runningTask;
+        if (curr && curr.task.kind === "autoplay-audio-task") {
+            const { audioId, url } = curr.task;
+            if (url === audio.url) {
+                this.runningTask = false;
+            } else {
+                // WARN ABOUT UNEXPECTED AUDIO ID && URL ??
+                console.warn("Unexpected audio completed url.");
+            }
+        }
+    }
+
+    videoCompleted(video: { videoId: string; url: string }) {
+        const curr = this.runningTask;
+        if (curr && curr.task.kind === "autoplay-video-task") {
+            const { url } = curr.task;
+            if (url === video.url) {
+                this.runningTask = false;
+            } else {
+                // WARN ABOUT UNEXPECTED AUDIO ID && URL ??
+                console.warn("Unexpected video completed url.");
+            }
+        }
+    }
+
+    abort() {
+        this.taskList = [];
+        this.runningTask = false;
+    }
+    get isCompleted() {
+        return !this.isRunning;
+    }
+    get isRunning() {
+        return this.runningTask || this.taskList.length;
+    }
+
+    nextTask(now: DTimestamp): NoopTask | AudioTask | VideoTask {
+        const curr = this.runningTask;
+
+        if (curr && curr.task.kind === "delay-task") {
+            const progress = DTimestamp.diff(curr.startedAt, now);
+            // DELAY COMPLETED.
+            if (progress >= curr.task.duration) {
+                this.runningTask = false;
+            }
+        }
+
+        // RETURN IF A TASK IS RUNNING.
+        if (this.runningTask) {
+            return { kind: "noop-task" };
+        }
+
+        const first = this.taskList.shift();
+        if (!first) {
+            return { kind: "noop-task" };
+        }
+
+        if (first.kind === "delay-task") {
+            this.runningTask = { task: first, startedAt: now };
+            return { kind: "noop-task" };
+        }
+
+        if (first.kind === "autoplay-video-task") {
+            this.runningTask = { task: first, startedAt: now };
+            return first;
+        }
+
+        if (first.kind === "autoplay-audio-task") {
+            this.runningTask = { task: first, startedAt: now };
+            return first;
+        }
+
+        return { kind: "noop-task" };
+    }
+}

package/src/state/Dstate.spec.ts

@@ -0,0 +1,7 @@
+import { DState } from "./Dstate";
+
+describe("Prop-utils work", () => {
+    it("isMutation works", () => {
+        expect(DState.isStringMutation({ propName: "", value: 2, kind: "set-number" })).toBe(false);
+    });
+});

package/src/state/Dstate.ts

@@ -0,0 +1,105 @@
+import { Fact } from "../rules/fact";
+import { Condition } from "../rules/condition";
+import { DEvent } from "../events/DEvents";
+import { StateCommand } from "../commands/DCommand";
+
+export namespace DState {
+    interface PropDefinition<TypeName, Type extends string | number> {
+        readonly _type: TypeName;
+        readonly propName: string;
+        readonly propDescription: string;
+        readonly initialValue?: Type;
+        readonly options?: ReadonlyArray<PropValue<Type>>;
+    }
+
+    export type NumericProp = PropDefinition<"number", number>;
+    export type StringProp = PropDefinition<"string", string>;
+
+    export interface fromEventHandler {
+        readonly onEvent: DEvent["kind"];
+        readonly thenExecute: ReadonlyArray<StateCommand>;
+    }
+
+    export interface PropValue<T> {
+        readonly value: T;
+        readonly valueLabel: string;
+    }
+    export type Prop = NumericProp | StringProp;
+
+    export interface SetStringMutation {
+        readonly kind: "set-string";
+        readonly propName: string;
+        readonly value: string;
+    }
+
+    export interface IncrementNumberMutation {
+        readonly kind: "increment-number";
+        readonly propName: string;
+        readonly stepSize: number;
+        readonly ifNotExistThenSetTo: number;
+    }
+    export interface DecrementNumberMutation {
+        readonly kind: "decrement-number";
+        readonly propName: string;
+        readonly stepSize: number;
+        readonly ifNotExistThenSetTo: number;
+    }
+
+    export interface SetNumberMutation {
+        readonly kind: "set-number";
+        readonly propName: string;
+        readonly value: number;
+    }
+    export type NumberMutations = IncrementNumberMutation | DecrementNumberMutation | SetNumberMutation;
+
+    export type StateMutation = SetStringMutation | NumberMutations;
+
+    export const isNumberMutation = (mutations: StateMutation): mutations is NumberMutations => {
+        if (!mutations) {
+            return false;
+        }
+
+        return (
+            mutations.kind === "set-number" ||
+            mutations.kind === "decrement-number" ||
+            mutations.kind === "increment-number"
+        );
+    };
+
+    export const isStringMutation = (mutation: StateMutation): mutation is SetStringMutation => {
+        return mutation && mutation.kind === "set-string";
+    };
+
+    export interface StateQuery {
+        readonly name: string;
+        readonly condition: Condition;
+    }
+
+    export interface StateQueryResult {
+        readonly queryName: string;
+        readonly prev: boolean;
+        readonly curr: boolean;
+    }
+
+    export const numericPropToFact = (prop: NumericProp, value: number) => {
+        const fact: Fact.Numeric = {
+            kind: "numeric-fact",
+            referenceId: prop.propName,
+            referenceLabel: prop.propDescription ?? " [STATE_PROPERTY] : " + prop.propName,
+            value,
+            label: " [VALUE] : " + value,
+        };
+        return fact;
+    };
+
+    export const stringPropToFact = (prop: StringProp, value: string) => {
+        const fact: Fact.String = {
+            kind: "string-fact",
+            referenceId: prop.propName,
+            referenceLabel: " [STATE_PROPERTY] : " + prop.propName,
+            value,
+            label: " [VALUE] : " + value,
+        };
+        return fact;
+    };
+}

package/src/state/boolean-property.ts

@@ -0,0 +1,69 @@
+import { DState } from "./Dstate";
+import { Condition } from "../rules/condition";
+import { StateCommand } from "../commands/DCommand";
+
+export class BooleanStateProperty<PropName extends string> {
+    readonly propName: PropName;
+    private static readonly TRUE = { value: 1, label: "TRUE" };
+    private static readonly FALSE = { value: 0, label: "FALSE" };
+    readonly propDefinition: DState.NumericProp;
+
+    getIsTrueCondition(): Condition.Numeric {
+        return {
+            kind: "numeric-condition",
+            referenceId: this.propName,
+            referenceLabel: this.propName + "[ BOOLEAN ]",
+            valueLabel: BooleanStateProperty.TRUE.label,
+            value: BooleanStateProperty.TRUE.value,
+            operator: "eq",
+        };
+    }
+    getIsFalseCondition(): Condition.Numeric {
+        return {
+            kind: "numeric-condition",
+            referenceId: this.propName,
+            referenceLabel: this.propName + "[ BOOLEAN ]",
+            valueLabel: BooleanStateProperty.FALSE.label,
+            value: BooleanStateProperty.FALSE.value,
+            operator: "eq",
+        };
+    }
+
+    getSetTrueCommand(): StateCommand {
+        return {
+            kind: "STATE_MUTATE_COMMAND",
+            target: "STATE",
+            targetId: "STATE",
+            payload: {
+                mutation: { propName: this.propName, kind: "set-number", value: 1 },
+            },
+        };
+    }
+
+    getSetFalseCommand(): StateCommand {
+        return {
+            kind: "STATE_MUTATE_COMMAND",
+            target: "STATE",
+            targetId: "STATE",
+            payload: {
+                mutation: { propName: this.propName, kind: "set-number", value: 0 },
+            },
+        };
+    }
+
+    constructor(propName: PropName, private readonly initialValue: boolean, description: string) {
+        this.propName = propName;
+        const initial = initialValue ? 1 : 0;
+        const propDescription = description ? description : "No description given";
+        this.propDefinition = {
+            propDescription,
+            propName: propName,
+            initialValue: initial,
+            options: [
+                { value: BooleanStateProperty.FALSE.value, valueLabel: BooleanStateProperty.FALSE.label },
+                { value: BooleanStateProperty.TRUE.value, valueLabel: BooleanStateProperty.TRUE.label },
+            ],
+            _type: "number",
+        };
+    }
+}