@media-quest/builder 0.0.3 → 0.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@media-quest/builder",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Builder library for Media-quest schemas",
   "main": "dist/public-api.js",
   "module": "dist/public-api.mjs",
@@ -9,10 +9,10 @@
   "scripts": {
     "check": "tsc --watch --noEmit",
     "clean": "rimraf dist",
-    "build": "npm run clean && tsup src/public-api.ts --format cjs,esm --dts",
+    "build": "npm run clean && tsup src/public-api.ts --sourcemap inline --format cjs,esm --dts",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@media-quest/engine": "0.0.3"
+    "@media-quest/engine": "0.0.5"
   }
 }

package/src/Builder-option.ts

@@ -4,64 +4,63 @@ import { DefaultTheme } from "./theme/IDefaultTheme";
 import { AudioFile } from "./media-files";
 
 export interface BuilderOptionDto {
-    readonly id: BuilderObjectId.QuestionOptionID;
-    readonly value: number;
-    readonly label: string;
-    readonly labelAudio?: AudioFile;
-    // readonly theme: BuilderPageTheme['nextButtonTheme'];
+  readonly id: BuilderObjectId.QuestionOptionID;
+  readonly value: number;
+  readonly label: string;
+  readonly labelAudio?: AudioFile;
 }
 
 export class BuilderOption extends BuilderObject<"builder-question-option", BuilderOptionDto> {
-    readonly objectType = "builder-question-option";
-    theme: BuilderOptionTheme = DefaultTheme.responseButtons;
+  readonly objectType = "builder-question-option";
+  theme: BuilderOptionTheme = DefaultTheme.responseButtons;
 
-    id: BuilderObjectId.QuestionOptionID;
-    value: number;
-    label = "";
-    private _labelAudioFile: AudioFile | false = false;
-    get labelAudioFile() {
-        return this._labelAudioFile;
-    }
-    set labelAudioFile(audioFile: AudioFile | false) {
-        this._labelAudioFile = audioFile;
-    }
+  id: BuilderObjectId.QuestionOptionID;
+  value: number;
+  label = "";
+  private _labelAudioFile: AudioFile | false = false;
+  get labelAudioFile() {
+    return this._labelAudioFile;
+  }
+  set labelAudioFile(audioFile: AudioFile | false) {
+    this._labelAudioFile = audioFile;
+  }
 
-    private constructor(dto: BuilderOptionDto) {
-        super(dto);
-        this.id = dto.id;
-        this.value = dto.value;
-        this.label = dto.label;
-        // this.theme = dto.theme;
-    }
-    public static create(value: number, label: string) {
-        const id = BuilderObjectId.questionOptionId();
-        const dto: BuilderOptionDto = {
-            id,
-            value,
-            label,
-        };
-        const instance = new BuilderOption(dto);
-        return instance;
-    }
+  private constructor(dto: BuilderOptionDto) {
+    super(dto);
+    this.id = dto.id;
+    this.value = dto.value;
+    this.label = dto.label;
+    // this.theme = dto.theme;
+  }
+  public static create(value: number, label: string) {
+    const id = BuilderObjectId.questionOptionId();
+    const dto: BuilderOptionDto = {
+      id,
+      value,
+      label,
+    };
+    const instance = new BuilderOption(dto);
+    return instance;
+  }
 
-    public static fromJson(dto: BuilderOptionDto) {
-        const instance = new BuilderOption(dto);
-        return instance;
-    }
+  public static fromJson(dto: BuilderOptionDto) {
+    const instance = new BuilderOption(dto);
+    return instance;
+  }
 
-    toJson(): BuilderOptionDto {
-        const dto: BuilderOptionDto = {
-            id: this.id,
-            value: this.value,
-            label: this.label,
-        };
-        return dto;
-    }
+  toJson(): BuilderOptionDto {
+    const dto: BuilderOptionDto = {
+      id: this.id,
+      value: this.value,
+      label: this.label,
+    };
+    return dto;
+  }
 
-    clone(): BuilderOptionDto {
-        const cloneId = BuilderObjectId.questionOptionId();
-        const dto = this.toJson();
-        const cloneDto: BuilderOptionDto = { ...dto, id: cloneId };
-        return cloneDto;
-    }
+  clone(): BuilderOptionDto {
+    const cloneId = BuilderObjectId.questionOptionId();
+    const dto = this.toJson();
+    const cloneDto: BuilderOptionDto = { ...dto, id: cloneId };
+    return cloneDto;
+  }
 }

