@media-quest/engine 0.0.1 → 0.0.3

package/src/events/DEvents.ts

@@ -0,0 +1,94 @@
+import { DTimestamp } from "../common/DTimestamp";
+import { AnsweredQuestion } from "../player/history-que";
+import { DState } from "../state/Dstate";
+
+type EventProducer =
+    | "DVideo"
+    | "DUser"
+    | "DAudio"
+    | "DImage"
+    | "MediaManager"
+    | "DPage"
+    | "Window"
+    | "HOST"
+    | "RuleEngine"
+    | "Engine"
+    | "STATE-SERVICE";
+
+interface Ev<K extends EventKind, P extends EventProducer, T> {
+    readonly kind: K;
+    readonly timestamp: DTimestamp;
+    readonly producer: P;
+    readonly producerId: string;
+    readonly data: T;
+}
+
+type EventKind = `${Uppercase<string>}_EVENT`;
+
+export type QueryChangedEvent = Ev<"STATE_QUERY_RESULT_CHANGED_EVENT", "STATE-SERVICE", DState.StateQueryResult>;
+
+export type AudioPlayEvent = Ev<"AUDIO_PLAY_EVENT", "DAudio", {}>;
+// export type AudioWillPlayEvent = Ev<"AUDIO_WILL_PLAY_EVENT", "DAudio", {}>;
+
+export type DAudioEvent =
+    | AudioPlayEvent
+    // | AudioWillPlayEvent
+    | Ev<"AUDIO_PAUSED_EVENT", "DAudio", {}>
+    | Ev<"AUDIO_ENDED_EVENT", "DAudio", { url: string }>
+    | Ev<"AUDIO_ERROR_EVENT", "DAudio", { error: unknown }>
+    | Ev<"AUDIO_METADATA_LOADED_EVENT", "DAudio", {}>
+    | Ev<"AUDIO_LOAD_EVENT", "DAudio", {}>
+    | Ev<"AUDIO_CAN_PLAY_THROUGH_EVENT", "DAudio", {}>
+    | Ev<"AUDIO_DURATION_CHANGE_EVENT", "DAudio", { duration: number; isInfinity: boolean }>
+    | Ev<"AUDIO_PROGRESS_EVENT", "DAudio", {}>;
+
+export type DVideoEvent =
+    | Ev<"VIDEO_PLAY_EVENT", "DVideo", {}>
+    | Ev<"VIDEO_PAUSED_EVENT", "DVideo", {}>
+    | Ev<"VIDEO_ERROR_EVENT", "DVideo", { error: unknown }>
+    | Ev<"VIDEO_EVENT", "DVideo", { error: unknown }>
+    | Ev<"VIDEO_LOADED_METADATA_EVENT", "DVideo", { duration: number; isInfinity: boolean }>
+    | Ev<"VIDEO_DURATION_CHANGE_EVENT", "DVideo", { duration: number; isInfinity: boolean }>
+    | Ev<"VIDEO_PROGRESS_EVENT", "DVideo", { duration: number; progress: number }>
+    | Ev<"VIDEO_ENDED_EVENT", "DVideo", {}>;
+
+// export type MediaManagerEvent =
+//     | Ev<"MEDIA_B
+//
+//
+//     LOCKING_START_EVENT", "MediaManager", {}>
+//     | Ev<"MEDIA_BLOCKING_END_EVENT", "MediaManager", {}>
+//     | Ev<"INPUT_BLOCKING_MEDIA_START_EVENT", "MediaManager", {}>
+//     | Ev<"INPUT_BLOCKING_MEDIA_END_EVENT", "MediaManager", {}>;
+
+export type DImageEvent =
+    | Ev<
+          "IMAGE_LOADED_EVENT",
+          "DImage",
+          { naturalHeight: number; naturalWidth: number; loadTime: DTimestamp.Diff; height: number; width: number }
+      >
+    | Ev<"IMAGE_ERROR_EVENT", "DImage", { error: unknown }>;
+export type DPageEvents =
+    | Ev<"PAGE_ENTER_EVENT", "DPage", { pageId: string }>
+    | Ev<"PAGE_COMPLETED_EVENT", "DPage", { pageId: string; answers: AnsweredQuestion[] }>;
+
+export type DWindowEvents =
+    | Ev<"WINDOW_VISIBILITY_CHANGE_EVENT", "Window", {}>
+    | Ev<"WINDOW_ONLINE_STATUS_CHANGE_EVENT", "Window", {}>;
+
+export type DEvent =
+    | DImageEvent
+    | DAudioEvent
+    | DVideoEvent
+    | DPageEvents
+    // | MediaManagerEvent
+    | DWindowEvents
+    | QueryChangedEvent
+    | Ev<"USER_CLICKED_EVENT", "DUser", { elementId: string }>
+    | Ev<"RULE_MATCH_EVENT", "Window", { ruleId: string }>
+    | Ev<
+          "ENGINE_SCHEMA_LOADED_EVENT",
+          "Engine",
+          { pageCount: number; hostHeight: number; hostWidth: number; scale: number }
+      >
+    | Ev<"HOST_SCALE_CHANGED_EVENT", "HOST", { scale: number }>;

