@media-quest/builder 0.0.23 → 0.0.25

package/src/variable/{mq-variable.ts → b-variable.ts}

@@ -1,63 +1,68 @@
-export interface MqVariable {
-  readonly kind: "numeric-variable" | "numeric-range-variable" | "string-variable";
-
-  label: string;
-  varId: string;
-  description?: string;
-
-  // Values - The actual value of the variable.
-  stringValue?: string;
-  numericValue?: number;
-  minValue?: number;
-  initialValue?: number;
-  maxValue?: number;
-  defaultValue?: number | string;
-  defaultMinValue?: number;
-  defaultMaxValue?: number;
-
-  // Context
-  origin:
-    | "question"
-    | "form-field"
-    | "predefined"
-    | "event"
-    | "calculated"
-    | "sum-score"
-    | "predefined-or-question";
-
-  pageId?: string;
-  eventSource?: string;
-  pagePrefix?: string;
-  modulePrefix?: string;
-  moduleID?: string;
-  pageNumber?: number;
-
-  // Validations
-  min?: number;
-  max?: number;
-  stepSize?: number;
-  minLength?: number;
-  maxLength?: number;
-  rangeFloor?: number;
-  rangeCeiling?: number;
-
-  // Analytics
-  options?: Array<{ label: string; value: number }>;
-  basedOn?: Array<{ varId: string; weight?: number }>;
-}
-
-export interface PageVariable extends MqVariable {
-  readonly pageId: string;
-  readonly pagePrefix: string;
-  readonly pagePosition: number;
-  readonly modulePrefix: string;
-  readonly origin: "question" | "form-field";
-}
-
-export interface PredefinedVariable extends MqVariable {
-  readonly origin: "predefined";
-  readonly modulePrefix: string;
-  readonly moduleID: string;
-  defaultValue: number;
-  options: Array<{ label: string; value: number }>;
-}
+export interface BVariable {
+  readonly kind: "numeric-variable" | "numeric-range-variable" | "string-variable";
+  label: string;
+  varId: string;
+  description?: string;
+
+  // Values - The actual value of the variable.
+  stringValue?: string;
+  numericValue?: number;
+  minValue?: number;
+  initialValue?: number;
+  maxValue?: number;
+  defaultValue?: number | string;
+  defaultMinValue?: number;
+  defaultMaxValue?: number;
+
+  // Context
+  origin:
+    | "question"
+    | "form-field"
+    | "predefined"
+    | "event"
+    | "calculated"
+    | "sum-score"
+    | "predefined-or-question";
+
+  pageId?: string;
+  eventSource?: string;
+  pagePrefix?: string;
+  questionPrefix?: string;
+  modulePrefix?: string;
+  moduleID?: string;
+  pageNumber?: number;
+
+  // Validations
+  min?: number;
+  max?: number;
+  stepSize?: number;
+  minLength?: number;
+  maxLength?: number;
+  rangeFloor?: number;
+  rangeCeiling?: number;
+
+  // Analytics
+  options?: Array<{ label: string; value: number }>;
+  basedOn?: Array<{ varId: string; weight?: number }>;
+}
+
+const MISSING = 999;
+export const BVariable = {
+  MISSING,
+} as const;
+
+export interface PageVariable extends BVariable {
+  readonly pageId: string;
+  readonly pagePrefix: string;
+  readonly pagePosition: number;
+  readonly modulePrefix: string;
+  readonly origin: "question" | "form-field";
+}
+
+export interface PredefinedVariable extends BVariable {
+  readonly origin: "predefined";
+  readonly modulePrefix: string;
+  readonly moduleID: string;
+  defaultValue: number;
+  options: Array<{ label: string; value: number }>;
+}

package/src/variable/mq-variable.spec.ts

