@media-quest/builder 0.0.1 → 0.0.3

package/src/rulebuilder/SingleSelectItem.ts

@@ -0,0 +1,135 @@
+import { BuilderVariable, BuilderVariableOption } from "./RuleVariable";
+import { BuilderOperator } from "./condition/Builder-operator";
+import { JumpToPageAction } from "./RuleAction";
+
+export abstract class SingleSelectItem<T> {
+  private readonly _selectLabel;
+  private readonly _toolTip;
+  private readonly _searchString;
+  get selectLabel(): string {
+    return this._selectLabel;
+  }
+  get tooltip() {
+    return this._toolTip;
+  }
+
+  get searchString() {
+    return this._searchString;
+  }
+
+  protected constructor(readonly data: T) {
+    this._selectLabel = this.getSelectLabel();
+    this._toolTip = this.getTooltip();
+    this._searchString = this.getSearchString();
+  }
+  protected abstract getSelectLabel(): string;
+  protected abstract getTooltip(): string;
+  protected abstract getSearchString(): string;
+}
+
+export class RuleVariableSelectItem extends SingleSelectItem<BuilderVariable> {
+  public static create = (data: BuilderVariable) => {
+    return new RuleVariableSelectItem(data);
+  };
+  readonly options: ReadonlyArray<RuleOptionSelectItem>;
+  constructor(readonly data: BuilderVariable) {
+    super(data);
+    this.options = data.options.map(RuleOptionSelectItem.create);
+  }
+
+  protected getSearchString(): string {
+    return this.data.varId + this.data.label;
+  }
+
+  getSelectLabel(): string {
+    return this.data.varId;
+  }
+
+  getTooltip(): string {
+    return this.data.label;
+  }
+}
+
+export class RuleOptionSelectItem extends SingleSelectItem<BuilderVariableOption> {
+  public static create = (option: BuilderVariableOption) => {
+    return new RuleOptionSelectItem(option);
+  };
+  private constructor(option: BuilderVariableOption) {
+    super(option);
+  }
+  protected getSearchString(): string {
+    return "";
+  }
+
+  protected getSelectLabel(): string {
+    return this.data.label + "(" + this.data.value + ")";
+  }
+
+  protected getTooltip(): string {
+    return "";
+  }
+}
+
+export class OperatorSelectItem extends SingleSelectItem<BuilderOperator | ""> {
+  public static readonly EQ = new OperatorSelectItem("equal");
+  public static readonly NOT_EQ = new OperatorSelectItem("notEqual");
+  public static readonly fromSymbol = (
+    symbol: BuilderOperator | Omit<string, BuilderOperator>,
+  ): OperatorSelectItem | false => {
+    if (symbol === "equal") {
+      return OperatorSelectItem.EQ;
+    }
+    if (symbol === "notEqual") {
+      return OperatorSelectItem.NOT_EQ;
+    }
+    return false;
+  };
+  private constructor(operator: BuilderOperator) {
+    super(operator);
+  }
+
+  protected getSearchString(): string {
+    return "";
+  }
+
+  protected getSelectLabel(): string {
+    const operator = this.data;
+    if (operator === "equal") {
+      return "Equals";
+    }
+    if (operator === "notEqual") {
+      return "Not equals";
+    }
+    return "";
+  }
+
+  protected getTooltip(): string {
+    const operator = this.data;
+    if (operator === "equal") {
+      return "Equals";
+    }
+    if (operator === "notEqual") {
+      return "Not equals";
+    }
+    return "";
+  }
+}
+
+export class JumpToPageSelectItem extends SingleSelectItem<JumpToPageAction> {
+  public static readonly create = (pageData: JumpToPageAction) => new JumpToPageSelectItem(pageData);
+  protected constructor(pageData: JumpToPageAction) {
+    super(pageData);
+  }
+
+  protected getSearchString(): string {
+    return this.data.pageId + this.data.mainText;
+  }
+
+  protected getSelectLabel(): string {
+    return this.data.pageId + " (" + this.data.pageNumber + ")";
+  }
+
+  protected getTooltip(): string {
+    return this.data.mainText;
+  }
+}

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

