@media-quest/builder 0.0.3 → 0.0.5

package/src/rulebuilder/page-action-manager.ts

@@ -1,20 +1,30 @@
 import type { RuleInput } from "./RuleInput";
 import { ExcludeByPageIdSelectItem } from "./multi-select-item";
+import { ExcludeByPageAction } from "./RuleAction";
 
 export class PageActionManager {
-    private readonly _initialSelection: Set<string>;
-    readonly selectItems: ReadonlyArray<ExcludeByPageIdSelectItem>;
+  private readonly _initialSelection: Set<string>;
+  readonly selectItems: ReadonlyArray<ExcludeByPageIdSelectItem>;
 
-    constructor(readonly validOptions: RuleInput["_pageIdActions"], readonly initialSelection: ReadonlyArray<string>) {
-        this._initialSelection = new Set([...initialSelection]);
-        this.selectItems = validOptions.map((opt) => {
-            const isSelected = this._initialSelection.has(opt.pageId);
-            return ExcludeByPageIdSelectItem.create(opt, isSelected);
-        });
-    }
+  constructor(
+    readonly validOptions: RuleInput["_pageIdActions"],
+    readonly initialSelection: ReadonlyArray<string>,
+  ) {
+    this._initialSelection = new Set([...initialSelection]);
+    this.selectItems = validOptions.map((opt) => {
+      const isSelected = this._initialSelection.has(opt.pageId);
+      return ExcludeByPageIdSelectItem.create(opt, isSelected);
+    });
+  }
 
-    getCurrentSelection(): ReadonlyArray<string> {
-        const selected = this.selectItems.filter((item) => item.isSelected).map((itm) => itm.data.pageId);
-        return selected;
-    }
+  getCurrentSelection(): ReadonlyArray<string> {
+    const selected = this.selectItems.filter((item) => item.isSelected).map((itm) => itm.data.pageId);
+    return selected;
+  }
+
+  getEngineAction(): ReadonlyArray<ExcludeByPageAction> {
+    const selectItems = this.selectItems.filter((item) => item.isSelected);
+    const actions = selectItems.map((item) => item.data);
+    return [...actions];
+  }
 }

package/src/rulebuilder/rule2/Rule2.ts