@@ -1,91 +1,147 @@
-import { MqVariable } from "./mq-variable";
-import { SumScoreVariable } from "./sum-score-variable";
-const createVariable = (value: number): MqVariable => {
-  return {
-    varId: "v" + value,
-    label: "label for v" + value,
-    numericValue: value,
-    origin: "question",
-    kind: "numeric-variable",
-  };
-};
-
-const createSumScore = (basedOn: Array<{ variable: MqVariable; weight?: number }>) => {
-  const sumVar1: SumScoreVariable = {
-    kind: "numeric-variable",
-    initialValue: 0,
-    min: 0,
-    origin: "sum-score",
-    label: "Sum 123",
-    varId: "sum-score-variable-id",
-    basedOn: basedOn.map((v) => ({ varId: v.variable.varId, weight: v.weight })),
-  };
-  return sumVar1;
-};
-
-const v0 = createVariable(0);
-const v1 = createVariable(1);
-const v2 = createVariable(2);
-const v3 = createVariable(3);
-const v4 = createVariable(4);
-const v5 = createVariable(5);
-const v6 = createVariable(6);
-const v7 = createVariable(7);
-const v8 = createVariable(8);
-const v9 = createVariable(9);
-
-const all = [v0, v1, v2, v3, v4, v5, v6, v7, v8, v9];
-describe("Sum score variable.", () => {
-  test("Will calculate 2", () => {
-    const ss1 = createSumScore([
-      { variable: v1, weight: 1 },
-      { variable: v2, weight: 1 },
-    ]);
-    const score = SumScoreVariable.calculate(ss1, all);
-    expect(score.sumScore).toBe(3);
-    expect(score.basedOn.length).toBe(2);
-  });
-  test("Will calculate 5 values", () => {
-    const ss1 = createSumScore([
-      { variable: v1, weight: 1 },
-      { variable: v2, weight: 1 },
-      { variable: v4, weight: 1 },
-      { variable: v5 },
-      { variable: v6, weight: 1 },
-    ]);
-    const score = SumScoreVariable.calculate(ss1, all);
-    expect(score.sumScore).toBe(18);
-    const basedOn1 = score.basedOn[0];
-    expect(basedOn1.value).toBe(v1.numericValue);
-    expect(basedOn1.weight).toBe(1);
-    expect(basedOn1.varId).toBe(v1.varId);
-    expect(basedOn1.varLabel).toBe(v1.label);
-  });
-  test("Will not include 9", () => {
-    const ss1 = createSumScore([
-      { variable: v1, weight: 1 },
-      { variable: v5, weight: 1 },
-      { variable: v9, weight: 1 },
-    ]);
-    const score = SumScoreVariable.calculate(ss1, all);
-    expect(score.sumScore).toBe(6);
-  });
-  test("Will not calculate weight", () => {
-    const ss1 = createSumScore([
-      { variable: v1, weight: 1 },
-      { variable: v8, weight: 0.5 },
-    ]);
-    const score = SumScoreVariable.calculate(ss1, all);
-    expect(score.sumScore).toBe(5);
-  });
-  test("Will not calculate many weighted variables.", () => {
-    const ss1 = createSumScore([
-      { variable: v1, weight: 1 },
-      { variable: v2, weight: 0.5 },
-      { variable: v5, weight: 1.2 },
-      { variable: v8, weight: 2 },
-    ]);
-    const score = SumScoreVariable.calculate(ss1, all);
-    expect(score.sumScore).toBe(24);
-  });
-});
+import { BVariable } from "./b-variable";
+import { SumScore } from "./sum-score";
+import { SumScoreVariableDto } from "./sum-score-variable";
+const createVariable = (value: number): BVariable => {
+  return {
+    varId: "v" + value,
+    label: "label for v" + value,
+    numericValue: value,
+    origin: "question",
+    kind: "numeric-variable",
+  };
+};
+
+const createSumScore = (basedOn: Array<{ variable: BVariable; weight?: number }>) => {
+  const sumVar1: SumScoreVariableDto = {
+    kind: "numeric-variable",
+    initialValue: 0,
+    min: 0,
+    origin: "sum-score",
+    label: "Sum 123",
+    varId: "sum-score-variable-id",
+    basedOn: basedOn.map((v) => ({ varId: v.variable.varId, weight: v.weight })),
+  };
+  return sumVar1;
+};
+
+const v0 = createVariable(0);
+const v1 = createVariable(1);
+const v2 = createVariable(2);
+const v3 = createVariable(3);
+const v4 = createVariable(4);
+const v5 = createVariable(5);
+const v6 = createVariable(6);
+const v7 = createVariable(7);
+const v8 = createVariable(8);
+const v9 = createVariable(9);
+
+const all = [v0, v1, v2, v3, v4, v5, v6, v7, v8, v9];
+describe("Sum score variable.", () => {
+  test("Is allowed SumScoreValue", () => {
+    expect(SumScore.isAllowedValue(-1)).toBeFalsy();
+    expect(SumScore.isAllowedValue(0)).toBeTruthy();
+    expect(SumScore.isAllowedValue(1)).toBeTruthy();
+    expect(SumScore.isAllowedValue(2)).toBeTruthy();
+    expect(SumScore.isAllowedValue(3)).toBeTruthy();
+    expect(SumScore.isAllowedValue(4)).toBeTruthy();
+    expect(SumScore.isAllowedValue(5)).toBeTruthy();
+    expect(SumScore.isAllowedValue(6)).toBeTruthy();
+    expect(SumScore.isAllowedValue(7)).toBeTruthy();
+    expect(SumScore.isAllowedValue(8)).toBeTruthy();
+    expect(SumScore.isAllowedValue(9)).toBeFalsy();
+    expect(SumScore.isAllowedValue(999)).toBeFalsy();
+  });
+
+  test("Will calculate 2", () => {
+    const ss1 = createSumScore([
+      { variable: v1, weight: 1 },
+      { variable: v2, weight: 1 },
+      { variable: v9, weight: 1 },
+    ]);
+    const score = SumScore.calculate(ss1, all);
+    expect(score.sumScore).toBe(3);
+    expect(score.basedOn.length).toBe(3);
+    expect(score.avg).toBe(1.5);
+    expect(score.skippedBy9Count).toBe(1);
+  });
+  test("Will calculate 5 values", () => {
+    const ss1 = createSumScore([
+      { variable: v1, weight: 1 },
+      { variable: v2, weight: 1 },
+      { variable: v4, weight: 1 },
+      { variable: v5, weight: 1 },
+      { variable: v6, weight: 1 },
+      { variable: v9, weight: 0.5 },
+    ]);
+    const score = SumScore.calculate(ss1, all);
+    expect(score.sumScore).toBe(18);
+    expect(score.avg).toBe(3.6);
+    const basedOn1 = score.basedOn[0];
+    expect(basedOn1.value).toBe(v1.numericValue);
+    expect(basedOn1.weight).toBe(1);
+    expect(basedOn1.varId).toBe(v1.varId);
+    expect(basedOn1.varLabel).toBe(v1.label);
+  });
+  test("Will not include 9 in includedAnswersCount", () => {
+    const ss1 = createSumScore([
+      { variable: v0, weight: 1 },
+      { variable: v1, weight: 1 },
+      { variable: v5, weight: 1 },
+      { variable: v9, weight: 1 },
+    ]);
+    const score = SumScore.calculate(ss1, all);
+    expect(score.sumScore).toBe(6);
+    expect(score.avg).toBe(2);
+    expect(score.includedAnswerCount).toBe(3);
+  });
+  test("Will calculate weight", () => {
+    const ss1 = createSumScore([
+      { variable: v1, weight: 1 },
+      { variable: v8, weight: 0.5 },
+    ]);
+    const score = SumScore.calculate(ss1, all);
+    expect(score.sumScore).toBe(5);
+  });
+  test("Will calculate many weighted variables.", () => {
+    const ss1 = createSumScore([
+      { variable: v1, weight: 1 },
+      { variable: v2, weight: 0.5 },
+      { variable: v5, weight: 1.2 },
+      { variable: v8, weight: 2 },
+    ]);
+    const score = SumScore.calculate(ss1, all);
+    expect(score.sumScore).toBe(24);
+  });
+  test("Will count missing answers (missingAnswersCount)", () => {
+    const ss1 = createSumScore([
+      { variable: v1 },
+      { variable: v2 },
+      { variable: v3 },
+      { variable: v5 },
+      { variable: v9 },
+    ]);
+    const missing5InDataSet = [v1, v2, v8];
+    const score = SumScore.calculate(ss1, missing5InDataSet);
+    expect(score.sumScore).toBe(3);
+    expect(score.includedAnswerCount).toBe(2);
+    expect(score.missingAnswerCount).toBe(3);
+    expect(score.avg).toBe(1.5);
+    expect(score.basedOn.length).toBe(2);
+    expect(score.avg).toBe(1.5);
+    expect(score.errorMessages.length).toBe(0);
+  });
+  test("includedAnswerCount + missingAnswerCount + skippedBy9Count = SumScoreVariable.basedOn.length", () => {
+    const ss1 = createSumScore([
+      { variable: v0 },
+      { variable: v1 },
+      { variable: v2 },
+      { variable: v9 },
+    ]);
+    const answers = [v1, v7, v8, v9];
+    const score = SumScore.calculate(ss1, answers);
+
+    expect(score.includedAnswerCount + score.missingAnswerCount + score.skippedBy9Count).toBe(
+      ss1.basedOn.length,
+    );
+  });
+});