package/src/Builder-schema.ts

@@ -135,6 +135,7 @@ export class BuilderSchema {
       input,
     );
     this._rules.push(rule);
+    return rule;
   }
   deleteRule(rule: BuilderRule) {
     this._rules = this._rules.filter((r) => r !== rule);
@@ -191,17 +192,16 @@ export class BuilderSchema {
     this.pages.forEach((page, index) => {
       const pageVariables = page.getQuestionVariables(prefix, index);
       qVars.push(...pageVariables);
-      const pageId = page.prefix;
       const mainText = page.mainText.text;
       const jumpAction: JumpToPageAction = {
         kind: "jump-to-page",
-        pageId: pageId,
+        pageId: page.id,
         pageNumber: index,
         mainText: page.mainText.text,
       };
       const excludePageAction: ExcludeByPageAction = {
         kind: "exclude-by-pageId",
-        pageId,
+        pageId: page.id,
         pageNumber: index,
         mainText,
       };

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

@@ -2,6 +2,8 @@ import { BuilderRule, type BuilderRuleDto } from "./Builder-rule";
 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 } from "@media-quest/engine";
 
 const { createBuilderVariables_A_H } = U;
 let questionVariables = createBuilderVariables_A_H();
@@ -9,23 +11,27 @@ const createDto = (): {
   ruleInput: RuleInput;
   builderRuleDto: BuilderRuleDto;
 } => {
-  const v1 = U.createRuleVariable("v1", 2);
+  const v1 = U.createRuleVariable("v1", 1);
   const v2 = U.createRuleVariable("v2", 2);
-  const v3 = U.createRuleVariable("v3", 2);
-  const v4 = U.createRuleVariable("v4", 2);
-  const vg1 = U.createRuleVariable("vg1", 2);
-  const vg2 = U.createRuleVariable("vg2", 2);
-  const vg3 = U.createRuleVariable("vg3", 2);
-  const vg4 = U.createRuleVariable("vg4", 2);
+  const v3 = U.createRuleVariable("v3", 3);
+  const v4 = U.createRuleVariable("v4", 4);
+  const vg1 = U.createRuleVariable("vg1", 5);
+  const vg2 = U.createRuleVariable("vg2", 6);
+  const vg3 = U.createRuleVariable("vg3", 7);
+  const vg4 = U.createRuleVariable("vg4", 8);
   const variableList = [v1, v2, v3, v4, vg1, vg2, vg3, vg4];
   const tagAction1 = U.excludeByTagAction("tag1");
   const tagAction2 = U.excludeByTagAction("tag2");
   const tagAction3 = U.excludeByTagAction("tag3");
   const tagAction4 = U.excludeByTagAction("tag4");
-  const pageAction1 = U.excludeByPageIdAction(v1.varId);
-  const pageAction2 = U.excludeByPageIdAction(v2.varId);
-  const pageAction3 = U.excludeByPageIdAction(v3.varId);
-  const pageAction4 = U.excludeByPageIdAction(v4.varId);
+  const pageAction1 = U.excludeByPageIdAction(v1.varId, v1.pageNumber);
+  const pageAction2 = U.excludeByPageIdAction(v2.varId, v2.pageNumber);
+  const pageAction3 = U.excludeByPageIdAction(v3.varId, v3.pageNumber);
+  const pageAction4 = U.excludeByPageIdAction(v4.varId, v4.pageNumber);
+  const jumpToPageAction1 = U.jumpToPageAction(v1.varId, v1.pageNumber);
+  const jumpToPageAction2 = U.jumpToPageAction(v2.varId, v2.pageNumber);
+  const jumpToPageAction3 = U.jumpToPageAction(v3.varId, v3.pageNumber);
+  const jumpToPageAction4 = U.jumpToPageAction(v4.varId, v1.pageNumber);
 
   // const pageAction =
   // const excludeByTagList = [];
@@ -34,7 +40,7 @@ const createDto = (): {
     [],
     [pageAction1, pageAction2, pageAction3, pageAction4],
     [tagAction1, tagAction2, tagAction3, tagAction4],
-    [],
+    [jumpToPageAction1, jumpToPageAction2, jumpToPageAction3, jumpToPageAction4],
   );
   const c1 = U.createConditionDto(v1);
   const c2 = U.createConditionDto(v2);
@@ -73,6 +79,7 @@ let dto: BuilderRuleDto = {
 
 const excludeByTagActionList = U.excludeByTagActionList();
 const pageActions = questionVariables.map((q) => U.excludeByPageIdAction(q.varId, q.pageNumber));
+
 let ruleInput = new RuleInput(questionVariables, [], [...pageActions], excludeByTagActionList, []);
 
 let rule: BuilderRule = BuilderRule.fromDto(dto, ruleInput);
@@ -204,4 +211,81 @@ describe("Builder Rule", () => {
     expect(ruleInput.excludeByTagActions.length).toStrictEqual(10);
     expect(ruleInput.excludeByTagActions.length).toStrictEqual(10);
   });
+
+  test("toEngineRuleWorks: ", () => {
+    const input = createDto().ruleInput;
+    const v1 = input.questionVars[0];
+    const v2 = input.questionVars[1];
+    const tag1 = input.excludeByTagActions[0];
+    const pageAction1 = input.excludeByPageIdActions[0];
+
+    const c1: BuilderConditionDto = {
+      kind: "condition",
+      name: "condition 1",
+      variableId: v1.varId,
+      operator: "equal",
+      value: v1.options[0].value,
+    };
+    const c2: BuilderConditionDto = {
+      name: "nested-condition",
+      kind: "condition",
+      value: v2.options[0].value,
+      operator: "equal",
+      variableId: v2.varId,
+    };
+    const conditionGroupANY: BuilderConditionGroupDto = {
+      kind: "condition-group",
+      conditions: [c1, c2],
+      name: "or-condition",
+      type: "any",
+    };
+
+    const conditionGroupALL: BuilderConditionGroupDto = {
+      kind: "condition-group",
+      conditions: [c2],
+      name: "condition group ALL - in testing.",
+      type: "all",
+    };
+
+    const dtoWithOneCondition: BuilderRuleDto = {
+      type: "all",
+      name: "dto-with-one-condition",
+      excludePages: [pageAction1.pageId],
+      excludeTags: [tag1.tag],
+      jumpToPage: v1.varId,
+      conditions: [c1, conditionGroupALL, conditionGroupANY],
+    };
+
+    const actionCount =
+      dtoWithOneCondition.excludeTags.length +
+      dtoWithOneCondition.excludePages.length +
+      (dtoWithOneCondition.jumpToPage ? 1 : 0);
+
+    const rule = BuilderRule.fromDto(dtoWithOneCondition, input);
+    const engineRule = rule.toEngineRule();
+
+    // console.log(rule);
+    expect(engineRule.all.length).toBe(3);
+    expect(engineRule.some.length).toBe(0);
+
+    const simple1 = engineRule.all.find(
+      (c) => c.kind === "numeric-condition" && c.referenceId === c1.variableId,
+    ) as Condition.Numeric;
+    const complex1 = engineRule.all.find(
+      (c) => c.kind === "complex-condition" && c.all.length === 1,
+    ) as Condition.Complex;
+
+    const complexChild1 = complex1.all[0] as Condition.Numeric;
+    expect(simple1).toBeTruthy();
+    expect(simple1.operator === "eq").toBeTruthy();
+    expect(simple1.value === c1.value).toBeTruthy();
+    expect(simple1.referenceLabel).toBe(v1.label);
+    expect(complex1).toBeTruthy();
+    expect(complexChild1).toBeTruthy();
+    expect(complexChild1.referenceId).toBe(c2.variableId);
+    expect(complexChild1.value).toBe(c2.value);
+    expect(complexChild1.referenceLabel).toBe(v2.label);
+    expect(complexChild1.operator === "eq").toBeTruthy();
+    expect(engineRule.onSuccess.length).toBe(actionCount);
+  });
 });

package/src/rulebuilder/Builder-rule.ts

@@ -9,6 +9,7 @@ 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, PageQueCommand, PageQueRules } from "@media-quest/engine";
 
 export interface BuilderRuleDto {
   readonly type: ConditionGroupType;
@@ -25,7 +26,7 @@ export class BuilderRule extends BuilderObject<"builder-rule", BuilderRuleDto> {
   // public countNumber = 1;
   private readonly _conditions: Array<BuilderCondition | BuilderConditionGroup> = [];
 
-  private _tagActionManager: TagActionManager;
+  private readonly _tagActionManager: TagActionManager;
   private _pageActionManager: PageActionManager;
   readonly jumpToActionManager: JumpToActionManager;
   public static readonly fromDto = (dto: BuilderRuleDto, input: RuleInput): BuilderRule => {
@@ -131,4 +132,68 @@ export class BuilderRule extends BuilderObject<"builder-rule", BuilderRuleDto> {
     };
     return dto;
   }
+  toEngineRule(modulePrefix: string): PageQueRules {
+    const conditions: Condition[] = [];
+    this._conditions.forEach((c) => {
+      if (c) {
+        if (c instanceof BuilderCondition) {
+          const simpleCondition = c.toEngineCondition(modulePrefix);
+          if (simpleCondition) {
+            conditions.push(simpleCondition);
+          }
+        }
+        if (c instanceof BuilderConditionGroup) {
+          const complexCondition = c.toEngineConditionComplex(modulePrefix);
+          if (complexCondition) conditions.push(complexCondition);
+        }
+      }
+    });
+    let all: Condition[] = [];
+    let some: Condition[] = [];
+
+    if (this.type === "all") {
+      all = [...conditions];
+    }
+    const pageQueCommands: Array<PageQueCommand> = [];
+    const maybeJumpToPage = this.jumpToActionManager.selected;
+    if (maybeJumpToPage) {
+      const jumpCommand: PageQueCommand = {
+        kind: "PAGE_QUE_JUMP_TO_PAGE_COMMAND",
+        target: "PAGE_QUE",
+        targetId: "PAGE_QUE",
+        payload: { pageId: maybeJumpToPage.data.pageId },
+      };
+      pageQueCommands.push(jumpCommand);
+    }
+
+    const excludePageByIdList = this._pageActionManager.getEngineAction().map((a) => a.pageId);
+    if (excludePageByIdList.length) {
+      const command: PageQueCommand = {
+        kind: "PAGE_QUE_EXCLUDE_BY_PAGE_ID_COMMAND",
+        target: "PAGE_QUE",
+        targetId: "PAGE_QUE",
+        payload: { pageIds: [...excludePageByIdList] },
+      };
+      pageQueCommands.push(command);
+    }
+    const excludeTags = this._tagActionManager.getEngineActions().map((tagA) => tagA.tag);
+    if (excludeTags.length) {
+      const excludeTagsCommand: PageQueCommand = {
+        kind: "PAGE_QUE_EXCLUDE_BY_TAG_COMMAND",
+        target: "PAGE_QUE",
+        targetId: "PAGE_QUE",
+        payload: { tagIds: [...excludeTags] },
+      };
+      pageQueCommands.push(excludeTagsCommand);
+    }
+
+    const rule: PageQueRules = {
+      description: this.name,
+      all,
+      some,
+      onFailure: [],
+      onSuccess: pageQueCommands,
+    };
+    return rule;
+  }
 }

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

@@ -4,7 +4,7 @@ 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 } from "./RuleAction";
+import type { ExcludeByPageAction, ExcludeByTagAction, JumpToPageAction } from "./RuleAction";
 import { ExcludeByPageIdSelectItem, ExcludeByTagSelectItem } from "./multi-select-item";
 
 export namespace RuleBuilderTestUtils {
@@ -24,7 +24,8 @@ export namespace RuleBuilderTestUtils {
     };
     return action;
   };
-  export const excludeByPageIdAction = (pageId: string, pageNumber = 1) => {
+
+  export const excludeByPageIdAction = (pageId: string, pageNumber: number) => {
     const action: ExcludeByPageAction = {
       kind: "exclude-by-pageId",
       mainText: "",
@@ -33,6 +34,16 @@ export namespace RuleBuilderTestUtils {
     };
     return action;
   };
+  export const jumpToPageAction = (pageId: string, pageNumber: number) => {
+    const action: JumpToPageAction = {
+      kind: "jump-to-page",
+      mainText: "TEXT: " + pageId,
+      pageId,
+      pageNumber,
+    };
+    return action;
+  };
+
   export const excludeByTagActionList = () => {
     const list = [
       excludeByTagAction("tag1"),

package/src/rulebuilder/RuleVariable.ts

@@ -1,38 +1,42 @@
 const BuilderVariableType = {
   numericWithOptions: true,
+  numeric: true,
   numericRange: true,
   text: true,
   date: true,
   dateRange: true,
   time: true,
   duration: true,
-  boolean: true
+  boolean: true,
 } as const;
 
-type BuilderVariableType = keyof typeof BuilderVariableType;
+export type BuilderVariableType = keyof typeof BuilderVariableType;
 
 export class BuilderVariableOption {
-  constructor(readonly label: string, readonly value: number) {}
+  constructor(
+    readonly label: string,
+    readonly value: number,
+  ) {}
 }
 
 export class QuestionVariable {
-  readonly kind: 'question-variable' = 'question-variable';
-  readonly dataType: BuilderVariableType = 'numericWithOptions';
+  readonly kind: "question-variable" = "question-variable";
+  readonly dataType: BuilderVariableType = "numericWithOptions";
   constructor(
     readonly varId: string,
     readonly label: string,
     readonly options: ReadonlyArray<BuilderVariableOption>,
-    readonly pageNumber: number
+    readonly pageNumber: number,
   ) {}
 }
 
 export class CustomVariable {
-  readonly kind: 'configuration-variable' = 'configuration-variable';
-  readonly dataType: BuilderVariableType = 'numericWithOptions';
+  readonly kind: "configuration-variable" = "configuration-variable";
+  readonly dataType: BuilderVariableType = "numericWithOptions";
   constructor(
     readonly varId: string,
     readonly label: string,
-    readonly options: ReadonlyArray<BuilderVariableOption>
+    readonly options: ReadonlyArray<BuilderVariableOption>,
   ) {}
 }
 

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

@@ -1,18 +1,19 @@
 import { BuilderCondition, type BuilderConditionDto } from "./Builder-condition";
 import { BuilderObject } from "../../BuilderObject";
 import type { BuilderVariable } from "../RuleVariable";
+import { Condition } from "@media-quest/engine";
 
 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 count?: number;
   readonly type: ConditionGroupType;
   readonly conditions: ReadonlyArray<BuilderConditionDto>;
 }
@@ -80,6 +81,32 @@ export class BuilderConditionGroup extends BuilderObject<"builder-condition-grou
       kind: "condition-group",
     };
   }
+
+  toEngineConditionComplex(modulePrefix: string): Condition.Complex | false {
+    const comp: Condition.Complex = {
+      kind: "complex-condition",
+      all: [],
+      some: [],
+      name: "",
+    };
+    const conditions: Condition.Simple[] = [];
+    this.conditions.forEach((c) => {
+      const maybeSimple = c.toEngineCondition(modulePrefix);
+      if (maybeSimple) {
+        conditions.push(maybeSimple);
+      }
+    });
+    if (this._type === "all") {
+      return { ...comp, all: conditions };
+    }
+    if (this._type === "any") {
+      return { ...comp, some: conditions };
+    }
+
+    console.log("INVALID COMPLEX CONDITION. TODO IMPLEMENT range, and count.");
+
+    return false;
+  }
   get type(): ConditionGroupType {
     return this._type;
   }

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

@@ -166,4 +166,20 @@ describe("Builder Operator", () => {
     expect(c.value).toBe(false);
     expect(c.validate().isValid).toBe(false);
   });
+  test("toEngineConditionWorks", () => {
+    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

@@ -2,6 +2,7 @@ import { BuilderObject } from "../../BuilderObject";
 import { BuilderOperator } from "./Builder-operator";
 import type { BuilderVariable, BuilderVariableOption } from "../RuleVariable";
 import { OperatorSelectItem, RuleOptionSelectItem, RuleVariableSelectItem } from "../SingleSelectItem";
+import { Condition } from "@media-quest/engine";
 export interface BuilderConditionDto {
   readonly kind: "condition";
   readonly operator: BuilderOperator | "";
@@ -102,6 +103,27 @@ export class BuilderCondition extends BuilderObject<"builder-condition", Builder
     return { isValid: true };
   }
 
+  toEngineCondition(modulePrefix: string): Condition.Simple | false {
+    const val = this.value;
+    const op = this._operator;
+    const v = this._variable;
+    if (!val) return false;
+    if (!op) return false;
+    if (!v) return false;
+    if (op === "equal") {
+      const engineCondition: Condition.Simple = {
+        kind: "numeric-condition",
+        value: val.value,
+        valueLabel: val.label,
+        referenceId: modulePrefix + "_" + v.varId,
+        referenceLabel: v.label,
+        operator: "eq",
+      };
+      return engineCondition;
+    }
+    return false;
+  }
+
   private findVariableInUniverse(variableId: string): BuilderVariable | false {
     const v = this._variableList.find((v) => v.varId === variableId);
     return v ?? false;

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

@@ -16,14 +16,14 @@ const BuilderOperatorSymbols = {
   empty: true,
   notEmpty: true,
   startsWith: true,
-  endsWith: 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') {
+  export const is = (symbol?: string): symbol is BuilderOperator => {
+    if (typeof symbol !== "string") {
       return false;
     }
     return Object.keys(BuilderOperatorSymbols).includes(symbol);

package/src/rulebuilder/jump-to-action-manager.ts

@@ -2,32 +2,32 @@ import type { RuleInput } from "./RuleInput";
 import { JumpToPageSelectItem } from "./SingleSelectItem";
 
 export class JumpToActionManager {
-    readonly options: ReadonlyArray<JumpToPageSelectItem>;
-    private _selected: JumpToPageSelectItem | false;
-    constructor(
-        private readonly validOptions: RuleInput["_jumpActions"],
-        private readonly initialSelection: string | false | undefined
-    ) {
-        this.options = validOptions.map(JumpToPageSelectItem.create);
-        this._selected = this.findSelected(initialSelection);
+  readonly options: ReadonlyArray<JumpToPageSelectItem>;
+  private _selected: JumpToPageSelectItem | false;
+  constructor(
+    private readonly validOptions: RuleInput["_jumpActions"],
+    private readonly initialSelection: string | false | undefined,
+  ) {
+    this.options = validOptions.map(JumpToPageSelectItem.create);
+    this._selected = this.findSelected(initialSelection);
+  }
+  get selected(): JumpToPageSelectItem | false {
+    return this._selected;
+  }
+  set selected(selected: JumpToPageSelectItem | false) {
+    this._selected = this.findSelected(selected);
+  }
+  getSelectedPageId(): string | false {
+    return this._selected ? this._selected.data.pageId : false;
+  }
+  private findSelected(value: unknown): JumpToPageSelectItem | false {
+    if (!value) return false;
+    if (value instanceof JumpToPageSelectItem) {
+      return this.options.find((v) => v === value) || false;
     }
-    get selected(): JumpToPageSelectItem | false {
-        return this._selected;
-    }
-    set selected(selected: JumpToPageSelectItem | false) {
-        this._selected = this.findSelected(selected);
-    }
-    getSelectedPageId(): string | false {
-        return this._selected ? this._selected.data.pageId : false;
-    }
-    private findSelected(value: unknown): JumpToPageSelectItem | false {
-        if (!value) return false;
-        if (value instanceof JumpToPageSelectItem) {
-            return this.options.find((v) => v === value) || false;
-        }
-        if (typeof value === "string") {
-            return this.options.find((v) => v.data.pageId === value) || false;
-        }
-        return false;
+    if (typeof value === "string") {
+      return this.options.find((v) => v.data.pageId === value) || false;
     }
+    return false;
+  }
 }