@@ -0,0 +1,211 @@
+import { BuilderOperator } from "../condition/Builder-operator";
+import { BuilderConditionDto } from "../condition/Builder-condition";
+import { BuilderConditionGroupDto, ConditionGroupType } from "../condition/Builder-condition-group";
+import { BuilderRuleDto } from "../Builder-rule";
+
+type SolveErrorReason =
+  | "INVALID_FACT_TYPE"
+  | "INVALID_OPERATOR"
+  | "INVALID_VALUE"
+  | "INVALID_VARIABLE"
+  | "UNIMPLEMENTED_VARIABLE_TYPE"
+  | "UNIMPLEMENTED_OPERATOR";
+
+type TrueResult = { readonly type: "IS_TRUE" };
+type FalseResult = { readonly type: "IS_FALSE" };
+type MissingFactsResult = { readonly type: "MISSING_FACTS"; readonly missingVariables: ReadonlyArray<string> };
+type ErrorResult = {
+  readonly type: "HAS_ERROR";
+  readonly reason: SolveErrorReason;
+  readonly data: Record<string, string>;
+};
+export type EvalResult = FalseResult | TrueResult | MissingFactsResult | ErrorResult;
+
+export interface Fact2 {
+  readonly variableType: "numeric";
+  readonly value: number;
+  readonly valueLabel: string;
+  readonly variableId: string;
+  readonly variableLabel: string;
+}
+
+export class FactCollection {
+  public static isFact = (value: unknown): value is Fact2 => {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return false;
+    }
+    const fact = value as Partial<Fact2>;
+    if (typeof fact.variableId !== "string" || fact.variableId.length === 0) {
+      return false;
+    }
+    if (typeof fact.variableLabel !== "string") {
+      return false;
+    }
+    if (typeof fact.value !== "number") {
+      return false;
+    }
+    if (typeof fact.valueLabel !== "string") {
+      return false;
+    }
+    // NB: This is a temporary check until we have more variable types.
+    if (typeof fact.variableType !== "string" || fact.variableType !== "numeric") {
+      return false;
+    }
+
+    return true;
+  };
+  public static create = (facts: ReadonlyArray<Fact2>): FactCollection => {
+    return new FactCollection(facts);
+  };
+
+  private readonly _facts: ReadonlyArray<Fact2>;
+
+  private constructor(facts: ReadonlyArray<Fact2>) {
+    if (!Array.isArray(facts)) {
+      console.log("Invalid facts", facts);
+      this._facts = [];
+    } else {
+      this._facts = [...facts];
+    }
+  }
+  byId(variableId: string): Fact2 | false {
+    const result = this._facts.find((fact) => fact.variableId === variableId);
+    if (!result) {
+      return false;
+    }
+    return { ...result };
+  }
+}
+interface FactEvaluator {
+  isTrue(facts: FactCollection): boolean;
+  evaluate(facts: FactCollection): EvalResult;
+}
+interface IsValid {
+  isValid(): boolean;
+}
+export class Condition implements FactEvaluator, IsValid {
+  public static create = (dto: BuilderConditionDto): Condition => {
+    return new Condition(dto);
+  };
+  private constructor(private readonly dto: BuilderConditionDto) {}
+  isTrue(facts: FactCollection): boolean {
+    const dto = this.dto;
+    const op = dto.operator;
+    const value = dto.value;
+    const varId = dto.variableId;
+    if (!BuilderOperator.is(op)) {
+      return false;
+    }
+
+    if (typeof value !== "number") {
+      return false;
+    }
+
+    const fact = facts.byId(this.dto.variableId);
+
+    if (!FactCollection.isFact(fact)) {
+      return false;
+    }
+
+    if (fact.variableType !== "numeric" && typeof fact.value !== "number") {
+      return false;
+    }
+
+    if (op === "equal") {
+      return fact.value === value;
+    }
+
+    if (op === "notEqual") {
+      return fact.value !== value;
+    }
+
+    return false;
+  }
+  isValid(): boolean {
+    return false;
+  }
+
+  evaluate(facts: FactCollection): EvalResult {
+    return { type: "HAS_ERROR", reason: "UNIMPLEMENTED_VARIABLE_TYPE", data: {} }; // TODO
+  }
+}
+export class ConditionGroup implements FactEvaluator, IsValid {
+  public static readonly create = (dto: BuilderConditionGroupDto): ConditionGroup => {
+    return new ConditionGroup(dto);
+  };
+
+  private readonly _conditions: ReadonlyArray<Condition>;
+  private constructor(private readonly dto: BuilderConditionGroupDto) {
+    this._conditions = dto.conditions.map(Condition.create);
+  }
+
+  isTrue(facts: FactCollection): boolean {
+    const results = this._conditions.map((condition) => condition.isTrue(facts));
+    let trueCount = 0;
+    let falseCount = 0;
+    results.forEach((results) => {
+      if (results) {
+        trueCount++;
+      } else {
+        falseCount++;
+      }
+    });
+    if (trueCount === 0 || falseCount === 0) {
+      return false;
+    }
+    const type = this.dto.type;
+
+    if (type === "all" && trueCount === this._conditions.length) {
+      return true;
+    }
+
+    if (type === "any" && trueCount > 0) {
+      return true;
+    }
+
+    const minLimit = this.dto.count;
+    if (type === "count" && typeof minLimit === "number" && trueCount >= minLimit) {
+      return true;
+    }
+
+    return false;
+  }
+
+  isValid(): boolean {
+    return true;
+  }
+
+  evaluate(facts: FactCollection): EvalResult {
+    return { type: "HAS_ERROR", reason: "UNIMPLEMENTED_VARIABLE_TYPE", data: {} }; // TODO
+  }
+}
+export class Rule2 implements FactEvaluator {
+  readonly name: string;
+  private readonly _conditions: ReadonlyArray<Condition | ConditionGroup>;
+  public static readonly create = (dto: BuilderRuleDto): Rule2 => {
+    return new Rule2(dto);
+  };
+  private _count = -1;
+  constructor(private readonly dto: BuilderRuleDto) {
+    this.name = dto.name;
+    const conditions: Array<Condition | ConditionGroup> = [];
+    dto.conditions.forEach((condition) => {
+      if (condition.kind === "condition-group") {
+        conditions.push(ConditionGroup.create(condition));
+      } else if (condition.kind === "condition") {
+        conditions.push(Condition.create(condition));
+      } else {
+        console.log("Unknown condition", condition);
+      }
+    });
+    this._conditions = conditions;
+  }
+
+  isTrue(facts: FactCollection): boolean {
+    return false;
+  }
+
+  evaluate(facts: FactCollection): EvalResult {
+    return { type: "HAS_ERROR", reason: "UNIMPLEMENTED_VARIABLE_TYPE", data: {} }; // TODO
+  }
+}