package/src/variable/sum-score-variable.ts

@@ -1,56 +1,50 @@
-import { MqVariable } from "./mq-variable";
-
-export interface SumScoreVariable extends MqVariable {
-  readonly origin: "sum-score";
-  initialValue: number;
-  basedOn: Array<{ varId: string; weight?: number }>;
-}
-
-/**
- *
- * A constant Array that contains all legal
- */
-const ALLOWED_SUM_SCORE_VALUES = [1, 2, 3, 4, 5, 6, 7, 8] as const;
-export interface SumScoreResult {
-  sumScore: number;
-  basedOn: Array<{ varId: string; value: number; weight: number; varLabel: string }>;
-}
-const calculate = (
-  sumScoreVariable: SumScoreVariable,
-  allVariables: Array<Pick<MqVariable, "varId" | "numericValue" | "kind" | "label">>,
-): SumScoreResult => {
-  const basedOnList = sumScoreVariable.basedOn;
-  // let sum = sumScoreVariable.initialValue ?? 0;
-  const result: SumScoreResult = {
-    sumScore: sumScoreVariable.initialValue ?? 0,
-    basedOn: [],
-  };
-  const legalValues: Array<number> = [...ALLOWED_SUM_SCORE_VALUES];
-  allVariables.forEach((v) => {
-    if (v.kind !== "numeric-variable") return;
-    const numValue = v.numericValue;
-    if (typeof numValue !== "number") return;
-    if (!legalValues.includes(numValue)) return;
-
-    basedOnList.forEach((item) => {
-      if (item.varId === v.varId) {
-        const weight = typeof item.weight === "number" ? item.weight : 1;
-        const weightedValue = numValue * weight;
-
-        result.basedOn.push({
-          varId: item.varId,
-          weight: weight,
-          varLabel: v.label,
-          value: numValue,
-        });
-        result.sumScore = result.sumScore + weightedValue;
-        // sum = sum + weightedValue;
-      }
-    });
-  });
-  return result;
-};
-export const SumScoreVariable = {
-  ALLOWED_SUM_SCORE_VALUES,
-  calculate,
-};
+import { BVariable } from "./b-variable";
+import { BuilderObjectId } from "../BuilderObject";
+// import { PageID } from "@media-quest/engine";
+// import { BuilderObject, BuilderObjectId } from "../BuilderObject";
+//
+// export class SumScoreVariable {}
+export interface SumScoreVariableDto extends BVariable {
+  readonly origin: "sum-score";
+  useAvg?: boolean;
+  /**
+   * All variables that the sum-score should be based on.
+   */
+  basedOn: Array<{ varId: string; weight?: number }>;
+}
+export interface SumScoreEntry {
+  sumScoreId: BuilderObjectId.SumScoreVariableId;
+  // pageId: PageID;
+}
+// export class SumScoreVariable extends BuilderObject<
+//   "builder-sum-score-variable",
+//   SumScoreVariableDto
+// > {
+//   readonly useAvg = false;
+//   readonly basedOn: Array<{ varId: string; weight?: number }>;
+//   readonly id: BuilderObjectId.SumScoreVariableId;
+//   label = ""
+//   description = ""
+//   toJson(): SumScoreVariableDto {
+//     const basedOn = [...this.basedOn]
+//     const varId = this.id
+//     const label = this.label;
+//
+//     return {
+//           origin: "sum-score",
+//       varId,
+//       label,
+//           useAvg: this.useAvg,
+//           basedOn,
+//         };
+//   }
+//   clone(): SumScoreVariableDto {
+//     throw new Error("Method not implemented.");
+//   }
+//   readonly objectType = "builder-sum-score-variable";
+//   constructor(dto: SumScoreVariableDto) {
+//     super(dto);
+//     this.useAvg = dto.useAvg;
+//     this.basedOn = dto.basedOn;
+//   }
+// }