package/src/events/event-bus.spec.ts

@@ -0,0 +1,21 @@
+import { EventBus } from "./event-bus";
+import { DTimestamp } from "../common/DTimestamp";
+describe("Event-bus-works", () => {
+    test("Can create event-bus", (done) => {
+        const bus = new EventBus();
+
+        bus.consoleLogEvents = false;
+        bus.subscribe((ev) => {
+            expect(ev.kind === "AUDIO_PLAY_EVENT").toBe(true);
+            done();
+        }, "TEST. CAN CREATE EVENTBUS");
+
+        bus.emit({
+            kind: "AUDIO_PLAY_EVENT",
+            timestamp: DTimestamp.now(),
+            data: {},
+            producerId: "",
+            producer: "DAudio",
+        });
+    });
+});

package/src/events/event-bus.ts

@@ -0,0 +1,81 @@
+import { DEvent } from "./DEvents";
+
+interface SubscriberData {
+    readonly subscriberId: string;
+    readonly cb: (event: DEvent) => void;
+}
+
+export interface DEventStore {
+    subscribe(cb: (event: DEvent) => void, subscriberId: string): void;
+}
+
+export interface DEventDispatcher {
+    emit(event: DEvent): void;
+}
+export class EventBus implements DEventStore, DEventDispatcher {
+    private readonly TAG = "[  EVENT_BUS  ] :";
+    // private readonly subscribers = new Set<(event: DEvent) => void>();
+    private readonly subscribers = new Set<SubscriberData>();
+
+    /**
+     * Emit on module end.
+     * @private
+     */
+    private readonly eventLog: DEvent[] = [];
+    consoleLogEvents = false;
+    // readonly sub
+
+    subscribe(cb: (event: DEvent) => void, subscriberId: string) {
+        // this.subscribers.add(cb);
+        const subscriberData: SubscriberData = {
+            subscriberId,
+            cb,
+        };
+        this.subscribers.add(subscriberData);
+        if (this.consoleLogEvents) {
+            console.log(this.TAG + "subscription added: " + subscriberId);
+            console.log(this.TAG + "subscription count: " + this.subscribers.size);
+        }
+        return () => {
+            if (this.consoleLogEvents) {
+                console.log(this.TAG + "subscription removed: " + subscriberId);
+                console.log(this.TAG + "subscription count  : " + this.subscribers.size);
+            }
+            // this.subscribers.delete(cb);
+            this.subscribers.delete(subscriberData);
+        };
+    }
+
+    getStats() {
+        return {
+            subscribersCount: this.subscribers.size,
+            eventLog: [...this.eventLog],
+            subscribers: [...this.subscribers],
+        };
+    }
+
+    emit(event: DEvent) {
+        if (this.consoleLogEvents) {
+            this.logEvent(event);
+        }
+        this.eventLog.push(event);
+        this.subscribers.forEach((data) => {
+            // console.log('CALLING EMIT');
+            data.cb(event);
+        });
+        // this.logEvents();
+    }
+
+    private logEvent(event: DEvent) {
+        console.groupCollapsed(this.TAG + " " + event.kind);
+        console.log("ProducerId: " + event.producerId);
+        console.log(event.data);
+        console.groupEnd();
+    }
+
+    private logEvents() {
+        console.group(this.TAG + "LOGG");
+        console.table(this.eventLog);
+        console.groupEnd();
+    }
+}