package/src/rulebuilder/tag-action-manager.ts

@@ -1,18 +1,28 @@
 import type { RuleInput } from "./RuleInput";
 import { ExcludeByTagSelectItem } from "./multi-select-item";
+import { ExcludeByTagAction } from "./RuleAction";
 
 export class TagActionManager {
-    private readonly _initialSelection: Set<string>;
-    readonly selectItems: ReadonlyArray<ExcludeByTagSelectItem>;
-    constructor(readonly validOptions: RuleInput["_tagActions"], readonly initialSelection: ReadonlyArray<string>) {
-        this._initialSelection = new Set([...initialSelection]);
-        this.selectItems = validOptions.map((opt) => {
-            const isSelected = this._initialSelection.has(opt.tag);
-            return ExcludeByTagSelectItem.create(opt, isSelected);
-        });
-    }
-    getCurrentSelection(): ReadonlyArray<string> {
-        const selected = this.selectItems.filter((item) => item.isSelected).map((itm) => itm.data.tag);
-        return selected;
-    }
+  private readonly _initialSelection: Set<string>;
+  readonly selectItems: ReadonlyArray<ExcludeByTagSelectItem>;
+  constructor(
+    readonly validOptions: RuleInput["_tagActions"],
+    readonly initialSelection: ReadonlyArray<string>,
+  ) {
+    this._initialSelection = new Set([...initialSelection]);
+    this.selectItems = validOptions.map((opt) => {
+      const isSelected = this._initialSelection.has(opt.tag);
+      return ExcludeByTagSelectItem.create(opt, isSelected);
+    });
+  }
+  getCurrentSelection(): ReadonlyArray<string> {
+    const selected = this.selectItems.filter((item) => item.isSelected).map((itm) => itm.data.tag);
+    return selected;
+  }
+
+  getEngineActions(): ReadonlyArray<ExcludeByTagAction> {
+    const selected = this.selectItems.filter((item) => item.isSelected);
+    const tagActions = selected.map((s) => s.data);
+    return [...tagActions];
+  }
 }

package/src/theme/default-theme-compiler.ts

@@ -1,5 +1,6 @@
 import { AbstractThemeCompiler } from "./AbstractThemeCompiler";
 import type { BuilderSchemaDto } from "../Builder-schema";
+import { BuilderSchema } from "../Builder-schema";
 import type { BuilderPageDto } from "../Builder-page";
 import { DStateProps } from "./standard-props";
 import { ThemeUtils } from "./theme-utils";
