@media-quest/builder 0.0.25 → 0.0.26

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,48 +1,34 @@
-import { VarID } from "../primitives/varID";
-
-const BuilderVariableType = {
-  numericWithOptions: true,
-  numeric: true,
-  numericRange: true,
-  text: true,
-  date: true,
-  dateRange: true,
-  time: true,
-  duration: true,
-  boolean: true,
-} as const;
-
-export type BuilderVariableType = keyof typeof BuilderVariableType;
-
-export class BuilderVariableOption {
-  constructor(
-    readonly label: string,
-    readonly value: number,
-  ) {}
-}
-
-export class QuestionVariable {
-  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 pageNumber: number,
-  ) {}
-}
-
-export class CustomVariable {
-  readonly kind: "configuration-variable" = "configuration-variable";
-  readonly dataType: BuilderVariableType = "numericWithOptions";
-  constructor(
-    readonly varId: VarID,
-    readonly label: string,
-    readonly options: ReadonlyArray<BuilderVariableOption>,
-  ) {}
-}
-
-export type BuilderVariable = QuestionVariable | CustomVariable;
+import { VarID } from "../primitives/varID";
+
+/*******************************************
+ ** ONLY USE THESE TYPES IN RULE-BUILDER  **
+ ******************************************/
+
+export class RuleVariableOption {
+  constructor(
+    readonly label: string,
+    readonly value: number,
+  ) {}
+}
+
+export class RuleQuestionVariable {
+  readonly kind: "question-variable" = "question-variable";
+  constructor(
+    readonly varId: VarID,
+    readonly label: string,
+    readonly options: ReadonlyArray<RuleVariableOption>,
+    readonly pageNumber: number,
+  ) {}
+}
+
+export class RuleCustomVariable {
+  readonly kind: "configuration-variable" = "configuration-variable";
+  constructor(
+    readonly varId: string,
+    readonly label: string,
+    readonly options: ReadonlyArray<RuleVariableOption>,
+  ) {}
+}
+
+// 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,33 +1,33 @@
-import type { RuleInput } from "./RuleInput";
-import { ExcludeByPageIdSelectItem } from "./multi-select-item";
-import { ExcludeByPageAction } from "./RuleAction";
-import { PageID } from "../primitives/ID";
-
-export class PageActionManager {
-  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);
-    });
-  }
-
-  getCurrentSelection(): ReadonlyArray<PageID> {
-    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];
-  }
-}
+import type { RuleInput } from "./RuleInput";
+import { ExcludeByPageIdSelectItem } from "./multi-select-item";
+import { ExcludeByPageAction } from "./RuleAction";
+import { PageID } from "../primitives/ID";
+
+export class PageActionManager {
+  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);
+    });
+  }
+
+  getCurrentSelection(): ReadonlyArray<PageID> {
+    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];
+  }
+}