@media-quest/builder 0.0.22 → 0.0.24

package/src/rulebuilder/multi-select-item.ts

@@ -1,73 +1,73 @@
-import { ExcludeByPageAction, ExcludeByTagAction } from "./RuleAction";
-
-export abstract class MultiSelectItem<T> {
-  private readonly _isSelectedInitially: boolean;
-  private readonly _selectLabel;
-  private readonly _toolTip;
-  private readonly _searchString;
-  public isSelected: boolean;
-  get selectLabel(): string {
-    return this._selectLabel;
-  }
-  get tooltip() {
-    return this._toolTip;
-  }
-
-  get searchString() {
-    return this._searchString;
-  }
-  protected constructor(
-    readonly data: T,
-    isSelected: boolean,
-  ) {
-    this._isSelectedInitially = isSelected;
-    this.isSelected = isSelected;
-    this._searchString = this.getSearchString();
-    this._toolTip = this.getTooltip();
-    this._selectLabel = this.getSelectLabel();
-  }
-  protected abstract getSelectLabel(): string;
-  protected abstract getTooltip(): string;
-  protected abstract getSearchString(): string;
-}
-
-export class ExcludeByTagSelectItem extends MultiSelectItem<ExcludeByTagAction> {
-  public static readonly create = (tagData: ExcludeByTagAction, isSelected: boolean) => {
-    return new ExcludeByTagSelectItem(tagData, isSelected);
-  };
-  protected constructor(data: ExcludeByTagAction, isSelected: boolean) {
-    super(data, isSelected);
-  }
-  protected getSearchString(): string {
-    return this.data.tag;
-  }
-
-  protected getSelectLabel(): string {
-    return this.data.tag + " (" + this.data.pageCount + ")";
-  }
-
-  protected getTooltip(): string {
-    return this.data.tag + "  (used in " + this.data.pageCount + " pages)";
-  }
-}
-
-export class ExcludeByPageIdSelectItem extends MultiSelectItem<ExcludeByPageAction> {
-  public static create = (ruleActionPage: ExcludeByPageAction, isSelected: boolean) => {
-    return new ExcludeByPageIdSelectItem(ruleActionPage, isSelected);
-  };
-
-  protected constructor(data: ExcludeByPageAction, isSelected: boolean) {
-    super(data, isSelected);
-  }
-  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 { ExcludeByPageAction, ExcludeByTagAction } from "./RuleAction";
+
+export abstract class MultiSelectItem<T> {
+  private readonly _isSelectedInitially: boolean;
+  private readonly _selectLabel;
+  private readonly _toolTip;
+  private readonly _searchString;
+  public isSelected: boolean;
+  get selectLabel(): string {
+    return this._selectLabel;
+  }
+  get tooltip() {
+    return this._toolTip;
+  }
+
+  get searchString() {
+    return this._searchString;
+  }
+  protected constructor(
+    readonly data: T,
+    isSelected: boolean,
+  ) {
+    this._isSelectedInitially = isSelected;
+    this.isSelected = isSelected;
+    this._searchString = this.getSearchString();
+    this._toolTip = this.getTooltip();
+    this._selectLabel = this.getSelectLabel();
+  }
+  protected abstract getSelectLabel(): string;
+  protected abstract getTooltip(): string;
+  protected abstract getSearchString(): string;
+}
+
+export class ExcludeByTagSelectItem extends MultiSelectItem<ExcludeByTagAction> {
+  public static readonly create = (tagData: ExcludeByTagAction, isSelected: boolean) => {
+    return new ExcludeByTagSelectItem(tagData, isSelected);
+  };
+  protected constructor(data: ExcludeByTagAction, isSelected: boolean) {
+    super(data, isSelected);
+  }
+  protected getSearchString(): string {
+    return this.data.tag;
+  }
+
+  protected getSelectLabel(): string {
+    return this.data.tag + " (" + this.data.pageCount + ")";
+  }
+
+  protected getTooltip(): string {
+    return this.data.tag + "  (used in " + this.data.pageCount + " pages)";
+  }
+}
+
+export class ExcludeByPageIdSelectItem extends MultiSelectItem<ExcludeByPageAction> {
+  public static create = (ruleActionPage: ExcludeByPageAction, isSelected: boolean) => {
+    return new ExcludeByPageIdSelectItem(ruleActionPage, isSelected);
+  };
+
+  protected constructor(data: ExcludeByPageAction, isSelected: boolean) {
+    super(data, isSelected);
+  }
+  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/page-action-manager.ts

@@ -1,31 +1,31 @@
-import type { RuleInput } from "./RuleInput";
-import { ExcludeByPageIdSelectItem } from "./multi-select-item";
-import { ExcludeByPageAction } from "./RuleAction";
-import { PageID } from "@media-quest/engine";
-
-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 "@media-quest/engine";
+
+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];
+  }
+}

