@media-quest/builder 0.0.22 → 0.0.23

package/src/rulebuilder/RuleInput.ts

@@ -1,44 +1,44 @@
-import type { QuestionVariable, CustomVariable, BuilderVariable } from "./RuleVariable";
-import type { ExcludeByPageAction, ExcludeByTagAction, JumpToPageAction } from "./RuleAction";
-import { JumpToPageSelectItem } from "./SingleSelectItem";
-
-/**
- * TODO Crate filters for "cardinality" or "order" of a variable;
- * 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>
-    ) {}
-
-    get questionVars(): ReadonlyArray<QuestionVariable> {
-        return this._questionVariables;
-    }
-
-    getConditionInput(): ReadonlyArray<BuilderVariable> {
-        return [...this.questionVars, ...this.customVars];
-    }
-
-    getJumpToPageOptions(): ReadonlyArray<JumpToPageSelectItem> {
-        return this._jumpActions.map(JumpToPageSelectItem.create);
-    }
-
-    get customVars(): ReadonlyArray<CustomVariable> {
-        return this._customVariables;
-    }
-
-    get excludeByPageIdActions() {
-        return this._pageIdActions;
-    }
-
-    get excludeByTagActions() {
-        return this._tagActions;
-    }
-    get jumpToPageActions() {
-        return this._jumpActions;
-    }
-}
+import type { QuestionVariable, CustomVariable, BuilderVariable } from "./RuleVariable";
+import type { ExcludeByPageAction, ExcludeByTagAction, JumpToPageAction } from "./RuleAction";
+import { JumpToPageSelectItem } from "./SingleSelectItem";
+
+/**
+ * TODO Crate filters for "cardinality" or "order" of a variable;
+ * 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>
+    ) {}
+
+    get questionVars(): ReadonlyArray<QuestionVariable> {
+        return this._questionVariables;
+    }
+
+    getConditionInput(): ReadonlyArray<BuilderVariable> {
+        return [...this.questionVars, ...this.customVars];
+    }
+
+    getJumpToPageOptions(): ReadonlyArray<JumpToPageSelectItem> {
+        return this._jumpActions.map(JumpToPageSelectItem.create);
+    }
+
+    get customVars(): ReadonlyArray<CustomVariable> {
+        return this._customVariables;
+    }
+
+    get excludeByPageIdActions() {
+        return this._pageIdActions;
+    }
+
+    get excludeByTagActions() {
+        return this._tagActions;
+    }
+    get jumpToPageActions() {
+        return this._jumpActions;
+    }
+}

package/src/rulebuilder/RuleVariable.ts

@@ -1,49 +1,49 @@
-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;
-
-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 { 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;
+
+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;

package/src/rulebuilder/SingleSelectItem.ts

@@ -1,135 +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.pagePrefix + this.data.mainText;
-  }
-
-  protected getSelectLabel(): string {
-    return this.data.pagePrefix + " (" + this.data.pageNumber + ")";
-  }
-
-  protected getTooltip(): string {
-    return this.data.mainText;
-  }
-}
+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.pagePrefix + this.data.mainText;
+  }
+
+  protected getSelectLabel(): string {
+    return this.data.pagePrefix + " (" + this.data.pageNumber + ")";
+  }
+
+  protected getTooltip(): string {
+    return this.data.mainText;
+  }
+}

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

@@ -1,47 +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", () => {});
-});
+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", () => {});
+});