@@ -0,0 +1,47 @@
+import { BuilderConditionGroup } from "./Builder-condition-group";
+
+let group = BuilderConditionGroup.fromDto(
+    {
+        kind: "condition-group",
+        name: "g1",
+        type: "all",
+        conditions: [],
+    },
+    []
+);
+beforeEach(() => {});
+
+describe("Builder Operator", () => {
+    test("Can create", () => {
+        expect(group).toBeInstanceOf(BuilderConditionGroup);
+        group.name = "group1";
+        expect(group.name).toBe("group1");
+    });
+
+    test("Can add condition", () => {
+        const condition = group.addCondition();
+        expect(group.conditions.length).toBe(1);
+        const success = group.removeCondition(condition);
+        expect(success).toBe(true);
+        expect(group.conditions.length).toBe(0);
+    });
+    test("Can add condition when many", () => {
+        const c1 = group.addCondition();
+        const c2 = group.addCondition();
+        const c3 = group.addCondition();
+        const c4 = group.addCondition();
+        const c5 = group.addCondition();
+        expect(group.conditionCount).toBe(5);
+        const success = group.removeCondition(c3);
+        expect(success).toBe(true);
+        const fail = group.removeCondition(c3);
+        expect(fail).toBe(false);
+        expect(group.conditions[0]).toBe(c1);
+        expect(group.conditions[1]).toBe(c2);
+        expect(group.conditions[2]).toBe(c4);
+        expect(group.conditions[3]).toBe(c5);
+        // expect(group.conditions.length).toBe(0);
+    });
+
+    test("Can create operator from symbol", () => {});
+});

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

@@ -0,0 +1,91 @@
+import { BuilderCondition, type BuilderConditionDto } from "./Builder-condition";
+import { BuilderObject } from "../../BuilderObject";
+import type { BuilderVariable } from "../RuleVariable";
+
+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 type: ConditionGroupType;
+  readonly conditions: ReadonlyArray<BuilderConditionDto>;
+}
+
+export class BuilderConditionGroup extends BuilderObject<"builder-condition-group", BuilderConditionGroupDto> {
+  static readonly isConditionGroupType = (value: string | symbol): value is ConditionGroupType => {
+    if (typeof value !== "string") {
+      return false;
+    }
+    const validValues = Object.keys(ConditionGroupType);
+    return validValues.includes(value);
+  };
+
+  readonly objectType: "builder-condition-group" = "builder-condition-group";
+  private _type: ConditionGroupType;
+  name = "";
+  private readonly _conditions: Array<BuilderCondition>;
+  private readonly _variableList: ReadonlyArray<BuilderVariable>;
+
+  public static readonly fromDto = (dto: BuilderConditionGroupDto, variableList: ReadonlyArray<BuilderVariable>) => {
+    return new BuilderConditionGroup(dto, variableList);
+  };
+  protected constructor(dto: BuilderConditionGroupDto, variableList: ReadonlyArray<BuilderVariable>) {
+    super(dto);
+    this.name = dto.name;
+    this._type = dto.type;
+    const conditionList = Array.isArray(dto.conditions) ? dto.conditions : [];
+    this._conditions = conditionList.map((dto) => BuilderCondition.fromDto(dto, variableList));
+    this._variableList = variableList;
+  }
+  get conditions(): ReadonlyArray<BuilderCondition> {
+    return this._conditions;
+  }
+
+  get conditionCount() {
+    return this._conditions.length;
+  }
+
+  addCondition(): BuilderCondition {
+    const newConditions = BuilderCondition.create(this._variableList);
+    this._conditions.push(newConditions);
+    return newConditions;
+  }
+
+  removeCondition(condition: BuilderCondition): boolean {
+    // this._conditions.
+    const index = this._conditions.indexOf(condition);
+    if (index < 0) {
+      return false;
+    }
+    this._conditions.splice(index, 1);
+    return true;
+  }
+
+  clone(): BuilderConditionGroupDto {
+    return this.toJson();
+  }
+
+  toJson(): BuilderConditionGroupDto {
+    const conditions: ReadonlyArray<BuilderConditionDto> = [...this._conditions.map((c) => c.toJson())];
+    return {
+      name: this.name,
+      conditions,
+      type: this._type,
+      kind: "condition-group",
+    };
+  }
+  get type(): ConditionGroupType {
+    return this._type;
+  }
+  set type(conditionGroupType: ConditionGroupType) {
+    if (BuilderConditionGroup.isConditionGroupType(conditionGroupType)) {
+      this._type = conditionGroupType;
+    }
+  }
+}

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