package/src/rulebuilder/rule2/Rule2.ts

@@ -1,211 +1,211 @@
-import { BuilderOperator } from "../condition/Builder-operator";
-import { BuilderConditionDto } from "../condition/Builder-condition";
-import { BuilderConditionGroupDto, ConditionGroupType } from "../condition/Builder-condition-group";
-import { BuilderRuleDto } from "../Builder-rule";
-
-type SolveErrorReason =
-  | "INVALID_FACT_TYPE"
-  | "INVALID_OPERATOR"
-  | "INVALID_VALUE"
-  | "INVALID_VARIABLE"
-  | "UNIMPLEMENTED_VARIABLE_TYPE"
-  | "UNIMPLEMENTED_OPERATOR";
-
-type TrueResult = { readonly type: "IS_TRUE" };
-type FalseResult = { readonly type: "IS_FALSE" };
-type MissingFactsResult = { readonly type: "MISSING_FACTS"; readonly missingVariables: ReadonlyArray<string> };
-type ErrorResult = {
-  readonly type: "HAS_ERROR";
-  readonly reason: SolveErrorReason;
-  readonly data: Record<string, string>;
-};
-export type EvalResult = FalseResult | TrueResult | MissingFactsResult | ErrorResult;
-
-export interface Fact2 {
-  readonly variableType: "numeric";
-  readonly value: number;
-  readonly valueLabel: string;
-  readonly variableId: string;
-  readonly variableLabel: string;
-}
-
-export class FactCollection {
-  public static isFact = (value: unknown): value is Fact2 => {
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-      return false;
-    }
-    const fact = value as Partial<Fact2>;
-    if (typeof fact.variableId !== "string" || fact.variableId.length === 0) {
-      return false;
-    }
-    if (typeof fact.variableLabel !== "string") {
-      return false;
-    }
-    if (typeof fact.value !== "number") {
-      return false;
-    }
-    if (typeof fact.valueLabel !== "string") {
-      return false;
-    }
-    // NB: This is a temporary check until we have more variable types.
-    if (typeof fact.variableType !== "string" || fact.variableType !== "numeric") {
-      return false;
-    }
-
-    return true;
-  };
-  public static create = (facts: ReadonlyArray<Fact2>): FactCollection => {
-    return new FactCollection(facts);
-  };
-
-  private readonly _facts: ReadonlyArray<Fact2>;
-
-  private constructor(facts: ReadonlyArray<Fact2>) {
-    if (!Array.isArray(facts)) {
-      console.log("Invalid facts", facts);
-      this._facts = [];
-    } else {
-      this._facts = [...facts];
-    }
-  }
-  byId(variableId: string): Fact2 | false {
-    const result = this._facts.find((fact) => fact.variableId === variableId);
-    if (!result) {
-      return false;
-    }
-    return { ...result };
-  }
-}
-interface FactEvaluator {
-  isTrue(facts: FactCollection): boolean;
-  evaluate(facts: FactCollection): EvalResult;
-}
-interface IsValid {
-  isValid(): boolean;
-}
-export class Condition implements FactEvaluator, IsValid {
-  public static create = (dto: BuilderConditionDto): Condition => {
-    return new Condition(dto);
-  };
-  private constructor(private readonly dto: BuilderConditionDto) {}
-  isTrue(facts: FactCollection): boolean {
-    const dto = this.dto;
-    const op = dto.operator;
-    const value = dto.value;
-    const varId = dto.variableId;
-    if (!BuilderOperator.is(op)) {
-      return false;
-    }
-
-    if (typeof value !== "number") {
-      return false;
-    }
-
-    const fact = facts.byId(this.dto.variableId);
-
-    if (!FactCollection.isFact(fact)) {
-      return false;
-    }
-
-    if (fact.variableType !== "numeric" && typeof fact.value !== "number") {
-      return false;
-    }
-
-    if (op === "equal") {
-      return fact.value === value;
-    }
-
-    if (op === "notEqual") {
-      return fact.value !== value;
-    }
-
-    return false;
-  }
-  isValid(): boolean {
-    return false;
-  }
-
-  evaluate(facts: FactCollection): EvalResult {
-    return { type: "HAS_ERROR", reason: "UNIMPLEMENTED_VARIABLE_TYPE", data: {} }; // TODO
-  }
-}
-export class ConditionGroup implements FactEvaluator, IsValid {
-  public static readonly create = (dto: BuilderConditionGroupDto): ConditionGroup => {
-    return new ConditionGroup(dto);
-  };
-
-  private readonly _conditions: ReadonlyArray<Condition>;
-  private constructor(private readonly dto: BuilderConditionGroupDto) {
-    this._conditions = dto.conditions.map(Condition.create);
-  }
-
-  isTrue(facts: FactCollection): boolean {
-    const results = this._conditions.map((condition) => condition.isTrue(facts));
-    let trueCount = 0;
-    let falseCount = 0;
-    results.forEach((results) => {
-      if (results) {
-        trueCount++;
-      } else {
-        falseCount++;
-      }
-    });
-    if (trueCount === 0 || falseCount === 0) {
-      return false;
-    }
-    const type = this.dto.type;
-
-    if (type === "all" && trueCount === this._conditions.length) {
-      return true;
-    }
-
-    if (type === "any" && trueCount > 0) {
-      return true;
-    }
-
-    const minLimit = this.dto.count;
-    if (type === "count" && typeof minLimit === "number" && trueCount >= minLimit) {
-      return true;
-    }
-
-    return false;
-  }
-
-  isValid(): boolean {
-    return true;
-  }
-
-  evaluate(facts: FactCollection): EvalResult {
-    return { type: "HAS_ERROR", reason: "UNIMPLEMENTED_VARIABLE_TYPE", data: {} }; // TODO
-  }
-}
-export class Rule2 implements FactEvaluator {
-  readonly name: string;
-  private readonly _conditions: ReadonlyArray<Condition | ConditionGroup>;
-  public static readonly create = (dto: BuilderRuleDto): Rule2 => {
-    return new Rule2(dto);
-  };
-  private _count = -1;
-  constructor(private readonly dto: BuilderRuleDto) {
-    this.name = dto.name;
-    const conditions: Array<Condition | ConditionGroup> = [];
-    dto.conditions.forEach((condition) => {
-      if (condition.kind === "condition-group") {
-        conditions.push(ConditionGroup.create(condition));
-      } else if (condition.kind === "condition") {
-        conditions.push(Condition.create(condition));
-      } else {
-        console.log("Unknown condition", condition);
-      }
-    });
-    this._conditions = conditions;
-  }
-
-  isTrue(facts: FactCollection): boolean {
-    return false;
-  }
-
-  evaluate(facts: FactCollection): EvalResult {
-    return { type: "HAS_ERROR", reason: "UNIMPLEMENTED_VARIABLE_TYPE", data: {} }; // TODO
-  }
-}
+import { BuilderOperator } from "../condition/Builder-operator";
+import { BuilderConditionDto } from "../condition/Builder-condition";
+import { BuilderConditionGroupDto, ConditionGroupType } from "../condition/Builder-condition-group";
+import { BuilderRuleDto } from "../Builder-rule";
+
+type SolveErrorReason =
+  | "INVALID_FACT_TYPE"
+  | "INVALID_OPERATOR"
+  | "INVALID_VALUE"
+  | "INVALID_VARIABLE"
+  | "UNIMPLEMENTED_VARIABLE_TYPE"
+  | "UNIMPLEMENTED_OPERATOR";
+
+type TrueResult = { readonly type: "IS_TRUE" };
+type FalseResult = { readonly type: "IS_FALSE" };
+type MissingFactsResult = { readonly type: "MISSING_FACTS"; readonly missingVariables: ReadonlyArray<string> };
+type ErrorResult = {
+  readonly type: "HAS_ERROR";
+  readonly reason: SolveErrorReason;
+  readonly data: Record<string, string>;
+};
+export type EvalResult = FalseResult | TrueResult | MissingFactsResult | ErrorResult;
+
+export interface Fact2 {
+  readonly variableType: "numeric";
+  readonly value: number;
+  readonly valueLabel: string;
+  readonly variableId: string;
+  readonly variableLabel: string;
+}
+
+export class FactCollection {
+  public static isFact = (value: unknown): value is Fact2 => {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return false;
+    }
+    const fact = value as Partial<Fact2>;
+    if (typeof fact.variableId !== "string" || fact.variableId.length === 0) {
+      return false;
+    }
+    if (typeof fact.variableLabel !== "string") {
+      return false;
+    }
+    if (typeof fact.value !== "number") {
+      return false;
+    }
+    if (typeof fact.valueLabel !== "string") {
+      return false;
+    }
+    // NB: This is a temporary check until we have more variable types.
+    if (typeof fact.variableType !== "string" || fact.variableType !== "numeric") {
+      return false;
+    }
+
+    return true;
+  };
+  public static create = (facts: ReadonlyArray<Fact2>): FactCollection => {
+    return new FactCollection(facts);
+  };
+
+  private readonly _facts: ReadonlyArray<Fact2>;
+
+  private constructor(facts: ReadonlyArray<Fact2>) {
+    if (!Array.isArray(facts)) {
+      console.log("Invalid facts", facts);
+      this._facts = [];
+    } else {
+      this._facts = [...facts];
+    }
+  }
+  byId(variableId: string): Fact2 | false {
+    const result = this._facts.find((fact) => fact.variableId === variableId);
+    if (!result) {
+      return false;
+    }
+    return { ...result };
+  }
+}
+interface FactEvaluator {
+  isTrue(facts: FactCollection): boolean;
+  evaluate(facts: FactCollection): EvalResult;
+}
+interface IsValid {
+  isValid(): boolean;
+}
+export class Condition implements FactEvaluator, IsValid {
+  public static create = (dto: BuilderConditionDto): Condition => {
+    return new Condition(dto);
+  };
+  private constructor(private readonly dto: BuilderConditionDto) {}
+  isTrue(facts: FactCollection): boolean {
+    const dto = this.dto;
+    const op = dto.operator;
+    const value = dto.value;
+    const varId = dto.variableId;
+    if (!BuilderOperator.is(op)) {
+      return false;
+    }
+
+    if (typeof value !== "number") {
+      return false;
+    }
+
+    const fact = facts.byId(this.dto.variableId);
+
+    if (!FactCollection.isFact(fact)) {
+      return false;
+    }
+
+    if (fact.variableType !== "numeric" && typeof fact.value !== "number") {
+      return false;
+    }
+
+    if (op === "equal") {
+      return fact.value === value;
+    }
+
+    if (op === "notEqual") {
+      return fact.value !== value;
+    }
+
+    return false;
+  }
+  isValid(): boolean {
+    return false;
+  }
+
+  evaluate(facts: FactCollection): EvalResult {
+    return { type: "HAS_ERROR", reason: "UNIMPLEMENTED_VARIABLE_TYPE", data: {} }; // TODO
+  }
+}
+export class ConditionGroup implements FactEvaluator, IsValid {
+  public static readonly create = (dto: BuilderConditionGroupDto): ConditionGroup => {
+    return new ConditionGroup(dto);
+  };
+
+  private readonly _conditions: ReadonlyArray<Condition>;
+  private constructor(private readonly dto: BuilderConditionGroupDto) {
+    this._conditions = dto.conditions.map(Condition.create);
+  }
+
+  isTrue(facts: FactCollection): boolean {
+    const results = this._conditions.map((condition) => condition.isTrue(facts));
+    let trueCount = 0;
+    let falseCount = 0;
+    results.forEach((results) => {
+      if (results) {
+        trueCount++;
+      } else {
+        falseCount++;
+      }
+    });
+    if (trueCount === 0 || falseCount === 0) {
+      return false;
+    }
+    const type = this.dto.type;
+
+    if (type === "all" && trueCount === this._conditions.length) {
+      return true;
+    }
+
+    if (type === "any" && trueCount > 0) {
+      return true;
+    }
+
+    const minLimit = this.dto.count;
+    if (type === "count" && typeof minLimit === "number" && trueCount >= minLimit) {
+      return true;
+    }
+
+    return false;
+  }
+
+  isValid(): boolean {
+    return true;
+  }
+
+  evaluate(facts: FactCollection): EvalResult {
+    return { type: "HAS_ERROR", reason: "UNIMPLEMENTED_VARIABLE_TYPE", data: {} }; // TODO
+  }
+}
+export class Rule2 implements FactEvaluator {
+  readonly name: string;
+  private readonly _conditions: ReadonlyArray<Condition | ConditionGroup>;
+  public static readonly create = (dto: BuilderRuleDto): Rule2 => {
+    return new Rule2(dto);
+  };
+  private _count = -1;
+  constructor(private readonly dto: BuilderRuleDto) {
+    this.name = dto.name;
+    const conditions: Array<Condition | ConditionGroup> = [];
+    dto.conditions.forEach((condition) => {
+      if (condition.kind === "condition-group") {
+        conditions.push(ConditionGroup.create(condition));
+      } else if (condition.kind === "condition") {
+        conditions.push(Condition.create(condition));
+      } else {
+        console.log("Unknown condition", condition);
+      }
+    });
+    this._conditions = conditions;
+  }
+
+  isTrue(facts: FactCollection): boolean {
+    return false;
+  }
+
+  evaluate(facts: FactCollection): EvalResult {
+    return { type: "HAS_ERROR", reason: "UNIMPLEMENTED_VARIABLE_TYPE", data: {} }; // TODO
+  }
+}