@media-quest/builder 0.0.25 → 0.0.27

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

@@ -0,0 +1,253 @@
+import { SumScore } from "./sum-score";
+import { SumScoreVariable, SumScoreVariableDto } from "./sum-score-variable";
+import { SchemaID, SumScoreVariableID } from "../primitives/ID";
+import { SumScoreAnswer } from "./sum-score-answer";
+import { BuilderSchema } from "../Builder-schema";
+import { SchemaPrefix } from "../primitives/schema-prefix";
+import { CodeBook } from "../code-book/codebook";
+import { BuilderPage } from "../page/Builder-page";
+import { VarID } from "../primitives/varID";
+
+const createAnswer = (value: number): SumScoreAnswer => {
+  const varId = "v" + value;
+  const varLabel = "label for " + varId;
+  const valueLabel = "label for value " + value;
+  return {
+    varId,
+    varLabel,
+    value,
+    valueLabel,
+  };
+};
+
+const createSumScore = () => {
+  const id = SumScoreVariableID.create();
+  const sumVar1: SumScoreVariableDto = {
+    id,
+    name: "",
+    description: "",
+    useAvg: true,
+  };
+  return sumVar1;
+};
+
+const a0 = createAnswer(0);
+const a1 = createAnswer(1);
+const a2 = createAnswer(2);
+const a3 = createAnswer(3);
+const a4 = createAnswer(4);
+const a5 = createAnswer(5);
+const a6 = createAnswer(6);
+const a7 = createAnswer(7);
+const a8 = createAnswer(8);
+const a9 = createAnswer(9);
+
+const all = [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9];
+
+describe("Sum score sum-score.", () => {
+  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();
+    const basedOn = [
+      { varId: a1.varId, varLabel: a1.varLabel, weight: 1 },
+      { varId: a2.varId, varLabel: a2.varLabel, weight: 1 },
+      { varId: a9.varId, varLabel: a9.varLabel, weight: 1 },
+    ];
+
+    const score = SumScore.calculate(ss1, basedOn, 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();
+    const basedOn = [
+      { varId: a1.varId, varLabel: a1.varLabel, weight: 1 },
+      { varId: a2.varId, varLabel: a2.varLabel, weight: 1 },
+      { varId: a4.varId, varLabel: a4.varLabel, weight: 1 },
+      { varId: a5.varId, varLabel: a5.varLabel, weight: 1 },
+      { varId: a6.varId, varLabel: a6.varLabel, weight: 1 },
+      { varId: a9.varId, varLabel: a9.varLabel, weight: 0.5 },
+    ];
+    const score = SumScore.calculate(ss1, basedOn, all);
+    expect(score.sumScore).toBe(18);
+    expect(score.avg).toBe(3.6);
+    const basedOn1 = score.basedOn[0];
+    expect(basedOn1.value).toBe(a1.value);
+    expect(basedOn1.weight).toBe(1);
+    expect(basedOn1.varId).toBe(a1.varId);
+    expect(basedOn1.varLabel).toBe(a1.varLabel);
+  });
+  test("Will not include 9 in includedAnswersCount", () => {
+    const ss1 = createSumScore();
+    const basedOn = [
+      { varId: a0.varId, varLabel: a0.varLabel, weight: 1 },
+      { varId: a1.varId, varLabel: a1.varLabel, weight: 1 },
+      { varId: a5.varId, varLabel: a5.varLabel, weight: 1 },
+      { varId: a9.varId, varLabel: a9.varLabel, weight: 1 },
+    ];
+    const score = SumScore.calculate(ss1, basedOn, all);
+    expect(score.sumScore).toBe(6);
+    expect(score.avg).toBe(2);
+    expect(score.includedAnswerCount).toBe(3);
+  });
+  test("Will calculate weight", () => {
+    const ss1 = createSumScore();
+    const basedOn = [
+      { varId: a1.varId, varLabel: a1.varLabel, weight: 1 },
+      { varId: a8.varId, varLabel: a8.varLabel, weight: 0.5 },
+    ];
+    const score = SumScore.calculate(ss1, basedOn, all);
+    expect(score.sumScore).toBe(5);
+  });
+  test("Will calculate many weighted variables.", () => {
+    const ss1 = createSumScore();
+    const basedOn = [
+      { varId: a1.varId, varLabel: a1.varLabel, weight: 1 },
+      { varId: a2.varId, varLabel: a2.varLabel, weight: 0.5 },
+      { varId: a5.varId, varLabel: a5.varLabel, weight: 1.2 },
+      { varId: a8.varId, varLabel: a8.varLabel, weight: 2 },
+    ];
+    const score = SumScore.calculate(ss1, basedOn, all);
+    expect(score.sumScore).toBe(24);
+  });
+  test("Will count missing answers (missingAnswersCount)", () => {
+    const ss1 = createSumScore();
+    const basedOn = [
+      { varId: a1.varId, varLabel: a1.varLabel, weight: 1 },
+      { varId: a2.varId, varLabel: a2.varLabel, weight: 1 },
+      { varId: a3.varId, varLabel: a3.varLabel, weight: 1 },
+      { varId: a5.varId, varLabel: a5.varLabel, weight: 1 },
+      { varId: a9.varId, varLabel: a9.varLabel, weight: 1 },
+    ];
+    const missing5InDataSet = [a1, a2, a8];
+    const score = SumScore.calculate(ss1, basedOn, 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();
+    const basedOn = [
+      { varId: a0.varId, varLabel: a0.varLabel, weight: 1 },
+      { varId: a1.varId, varLabel: a1.varLabel, weight: 1 },
+      { varId: a2.varId, varLabel: a2.varLabel, weight: 1 },
+      { varId: a9.varId, varLabel: a9.varLabel, weight: 1 },
+    ];
+    const answers = [a1, a7, a8, a9];
+    const score = SumScore.calculate(ss1, basedOn, answers);
+
+    expect(score.includedAnswerCount + score.missingAnswerCount + score.skippedBy9Count).toBe(
+      basedOn.length,
+    );
+  });
+  test("calculateAll", () => {
+    const prefix = SchemaPrefix.fromValueOrThrow("angst");
+    const schema = BuilderSchema.create(SchemaID.create(), "testing", prefix.value);
+    const p1 = schema.addPage("question");
+    const p2 = schema.addPage("question");
+    const p3 = schema.addPage("question");
+
+    // Setting question text
+    p1.mainText.text = "q1";
+    p2.mainText.text = "q2";
+    p3.mainText.text = "q3";
+    const v1 = schema.sumScoreVariableCreate({
+      name: "ss1",
+      description: "ss1-desc",
+      useAvg: true,
+    });
+    const v2 = schema.sumScoreVariableCreate({
+      name: "ss2",
+      description: "ss2-desc",
+      useAvg: true,
+    });
+    const v3 = schema.sumScoreVariableCreate({
+      name: "ss3",
+      description: "ss3-desc",
+      useAvg: true,
+    });
+    const success_v1_p1 = schema.sumScoreVariableAddToPage(v1, p1, 1);
+    const success_v1_p2 = schema.sumScoreVariableAddToPage(v1, p2, 1);
+    const success_v2_p2 = schema.sumScoreVariableAddToPage(v2, p2, 1);
+    const success_v3_p1 = schema.sumScoreVariableAddToPage(v3, p1, 1);
+    const success_v3_p2 = schema.sumScoreVariableAddToPage(v3, p2, 1);
+    const success_v3_p3 = schema.sumScoreVariableAddToPage(v3, p3, 1);
+    expect(success_v1_p1).toBeTruthy();
+    expect(success_v1_p2).toBeTruthy();
+    expect(success_v2_p2).toBeTruthy();
+    expect(success_v3_p1).toBeTruthy();
+    expect(success_v3_p2).toBeTruthy();
+    expect(success_v3_p3).toBeTruthy();
+
+    // const v = schema.
+    const p1_questionVariable = p1.getQuestionVariables(prefix, 0)[0];
+    const p2_questionVariable = p2.getQuestionVariables(prefix, 1)[0];
+    const p3_questionVariable = p3.getQuestionVariables(prefix, 2)[0];
+
+    const ans1: SumScoreAnswer = {
+      varId: p1_questionVariable.varId,
+      value: 1,
+      varLabel: p1_questionVariable.label,
+      valueLabel: "Ja",
+    };
+
+    const ans2: SumScoreAnswer = {
+      varId: p2_questionVariable.varId,
+      value: 2,
+      varLabel: p2_questionVariable.label,
+      valueLabel: "Ja",
+    };
+    const ans3: SumScoreAnswer = {
+      varId: p3_questionVariable.varId,
+      value: 3,
+      varLabel: p3_questionVariable.label,
+      valueLabel: "Ja",
+    };
+
+    const sumScores = SumScore.calculateAll(schema.toJson(), [ans1, ans2, ans3]);
+    const ss1 = sumScores[0] as SumScore;
+    const ss2 = sumScores[1] as SumScore;
+    const ss3 = sumScores[2] as SumScore;
+
+    expect(sumScores.length).toBe(3);
+    // BASED ON IS WORKING.
+    expect(ss1.basedOn.length).toBe(2);
+    expect(ss2.basedOn.length).toBe(1);
+    expect(ss3.basedOn.length).toBe(3);
+    const isBasedOn = (sumScore: SumScore, variableId: string, variableLabel: string) => {
+      const found = sumScore.basedOn.find((basedOnItem) => basedOnItem.varId === variableId);
+
+      expect(found?.varId).toBe(variableId);
+      expect(found?.varLabel).toBe(variableLabel);
+    };
+    isBasedOn(ss1, ans1.varId, p1_questionVariable.label);
+    isBasedOn(ss1, ans2.varId, p2_questionVariable.label);
+    isBasedOn(ss2, ans2.varId, p2_questionVariable.label);
+    isBasedOn(ss3, ans1.varId, p1_questionVariable.label);
+    isBasedOn(ss3, ans2.varId, p2_questionVariable.label);
+    isBasedOn(ss3, ans3.varId, p3_questionVariable.label);
+    expect(ss1.sumScore).toBe(3);
+    expect(ss2.sumScore).toBe(2);
+    expect(ss3.sumScore).toBe(6);
+  });
+});

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

