@media-quest/engine 0.0.6 → 0.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@media-quest/engine",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "Rendering engine for media-quest schemas.",
   "main": "dist/public-api.js",
   "module": "dist/public-api.mjs",
@@ -10,6 +10,6 @@
     "clean": "rimraf dist",
     "build": "npm run clean && tsup src/public-api.ts --sourcemap inline --format cjs,esm --dts",
     "prepublishOnly": "npm run build",
-    "tsc:check": "tsc --watch --noEmit"
+    "tsc:check:engine": "tsc --watch --noEmit"
   }
 }

package/src/commands/DCommand.ts

@@ -2,6 +2,7 @@ import { DStyle } from "../Delement/DStyle";
 import { AnimationDto } from "../dto/AnimationDto";
 import { Fact } from "../rules/fact";
 import { DState } from "../state/Dstate";
+import { PageID } from "../utils/ID";
 
 type CommandTarget = "VIDEO" | "AUDIO" | "ELEMENT" | "PAGE_QUE" | "ENGINE" | "STATE";
 type CommandKind = `${Uppercase<CommandTarget>}_${Uppercase<string>}_COMMAND`;
@@ -10,53 +11,53 @@ export type StateCommand = CommandDto<"STATE_MUTATE_COMMAND", "STATE", { mutatio
 // export type StateCommand = CommandDto<"STATE_MUTATE_COMMAND", "STATE", { mutation: DState.StateMutation }>;
 
 export type NavigationCommand =
-    | CommandDto<"PAGE_QUE_NEXT_PAGE_COMMAND", "PAGE_QUE", {}>
-    | CommandDto<"PAGE_QUE_GO_TO_SEQUENCE_COMMAND", "PAGE_QUE", { sequenceId: string }>
-    | CommandDto<"PAGE_QUE_GO_TO_PAGE_COMMAND", "PAGE_QUE", { pageId: string }>;
+  | CommandDto<"PAGE_QUE_NEXT_PAGE_COMMAND", "PAGE_QUE", {}>
+  | CommandDto<"PAGE_QUE_GO_TO_SEQUENCE_COMMAND", "PAGE_QUE", { sequenceId: string }>
+  | CommandDto<"PAGE_QUE_GO_TO_PAGE_COMMAND", "PAGE_QUE", { pageId: string }>;
 
 export type EngineCommand = CommandDto<
-    "ENGINE_LEAVE_PAGE_COMMAND",
-    "ENGINE",
-    {
-        readonly pageId: string;
-        readonly factsCollected: ReadonlyArray<Fact>;
-    }
+  "ENGINE_LEAVE_PAGE_COMMAND",
+  "ENGINE",
+  {
+    readonly pageId: string;
+    readonly factsCollected: ReadonlyArray<Fact>;
+  }
 >;
 
 interface CommandDto<K extends CommandKind, T extends CommandTarget, P> {
-    readonly kind: K;
-    readonly target: T;
-    readonly targetId: T | Omit<string, T>;
-    readonly payload: P;
+  readonly kind: K;
+  readonly target: T;
+  readonly targetId: T | Omit<string, T>;
+  readonly payload: P;
 }
 
 export type VideoCommand =
-    | CommandDto<"VIDEO_PLAY_COMMAND", "VIDEO", { volume?: number }>
-    | CommandDto<"VIDEO_SET_VOLUME_COMMAND", "VIDEO", { volume: number }>
-    | CommandDto<"VIDEO_JUMP_TO_COMMAND", "VIDEO", { volume?: number; ms: number }>
-    | CommandDto<"VIDEO_PAUSE_COMMAND", "VIDEO", {}>;
+  | CommandDto<"VIDEO_PLAY_COMMAND", "VIDEO", { volume?: number }>
+  | CommandDto<"VIDEO_SET_VOLUME_COMMAND", "VIDEO", { volume: number }>
+  | CommandDto<"VIDEO_JUMP_TO_COMMAND", "VIDEO", { volume?: number; ms: number }>
+  | CommandDto<"VIDEO_PAUSE_COMMAND", "VIDEO", {}>;
 
 export type AudioCommand =
-    | CommandDto<"AUDIO_PAUSE_COMMAND", "AUDIO", {}>
-    | CommandDto<"AUDIO_PLAY_COMMAND", "AUDIO", { volume?: number; startAt?: number }>
-    | CommandDto<"AUDIO_SET_VOLUME_COMMAND", "AUDIO", { volume: number }>;
+  | CommandDto<"AUDIO_PAUSE_COMMAND", "AUDIO", {}>
+  | CommandDto<"AUDIO_PLAY_COMMAND", "AUDIO", { volume?: number; startAt?: number }>
+  | CommandDto<"AUDIO_SET_VOLUME_COMMAND", "AUDIO", { volume: number }>;
 
 export type ElementCommand =
-    | CommandDto<"ELEMENT_ANIMATE_COMMAND", "ELEMENT", AnimationDto>
-    | CommandDto<"ELEMENT_DISABLE_CLICK_COMMAND", "ELEMENT", {}>
-    | CommandDto<"ELEMENT_ENABLE_CLICK_COMMAND", "ELEMENT", {}>
-    | CommandDto<"ELEMENT_STYLE_COMMAND", "ELEMENT", { changes: Partial<DStyle>; clickIsAllowed?: boolean }>;
+  | CommandDto<"ELEMENT_ANIMATE_COMMAND", "ELEMENT", AnimationDto>
+  | CommandDto<"ELEMENT_DISABLE_CLICK_COMMAND", "ELEMENT", {}>
+  | CommandDto<"ELEMENT_ENABLE_CLICK_COMMAND", "ELEMENT", {}>
+  | CommandDto<"ELEMENT_STYLE_COMMAND", "ELEMENT", { changes: Partial<DStyle>; clickIsAllowed?: boolean }>;
 
 export type PageQueCommand =
-    | CommandDto<"PAGE_QUE_EXCLUDE_BY_TAG_COMMAND", "PAGE_QUE", { tagIds: string[] }>
-    | CommandDto<"PAGE_QUE_EXCLUDE_BY_PAGE_ID_COMMAND", "PAGE_QUE", { pageIds: Array<string> }>
-    | CommandDto<"PAGE_QUE_JUMP_TO_PAGE_COMMAND", "PAGE_QUE", { readonly pageId: string }>;
+  | CommandDto<"PAGE_QUE_EXCLUDE_BY_TAG_COMMAND", "PAGE_QUE", { tagIds: string[] }>
+  | CommandDto<"PAGE_QUE_EXCLUDE_BY_PAGE_ID_COMMAND", "PAGE_QUE", { pageIds: Array<PageID> }>
+  | CommandDto<"PAGE_QUE_JUMP_TO_PAGE_COMMAND", "PAGE_QUE", { readonly pageId: string }>;
 
 export type DCommand =
-    | StateCommand
-    | NavigationCommand
-    | VideoCommand
-    | AudioCommand
-    | ElementCommand
-    | EngineCommand
-    | PageQueCommand;
+  | StateCommand
+  | NavigationCommand
+  | VideoCommand
+  | AudioCommand
+  | ElementCommand
+  | EngineCommand
+  | PageQueCommand;

package/src/dto/SchemaDto.ts

@@ -4,62 +4,62 @@ import { Rule } from "../rules/rule";
 import { Fact } from "../rules/fact";
 import { PageQueCommand } from "../commands/DCommand";
 import { DState } from "../state/Dstate";
+import { PageID, SchemaID } from "../utils/ID";
 
 export type PageQueRules = Rule<PageQueCommand, never>;
 export interface PageDto {
-    readonly id: string;
-    readonly elements: Array<DElementDto>;
-    readonly tags?: string[];
-    readonly mainVideoId?: string;
-    readonly backgroundColor?: string;
-    readonly video?: Array<DVideoDto>;
-    readonly audio?: Array<DAudioDto>;
-    readonly autoPlaySequence?: DAutoPlaySequence;
+  readonly id: PageID;
+  readonly elements: Array<DElementDto>;
+  readonly tags?: string[];
+  readonly mainVideoId?: string;
+  readonly backgroundColor?: string;
+  readonly video?: Array<DVideoDto>;
+  readonly audio?: Array<DAudioDto>;
+  readonly autoPlaySequence?: DAutoPlaySequence;
 }
 
 export interface PageSequenceDto {
-    readonly id: string;
-    readonly rules: Array<PageQueRules>;
-    readonly pages: Array<PageDto>;
+  readonly id: string;
+  readonly rules: Array<PageQueRules>;
+  readonly pages: Array<PageDto>;
 }
 
 export interface SchemaDto {
-    readonly id: string;
-    readonly prefix: string;
-    readonly baseHeight: number;
-    readonly baseWidth: number;
-    readonly backgroundColor: string;
-    readonly pages: PageDto[];
-    readonly rules: Array<PageQueRules>;
-    readonly stateProps?: ReadonlyArray<DState.Prop>;
-    readonly stateQueries?: ReadonlyArray<DState.StateQuery>;
-    readonly stateFromEvent: ReadonlyArray<DState.fromEventHandler>;
-    readonly pageSequences?: Array<PageSequenceDto>;
-    readonly predefinedFacts?: ReadonlyArray<Fact>;
+  readonly id: SchemaID;
+  readonly baseHeight: number;
+  readonly baseWidth: number;
+  readonly backgroundColor: string;
+  readonly pages: PageDto[];
+  readonly rules: Array<PageQueRules>;
+  readonly stateProps?: ReadonlyArray<DState.Prop>;
+  readonly stateQueries?: ReadonlyArray<DState.StateQuery>;
+  readonly stateFromEvent: ReadonlyArray<DState.fromEventHandler>;
+  readonly pageSequences?: Array<PageSequenceDto>;
+  readonly predefinedFacts?: ReadonlyArray<Fact>;
 }
 
 export namespace SchemaDto {
-    export const getResources = (
-        schema: SchemaDto
-    ): {
-        videoList: ReadonlyArray<DVideoDto>;
-        audioList: ReadonlyArray<DAudioDto>;
-        imageList: ReadonlyArray<DImgDto>;
-    } => {
-        const { pages } = schema;
-        const videoList = pages.reduce<Array<DVideoDto>>((acc, curr) => {
-            if (Array.isArray(curr.video)) {
-                acc.push(...curr.video);
-            }
-            return acc;
-        }, []);
-        const audioList: Array<DAudioDto> = pages.reduce<Array<DAudioDto>>((acc, curr) => {
-            if (Array.isArray(curr.audio)) {
-                acc.push(...curr.audio);
-            }
-            return acc;
-        }, []);
+  export const getResources = (
+    schema: SchemaDto,
+  ): {
+    videoList: ReadonlyArray<DVideoDto>;
+    audioList: ReadonlyArray<DAudioDto>;
+    imageList: ReadonlyArray<DImgDto>;
+  } => {
+    const { pages } = schema;
+    const videoList = pages.reduce<Array<DVideoDto>>((acc, curr) => {
+      if (Array.isArray(curr.video)) {
+        acc.push(...curr.video);
+      }
+      return acc;
+    }, []);
+    const audioList: Array<DAudioDto> = pages.reduce<Array<DAudioDto>>((acc, curr) => {
+      if (Array.isArray(curr.audio)) {
+        acc.push(...curr.audio);
+      }
+      return acc;
+    }, []);
 
-        return { videoList, audioList, imageList: [] };
-    };
+    return { videoList, audioList, imageList: [] };
+  };
 }

package/src/engine/DPage.ts

@@ -7,49 +7,54 @@ import { DTimestamp } from "../common/DTimestamp";
 import { ScaleService } from "./scale";
 
 export class DPage {
-    private readonly TAG = "[ DPage ]: ";
-    private elements: DElement<HTMLElement>[] = [];
-    private readonly eventBus;
-    private readonly commandBus;
-    private readonly scale: ScaleService;
-    // Todo GLOBAL EVENT_BUSS AND PAGE EVENTS:
+  private readonly TAG = "[ DPage ]: ";
+  private elements: DElement<HTMLElement>[] = [];
+  private readonly eventBus;
+  private readonly commandBus;
+  private readonly scale: ScaleService;
+  // Todo GLOBAL EVENT_BUSS AND PAGE EVENTS:
 
-    constructor(private readonly dto: PageDto, eventBus: EventBus, commandBus: DCommandBus, scale: ScaleService) {
-        this.eventBus = eventBus;
-        this.commandBus = commandBus;
-        this.scale = scale;
-        this.elements = dto.elements.map((dto) => createDElement(dto, this.commandBus, this.eventBus, this.scale));
-    }
+  constructor(
+    private readonly dto: PageDto,
+    eventBus: EventBus,
+    commandBus: DCommandBus,
+    scale: ScaleService,
+  ) {
+    this.eventBus = eventBus;
+    this.commandBus = commandBus;
+    this.scale = scale;
+    this.elements = dto.elements.map((dto) => createDElement(dto, this.commandBus, this.eventBus, this.scale));
+  }
 
-    appendYourself(parent: HTMLElement) {
-        // console.log(this.TAG + " APPENDING TO PARENT");
-        this.elements.forEach((el) => {
-            el.appendYourself(parent);
-            // parent.appendChild(el.el);
-        });
+  appendYourself(parent: HTMLElement) {
+    // console.log(this.TAG + " APPENDING TO PARENT");
+    this.elements.forEach((el) => {
+      el.appendYourself(parent);
+      // parent.appendChild(el.el);
+    });
 
-        // if (!preloadMode) {
-        this.eventBus.emit({
-            kind: "PAGE_ENTER_EVENT",
-            timestamp: DTimestamp.now(),
-            producer: "DPage",
-            producerId: this.id,
-            data: { pageId: this.id },
-        });
-        // }
-    }
+    // if (!preloadMode) {
+    this.eventBus.emit({
+      kind: "PAGE_ENTER_EVENT",
+      timestamp: DTimestamp.now(),
+      producer: "DPage",
+      producerId: this.id,
+      data: { pageId: this.id },
+    });
+    // }
+  }
 
-    destroy() {
-        this.elements.forEach((el) => {
-            el.destroy();
-        });
-    }
+  destroy() {
+    this.elements.forEach((el) => {
+      el.destroy();
+    });
+  }
 
-    log(): void {
-        // console.log(this.TAG + 'scale - ' + this.scale);
-    }
+  log(): void {
+    // console.log(this.TAG + 'scale - ' + this.scale);
+  }
 
-    get id() {
-        return this.dto.id;
-    }
+  get id() {
+    return this.dto.id;
+  }
 }

package/src/player/dplayer.spec.ts

@@ -4,9 +4,10 @@ import { Rule } from "../rules/rule";
 import { PageHistory } from "./history-que";
 import { DTimestamp } from "../common/DTimestamp";
 import { PageQueCommand } from "../commands/DCommand";
+import { PageID } from "../utils/ID";
 
 const page = (id: number): PageDto => {
-    return { id: "" + id, elements: [] };
+  return { id: PageID.create(), elements: [] };
 };
 const p1 = page(1);
 const p2 = page(2);
@@ -16,93 +17,93 @@ 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),
+  p10: page(10),
+  p11: page(11),
+  p12: page(12),
 };
 
 const seq1: PageSequenceDto = {
-    id: "s1",
-    pages: [Seq1.p10, Seq1.p11, Seq1.p12],
-    rules: [],
+  id: "s1",
+  pages: [Seq1.p10, Seq1.p11, Seq1.p12],
+  rules: [],
 };
 const data = (
-    pages: PageDto[],
-    pageSequences: PageSequenceDto[] = [],
-    rules: Rule<PageQueCommand, never>[] = []
+  pages: PageDto[],
+  pageSequences: PageSequenceDto[] = [],
+  rules: Rule<PageQueCommand, never>[] = [],
 ): DPlayerData => ({ pages, pageSequences, rules });
 // const seq = (pages: PageDto[], rules: Rule[]) => {};
 beforeEach(() => {
-    // data = { pages: [], rules: [], pageSequences: [] };
+  // data = { pages: [], rules: [], pageSequences: [] };
 });
 
 describe("DPlayer", () => {
-    it("should create an instance", () => {
-        const player = new DPlayer(data([p1, p1]));
-        expect(player).toBeTruthy();
-    });
+  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]));
+  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);
-    });
+    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]));
+  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);
+    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));
+  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);
+    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;
+  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);
-    });
+    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/history-que.spec.ts

@@ -1,24 +1,25 @@
 import { AnsweredQuestion, HistoryQue, PageHistory } from "./history-que";
 import { DTimestamp } from "../common/DTimestamp";
 import { PageDto } from "../dto/SchemaDto";
+import { PageID } from "../utils/ID";
 
 const p = (id: number): PageDto => {
-    return { id: "" + id, elements: [] };
+  return { id: PageID.create(), 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",
-    },
+  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,
+  pageId: page.id,
+  answeredQuestions,
 });
 const p1 = p(1);
 const p2 = p(2);
@@ -30,16 +31,16 @@ const all = [p1, p2, p3, p4, p5, p6];
 
 let history = new HistoryQue();
 beforeEach(() => {
-    history = new HistoryQue();
+  history = new HistoryQue();
 });
 
 describe("HistoryQue", () => {
-    it("should create an instance", () => {
-        expect(history).toBeTruthy();
-    });
+  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);
-    });
+  it("Can add history, and get facts back", () => {
+    history.addToHistory(h(p1, [answer(1, 2)]));
+    expect(history.getFacts().length).toBe(1);
+  });
 });