package/src/kladd/context-menu-manager.ts

@@ -0,0 +1,56 @@
+// @ts-ignore
+class ContextMenuManager {
+  private static ROOT = document.createElement("div");
+  public static hasMenu = false;
+  private hasMenu = false;
+
+  createMenu() {
+    const root = document.createElement("div");
+    const menu = document.createElement("div");
+    const backDrop = document.createElement("div");
+    backDrop.style.position = "fixed";
+    backDrop.style.height = "100vh";
+    backDrop.style.width = "100vw";
+    backDrop.style.backgroundColor = "rgba(255, 0, 0, 0.25)";
+    backDrop.style.top = "0";
+    backDrop.style.right = "0";
+    backDrop.style.zIndex = "1000";
+    // backDrop.style.opacity = '0.5';
+
+    menu.style.height = "50%";
+    menu.style.width = "50%";
+    menu.style.top = "10%";
+    menu.style.right = "25%";
+    menu.style.backgroundColor = "green";
+    menu.style.position = "absolute";
+    menu.style.zIndex = "1001";
+    menu.contentEditable = "false";
+    const createOption = (text: string) => {
+      const p = document.createElement("p");
+      p.textContent = text;
+      return p;
+    };
+
+    const options = ["Select On-Click Actions", "Select On-Hover Actions"].map(
+      createOption
+    );
+    options.forEach((op) => {
+      menu.appendChild(op);
+    });
+    root.appendChild(backDrop);
+    root.appendChild(menu);
+    document.body.appendChild(root);
+    this.hasMenu = true;
+    backDrop.onclick = (ev: MouseEvent) => {
+      console.log("BACKDROP CLICKED");
+      console.log(ev.type);
+      root.removeChild(backDrop);
+      root.removeChild(menu);
+      this.hasMenu = false;
+    };
+
+    menu.onclick = (_: MouseEvent) => {
+      console.log("NODE CLICKED");
+    };
+  }
+}

package/src/player/dplayer.spec.ts

