@media-quest/engine 0.0.22 → 0.0.24

package/src/page/task.ts

@@ -1,90 +1,90 @@
-type BaseTask = {
-  readonly blockAudio: boolean;
-  readonly blockVideo: boolean;
-  readonly blockResponseButton: boolean;
-  readonly blockFormInput: boolean;
-  readonly priority:
-    | "run-if-idle"
-    | "follow-queue"
-    | "replace-all"
-    | "replace-current"
-    | "replace-queue"
-    | "prepend-to-queue"
-    | "append-to-queue";
-};
-export type DelayTask = BaseTask & {
-  readonly kind: "delay-task";
-  readonly duration: number;
-};
-
-export type PlayAudioTask = BaseTask & {
-  readonly kind: "play-audio-task";
-  readonly url: string;
-  readonly audioId: string;
-};
-
-export type PlayVideoTask = BaseTask & {
-  readonly kind: "play-video-task";
-  readonly url: string;
-  readonly videoId: string;
-  readonly loop?: boolean;
-  readonly startAt?: number;
-  readonly stopAt?: "end" | "start" | number;
-  readonly volume?: number;
-};
-const eq = (a: Task, b: Task) => {
-  if (!b) {
-    return false;
-  }
-  if (a.kind !== b.kind) {
-    return false;
-  }
-  if (a.kind === "delay-task" && b.kind === "delay-task") {
-    return a.duration === b.duration;
-  }
-
-  if (a.kind === "play-audio-task" && b.kind === "play-audio-task") {
-    return a.url === b.url && a.audioId === b.audioId;
-  }
-  if (a.kind === "play-video-task" && b.kind === "play-video-task") {
-    return (
-      a.url === b.url &&
-      a.videoId === b.videoId &&
-      a.startAt === b.startAt &&
-      a.stopAt === b.stopAt &&
-      a.volume === b.volume
-    );
-  }
-  return false;
-};
-const deleteTaskList = (task: Task) => {
-  return task.priority === "replace-all" || task.priority === "replace-queue";
-};
-
-const shallRemoveCurrent = (task: Task) => {
-  return task.priority === "replace-current" || task.priority === "replace-all";
-};
-
-const notEq = (a: Task, b: Task) => !eq(a, b);
-
-const is = (task: Task | undefined | false | null | {}): task is Task => {
-  if (!task) {
-    return false;
-  }
-  if (typeof task !== "object") {
-    return false;
-  }
-  if (Array.isArray(task)) {
-    return false;
-  }
-  return true;
-};
-
-export const Task = {
-  eq,
-  is,
-  notEq,
-  deleteTaskList,
-  shallRemoveCurrent,
-};
-export type Task = PlayVideoTask | PlayAudioTask | DelayTask;
+type BaseTask = {
+  readonly blockAudio: boolean;
+  readonly blockVideo: boolean;
+  readonly blockResponseButton: boolean;
+  readonly blockFormInput: boolean;
+  readonly priority:
+    | "run-if-idle"
+    | "follow-queue"
+    | "replace-all"
+    | "replace-current"
+    | "replace-queue"
+    | "prepend-to-queue"
+    | "append-to-queue";
+};
+export type DelayTask = BaseTask & {
+  readonly kind: "delay-task";
+  readonly duration: number;
+};
+
+export type PlayAudioTask = BaseTask & {
+  readonly kind: "play-audio-task";
+  readonly url: string;
+  readonly audioId: string;
+};
+
+export type PlayVideoTask = BaseTask & {
+  readonly kind: "play-video-task";
+  readonly url: string;
+  readonly videoId: string;
+  readonly loop?: boolean;
+  readonly startAt?: number;
+  readonly stopAt?: "end" | "start" | number;
+  readonly volume?: number;
+};
+const eq = (a: Task, b: Task) => {
+  if (!b) {
+    return false;
+  }
+  if (a.kind !== b.kind) {
+    return false;
+  }
+  if (a.kind === "delay-task" && b.kind === "delay-task") {
+    return a.duration === b.duration;
+  }
+
+  if (a.kind === "play-audio-task" && b.kind === "play-audio-task") {
+    return a.url === b.url && a.audioId === b.audioId;
+  }
+  if (a.kind === "play-video-task" && b.kind === "play-video-task") {
+    return (
+      a.url === b.url &&
+      a.videoId === b.videoId &&
+      a.startAt === b.startAt &&
+      a.stopAt === b.stopAt &&
+      a.volume === b.volume
+    );
+  }
+  return false;
+};
+const deleteTaskList = (task: Task) => {
+  return task.priority === "replace-all" || task.priority === "replace-queue";
+};
+
+const shallRemoveCurrent = (task: Task) => {
+  return task.priority === "replace-current" || task.priority === "replace-all";
+};
+
+const notEq = (a: Task, b: Task) => !eq(a, b);
+
+const is = (task: Task | undefined | false | null | {}): task is Task => {
+  if (!task) {
+    return false;
+  }
+  if (typeof task !== "object") {
+    return false;
+  }
+  if (Array.isArray(task)) {
+    return false;
+  }
+  return true;
+};
+
+export const Task = {
+  eq,
+  is,
+  notEq,
+  deleteTaskList,
+  shallRemoveCurrent,
+};
+export type Task = PlayVideoTask | PlayAudioTask | DelayTask;

package/src/public-api.ts

@@ -1,26 +1,26 @@
-export * from "./engine/SchemaResult";
-export * from "./engine/SchemaEngine";
-export * from "./engine/SchemaDto";
-export * from "./engine/page-que-ruleengine-action";
-export * from "./rules/rule";
-export * from "./rules/fact";
-export * from "./rules/rule-engine";
-export * from "./rules/condition";
-export * from "./utils/DUtil";
-export * from "./utils/ID";
-
-export * from "./events/mq-events";
-
-export * from "./page/page-component";
-
-// ELEMENTS
-export * from "./Delement/css";
-export * from "./Delement/DStyle";
-export * from "./Delement/DImg";
-export * from "./Delement/DText";
-export * from "./Delement/Ddiv";
-export * from "./Delement/button-click-action";
-export * from "./Delement/DElement";
-export * from "./Delement/DElement.dto";
-export { PageDto } from "./page/Page";
-export * from "./page/task";
+export * from "./engine/SchemaResult";
+export * from "./engine/SchemaEngine";
+export * from "./engine/SchemaDto";
+export * from "./engine/page-que-ruleengine-action";
+export * from "./rules/rule";
+export * from "./rules/fact";
+export * from "./rules/rule-engine";
+export * from "./rules/condition";
+export * from "./utils/DUtil";
+export * from "./utils/ID";
+
+export * from "./events/mq-events";
+
+export * from "./page/page-component";
+
+// ELEMENTS
+export * from "./Delement/css";
+export * from "./Delement/DStyle";
+export * from "./Delement/DImg";
+export * from "./Delement/DText";
+export * from "./Delement/Ddiv";
+export * from "./Delement/button-click-action";
+export * from "./Delement/DElement";
+export * from "./Delement/DElement.dto";
+export { PageDto } from "./page/Page";
+export * from "./page/task";

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

@@ -1,15 +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);
-  });
-});
+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

@@ -1,124 +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);
-    });
-});
+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);
+    });
+});