@media-quest/builder 0.0.24 → 0.0.25

package/src/rulebuilder/RuleVariable.ts

@@ -1,49 +1,48 @@
-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 { VarID } from "../primitives/varID";
+
+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/page-action-manager.ts

@@ -1,31 +1,33 @@
-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 "../primitives/ID";
+
+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,215 @@
-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 } 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
+  }
+}

package/src/schema-config.ts

@@ -1,25 +1,25 @@
-import { PredefinedVariable } from "./variable/mq-variable";
-import { BuilderSchemaDto } from "./Builder-schema";
-
-/**
- * This interface is ment to define all information that a schema-admin app
- * needs to generate a dynamic form for setting values for predefined variables.
- */
-export interface SchemaConfig {
-  readonly schemaName: string;
-  readonly schemaId: string;
-  readonly schemaPrefix: string;
-  readonly variables: ReadonlyArray<Readonly<PredefinedVariable>>;
-}
-
-export const SchemaConfig = {
-  fromSchema: (schema: BuilderSchemaDto): SchemaConfig => {
-    const variables = schema.predefinedVariables ?? [];
-    return {
-      schemaId: schema.id,
-      schemaName: schema.name,
-      schemaPrefix: schema.prefix,
-      variables,
-    };
-  },
-} as const;
+import { PredefinedVariable } from "./variable/b-variable";
+import { BuilderSchemaDto } from "./Builder-schema";
+
+/**
+ * This interface is ment to define all information that a schema-admin app
+ * needs to generate a dynamic form for setting values for predefined variables.
+ */
+export interface SchemaConfig {
+  readonly schemaName: string;
+  readonly schemaId: string;
+  readonly schemaPrefix: string;
+  readonly variables: ReadonlyArray<Readonly<PredefinedVariable>>;
+}
+
+export const SchemaConfig = {
+  fromSchema: (schema: BuilderSchemaDto): SchemaConfig => {
+    const variables = schema.predefinedVariables ?? [];
+    return {
+      schemaId: schema.id,
+      schemaName: schema.name,
+      schemaPrefix: schema.prefix,
+      variables,
+    };
+  },
+} as const;