@@ -0,0 +1,169 @@
+import { BuilderCondition, type BuilderConditionDto } from "./Builder-condition";
+import { RuleBuilderTestUtils } from "../RuleBuilder-test-utils";
+import type { BuilderVariable, BuilderVariableOption } from "../RuleVariable";
+import { QuestionVariable } from "../RuleVariable";
+
+let condition = BuilderCondition.create([]);
+
+beforeEach(() => {
+  condition = BuilderCondition.create([]);
+});
+
+describe("Builder Operator", () => {
+  test("Can create", () => {
+    expect(condition).toBeInstanceOf(BuilderCondition);
+  });
+  test("Can resolve dto from Variables in universe.", () => {
+    const vs = RuleBuilderTestUtils.createBuilderVariables_A_H();
+    const a = vs[0];
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "a",
+      variableId: a.varId,
+      operator: "equal",
+      value: 1,
+    };
+    const c = BuilderCondition.fromDto(dto, vs);
+    // c.setVariableList(vs);
+    expect(c.operatorsSelectItems.length).toBe(2);
+    expect(c.operator === "equal").toBe(true);
+    expect(c.value).toBeTruthy();
+  });
+  test("Can not resolve value if invalid value", () => {
+    const vs = RuleBuilderTestUtils.createBuilderVariables_A_H();
+    const a = vs[0];
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "a",
+      variableId: a.varId,
+      operator: "equal",
+      value: 8,
+    };
+    const c = BuilderCondition.fromDto(dto, vs);
+    expect(c.operatorsSelectItems.length).toBe(2);
+    expect(c.value).toBe(false);
+    // expect(match).toBe(false);
+  });
+  test("Will nullify dto if not matchedFrom is called", () => {
+    const vs = RuleBuilderTestUtils.createBuilderVariables_A_H();
+    const a = vs[0];
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "a",
+      variableId: a.varId,
+      operator: "equal",
+      value: 0,
+    };
+    const c = BuilderCondition.fromDto(dto, []);
+    expect(c.operatorsSelectItems.length).toBe(0);
+    expect(c.toJson().name).toBe(dto.name);
+    expect(c.toJson().value).toBe("");
+    expect(c.toJson().operator).toBe("");
+    expect(c.toJson().variableId).toBe("");
+    // expect(match).toBe(false);
+  });
+  test("Will not nullify if created with valid universe", () => {
+    const vs = RuleBuilderTestUtils.createBuilderVariables_A_H();
+    const a = vs[0];
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "a",
+      variableId: a.varId,
+      operator: "equal",
+      value: 0,
+    };
+    const c = BuilderCondition.fromDto(dto, vs);
+    expect(c.variable).toBeInstanceOf(QuestionVariable);
+    expect(c.operator === "equal").toBe(true);
+    const value = c.value as BuilderVariableOption;
+    expect(value.value).toBe(0);
+    expect(value.label).toBe("Nei");
+    expect(c.variable).toBe(a);
+  });
+  test("Condition is valid, when in sync with universe.", () => {
+    const vs = RuleBuilderTestUtils.createBuilderVariables_A_H();
+    const a = vs[0];
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+
+      name: "name of a",
+      variableId: a.varId,
+      operator: "equal",
+      value: 0,
+    };
+    const c = BuilderCondition.fromDto(dto, vs);
+    expect(c.variable).toBeInstanceOf(QuestionVariable);
+    expect(c.operator === "equal").toBe(true);
+    const value = c.value as BuilderVariableOption;
+    expect(value.value).toBe(0);
+    expect(value.label).toBe("Nei");
+    expect(c.validate().isValid).toBe(true);
+  });
+  test("Condition is invalid, when not matched against universe", () => {
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "name of a",
+      variableId: "a",
+      operator: "equal",
+      value: 0,
+    };
+    const c = BuilderCondition.fromDto(dto, []);
+    expect(c.validate().isValid).toBe(false);
+  });
+  test("Condition is invalid, when variable dont exist in universe.", () => {
+    const universe = RuleBuilderTestUtils.createBuilderVariables_A_H();
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "invalid variable name in dto",
+      variableId: "kkk",
+      operator: "equal",
+      value: 9,
+    };
+    const c = BuilderCondition.fromDto(dto, universe);
+    expect(c.variable).toBe(false);
+    expect(c.validate().isValid).toBe(false);
+  });
+  test("Condition is invalid if not all set, when variable dont exist in universe.", () => {
+    const universe = RuleBuilderTestUtils.createBuilderVariables_A_H();
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "invalid variable name in dto",
+      variableId: "kkk",
+      operator: "equal",
+      value: 9,
+    };
+    const c = BuilderCondition.fromDto(dto, universe);
+    expect(c.variable).toBe(false);
+    expect(c.validate().isValid).toBe(false);
+  });
+  test("Condition is invalid if operator is not set", () => {
+    const universe = RuleBuilderTestUtils.createBuilderVariables_A_H();
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "invalid variable name in dto",
+      variableId: "a",
+      operator: "",
+      value: 1,
+    };
+    const c = BuilderCondition.fromDto(dto, universe);
+    expect(c.variable).toBeInstanceOf(QuestionVariable);
+    expect(c.validate().isValid).toBe(false);
+    expect(c.value).toBe(false);
+  });
+  test("Condition is invalid if value (from dto) is not found in variable", () => {
+    const universe = RuleBuilderTestUtils.createBuilderVariables_A_H();
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "invalid variable name in dto",
+      variableId: "a",
+      operator: "equal",
+      value: 7,
+    };
+    const c = BuilderCondition.fromDto(dto, universe);
+    expect(c.variable).toBeInstanceOf(QuestionVariable);
+    expect(c.operator).toBe("equal");
+    expect(c.operatorsSelectItems.length).toBe(BuilderCondition.NUMBER_OPERATORS.length);
+    expect(c.value).toBe(false);
+    expect(c.validate().isValid).toBe(false);
+  });
+});

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