package/src/variable/sum-score.ts

@@ -0,0 +1,130 @@
+import { BVariable } from "./b-variable";
+import { SumScoreVariableDto } from "./sum-score-variable";
+
+/**
+ *
+ * A constant Array that contains all legal
+ */
+const ALLOWED_VALUES = [0, 1, 2, 3, 4, 5, 6, 7, 8];
+const isAllowedValue = (num: number) => {
+  const notNegative = num >= 0;
+  const lessThanNine = num < 9;
+  return notNegative && lessThanNine;
+};
+
+type BasedOnEntry =
+  | { kind: "missing"; varId: string }
+  | { kind: "invalid-variable"; varId: string; message: string }
+  | { kind: "has-value"; varId: string; value: number; weight: number; varLabel: string };
+
+export interface SumScore {
+  sumScore: number;
+  avg: number; // Alle besvarte spørsmål som ikke er 9.
+  useAvg: boolean;
+  includedAnswerCount: number;
+  missingAnswerCount: number;
+  skippedBy9Count: number; // Antall vetikke / hopp over
+  basedOn: Array<{ varId: string; value: number; weight: number; varLabel: string }>;
+  errorMessages: string[];
+}
+
+const calculate = (
+  sumScoreVariable: SumScoreVariableDto,
+  allVariables: Array<Pick<BVariable, "varId" | "numericValue" | "kind" | "label">>,
+): SumScore => {
+  const legalValues: Array<number> = [...ALLOWED_VALUES];
+
+  // CALCULATE THESE!!
+  let includedAnswerCount = 0;
+  let skippedBy9Count = 0;
+  let missingAnswerCount = 0;
+  let sumScore = 0;
+  const errorMessages: string[] = [];
+  const basedOn: SumScore["basedOn"] = [];
+  const useAvg = !!sumScoreVariable.useAvg;
+
+  const basedOnEntries: BasedOnEntry[] = sumScoreVariable.basedOn.map((scv) => {
+    const maybeVariable = allVariables.find((v) => v.varId === scv.varId);
+    let result: BasedOnEntry = { kind: "missing", varId: scv.varId };
+    if (!maybeVariable) {
+      return result;
+    }
+
+    if (maybeVariable.kind !== "numeric-variable") {
+      result = {
+        kind: "invalid-variable",
+        varId: scv.varId,
+        message: "The actual variable is not a numeric-variable",
+      };
+      return result;
+    }
+    const value = maybeVariable.numericValue ?? BVariable.MISSING;
+    const varLabel = maybeVariable.label;
+    const weight = scv.weight ?? 1;
+    const varId = maybeVariable.varId;
+
+    result = {
+      kind: "has-value",
+      varId,
+      weight,
+      value,
+      varLabel,
+    };
+
+    return result;
+  });
+
+  basedOnEntries.forEach((entry) => {
+    if (entry.kind === "missing") {
+      missingAnswerCount++;
+    }
+    if (entry.kind === "has-value") {
+      const { varId, varLabel, weight, value } = { ...entry };
+      const isAllowed = isAllowedValue(value);
+      if (isAllowed) {
+        basedOn.push({ varId, weight, value, varLabel });
+        sumScore += entry.value * entry.weight;
+        includedAnswerCount++;
+      }
+      if (value === 9) {
+        skippedBy9Count++;
+        basedOn.push({ varId, weight, value, varLabel });
+      }
+    }
+    if (entry.kind === "invalid-variable") {
+      errorMessages.push(entry.message);
+    }
+  });
+
+  const avg = sumScore / includedAnswerCount;
+  const result: SumScore = {
+    avg,
+    useAvg,
+    includedAnswerCount,
+    skippedBy9Count,
+    sumScore,
+    basedOn,
+    missingAnswerCount,
+    errorMessages,
+  };
+  // Calculate avg
+
+  return result;
+};
+const createVariable = (varId: string): SumScoreVariableDto => {
+  return {
+    origin: "sum-score",
+    kind: "numeric-variable",
+    initialValue: 0,
+    min: 0,
+    label: "Sum 123",
+    varId: "sum-score-variable-id",
+    basedOn: [],
+  };
+};
+export const SumScore = {
+  ALLOWED_VALUES,
+  calculate,
+  isAllowedValue,
+  createVariable,
+};