@@ -0,0 +1,98 @@
+import { SumScoreVariableID } from "../primitives/ID";
+import { BuilderObject } from "../BuilderObject";
+import { DUtil } from "@media-quest/engine";
+
+export interface SumScoreVariableDto {
+  id: SumScoreVariableID;
+  name: string;
+  description: string;
+  useAvg: boolean;
+  /**
+   * All variables that the sum-score should be based on.
+   */
+  // basedOn: Array<{ varId: string; varLabel: string; weight?: number }>;
+}
+
+export class SumScoreVariable extends BuilderObject<
+  "builder-sum-score-variable",
+  SumScoreVariableDto
+> {
+  readonly objectType = "builder-sum-score-variable";
+  readonly id: SumScoreVariableID;
+  private _useAvg = true;
+  private _name = "";
+  private _description = "";
+  private _error = "";
+  // private _basedOn = new Map<pageId: Page>()
+
+  // private _basedOn: Array<{ varId: string }> = [];
+  public static readonly create = (data: {
+    name: string;
+    description: string;
+    useAvg: boolean;
+  }): SumScoreVariable => {
+    const id = SumScoreVariableID.create();
+    return new SumScoreVariable({ id, ...data });
+  };
+
+  get hasErrors() {
+    return this._error.length !== 0;
+  }
+
+  public static fromDto = (dto: SumScoreVariableDto): SumScoreVariable => {
+    return new SumScoreVariable(dto);
+  };
+
+  private constructor(dto: SumScoreVariableDto) {
+    super(dto);
+    this.id = dto.id;
+    this._name = dto.name;
+    this._useAvg = dto.useAvg;
+    this._description = dto.description;
+  }
+  toJson(): SumScoreVariableDto {
+    const dto: SumScoreVariableDto = {
+      description: this.description,
+      id: this.id,
+      name: this.name,
+      useAvg: this.useAvg,
+    };
+    return dto;
+  }
+  clone(): SumScoreVariableDto {
+    const id = SumScoreVariableID.create();
+    const dto = this.toJson();
+    return { ...dto, id };
+  }
+
+  /** @internal*/
+  _update(data: { name?: string; description?: string; useAvg?: boolean }) {
+    const d = data ?? {};
+    if (DUtil.isString(d.name)) {
+      this._name = d.name;
+    }
+    if (DUtil.isString(d.description)) {
+      this._description = d.description;
+    }
+    if (DUtil.isBool(d.useAvg)) {
+      this._useAvg = d.useAvg;
+    }
+  }
+
+  /**
+   * @internal - used by sum-score-variable-collection.
+   */
+  _setError(error: "" | "Duplicate name") {
+    this._error = error;
+  }
+
+  get name() {
+    return this._name;
+  }
+  get description() {
+    return this._description;
+  }
+  get useAvg() {
+    return this._useAvg;
+  }
+}