@@ -0,0 +1,186 @@
+import { BuilderObject } from "../../BuilderObject";
+import { BuilderOperator } from "./Builder-operator";
+import type { BuilderVariable, BuilderVariableOption } from "../RuleVariable";
+import { OperatorSelectItem, RuleOptionSelectItem, RuleVariableSelectItem } from "../SingleSelectItem";
+export interface BuilderConditionDto {
+  readonly kind: "condition";
+  readonly operator: BuilderOperator | "";
+  readonly name: string;
+  readonly variableId: string;
+  readonly value: number | string | boolean;
+}
+
+export class BuilderCondition extends BuilderObject<"builder-condition", BuilderConditionDto> {
+  readonly objectType: "builder-condition" = "builder-condition";
+  public static readonly NUMBER_OPERATORS: ReadonlyArray<OperatorSelectItem> = [
+    OperatorSelectItem.EQ,
+    OperatorSelectItem.NOT_EQ,
+  ];
+
+  private initialDto: BuilderConditionDto;
+  name = "";
+
+  public static create = (variableList: ReadonlyArray<BuilderVariable>) => {
+    const condition = new BuilderCondition(
+      {
+        kind: "condition",
+        name: "",
+        operator: "",
+        variableId: "",
+        value: "",
+      },
+      variableList,
+    );
+    return condition;
+  };
+
+  public static fromDto = (dto: BuilderConditionDto, variables: ReadonlyArray<BuilderVariable>) => {
+    const _dto: BuilderConditionDto = {
+      kind: "condition",
+      name: dto.name ?? "",
+      value: dto.value ?? "",
+      operator: dto.operator ?? "",
+      variableId: dto.variableId ?? "",
+    };
+    const instance = new BuilderCondition(_dto, variables);
+    return instance;
+  };
+  private _variable: BuilderVariable | false = false;
+  private _operator: BuilderOperator | "" = "";
+  private _value: BuilderVariableOption | false = false;
+  private _variableList: ReadonlyArray<BuilderVariable> = [];
+
+  /**
+   * Can only set variables that exist in variableList.
+   * @param variable
+   */
+  set variable(variable: BuilderVariable | false) {
+    if (variable === this._variable) {
+      return;
+    }
+    this._variable = variable;
+    this._operator = "";
+    this._value = false;
+  }
+
+  get variable() {
+    return this._variable;
+  }
+
+  set value(variableValue: BuilderVariableOption | false) {
+    this._value = variableValue;
+  }
+  get value() {
+    return this._value;
+  }
+
+  validate(): { isValid: true } | { isValid: false; message: string } {
+    if (this._variableList.length === 0) {
+      return {
+        isValid: false,
+        message: "Has no variableList to check dto against.",
+      };
+    }
+    if (!this._variable) {
+      return {
+        isValid: false,
+        message: "Variable has not been initialized from variableList.",
+      };
+    }
+
+    if (!this._operator) {
+      return { isValid: false, message: "Operator has not been initialized" };
+    }
+
+    if (!this._value) {
+      return {
+        isValid: false,
+        message: "Value (BuilderVariableOption) is not initialized",
+      };
+    }
+
+    return { isValid: true };
+  }
+
+  private findVariableInUniverse(variableId: string): BuilderVariable | false {
+    const v = this._variableList.find((v) => v.varId === variableId);
+    return v ?? false;
+  }
+
+  set operator(operator: BuilderOperator | "") {
+    if (BuilderOperator.is(operator)) {
+      this._operator = operator;
+    } else {
+      this._operator = "";
+    }
+  }
+
+  get operator() {
+    return this._operator;
+  }
+
+  private constructor(dto: BuilderConditionDto, variables: ReadonlyArray<BuilderVariable>) {
+    super(dto);
+    this.initialDto = dto;
+    this.name = dto.name;
+    this._setVariableList(variables);
+  }
+
+  get variableSelectItemsInUniverse(): ReadonlyArray<RuleVariableSelectItem> {
+    return this._variableList.map(RuleVariableSelectItem.create);
+  }
+
+  get operatorsSelectItems(): ReadonlyArray<OperatorSelectItem> {
+    return this._variable ? BuilderCondition.NUMBER_OPERATORS : [];
+  }
+
+  get selectValueItems(): ReadonlyArray<RuleOptionSelectItem> {
+    if (!this._variable) {
+      return [];
+    }
+    const opt = this._variable.options.map(RuleOptionSelectItem.create);
+    return opt;
+  }
+
+  clone(): BuilderConditionDto {
+    return this.toJson();
+  }
+
+  private _setVariableList(variables: ReadonlyArray<BuilderVariable>): boolean {
+    this._variableList = variables;
+    const v = this._variableList.find((v) => v.varId === this.originalDto.variableId);
+    if (!v) {
+      this._variable = false;
+      this._operator = "";
+      this._value = false;
+      return false;
+    }
+    this._variable = v;
+    const op = this.originalDto.operator;
+
+    if (!BuilderOperator.is(op)) {
+      return false;
+    }
+    this._operator = op;
+    const maybeOption = v.options.find((op) => op.value === this.originalDto.value);
+    if (!maybeOption) {
+      return false;
+    }
+    this._value = maybeOption;
+    return true;
+  }
+
+  toJson(): BuilderConditionDto {
+    const name = this.name;
+    const variableId = this._variable ? this._variable.varId : "";
+    const operator = this._operator ? this._operator : "";
+    const value = this._value ? this._value.value : "";
+    return {
+      kind: "condition",
+      name,
+      operator,
+      variableId,
+      value,
+    };
+  }
+}

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

