@media-quest/builder 0.0.2 → 0.0.3

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/index.ts

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

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

@@ -1,169 +0,0 @@
-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/Builder-condition.ts

@@ -1,186 +0,0 @@
-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,
-        };
-    }
-}