@media-quest/builder 0.0.24 → 0.0.26

package/src/public-api.ts

@@ -1,24 +1,28 @@
-export { type BuilderOptionDto, BuilderOption } from "./Builder-option";
-export { type BuilderPageDto, type BuilderPageType, BuilderPage } from "./Builder-page";
-export {
-  type BuilderQuestionDto,
-  BuilderQuestion,
-  type BuilderQuestionType,
-} from "./Builder-question";
-export { BuilderSchema, type BuilderSchemaDto } from "./Builder-schema";
-export { BuilderText, type BuilderTextDto } from "./Builder-text";
-export { type BuilderMainImageDto } from "./BuilderMainImageDto";
-export { BuilderMainText, type BuilderMainTextDto } from "./BuilderMainText";
-export { type BuilderMainVideoDto } from "./BuilderMainVideoDto";
-export { type BuilderTagDto, BuilderTag, TagCollection } from "./BuilderTag";
-export { type AudioFile, type ImageFile, type VideoFile } from "./media-files";
-// Public Api of rule-builder
-export * from "./rulebuilder";
-export { PagePrefix, PagePrefixValue } from "./primitives/page-prefix";
-export { SchemaPrefix, SchemaPrefixValue } from "./primitives/schema-prefix";
-export * from "./schema-config";
-export * from "./codebook";
-export { VarID } from "./primitives/varID";
-export * from "./variable/mq-variable";
-export * from "./builder-compiler";
-export * from "./variable/sum-score";
+export { type BuilderOptionDto, BuilderOption } from "./Builder-option";
+export { type BuilderPageDto, type BuilderPageType, BuilderPage } from "./Builder-page";
+export {
+  type BuilderQuestionDto,
+  BuilderQuestion,
+  type BuilderQuestionType,
+} from "./Builder-question";
+export { BuilderSchema, type BuilderSchemaDto } from "./Builder-schema";
+export { BuilderText, type BuilderTextDto } from "./Builder-text";
+export { type BuilderMainImageDto } from "./BuilderMainImageDto";
+export { BuilderMainText, type BuilderMainTextDto } from "./BuilderMainText";
+export { type BuilderMainVideoDto } from "./BuilderMainVideoDto";
+export { type BuilderTagDto, BuilderTag, TagCollection } from "./BuilderTag";
+export { type AudioFile, type ImageFile, type VideoFile } from "./media-files";
+// Public Api of rule-builder
+export * from "./rulebuilder";
+export { PagePrefix, PagePrefixValue } from "./primitives/page-prefix";
+export { SchemaPrefix, SchemaPrefixValue } from "./primitives/schema-prefix";
+export * from "./schema-config";
+export * from "./code-book/codebook";
+export { VarID } from "./primitives/varID";
+export * from "./primitives/ID";
+export * from "./code-book/codebook-variable";
+export * from "./builder-compiler";
+export * from "./sum-score/sum-score";
+export { SumScoreVariableDto } from "./sum-score/sum-score-variable";
+export { SumScoreAnswer } from "./sum-score/sum-score-answer";
+export { SumScoreManager } from "./sum-score/sum-score-manager";

package/src/rulebuilder/Builder-rule.spec.ts

@@ -3,10 +3,11 @@ import { RuleBuilderTestUtils as U } from "./RuleBuilder-test-utils";
 import { RuleInput } from "./RuleInput";
 import type { BuilderConditionGroupDto } from "./condition/Builder-condition-group";
 import { BuilderConditionDto } from "./condition/Builder-condition";
-import { Condition, PageID } from "@media-quest/engine";
+import { Condition } from "@media-quest/engine";
 import { PagePrefix } from "../primitives/page-prefix";
 import { VarID } from "../primitives/varID";
 import { SchemaPrefix } from "../primitives/schema-prefix";
+import { PageID } from "../primitives/ID";
 
 const { createPagesAndVars_A_H } = U;
 
@@ -155,7 +156,7 @@ describe("Builder Rule", () => {
     expect(rule.conditionCount).toBe(2);
   });
 