@@ -0,0 +1,9 @@
+import { BuilderOperator } from "./Builder-operator";
+
+describe("Builder Operator", () => {
+    test("Can validate symbol", () => {
+        let symbol: BuilderOperator = "notBetween";
+        expect(BuilderOperator.is("invalid")).toBe(false);
+        expect(BuilderOperator.is(symbol)).toBe(true);
+    });
+});

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

@@ -0,0 +1,31 @@
+const BuilderOperatorSymbols = {
+  equal: true,
+  notEqual: true,
+  lessThan: true,
+  lessThanOrEqual: true,
+  greaterThan: true,
+  greaterThanOrEqual: true,
+  between: true,
+  notBetween: true,
+  in: true,
+  notIn: true,
+  missing: true,
+  notMissing: true,
+  contains: true,
+  notContains: true,
+  empty: true,
+  notEmpty: true,
+  startsWith: 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') {
+      return false;
+    }
+    return Object.keys(BuilderOperatorSymbols).includes(symbol);
+  };
+}

package/src/rulebuilder/index.ts

@@ -0,0 +1,22 @@
+export { BuilderCondition, type BuilderConditionDto } from "./condition/Builder-condition";
+export {
+  BuilderConditionGroup,
+  type BuilderConditionGroupDto,
+  type ConditionGroupType,
+} from "./condition/Builder-condition-group";
+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 { PageActionManager } from "./page-action-manager";
+export { type ExcludeByPageAction, type ExcludeByTagAction, type JumpToPageAction } from "./RuleAction";
+export { RuleInput } from "./RuleInput";
+export { CustomVariable, BuilderVariableOption, type BuilderVariable, QuestionVariable } from "./RuleVariable";
+export {
+  SingleSelectItem,
+  OperatorSelectItem,
+  RuleOptionSelectItem,
+  RuleVariableSelectItem,
+  JumpToPageSelectItem,
+} from "./SingleSelectItem";
+export { TagActionManager } from "./tag-action-manager";