@media-quest/builder 0.0.4 → 0.0.5

package/package.json

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

package/src/Builder-schema.ts

@@ -192,17 +192,16 @@ export class BuilderSchema {
     this.pages.forEach((page, index) => {
       const pageVariables = page.getQuestionVariables(prefix, index);
       qVars.push(...pageVariables);
-      const pageId = page.prefix;
       const mainText = page.mainText.text;
       const jumpAction: JumpToPageAction = {
         kind: "jump-to-page",
-        pageId: pageId,
+        pageId: page.id,
         pageNumber: index,
         mainText: page.mainText.text,
       };
       const excludePageAction: ExcludeByPageAction = {
         kind: "exclude-by-pageId",
-        pageId,
+        pageId: page.id,
         pageNumber: index,
         mainText,
       };

package/src/rulebuilder/Builder-rule.ts

@@ -9,10 +9,7 @@ import { BuilderObject } from "../BuilderObject";
 import { TagActionManager } from "./tag-action-manager";
 import { PageActionManager } from "./page-action-manager";
 import { JumpToActionManager } from "./jump-to-action-manager";
-import { Condition, DUtil, PageQueCommand, PageQueRules, Rule } from "@media-quest/engine";
-import { ExcludeByPageAction, ExcludeByTagAction, JumpToPageAction } from "./RuleAction";
-import { RuleBuilderTestUtils } from "./RuleBuilder-test-utils";
-import jumpToPageAction = RuleBuilderTestUtils.jumpToPageAction;
+import { Condition, PageQueCommand, PageQueRules } from "@media-quest/engine";
 
 export interface BuilderRuleDto {
   readonly type: ConditionGroupType;
@@ -135,18 +132,18 @@ export class BuilderRule extends BuilderObject<"builder-rule", BuilderRuleDto> {
     };
     return dto;
   }
-  toEngineRule(): PageQueRules {
+  toEngineRule(modulePrefix: string): PageQueRules {
     const conditions: Condition[] = [];
     this._conditions.forEach((c) => {
       if (c) {
         if (c instanceof BuilderCondition) {
-          const simpleCondition = c.toEngineCondition();
+          const simpleCondition = c.toEngineCondition(modulePrefix);
           if (simpleCondition) {
             conditions.push(simpleCondition);
           }
         }
         if (c instanceof BuilderConditionGroup) {
-          const complexCondition = c.toEngineConditionComplex();
+          const complexCondition = c.toEngineConditionComplex(modulePrefix);
           if (complexCondition) conditions.push(complexCondition);
         }
       }
@@ -190,9 +187,7 @@ export class BuilderRule extends BuilderObject<"builder-rule", BuilderRuleDto> {
       pageQueCommands.push(excludeTagsCommand);
     }
 
-    const id = DUtil.randomObjectId();
     const rule: PageQueRules = {
-      id: "",
       description: this.name,
       all,
       some,

package/src/rulebuilder/condition/Builder-condition-group.ts

@@ -7,13 +7,13 @@ const ConditionGroupType = {
   all: true,
   any: true,
   count: true,
-  range: true,
 };
 
 export type ConditionGroupType = keyof typeof ConditionGroupType;
 export interface BuilderConditionGroupDto {
   readonly kind: "condition-group";
   readonly name: string;
+  readonly count?: number;
   readonly type: ConditionGroupType;
   readonly conditions: ReadonlyArray<BuilderConditionDto>;
 }
@@ -82,7 +82,7 @@ export class BuilderConditionGroup extends BuilderObject<"builder-condition-grou
     };
   }
 
-  toEngineConditionComplex(): Condition.Complex | false {
+  toEngineConditionComplex(modulePrefix: string): Condition.Complex | false {
     const comp: Condition.Complex = {
       kind: "complex-condition",
       all: [],
@@ -91,7 +91,7 @@ export class BuilderConditionGroup extends BuilderObject<"builder-condition-grou
     };
     const conditions: Condition.Simple[] = [];
     this.conditions.forEach((c) => {
-      const maybeSimple = c.toEngineCondition();
+      const maybeSimple = c.toEngineCondition(modulePrefix);
       if (maybeSimple) {
         conditions.push(maybeSimple);
       }

package/src/rulebuilder/condition/Builder-condition.ts

@@ -103,7 +103,7 @@ export class BuilderCondition extends BuilderObject<"builder-condition", Builder
     return { isValid: true };
   }
 
-  toEngineCondition(): Condition.Simple | false {
+  toEngineCondition(modulePrefix: string): Condition.Simple | false {
     const val = this.value;
     const op = this._operator;
     const v = this._variable;
@@ -115,7 +115,7 @@ export class BuilderCondition extends BuilderObject<"builder-condition", Builder
         kind: "numeric-condition",
         value: val.value,
         valueLabel: val.label,
-        referenceId: v.varId,
+        referenceId: modulePrefix + "_" + v.varId,
         referenceLabel: v.label,
         operator: "eq",
       };

package/src/rulebuilder/condition/Builder-operator.ts

@@ -16,14 +16,14 @@ const BuilderOperatorSymbols = {
   empty: true,
   notEmpty: true,
   startsWith: true,
-  endsWith: true
+  endsWith: true,
 } as const;
 
 export type BuilderOperator = keyof typeof BuilderOperatorSymbols;
 
 export namespace BuilderOperator {
-  export const is = (symbol: string): symbol is BuilderOperator => {
-    if (typeof symbol !== 'string') {
+  export const is = (symbol?: string): symbol is BuilderOperator => {
+    if (typeof symbol !== "string") {
       return false;
     }
     return Object.keys(BuilderOperatorSymbols).includes(symbol);

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/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";
@@ -19,12 +20,10 @@ import {
   Fact,
   PageDto,
   PageQueCommand,
-  PageQueRules,
   Rule,
   SchemaDto,
 } from "@media-quest/engine";
 import { AudioFile } from "../media-files";
-import { BuilderSchema } from "../Builder-schema";
 import { BuilderRule } from "../rulebuilder";
 
 const U = DUtil;
@@ -41,7 +40,7 @@ export class DefaultThemeCompiler extends AbstractThemeCompiler<IDefaultTheme> {
     const ruleInput = builderSchema.getRuleInput();
     const pageQueRules: Rule<PageQueCommand, never>[] = [];
     source.rules.forEach((rule) => {
-      const engineRule = BuilderRule.fromDto(rule, ruleInput).toEngineRule();
+      const engineRule = BuilderRule.fromDto(rule, ruleInput).toEngineRule(source.prefix);
       if (!Rule.isEmpty(engineRule)) {
         pageQueRules.push(engineRule);
       } else {
@@ -55,7 +54,7 @@ export class DefaultThemeCompiler extends AbstractThemeCompiler<IDefaultTheme> {
   }
 
   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,
@@ -117,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[] = [];
@@ -135,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);
     }
@@ -331,6 +331,7 @@ export class DefaultThemeCompiler extends AbstractThemeCompiler<IDefaultTheme> {
   private compileQuestion(
     pageId: string,
     page: BuilderPageDto,
+    variableId: string,
   ): {
     question: DTextDto;
     buttons: DDivDto[];
@@ -352,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"
+  },
 }

package/src/rulebuilder/Rule2.ts

@@ -1,87 +0,0 @@
-import { BuilderVariableType } from "./RuleVariable";
-import { BuilderOperator } from "./condition/Builder-operator";
-import { BuilderConditionDto } from "./condition/Builder-condition";
-
-type ConditionType = "all" | "any" | "";
-
-type SolveResultType = "TRUE" | "FALSE" | "NOT_ENOUGH_DATA" | "ERROR";
-
-type SolveErrorReason =
-  | "INVALID_FACT_TYPE"
-  | "INVALID_OPERATOR"
-  | "INVALID_VALUE"
-  | "INVALID_VARIABLE"
-  | "UNIMPLEMENTED_VARIABLE_TYPE"
-  | "UNIMPLEMENTED_OPERATOR";
-
-type IsTrue = { readonly type: "IS_TRUE" };
-type IsFalse = { readonly type: "IS_FALSE" };
-type IsMissingFacts = { readonly type: "MISSING_FACTS"; readonly missingVariables: ReadonlyArray<string> };
-type HasError = {
-  readonly type: "HAS_ERROR";
-  readonly reason: SolveErrorReason;
-  readonly data: Record<string, string>;
-};
-export type SolveResult = IsFalse | IsTrue | IsMissingFacts | HasError;
-
-export interface Fact2 {
-  readonly variableType: "numeric";
-  readonly value: number;
-  readonly valueLabel: string;
-  readonly variableId: string;
-  readonly variableLabel: string;
-}
-
-class FactCollection {
-  constructor(private readonly facts: ReadonlyArray<Fact2>) {}
-  byId(variableId: string): Fact2 | false {
-    const result = this.facts.find((fact) => fact.variableId === variableId);
-    if (!result) {
-      return false;
-    }
-    return result;
-  }
-}
-interface Solvable {
-  isTrue(facts: FactCollection): boolean;
-  solve(facts: FactCollection): SolveResult;
-}
-interface IsValid {
-  isValid(): boolean;
-}
-export class Condition implements Solvable, IsValid {
-  constructor(private readonly dto: BuilderConditionDto) {}
-  isTrue(facts: FactCollection): boolean {
-    const op = this.dto.operator;
-    if (!BuilderOperator.is(op)) {
-      return false;
-    }
-
-    const fact = facts.byId(this.dto.variableId);
-
-    if (!fact) {
-      return false;
-    }
-
-    if (fact.variableType !== "numeric" && typeof fact.value !== "number") {
-      return false;
-    }
-
-    return false;
-  }
-  isValid(): boolean {
-    return false;
-  }
-
-  solve(facts: FactCollection): SolveResult {
-    return { type: "HAS_ERROR", reason: "UNIMPLEMENTED_VARIABLE_TYPE", data: {} }; // TODO
-  }
-}
-export class ConditionGroup {}
-export class Rule2 {
-  private _count = -1;
-  constructor(
-    private readonly dto: any,
-    private readonly _ruleInput: any,
-  ) {}
-}