-  test("Conditions have no operators available before variable is set.", () => {
+  test("Conditions have no operators available before sum-score is set.", () => {
     const c1 = rule.addCondition();
     expect(c1.operatorsSelectItems.length).toBe(0);
 

package/src/rulebuilder/Builder-rule.ts

@@ -9,7 +9,8 @@ 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, PageID, RuleActionPageQue, PageQueRules } from "@media-quest/engine";
+import { Condition, RuleActionPageQue, PageQueRules } from "@media-quest/engine";
+import { PageID } from "../primitives/ID";
 
 export interface BuilderRuleDto {
   readonly type: ConditionGroupType;

package/src/rulebuilder/RuleBuilder-test-utils.ts

@@ -1,15 +1,15 @@
 import { BuilderOption } from "../Builder-option";
-import { type BuilderVariable, QuestionVariable } from "./RuleVariable";
+import { type RuleVariable, RuleQuestionVariable } from "./RuleVariable";
 import type { BuilderRuleDto } from "./Builder-rule";
 import type { BuilderConditionGroupDto } from "./condition/Builder-condition-group";
 import type { BuilderConditionDto } from "./condition/Builder-condition";
 import type { BuilderOperator } from "./condition/Builder-operator";
 import type { ExcludeByPageAction, ExcludeByTagAction, JumpToPageAction } from "./RuleAction";
 import { ExcludeByPageIdSelectItem, ExcludeByTagSelectItem } from "./multi-select-item";
-import { PageID } from "@media-quest/engine";
-import { PagePrefix, PagePrefixValue } from "../primitives/page-prefix";
+import { PagePrefix } from "../primitives/page-prefix";
 import { VarID } from "../primitives/varID";
 import { SchemaPrefix } from "../primitives/schema-prefix";
+import { PageID } from "../primitives/ID";
 
 const idPxx = () => {
   const id = PageID.create();
@@ -72,8 +72,8 @@ export namespace RuleBuilderTestUtils {
     ] as const;
     return list;
   };
-  export const createRuleVariable = (varId: VarID, pageNumber: number): QuestionVariable =>
-    new QuestionVariable(varId, "Har du " + varId + "?", createOptions(), pageNumber);
+  export const createRuleVariable = (varId: VarID, pageNumber: number): RuleQuestionVariable =>
+    new RuleQuestionVariable(varId, "Har du " + varId + "?", createOptions(), pageNumber);
 
   /**
    *
@@ -117,7 +117,7 @@ export namespace RuleBuilderTestUtils {
     return { list, items, pageIds, pageIdList };
   };
 
-  export const createConditionDto = (variable: BuilderVariable): BuilderConditionDto => {
+  export const createConditionDto = (variable: RuleVariable): BuilderConditionDto => {
     const operator: BuilderOperator = Math.random() > 0 ? "equal" : "notEqual";
     const opt = variable.options[0];
     return {
@@ -129,7 +129,9 @@ export namespace RuleBuilderTestUtils {
     };
   };
 
-  export const createConditionGroupDto = (conditions: BuilderConditionDto[]): BuilderConditionGroupDto => {
+  export const createConditionGroupDto = (
+    conditions: BuilderConditionDto[],
+  ): BuilderConditionGroupDto => {
     return {
       kind: "condition-group",
       conditions,
@@ -138,7 +140,9 @@ export namespace RuleBuilderTestUtils {
     };
   };
 
-  export const createBuilderRuleDto = (schemaPrefix: SchemaPrefix): ReadonlyArray<BuilderRuleDto> => {
+  export const createBuilderRuleDto = (
+    schemaPrefix: SchemaPrefix,
+  ): ReadonlyArray<BuilderRuleDto> => {
     const v = createPagesAndVars_A_H(schemaPrefix);
     const condition0 = createConditionDto(v.items.a);
     const condition1 = createConditionDto(v.items.b);

package/src/rulebuilder/RuleInput.ts

@@ -1,44 +1,44 @@
-import type { QuestionVariable, CustomVariable, BuilderVariable } from "./RuleVariable";
+import type { RuleQuestionVariable, RuleCustomVariable, RuleVariable } from "./RuleVariable";
 import type { ExcludeByPageAction, ExcludeByTagAction, JumpToPageAction } from "./RuleAction";
 import { JumpToPageSelectItem } from "./SingleSelectItem";
 
 /**
- * TODO Crate filters for "cardinality" or "order" of a variable;
+ * TODO Crate filters for "cardinality" or "order" of a sum-score;
  * Return legal lists of variables.
  */
 export class RuleInput {
-    constructor(
-        private readonly _questionVariables: ReadonlyArray<QuestionVariable>,
-        private readonly _customVariables: ReadonlyArray<CustomVariable>,
-        private readonly _pageIdActions: ReadonlyArray<ExcludeByPageAction>,
-        private readonly _tagActions: ReadonlyArray<ExcludeByTagAction>,
-        private readonly _jumpActions: ReadonlyArray<JumpToPageAction>
-    ) {}
+  constructor(
+    private readonly _questionVariables: ReadonlyArray<RuleQuestionVariable>,
+    private readonly _customVariables: ReadonlyArray<RuleCustomVariable>,
+    private readonly _pageIdActions: ReadonlyArray<ExcludeByPageAction>,
+    private readonly _tagActions: ReadonlyArray<ExcludeByTagAction>,
+    private readonly _jumpActions: ReadonlyArray<JumpToPageAction>,
+  ) {}
 
-    get questionVars(): ReadonlyArray<QuestionVariable> {
-        return this._questionVariables;
-    }
+  get questionVars(): ReadonlyArray<RuleVariable> {
+    return this._questionVariables;
+  }
 
-    getConditionInput(): ReadonlyArray<BuilderVariable> {
-        return [...this.questionVars, ...this.customVars];
-    }
+  getConditionInput(): ReadonlyArray<RuleVariable> {
+    return [...this.questionVars, ...this.customVars];
+  }
 
-    getJumpToPageOptions(): ReadonlyArray<JumpToPageSelectItem> {
-        return this._jumpActions.map(JumpToPageSelectItem.create);
-    }
+  getJumpToPageOptions(): ReadonlyArray<JumpToPageSelectItem> {
+    return this._jumpActions.map(JumpToPageSelectItem.create);
+  }
 
-    get customVars(): ReadonlyArray<CustomVariable> {
-        return this._customVariables;
-    }
+  get customVars(): ReadonlyArray<RuleCustomVariable> {
+    return this._customVariables;
+  }
 
-    get excludeByPageIdActions() {
-        return this._pageIdActions;
-    }
+  get excludeByPageIdActions() {
+    return this._pageIdActions;
+  }
 
-    get excludeByTagActions() {
-        return this._tagActions;
-    }
-    get jumpToPageActions() {
-        return this._jumpActions;
-    }
+  get excludeByTagActions() {
+    return this._tagActions;
+  }
+  get jumpToPageActions() {
+    return this._jumpActions;
+  }
 }

package/src/rulebuilder/RuleVariable.ts

@@ -1,49 +1,34 @@
-import { PagePrefix } from "../primitives/page-prefix";
 import { VarID } from "../primitives/varID";
-import { SchemaPrefix } from "../primitives/schema-prefix";
 
-const BuilderVariableType = {
-  numericWithOptions: true,
-  numeric: true,
-  numericRange: true,
-  text: true,
-  date: true,
-  dateRange: true,
-  time: true,
-  duration: true,
-  boolean: true,
-} as const;
+/*******************************************
+ ** ONLY USE THESE TYPES IN RULE-BUILDER  **
+ ******************************************/
 
-export type BuilderVariableType = keyof typeof BuilderVariableType;
-
-export class BuilderVariableOption {
+export class RuleVariableOption {
   constructor(
     readonly label: string,
     readonly value: number,
   ) {}
 }
 
-export class QuestionVariable {
+export class RuleQuestionVariable {
   readonly kind: "question-variable" = "question-variable";
-  readonly dataType: BuilderVariableType = "numericWithOptions";
   constructor(
-    // private schemaPrefix: SchemaPrefix,
-    // private pagePrefix: PagePrefix,
     readonly varId: VarID,
     readonly label: string,
-    readonly options: ReadonlyArray<BuilderVariableOption>,
+    readonly options: ReadonlyArray<RuleVariableOption>,
     readonly pageNumber: number,
   ) {}
 }
 
-export class CustomVariable {
+export class RuleCustomVariable {
   readonly kind: "configuration-variable" = "configuration-variable";
-  readonly dataType: BuilderVariableType = "numericWithOptions";
   constructor(
-    readonly varId: VarID,
+    readonly varId: string,
     readonly label: string,
-    readonly options: ReadonlyArray<BuilderVariableOption>,
+    readonly options: ReadonlyArray<RuleVariableOption>,
   ) {}
 }
 
-export type BuilderVariable = QuestionVariable | CustomVariable;
+// export class RuleVariable {}
+export type RuleVariable = RuleQuestionVariable | RuleCustomVariable;

package/src/rulebuilder/SingleSelectItem.ts

@@ -1,4 +1,4 @@
-import { BuilderVariable, BuilderVariableOption } from "./RuleVariable";
+import { RuleVariable, RuleVariableOption } from "./RuleVariable";
 import { BuilderOperator } from "./condition/Builder-operator";
 import { JumpToPageAction } from "./RuleAction";
 
@@ -27,12 +27,12 @@ export abstract class SingleSelectItem<T> {
   protected abstract getSearchString(): string;
 }
 
-export class RuleVariableSelectItem extends SingleSelectItem<BuilderVariable> {
-  public static create = (data: BuilderVariable) => {
+export class RuleVariableSelectItem extends SingleSelectItem<RuleVariable> {
+  public static create = (data: RuleVariable) => {
     return new RuleVariableSelectItem(data);
   };
   readonly options: ReadonlyArray<RuleOptionSelectItem>;
-  constructor(readonly data: BuilderVariable) {
+  constructor(readonly data: RuleVariable) {
     super(data);
     this.options = data.options.map(RuleOptionSelectItem.create);
   }
@@ -50,11 +50,11 @@ export class RuleVariableSelectItem extends SingleSelectItem<BuilderVariable> {
   }
 }
 
-export class RuleOptionSelectItem extends SingleSelectItem<BuilderVariableOption> {
-  public static create = (option: BuilderVariableOption) => {
+export class RuleOptionSelectItem extends SingleSelectItem<RuleVariableOption> {
+  public static create = (option: RuleVariableOption) => {
     return new RuleOptionSelectItem(option);
   };
-  private constructor(option: BuilderVariableOption) {
+  private constructor(option: RuleVariableOption) {
     super(option);
   }
   protected getSearchString(): string {
@@ -116,7 +116,8 @@ export class OperatorSelectItem extends SingleSelectItem<BuilderOperator | ""> {
 }
 
 export class JumpToPageSelectItem extends SingleSelectItem<JumpToPageAction> {
-  public static readonly create = (pageData: JumpToPageAction) => new JumpToPageSelectItem(pageData);
+  public static readonly create = (pageData: JumpToPageAction) =>
+    new JumpToPageSelectItem(pageData);
   protected constructor(pageData: JumpToPageAction) {
     super(pageData);
   }

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

@@ -1,6 +1,6 @@
 import { BuilderCondition, type BuilderConditionDto } from "./Builder-condition";
 import { BuilderObject } from "../../BuilderObject";
-import type { BuilderVariable } from "../RuleVariable";
+import type { RuleVariable } from "../RuleVariable";
 import { Condition } from "@media-quest/engine";
 
 const ConditionGroupType = {
@@ -18,7 +18,10 @@ export interface BuilderConditionGroupDto {
   readonly conditions: ReadonlyArray<BuilderConditionDto>;
 }
 
-export class BuilderConditionGroup extends BuilderObject<"builder-condition-group", BuilderConditionGroupDto> {
+export class BuilderConditionGroup extends BuilderObject<
+  "builder-condition-group",
+  BuilderConditionGroupDto
+> {
   static readonly isConditionGroupType = (value: string | symbol): value is ConditionGroupType => {
     if (typeof value !== "string") {
       return false;
@@ -31,12 +34,15 @@ export class BuilderConditionGroup extends BuilderObject<"builder-condition-grou
   private _type: ConditionGroupType;
   name = "";
   private readonly _conditions: Array<BuilderCondition>;
-  private readonly _variableList: ReadonlyArray<BuilderVariable>;
+  private readonly _variableList: ReadonlyArray<RuleVariable>;
 
-  public static readonly fromDto = (dto: BuilderConditionGroupDto, variableList: ReadonlyArray<BuilderVariable>) => {
+  public static readonly fromDto = (
+    dto: BuilderConditionGroupDto,
+    variableList: ReadonlyArray<RuleVariable>,
+  ) => {
     return new BuilderConditionGroup(dto, variableList);
   };
-  protected constructor(dto: BuilderConditionGroupDto, variableList: ReadonlyArray<BuilderVariable>) {
+  protected constructor(dto: BuilderConditionGroupDto, variableList: ReadonlyArray<RuleVariable>) {
     super(dto);
     this.name = dto.name;
     this._type = dto.type;
@@ -73,7 +79,9 @@ export class BuilderConditionGroup extends BuilderObject<"builder-condition-grou
   }
 
   toJson(): BuilderConditionGroupDto {
-    const conditions: ReadonlyArray<BuilderConditionDto> = [...this._conditions.map((c) => c.toJson())];
+    const conditions: ReadonlyArray<BuilderConditionDto> = [
+      ...this._conditions.map((c) => c.toJson()),
+    ];
     return {
       name: this.name,
       conditions,

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

@@ -1,7 +1,7 @@
 import { BuilderCondition, type BuilderConditionDto } from "./Builder-condition";
 import { RuleBuilderTestUtils } from "../RuleBuilder-test-utils";
-import type { BuilderVariable, BuilderVariableOption } from "../RuleVariable";
-import { QuestionVariable } from "../RuleVariable";
+import { type RuleVariable, RuleVariableOption, RuleQuestionVariable } from "../RuleVariable";
+// import { QuestionVariable } from "../RuleVariable";
 
 import { SchemaPrefix } from "../../primitives/schema-prefix";
 
@@ -77,9 +77,9 @@ describe("Builder Operator", () => {
       value: 0,
     };
     const c = BuilderCondition.fromDto(dto, vs.list);
-    expect(c.variable).toBeInstanceOf(QuestionVariable);
+    expect(c.variable).toBeInstanceOf(RuleQuestionVariable);
     expect(c.operator === "equal").toBe(true);
-    const value = c.value as BuilderVariableOption;
+    const value = c.value as RuleVariableOption;
     expect(value.value).toBe(0);
     expect(value.label).toBe("Nei");
     expect(c.variable).toBe(a);
@@ -96,9 +96,9 @@ describe("Builder Operator", () => {
       value: 0,
     };
     const c = BuilderCondition.fromDto(dto, vs.list);
-    expect(c.variable).toBeInstanceOf(QuestionVariable);
+    expect(c.variable).toBeInstanceOf(RuleQuestionVariable);
     expect(c.operator === "equal").toBe(true);
-    const value = c.value as BuilderVariableOption;
+    const value = c.value as RuleVariableOption;
     expect(value.value).toBe(0);
     expect(value.label).toBe("Nei");
     expect(c.validate().isValid).toBe(true);
@@ -114,7 +114,7 @@ describe("Builder Operator", () => {
     const c = BuilderCondition.fromDto(dto, []);
     expect(c.validate().isValid).toBe(false);
   });
-  test("Condition is invalid, when variable dont exist in universe.", () => {
+  test("Condition is invalid, when sum-score dont exist in universe.", () => {
     const variables = RuleBuilderTestUtils.createPagesAndVars_A_H(as);
     const dto: BuilderConditionDto = {
       kind: "condition",
@@ -127,7 +127,7 @@ describe("Builder Operator", () => {
     expect(c.variable).toBe(false);
     expect(c.validate().isValid).toBe(false);
   });
-  test("Condition is invalid if not all set, when variable dont exist in variables.", () => {
+  test("Condition is invalid if not all set, when sum-score dont exist in variables.", () => {
     const variables = RuleBuilderTestUtils.createPagesAndVars_A_H(as);
     const dto: BuilderConditionDto = {
       kind: "condition",
@@ -153,11 +153,11 @@ describe("Builder Operator", () => {
     };
     expect(a.varId).toBe("as_a");
     const c = BuilderCondition.fromDto(dto, variables.list);
-    expect(c.variable).toBeInstanceOf(QuestionVariable);
+    expect(c.variable).toBeInstanceOf(RuleQuestionVariable);
     expect(c.validate().isValid).toBe(false);
     expect(c.value).toBe(false);
   });
-  test("Condition is invalid if value (from dto) is not found in variable", () => {
+  test("Condition is invalid if value (from dto) is not found in sum-score", () => {
     const { list, items } = RuleBuilderTestUtils.createPagesAndVars_A_H(as);
     expect(items.a.varId).toBe("as_a");
     const dto: BuilderConditionDto = {
@@ -169,7 +169,7 @@ describe("Builder Operator", () => {
     };
     const c = BuilderCondition.fromDto(dto, list);
     expect(c).toBeInstanceOf(BuilderCondition);
-    expect(c.variable).toBeInstanceOf(QuestionVariable);
+    expect(c.variable).toBeInstanceOf(RuleQuestionVariable);
     expect(c.operator).toBe("equal");
     expect(c.operatorsSelectItems.length).toBe(BuilderCondition.NUMBER_OPERATORS.length);
     expect(c.value).toBe(false);
@@ -186,7 +186,7 @@ describe("Builder Operator", () => {
       value: 7,
     };
     const c = BuilderCondition.fromDto(dto, variables.list);
-    expect(c.variable).toBeInstanceOf(QuestionVariable);
+    expect(c.variable).toBeInstanceOf(RuleQuestionVariable);
     expect(c.operator).toBe("equal");
     expect(c.operatorsSelectItems.length).toBe(BuilderCondition.NUMBER_OPERATORS.length);
     expect(c.value).toBe(false);

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

@@ -1,7 +1,11 @@
 import { BuilderObject } from "../../BuilderObject";
 import { BuilderOperator } from "./Builder-operator";
-import type { BuilderVariable, BuilderVariableOption } from "../RuleVariable";
-import { OperatorSelectItem, RuleOptionSelectItem, RuleVariableSelectItem } from "../SingleSelectItem";
+import type { RuleVariable, RuleVariableOption } from "../RuleVariable";
+import {
+  OperatorSelectItem,
+  RuleOptionSelectItem,
+  RuleVariableSelectItem,
+} from "../SingleSelectItem";
 import { Condition } from "@media-quest/engine";
 export interface BuilderConditionDto {
   readonly kind: "condition";
@@ -21,7 +25,7 @@ export class BuilderCondition extends BuilderObject<"builder-condition", Builder
   private initialDto: BuilderConditionDto;
   name = "";
 
-  public static create = (variableList: ReadonlyArray<BuilderVariable>) => {
+  public static create = (variableList: ReadonlyArray<RuleVariable>) => {
     const condition = new BuilderCondition(
       {
         kind: "condition",
@@ -35,7 +39,7 @@ export class BuilderCondition extends BuilderObject<"builder-condition", Builder
     return condition;
   };
 
-  public static fromDto = (dto: BuilderConditionDto, variables: ReadonlyArray<BuilderVariable>) => {
+  public static fromDto = (dto: BuilderConditionDto, variables: ReadonlyArray<RuleVariable>) => {
     const _dto: BuilderConditionDto = {
       kind: "condition",
       name: dto.name ?? "",
@@ -46,16 +50,16 @@ export class BuilderCondition extends BuilderObject<"builder-condition", Builder
     const instance = new BuilderCondition(_dto, variables);
     return instance;
   };
-  private _variable: BuilderVariable | false = false;
+  private _variable: RuleVariable | false = false;
   private _operator: BuilderOperator | "" = "";
-  private _value: BuilderVariableOption | false = false;
-  private _variableList: ReadonlyArray<BuilderVariable> = [];
+  private _value: RuleVariableOption | false = false;
+  private _variableList: ReadonlyArray<RuleVariable> = [];
 
   /**
    * Can only set variables that exist in variableList.
    * @param variable
    */
-  set variable(variable: BuilderVariable | false) {
+  set variable(variable: RuleVariable | false) {
     if (variable === this._variable) {
       return;
     }
@@ -68,7 +72,7 @@ export class BuilderCondition extends BuilderObject<"builder-condition", Builder
     return this._variable;
   }
 
-  set value(variableValue: BuilderVariableOption | false) {
+  set value(variableValue: RuleVariableOption | false) {
     this._value = variableValue;
   }
   get value() {
@@ -96,7 +100,7 @@ export class BuilderCondition extends BuilderObject<"builder-condition", Builder
     if (!this._value) {
       return {
         isValid: false,
-        message: "Value (BuilderVariableOption) is not initialized",
+        message: "Value (RuleVariableOption) is not initialized",
       };
     }
 
@@ -124,7 +128,7 @@ export class BuilderCondition extends BuilderObject<"builder-condition", Builder
     return false;
   }
 
-  private findVariableInUniverse(variableId: string): BuilderVariable | false {
+  private findVariableInUniverse(variableId: string): RuleVariable | false {
     const v = this._variableList.find((v) => v.varId === variableId);
     return v ?? false;
   }
@@ -141,7 +145,7 @@ export class BuilderCondition extends BuilderObject<"builder-condition", Builder
     return this._operator;
   }
 
-  private constructor(dto: BuilderConditionDto, variables: ReadonlyArray<BuilderVariable>) {
+  private constructor(dto: BuilderConditionDto, variables: ReadonlyArray<RuleVariable>) {
     super(dto);
     this.initialDto = dto;
     this.name = dto.name;
@@ -168,7 +172,7 @@ export class BuilderCondition extends BuilderObject<"builder-condition", Builder
     return this.toJson();
   }
 
-  private _setVariableList(variables: ReadonlyArray<BuilderVariable>): boolean {
+  private _setVariableList(variables: ReadonlyArray<RuleVariable>): boolean {
     this._variableList = variables;
     const v = this._variableList.find((v) => v.varId === this.originalDto.variableId);
     if (!v) {

package/src/rulebuilder/index.ts

@@ -7,11 +7,24 @@ export {
 export { BuilderOperator } from "./condition/Builder-operator";
 export { BuilderRule, type BuilderRuleDto } from "./Builder-rule";
 export { JumpToActionManager } from "./jump-to-action-manager";
-export { MultiSelectItem, ExcludeByPageIdSelectItem, ExcludeByTagSelectItem } from "./multi-select-item";
+export {
+  MultiSelectItem,
+  ExcludeByPageIdSelectItem,
+  ExcludeByTagSelectItem,
+} from "./multi-select-item";
 export { PageActionManager } from "./page-action-manager";
-export { type ExcludeByPageAction, type ExcludeByTagAction, type JumpToPageAction } from "./RuleAction";
+export {
+  type ExcludeByPageAction,
+  type ExcludeByTagAction,
+  type JumpToPageAction,
+} from "./RuleAction";
 export { RuleInput } from "./RuleInput";
-export { CustomVariable, BuilderVariableOption, type BuilderVariable, QuestionVariable } from "./RuleVariable";
+export {
+  RuleCustomVariable,
+  RuleVariableOption,
+  type RuleVariable,
+  RuleQuestionVariable,
+} from "./RuleVariable";
 export {
   SingleSelectItem,
   OperatorSelectItem,

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

@@ -1,7 +1,7 @@
 import type { RuleInput } from "./RuleInput";
 import { ExcludeByPageIdSelectItem } from "./multi-select-item";
 import { ExcludeByPageAction } from "./RuleAction";
-import { PageID } from "@media-quest/engine";
+import { PageID } from "../primitives/ID";
 
 export class PageActionManager {
   private readonly _initialSelection: Set<string>;
@@ -19,7 +19,9 @@ export class PageActionManager {
   }
 
   getCurrentSelection(): ReadonlyArray<PageID> {
-    const selected = this.selectItems.filter((item) => item.isSelected).map((itm) => itm.data.pageId);
+    const selected = this.selectItems
+      .filter((item) => item.isSelected)
+      .map((itm) => itm.data.pageId);
     return selected;
   }
 

package/src/rulebuilder/rule2/Rule2.ts

@@ -1,6 +1,6 @@
 import { BuilderOperator } from "../condition/Builder-operator";
 import { BuilderConditionDto } from "../condition/Builder-condition";
-import { BuilderConditionGroupDto, ConditionGroupType } from "../condition/Builder-condition-group";
+import { BuilderConditionGroupDto } from "../condition/Builder-condition-group";
 import { BuilderRuleDto } from "../Builder-rule";
 
 type SolveErrorReason =
@@ -13,12 +13,16 @@ type SolveErrorReason =
 
 type TrueResult = { readonly type: "IS_TRUE" };
 type FalseResult = { readonly type: "IS_FALSE" };
-type MissingFactsResult = { readonly type: "MISSING_FACTS"; readonly missingVariables: ReadonlyArray<string> };
+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 {
@@ -47,7 +51,7 @@ export class FactCollection {
     if (typeof fact.valueLabel !== "string") {
       return false;
     }
-    // NB: This is a temporary check until we have more variable types.
+    // NB: This is a temporary check until we have more sum-score types.
     if (typeof fact.variableType !== "string" || fact.variableType !== "numeric") {
       return false;
     }
@@ -164,11 +168,7 @@ export class ConditionGroup implements FactEvaluator, IsValid {
     }
 
     const minLimit = this.dto.count;
-    if (type === "count" && typeof minLimit === "number" && trueCount >= minLimit) {
-      return true;
-    }
-
-    return false;
+    return type === "count" && typeof minLimit === "number" && trueCount >= minLimit;
   }
 
   isValid(): boolean {