@@ -0,0 +1,108 @@
+import { DPlayer, DPlayerData } from "./dplayer";
+import { PageDto, PageSequenceDto } from "../dto/SchemaDto";
+import { Rule } from "../rules/rule";
+import { PageHistory } from "./history-que";
+import { DTimestamp } from "../common/DTimestamp";
+import { PageQueCommand } from "../commands/DCommand";
+
+const page = (id: number): PageDto => {
+    return { id: "" + id, elements: [] };
+};
+const p1 = page(1);
+const p2 = page(2);
+const p3 = page(3);
+const p4 = page(4);
+const p5 = page(5);
+const p6 = page(6);
+const all = [p1, p2, p3, p4, p5, p6];
+const Seq1 = {
+    p10: page(10),
+    p11: page(11),
+    p12: page(12),
+};
+
+const seq1: PageSequenceDto = {
+    id: "s1",
+    pages: [Seq1.p10, Seq1.p11, Seq1.p12],
+    rules: [],
+};
+const data = (
+    pages: PageDto[],
+    pageSequences: PageSequenceDto[] = [],
+    rules: Rule<PageQueCommand, never>[] = []
+): DPlayerData => ({ pages, pageSequences, rules });
+// const seq = (pages: PageDto[], rules: Rule[]) => {};
+beforeEach(() => {
+    // data = { pages: [], rules: [], pageSequences: [] };
+});
+
+describe("DPlayer", () => {
+    it("should create an instance", () => {
+        const player = new DPlayer(data([p1, p1]));
+        expect(player).toBeTruthy();
+    });
+
+    it("can app pages, and get next", () => {
+        const player = new DPlayer(data([p1, p2]));
+
+        expect(player.getNextPage()).toBe(p1);
+        expect(player.getNextPage()).toBe(p2);
+        expect(player.getNextPage()).toBe(false);
+    });
+
+    it("Can insert a sequence", () => {
+        const player = new DPlayer(data(all, [seq1]));
+
+        expect(player.getNextPage()).toBe(p1);
+        expect(player.getNextPage()).toBe(p2);
+        player.handleNavigationCommand({
+            kind: "PAGE_QUE_GO_TO_SEQUENCE_COMMAND",
+            target: "PAGE_QUE",
+            targetId: "PAGE_QUE",
+            payload: {
+                sequenceId: seq1.id,
+            },
+        });
+        expect(player.getNextPage()).toBe(Seq1.p10);
+        expect(player.getNextPage()).toBe(Seq1.p11);
+        expect(player.getNextPage()).toBe(Seq1.p12);
+        expect(player.getNextPage()).toBe(p3);
+    });
+
+    it("Can jump forward to a pageId", () => {
+        const player = new DPlayer(data(all));
+
+        expect(player.getNextPage()).toBe(p1);
+        player.handleNavigationCommand({
+            kind: "PAGE_QUE_GO_TO_PAGE_COMMAND",
+            target: "PAGE_QUE",
+            targetId: "PAGE_QUE",
+            payload: { pageId: p4.id },
+        });
+        expect(player.getNextPage()).toBe(p4);
+    });
+
+    it("Save history", () => {
+        const player = new DPlayer(data(all));
+        const curr = player.getNextPage() as PageDto;
+
+        const history: PageHistory = {
+            pageId: curr.id,
+            answeredQuestions: [
+                {
+                    timestamp: DTimestamp.now(),
+                    fact: {
+                        referenceId: "as",
+                        referenceLabel: "as-label",
+                        kind: "numeric-fact",
+                        label: "litt",
+                        value: 2,
+                    },
+                },
+            ],
+        };
+        player.saveHistory(history);
+        expect(player.getNextPage()).toBe(p2);
+        expect(player.getResults().length).toBe(1);
+    });
+});

package/src/player/dplayer.ts

@@ -0,0 +1,70 @@
+import { AnsweredQuestion, HistoryQue, PageHistory } from "./history-que";
+import { RuleEngine } from "../rules/rule-engine";
+import { NextQue } from "./next-que";
+import { PageDto, SchemaDto } from "../dto/SchemaDto";
+import { NavigationCommand, PageQueCommand } from "../commands/DCommand";
+import { DUtil } from "../utils/DUtil";
+
+export type DPlayerData = Pick<SchemaDto, "pages" | "pageSequences" | "rules">;
+export class DPlayer {
+    private history = new HistoryQue();
+    private ruleEngine = new RuleEngine<PageQueCommand, PageQueCommand>();
+    private nextQue = new NextQue();
+    private data: DPlayerData;
+
+    constructor(data: DPlayerData) {
+        this.data = data;
+        this.nextQue.resetQue(data.pages);
+    }
+
+    saveHistory(pageHistory: PageHistory) {
+        this.history.addToHistory(pageHistory);
+    }
+
+    getResults(): AnsweredQuestion[] {
+        return this.history.getAnswers();
+    }
+
+    private goToPageById(pageId: string) {
+        this.nextQue.jumpToPageById(pageId);
+    }
+
+    handleNavigationCommand(command: NavigationCommand) {
+        switch (command.kind) {
+            case "PAGE_QUE_NEXT_PAGE_COMMAND":
+                // NO NEED TO DO ANYTHING
+                break;
+            case "PAGE_QUE_GO_TO_PAGE_COMMAND":
+                this.goToPageById(command.payload.pageId);
+                break;
+            case "PAGE_QUE_GO_TO_SEQUENCE_COMMAND":
+                this.insertSequenceById(command.payload.sequenceId);
+                break;
+
+            default:
+                DUtil.neverCheck(command);
+        }
+    }
+
+    getNextPage(): PageDto | false {
+        // TODO HANDLE RULES!!
+        return this.nextQue.pop();
+    }
+
+    private insertSequenceById(id: string) {
+        const seq = this.data.pageSequences?.find((s) => s.id === id);
+        if (seq) {
+            this.nextQue.insertAsNextByForce([...seq.pages]);
+        } else {
+            // HOW TO HANDLE INVALID ID_REFS?? LOGGER??
+            // LOG INVALID COMMAND.
+        }
+    }
+
+    /**
+     * Total number of pages.
+     */
+    get pageCount(): number {
+        return this.nextQue.pageCount;
+    }
+}