@@ -18,20 +19,43 @@ import {
   DVideoDto,
   Fact,
   PageDto,
+  PageQueCommand,
+  Rule,
   SchemaDto,
 } from "@media-quest/engine";
 import { AudioFile } from "../media-files";
+import { BuilderRule } from "../rulebuilder";
 
 const U = DUtil;
 const generateElementId = () => U.randomString(32);
 export class DefaultThemeCompiler extends AbstractThemeCompiler<IDefaultTheme> {
   readonly name = "Ispe default theme.";
+  private readonly TAG = "[ DEFAULT_THEME_COMPILER ]: ";
   constructor() {
     super(DefaultTheme);
   }
 
+  private compileRules(source: BuilderSchemaDto): Rule<PageQueCommand, never>[] {
+    const builderSchema = BuilderSchema.fromJson(source);
+    const ruleInput = builderSchema.getRuleInput();
+    const pageQueRules: Rule<PageQueCommand, never>[] = [];
+    source.rules.forEach((rule) => {
+      const engineRule = BuilderRule.fromDto(rule, ruleInput).toEngineRule(source.prefix);
+      if (!Rule.isEmpty(engineRule)) {
+        pageQueRules.push(engineRule);
+      } else {
+        console.groupCollapsed(this.TAG, "Throws away empty rule.");
+        console.log(rule);
+        console.log(ruleInput);
+        console.groupEnd();
+      }
+    });
+    return pageQueRules;
+  }
+
   compile(source: BuilderSchemaDto): SchemaDto {
-    const pages = source.pages.map((p) => this.compilePage(p, source.id));
+    const pages = source.pages.map((p) => this.compilePage(p, source.prefix));
+    const rules = this.compileRules(source);
     const dto: SchemaDto = {
       backgroundColor: source.backgroundColor,
       baseHeight: source.baseHeight,
@@ -41,7 +65,7 @@ export class DefaultThemeCompiler extends AbstractThemeCompiler<IDefaultTheme> {
       pages,
       predefinedFacts: [],
       prefix: source.prefix,
-      rules: [],
+      rules,
       stateFromEvent: [
         {
           onEvent: "VIDEO_ENDED_EVENT",
@@ -92,8 +116,8 @@ export class DefaultThemeCompiler extends AbstractThemeCompiler<IDefaultTheme> {
     };
     return dto;
   }
-  private compilePage(page: BuilderPageDto, _moduleId: string): PageDto {
-    // console.log(moduleId);
+  private compilePage(page: BuilderPageDto, modulePrefix: string): PageDto {
+    // console.log(_moduleId);
     // const textElement
     const { nextButton, mainText, id, mainMedia, _type } = page;
     const elements: DElementDto[] = [];
@@ -110,7 +134,8 @@ export class DefaultThemeCompiler extends AbstractThemeCompiler<IDefaultTheme> {
     }
 
     if (_type === "question") {
-      const { buttons, question } = this.compileQuestion(id, page);
+      const variableId = modulePrefix + "_" + page.prefix;
+      const { buttons, question } = this.compileQuestion(id, page, variableId);
       // console.log(question);
       elements.push(...buttons, question);
     }
@@ -306,6 +331,7 @@ export class DefaultThemeCompiler extends AbstractThemeCompiler<IDefaultTheme> {
   private compileQuestion(
     pageId: string,
     page: BuilderPageDto,
+    variableId: string,
   ): {
     question: DTextDto;
     buttons: DDivDto[];
@@ -327,7 +353,7 @@ export class DefaultThemeCompiler extends AbstractThemeCompiler<IDefaultTheme> {
     const buttons = q.options.map((o) => {
       const btns = this.compileButton(pageId, o, {
         kind: "response-button",
-        questionId: "",
+        questionId: variableId,
       });
       return btns;
     });

package/tsconfig.json

@@ -9,6 +9,6 @@
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
     "rootDir": "./src",
-    "outDir": "./dist",
-  }
+    "outDir": "./dist"
+  },
 }