package/src/{variable → sum-score}/sum-score.ts

@@ -1,5 +1,8 @@
-import { BVariable } from "./b-variable";
 import { SumScoreVariableDto } from "./sum-score-variable";
+import { SumScoreVariableID } from "../primitives/ID";
+import { SumScoreAnswer } from "./sum-score-answer";
+import { CodeBook } from "../code-book/codebook";
+import { BuilderSchemaDto } from "../Builder-schema";
 
 /**
  *
@@ -28,12 +31,48 @@ export interface SumScore {
   errorMessages: string[];
 }
 
+const calculateAll = (
+  schemaDto: BuilderSchemaDto,
+  answers: Array<SumScoreAnswer>,
+): ReadonlyArray<SumScore> => {
+  const vs = schemaDto.sumScoreVariables ?? [];
+
+  const basedOnMap = new Map<SumScoreVariableID, Array<{ varId: string; weight: number }>>();
+  const codeBook = CodeBook.fromSchema(schemaDto);
+  // codeBook.pageVariables.find(v => v.pageId === )
+  const pages = schemaDto.pages;
+  // const a: Array<{pageId: PageID,  sumScoreVariableId: SumScoreVariableID, weight: number, varId: string}> = []
+
+  pages.forEach((page) => {
+    page.includedInSumScores.forEach((includedInScores) => {
+      const variableId = includedInScores.sumScoreVariableId;
+      const weight = includedInScores.weight;
+      const p = codeBook.pageVariables.find((v) => v.pageId === page.id);
+      if (p) {
+        const currentBasedOnArray = basedOnMap.get(variableId) ?? [];
+        currentBasedOnArray.push({ varId: p.varId, weight });
+        basedOnMap.set(variableId, currentBasedOnArray);
+      } else {
+        // TODO - Global event-bus for errors?
+        console.error("INVALID DATA in calculate all sum-scores.");
+        // throw Error("Invalid data...");
+      }
+    });
+  });
+  // const pages = Array.isArray(schemaDto.pages) ? schemaDto.pages : [];
+  const results: ReadonlyArray<SumScore> = vs.map((v) => {
+    const basedOn = basedOnMap.get(v.id) ?? [];
+    return calculate(v, basedOn, answers);
+  });
+
+  return results;
+};
 const calculate = (
   sumScoreVariable: SumScoreVariableDto,
-  allVariables: Array<Pick<BVariable, "varId" | "numericValue" | "kind" | "label">>,
+  basedOnVariables: Array<{ varId: string; weight: number }>,
+  answers: Array<SumScoreAnswer>,
 ): SumScore => {
   const legalValues: Array<number> = [...ALLOWED_VALUES];
-
   // CALCULATE THESE!!
   let includedAnswerCount = 0;
   let skippedBy9Count = 0;
@@ -41,27 +80,19 @@ const calculate = (
   let sumScore = 0;
   const errorMessages: string[] = [];
   const basedOn: SumScore["basedOn"] = [];
-  const useAvg = !!sumScoreVariable.useAvg;
+  const useAvg = sumScoreVariable.useAvg;
 
-  const basedOnEntries: BasedOnEntry[] = sumScoreVariable.basedOn.map((scv) => {
-    const maybeVariable = allVariables.find((v) => v.varId === scv.varId);
+  const basedOnEntries: BasedOnEntry[] = basedOnVariables.map((scv) => {
+    const maybeAnswer = answers.find((v) => v.varId === scv.varId);
     let result: BasedOnEntry = { kind: "missing", varId: scv.varId };
-    if (!maybeVariable) {
+    if (!maybeAnswer) {
       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 value = maybeAnswer.value;
+    const varLabel = maybeAnswer.varLabel;
     const weight = scv.weight ?? 1;
-    const varId = maybeVariable.varId;
+    const varId = maybeAnswer.varId;
 
     result = {
       kind: "has-value",
@@ -111,20 +142,20 @@ const calculate = (
 
   return result;
 };
-const createVariable = (varId: string): SumScoreVariableDto => {
+const createVariable = (): SumScoreVariableDto => {
+  const id = SumScoreVariableID.create();
   return {
-    origin: "sum-score",
-    kind: "numeric-variable",
-    initialValue: 0,
-    min: 0,
-    label: "Sum 123",
-    varId: "sum-score-variable-id",
-    basedOn: [],
+    id,
+    name: "",
+    useAvg: true,
+    description: "",
+    // basedOn: [],
   };
 };
 export const SumScore = {
   ALLOWED_VALUES,
   calculate,
+  calculateAll,
   isAllowedValue,
   createVariable,
 };

package/src/tag/BuilderTag.ts

@@ -0,0 +1,45 @@
+import { BuilderObject } from "../BuilderObject";
+import { TagID } from "../primitives/ID";
+
+export interface BuilderTagDto {
+  readonly id: TagID;
+  readonly tag: string;
+  readonly description: string;
+}
+
+export class BuilderTag extends BuilderObject<"builder-tag", BuilderTagDto> {
+  readonly objectType: "builder-tag" = "builder-tag";
+  readonly id: TagID;
+  tagText = "";
+  tagDescription = "";
+  public static readonly MAX_LENGTH = 20;
+  public static readonly MIN_LENGTH = 1;
+
+  public static readonly create = (tag: string, description: string = "") => {
+    const id = TagID.create();
+    const dto: BuilderTagDto = {
+      id,
+      tag,
+      description,
+    };
+    return new BuilderTag(dto);
+  };
+  public static readonly fromDto = (dto: BuilderTagDto) => {
+    return new BuilderTag(dto);
+  };
+  protected constructor(dto: BuilderTagDto) {
+    const id = TagID.validateOrCreate(dto.id);
+    const withId = { ...dto, id };
+    super(withId);
+    this.id = id;
+    this.tagText = dto.tag ?? "";
+    this.tagDescription = dto.description ?? "";
+  }
+  clone(): BuilderTagDto {
+    return this.toJson();
+  }
+
+  toJson(): BuilderTagDto {
+    return { tag: this.tagText, description: this.tagDescription, id: this.id };
+  }
+}

package/src/tag/Tag-Collection.ts

@@ -0,0 +1,53 @@
+import { BuilderTag, BuilderTagDto } from "./BuilderTag";
+
+export class TagCollection implements Iterable<BuilderTag> {
+  private readonly _tags = new Set<BuilderTag>();
+  public static readonly create = () => {
+    return new TagCollection([]);
+  };
+
+  [Symbol.iterator]() {
+    const list = [...this._tags];
+    return list[Symbol.iterator]();
+  }
+
+  private constructor(initialTags: ReadonlyArray<BuilderTag>) {
+    initialTags.forEach((tag) => {
+      this._tags.add(tag);
+    });
+  }
+
+  init(tags: ReadonlyArray<BuilderTagDto>) {
+    const dtoList: ReadonlyArray<BuilderTagDto> = Array.isArray(tags) ? tags : [];
+    const all = dtoList.map(BuilderTag.fromDto);
+    all.forEach((tag) => {
+      this._tags.add(tag);
+    });
+  }
+
+  add(tag: BuilderTag) {
+    this._tags.add(tag);
+  }
+
+  /**
+   * Delete this tag from collection;
+   * @param tag
+   */
+  delete(tag: BuilderTag) {
+    this._tags.delete(tag);
+  }
+
+  toJson(): ReadonlyArray<BuilderTagDto> {
+    const list = [...this._tags];
+    const dtoList = list.map((t) => t.toJson());
+    return dtoList;
+  }
+
+  deleteAll(tags: Iterable<BuilderTag>) {
+    const l = tags[Symbol.iterator]();
+    const asList = [...tags];
+    asList.forEach((t) => {
+      this.delete(t);
+    });
+  }
+}