package/src/player/history-que.spec.ts

@@ -0,0 +1,45 @@
+import { AnsweredQuestion, HistoryQue, PageHistory } from "./history-que";
+import { DTimestamp } from "../common/DTimestamp";
+import { PageDto } from "../dto/SchemaDto";
+
+const p = (id: number): PageDto => {
+    return { id: "" + id, elements: [] };
+};
+
+const answer = (id: number, value: number): AnsweredQuestion => ({
+    timestamp: DTimestamp.now(),
+    fact: {
+        referenceId: "" + id,
+        referenceLabel: "label-for-" + id,
+        value,
+        label: "value-label " + value,
+        kind: "numeric-fact",
+    },
+});
+const h = (page: PageDto, answeredQuestions: AnsweredQuestion[]): PageHistory => ({
+    pageId: page.id,
+    answeredQuestions,
+});
+const p1 = p(1);
+const p2 = p(2);
+const p3 = p(3);
+const p4 = p(4);
+const p5 = p(5);
+const p6 = p(6);
+const all = [p1, p2, p3, p4, p5, p6];
+
+let history = new HistoryQue();
+beforeEach(() => {
+    history = new HistoryQue();
+});
+
+describe("HistoryQue", () => {
+    it("should create an instance", () => {
+        expect(history).toBeTruthy();
+    });
+
+    it("Can add history, and get facts back", () => {
+        history.addToHistory(h(p1, [answer(1, 2)]));
+        expect(history.getFacts().length).toBe(1);
+    });
+});

package/src/player/history-que.ts

@@ -0,0 +1,38 @@
+import { Fact } from "../rules/fact";
+import { DTimestamp } from "../common/DTimestamp";
+
+export interface AnsweredQuestion {
+    readonly timestamp: DTimestamp;
+    readonly fact: Fact;
+}
+
+export namespace AnsweredQuestion {
+    export const eq = (a: AnsweredQuestion, b: AnsweredQuestion): boolean => {
+        return a.fact === b.fact;
+    };
+}
+
+export interface PageHistory {
+    readonly pageId: string;
+    readonly answeredQuestions: AnsweredQuestion[];
+}
+
+export class HistoryQue {
+    private history: PageHistory[] = [];
+
+    getFacts(): Array<Fact> {
+        const answers = this.history.map((h) => h.answeredQuestions).flat(1);
+        const facts = answers.map((a) => a.fact);
+        // TODO FIND LATEST FACT (answer) if have multiple.
+        return facts;
+    }
+
+    getAnswers(): Array<AnsweredQuestion> {
+        const answers = this.history.map((h) => h.answeredQuestions).flat(1);
+        return answers;
+    }
+
+    addToHistory(page: PageHistory) {
+        this.history.push(page);
+    }
+}

package/src/player/next-que.spec.ts

@@ -0,0 +1,108 @@
+import { NextQue } from "./next-que";
+import { PageDto } from "../dto/SchemaDto";
+
+const tag1 = "tag1";
+const tag2 = "tag2";
+const tag3 = "tag3";
+
+let que = new NextQue();
+const createPage = () => {};
+const p1: PageDto = { id: "1", elements: [], tags: [tag1] };
+const p2: PageDto = { id: "2", elements: [], tags: [] };
+const p3: PageDto = { id: "3", elements: [], tags: [tag2] };
+const p4: PageDto = { id: "4", elements: [], tags: [] };
+const p5: PageDto = { id: "5", elements: [], tags: [tag3, tag2] };
+const p6: PageDto = { id: "6", elements: [], tags: [tag3] };
+const all = [p1, p2, p3, p4, p5, p6];
+
+beforeEach(() => {
+    que = new NextQue();
+});
+
+describe("NextQue testing", () => {
+    it("Can pop", () => {
+        que.resetQue(all);
+        expect(que.pop()).toBe(p1);
+        expect(que.pop()).toBe(p2);
+        expect(que.size).toBe(all.length - 2);
+    });
+
+    it("Can remove by tag", () => {
+        que.resetQue(all);
+        expect(que.size).toBe(6);
+        que.removeByTag(tag3);
+        expect(que.size).toBe(4);
+        expect(que.peek()).toBe(p1);
+        que.pop();
+        expect(que.peek()).toBe(p2);
+        expect(que.size).toBe(3);
+    });
+
+    it("Can remove by tags[]", () => {
+        que.resetQue(all);
+        que.removeByTag([tag3, tag2, tag1]);
+        expect(que.size).toBe(2);
+    });
+
+    it("Can remove by pageIds[]", () => {
+        que.resetQue(all);
+        que.removeByPageId([p1.id, p2.id, p3.id]);
+        expect(que.pop()).toBe(p4);
+        expect(que.size).toBe(2);
+    });
+
+    it("Can remove by pageId", () => {
+        que.resetQue(all);
+        que.removeByPageId(p1.id);
+        expect(que.peek()).toBe(p2);
+        que.pop();
+        expect(que.peek()).toBe(p3);
+        expect(que.size).toBe(4);
+        que.removeByPageId(p3.id);
+        expect(que.size).toBe(3);
+    });
+
+    it("Can set pages in constuctor", () => {
+        que = new NextQue(all);
+        expect(que.size).toBe(all.length);
+    });
+
+    it("Can set pages in constuctor", () => {
+        que = new NextQue(all);
+        expect(que.size).toBe(all.length);
+    });
+
+    it("Can reset que to start over.", () => {
+        que = new NextQue(all);
+        expect(que.size).toBe(all.length);
+    });
+
+    it("Can insert new pages in the middle of the test.", () => {
+        que = new NextQue(all);
+        que.pop();
+        que.pop();
+        que.pop();
+        expect(que.peek()).toBe(p4);
+        que.insertAsNextByForce([p1, p2]);
+        expect(que.peek()).toBe(p1);
+        expect(que.size).toBe(5);
+        expect(que.pop()).toBe(p1);
+        expect(que.pop()).toBe(p2);
+        expect(que.pop()).toBe(p4);
+    });
+
+    it("Can jump to page by id", () => {
+        que = new NextQue(all);
+        que.pop();
+        que.jumpToPageById(p5.id);
+        // expect(que.size).toBe(5);
+        expect(que.peek()).toBe(p5);
+        que.jumpToPageById("noncence");
+        expect(que.peek()).toBe(p5);
+        // CAn not jump back
+        que.jumpToPageById(p2.id);
+        expect(que.peek()).toBe(p5);
+        que.jumpToPageById(p6.id);
+        expect(que.peek()).toBe(p6);
+    });
+});