@molgenis/vip-report-template 6.2.0 → 7.0.0

package/vite.config.mts

@@ -1,14 +1,17 @@
-import { defineConfig } from "vitest/config";
+import { coverageConfigDefaults, defineConfig } from "vitest/config";
 import solidPlugin from "vite-plugin-solid";
 import inlinePlugin from "@molgenis/vite-plugin-inline";
 
-export default defineConfig({
+export default defineConfig(({ command }) => ({
   plugins: [solidPlugin(), inlinePlugin()],
   esbuild: {
     // @molgenis/vite-plugin-inline requires ascii input and cannot handle UTF-8 input
     charset: "ascii",
+    pure: command === "build" ? ["console.log"] : [],
   },
   build: {
+    modulePreload: false,
+    reportCompressedSize: false,
     // inline plugin build options
     rollupOptions: {
       input: ["./index.html", "./node_modules/@molgenis/vite-plugin-inline/dist/loader.mjs"],
@@ -18,4 +21,18 @@ export default defineConfig({
     },
   },
   assetsInclude: "**/*.blob",
-});
+  test: {
+    coverage: {
+      include: ["src/**"],
+      exclude: [...coverageConfigDefaults.exclude, "src/mocks/**"],
+      // TODO add .tsx once component tests are added
+      extension: [".ts"],
+      thresholds: {
+        branches: 80,
+        lines: 80,
+        functions: 80,
+        statements: 80,
+      },
+    },
+  },
+}));

package/.eslintignore

@@ -1,4 +0,0 @@
-node_modules
-dist
-/.idea/
-coverage

package/.eslintrc.js

@@ -1,23 +0,0 @@
-module.exports = {
-  parser: "@typescript-eslint/parser",
-  parserOptions: {
-    project: ["./tsconfig.json"],
-    ecmaVersion: 2021,
-    sourceType: "module",
-    ecmaFeatures: {
-      jsx: true,
-    },
-  },
-  extends: [
-    "plugin:@typescript-eslint/recommended",
-    "plugin:@typescript-eslint/recommended-requiring-type-checking",
-    "prettier",
-    "plugin:prettier/recommended",
-    "plugin:solid/typescript",
-  ],
-  rules: {
-    "@typescript-eslint/no-non-null-assertion": "off",
-    "solid/prefer-show": "off",
-  },
-  plugins: ["prettier", "@typescript-eslint"],
-};

package/src/Api.ts

@@ -1,12 +0,0 @@
-import { WindowApiClient } from "@molgenis/vip-report-api/src/WindowApiClient";
-
-// lazy import MockApiClient to ensure that it is excluded from the build artifact
-const api = import.meta.env.PROD
-  ? new WindowApiClient()
-  : await (function () {
-      return import("./mocks/MockApiClient").then((module) => {
-        return new module.MockApiClient();
-      });
-    })();
-
-export default api;

package/src/__tests__/decisionTreeUtils.test.ts

@@ -1,75 +0,0 @@
-import { expect, test } from "vitest";
-import { getDecisionTreePath } from "../utils/decisionTreeUtils";
-import { Item } from "@molgenis/vip-report-api/src/Api";
-import { Record } from "@molgenis/vip-report-vcf/src/Vcf";
-import { FieldMetadata } from "@molgenis/vip-report-vcf/src/MetadataParser";
-
-test("Get DecisionTree Path", () => {
-  const fieldMetaVIPP: FieldMetadata = {
-    description: "VIP Decision tree path",
-    id: "VIPP",
-    number: { type: "NUMBER" },
-    type: "STRING",
-  };
-  const fieldMetaOther: FieldMetadata = {
-    description: "Other",
-    id: "Other",
-    number: { type: "NUMBER" },
-    type: "STRING",
-  };
-
-  const fieldMetaCsq: FieldMetadata = {
-    description: "VEP",
-    id: "CSQ",
-    number: { type: "NUMBER" },
-    type: "STRING",
-    nested: { items: [fieldMetaOther, fieldMetaVIPP], separator: "|" },
-  };
-
-  const variant: Item<Record> = {
-    data: {
-      a: [],
-      c: "",
-      f: [],
-      i: [],
-      n: {
-        CSQ: [["T", "gnomad&mvl&clinvar&exit", "MODERATE"]],
-      },
-    },
-  } as unknown as Item<Record>;
-  expect(getDecisionTreePath({ info: { CSQ: fieldMetaCsq }, lines: [], format: {}, samples: [] }, variant, 0)).toBe(
-    "gnomad&mvl&clinvar&exit",
-  );
-});
-
-test("Get DecisionTree Path - no VIPP", () => {
-  const fieldMetaOther: FieldMetadata = {
-    description: "Other",
-    id: "Other",
-    number: { type: "NUMBER" },
-    type: "STRING",
-  };
-
-  const fieldMetaCsq: FieldMetadata = {
-    description: "VEP",
-    id: "CSQ",
-    number: { type: "NUMBER" },
-    type: "STRING",
-    nested: { items: [fieldMetaOther], separator: "|" },
-  };
-
-  const variant: Item<Record> = {
-    data: {
-      a: [],
-      c: "",
-      f: [],
-      i: [],
-      n: {
-        CSQ: [["T", "gnomad&mvl&clinvar&exit", "MODERATE"]],
-      },
-    },
-  } as unknown as Item<Record>;
-  expect(getDecisionTreePath({ info: { CSQ: fieldMetaCsq }, lines: [], format: {}, samples: [] }, variant, 0)).toBe(
-    undefined,
-  );
-});

package/src/__tests__/field.test.ts

@@ -1,107 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { abbreviateHeader, findInfoField, isNumerical } from "../utils/field";
-import { FieldMetadata } from "@molgenis/vip-report-vcf/src/MetadataParser";
-import { Metadata } from "@molgenis/vip-report-vcf/src/Vcf";
-import { FieldMetadataContainer } from "@molgenis/vip-report-vcf/src/VcfParser";
-
-describe("field utilities", () => {
-  test("FLOAT is numerical", () => {
-    expect(isNumerical({ type: "FLOAT" } as FieldMetadata)).toBe(true);
-  });
-
-  test("INTEGER is numerical", () => {
-    expect(isNumerical({ type: "INTEGER" } as FieldMetadata)).toBe(true);
-  });
-
-  test("STRING is not numerical", () => {
-    expect(isNumerical({ type: "STRING" } as FieldMetadata)).toBe(false);
-  });
-
-  test("abbreviate header long text", () => {
-    expect(abbreviateHeader("abcdefghijklmnopqrstuvwxyz")).toBe("abcdefghijk\u2026");
-  });
-
-  test("abbreviate header short text", () => {
-    expect(abbreviateHeader("abcdef")).toBe("abcdef");
-  });
-
-  test("find info field", () => {
-    const field = { id: "field" } as FieldMetadata;
-    const recordsMetadata = {
-      info: {
-        field,
-      } as FieldMetadataContainer,
-    } as Metadata;
-
-    expect(findInfoField(recordsMetadata, ["n", "field"])).toBe(field);
-  });
-
-  test("find info field: unknown field", () => {
-    const recordsMetadata = {
-      info: {} as FieldMetadataContainer,
-    } as Metadata;
-
-    expect(() => findInfoField(recordsMetadata, ["n", "field"])).toThrowError();
-  });
-
-  test("find info field: nested", () => {
-    const childField0 = { id: "childField0" } as FieldMetadata;
-    const childField1 = { id: "childField1" } as FieldMetadata;
-    const nestedField = { id: "nestedField", nested: { items: [childField0, childField1] } } as FieldMetadata;
-
-    const recordsMetadata = {
-      info: {
-        nestedField,
-      } as FieldMetadataContainer,
-    } as Metadata;
-
-    expect(findInfoField(recordsMetadata, ["n", "nestedField", 1])).toBe(childField1);
-  });
-
-  test("find info field: missing 'n' path item", () => {
-    const field = { id: "field" } as FieldMetadata;
-    const recordsMetadata = {
-      info: {
-        field,
-      } as FieldMetadataContainer,
-    } as Metadata;
-
-    expect(() => findInfoField(recordsMetadata, ["field"])).toThrowError();
-  });
-
-  test("find info field: missing 'n' path item nested", () => {
-    const recordsMetadata = {
-      info: {} as FieldMetadataContainer,
-    } as Metadata;
-
-    expect(() => findInfoField(recordsMetadata, ["nestedField", 1])).toThrowError();
-  });
-
-  test("find info field: nested invalid index", () => {
-    const childField0 = { id: "childField0" } as FieldMetadata;
-    const childField1 = { id: "childField1" } as FieldMetadata;
-    const nestedField = { id: "nestedField", nested: { items: [childField0, childField1] } } as FieldMetadata;
-
-    const recordsMetadata = {
-      info: {
-        nestedField,
-      } as FieldMetadataContainer,
-    } as Metadata;
-
-    expect(() => findInfoField(recordsMetadata, ["n", "nestedField", 2])).toThrowError();
-  });
-
-  test("find info field: nested invalid index type", () => {
-    const childField0 = { id: "childField0" } as FieldMetadata;
-    const childField1 = { id: "childField1" } as FieldMetadata;
-    const nestedField = { id: "nestedField", nested: { items: [childField0, childField1] } } as FieldMetadata;
-
-    const recordsMetadata = {
-      info: {
-        nestedField,
-      } as FieldMetadataContainer,
-    } as Metadata;
-
-    expect(() => findInfoField(recordsMetadata, ["n", "nestedField", "childField1"])).toThrowError();
-  });
-});

package/src/__tests__/query.test.ts

@@ -1,188 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { FieldMetadata } from "@molgenis/vip-report-vcf/src/MetadataParser";
-import { Metadata } from "@molgenis/vip-report-vcf/src/Vcf";
-import { FilterQueries } from "../store";
-import {
-  createQuery,
-  createSampleQuery,
-  infoFieldKey,
-  infoSelector,
-  infoSortPath,
-  sampleFieldKey,
-  sampleSelector,
-  selectorKey,
-} from "../utils/query";
-import { Item, Person, Query, QueryClause, Sample } from "@molgenis/vip-report-api/src/Api";
-
-describe("query utilities", () => {
-  let fieldMetaCsq: FieldMetadata = {
-    id: "CSQ",
-    number: { type: "NUMBER" },
-    type: "STRING",
-  };
-
-  const fieldMeta1: FieldMetadata = {
-    id: "field1",
-    number: { type: "NUMBER" },
-    type: "CATEGORICAL",
-    parent: fieldMetaCsq,
-  };
-
-  const fieldMeta2: FieldMetadata = {
-    id: "field2",
-    number: { type: "NUMBER" },
-    type: "CATEGORICAL",
-    parent: fieldMetaCsq,
-  };
-
-  fieldMetaCsq = {
-    id: "CSQ",
-    number: { type: "NUMBER" },
-    type: "STRING",
-    nested: { items: [fieldMeta1, fieldMeta2], separator: "|" },
-  };
-
-  const person: Person = {
-    familyId: "FAM001",
-    individualId: "Patient",
-    sex: "FEMALE",
-    affectedStatus: "AFFECTED",
-    maternalId: "Mother",
-    paternalId: "Father",
-  };
-
-  const meta: Metadata = { info: { CSQ: fieldMetaCsq } } as unknown as Metadata;
-
-  test("create sample query - filters", () => {
-    const sample = { data: { index: 1 } } as Item<Sample>;
-    const queryClause: Query = {
-      operator: "and",
-      args: [
-        { selector: ["s", 1, "GT", "t"], operator: "!=", args: "hom_r" },
-        { selector: ["s", 1, "GT", "t"], operator: "!=", args: "miss" },
-      ],
-    };
-    const filterQueryClause: QueryClause = { selector: ["n", "CSQ", "*", 0], operator: "==", args: [0] };
-    const filterQueries: FilterQueries = {
-      "CSQ/field1": filterQueryClause,
-    };
-    expect(createSampleQuery(sample, undefined, filterQueries, meta)).toStrictEqual({
-      operator: "and",
-      args: [queryClause, filterQueryClause],
-    });
-  });
-
-  test("create sample query - undefined search and undefined filters", () => {
-    const sample = { data: { index: 1 } } as Item<Sample>;
-    const queryClause: Query = {
-      operator: "and",
-      args: [
-        { selector: ["s", 1, "GT", "t"], operator: "!=", args: "hom_r" },
-        { selector: ["s", 1, "GT", "t"], operator: "!=", args: "miss" },
-      ],
-    };
-    expect(createSampleQuery(sample, undefined, undefined, meta)).toStrictEqual(queryClause);
-  });
-
-  test("create query", () => {
-    const searchText = "my search text";
-    const filterQueries: FilterQueries = {
-      "CSQ/field1": { selector: ["n", "CSQ", "*", 0], operator: "==", args: [0] },
-      "CSQ/field2": { selector: ["n", "CSQ", "*", 1], operator: "==", args: [1, 2] },
-    };
-    expect(createQuery(searchText, filterQueries, meta)).toStrictEqual({
-      operator: "and",
-      args: [
-        {
-          operator: "or",
-          args: [
-            { selector: ["n", "CSQ", "*", "0"], operator: "any_~=_any", args: ["my search text"] },
-            { selector: ["n", "CSQ", "*", "1"], operator: "any_~=_any", args: ["my search text"] },
-          ],
-        },
-        {
-          operator: "and",
-          args: [
-            { selector: ["n", "CSQ", "*", 0], operator: "==", args: [0] },
-            { selector: ["n", "CSQ", "*", 1], operator: "==", args: [1, 2] },
-          ],
-        },
-      ],
-    });
-  });
-
-  test("create query: undefined search and undefined filters", () => {
-    expect(createQuery(undefined, undefined, meta)).toBe(null);
-  });
-
-  test("create query: undefined search and empty filters", () => {
-    expect(createQuery(undefined, {}, meta)).toBe(null);
-  });
-
-  test("create query: undefined search and empty filters with keys", () => {
-    expect(createQuery(undefined, { filterId: undefined }, meta)).toBe(null);
-  });
-
-  test("create query - search query only", () => {
-    const searchText = "searchString";
-    expect(createQuery(searchText, undefined, meta)).toStrictEqual({
-      args: [
-        {
-          args: ["searchString"],
-          operator: "any_~=_any",
-          selector: ["n", "CSQ", "*", "0"],
-        },
-        {
-          args: ["searchString"],
-          operator: "any_~=_any",
-          selector: ["n", "CSQ", "*", "1"],
-        },
-      ],
-      operator: "or",
-    });
-  });
-
-  test("create query - filter queries only", () => {
-    const filterQueries = {};
-    expect(createQuery(undefined, filterQueries, meta)).toBe(null);
-  });
-
-  test("create query - one filter query", () => {
-    const queryClause: QueryClause = { selector: ["n", "CSQ", "*", 0], operator: "==", args: [0] };
-    const filterQueries: FilterQueries = {
-      "CSQ/field1": queryClause,
-    };
-    expect(createQuery(undefined, filterQueries, meta)).toBe(queryClause);
-  });
-
-  test("infoSelector", () => {
-    expect(infoSelector(fieldMeta1)).toStrictEqual(["n", "CSQ", "field1"]);
-  });
-
-  test("sampleSelector", () => {
-    expect(sampleSelector({ id: 1, data: { person: person, index: 0, proband: false } }, fieldMeta1)).toStrictEqual([
-      "s",
-      0,
-      "CSQ",
-      "field1",
-    ]);
-  });
-
-  test("selectorKey", () => {
-    expect(selectorKey([1, "test", 2, "3"])).toStrictEqual("1/test/2/3");
-  });
-
-  test("infoFieldKey", () => {
-    expect(infoFieldKey(fieldMeta1)).toStrictEqual("n/CSQ/field1");
-  });
-
-  test("sampleFieldKey", () => {
-    expect(sampleFieldKey({ id: 1, data: { person: person, index: 0, proband: false } }, fieldMeta1)).toStrictEqual(
-      "s/0/CSQ/field1",
-    );
-  });
-
-  test("infoSortPath", () => {
-    expect(infoSortPath(fieldMetaCsq)).toStrictEqual(["n", "CSQ"]);
-  });
-});

package/src/__tests__/sample.test.ts

@@ -1,184 +0,0 @@
-import { describe, expect, test } from "vitest";
-import {
-  getSampleAffectedStatusLabel,
-  getSampleFamilyMembersWithoutParents,
-  getSampleFather,
-  getSampleLabel,
-  getSampleMother,
-  getSampleSexLabel,
-} from "../utils/sample";
-import { Sample } from "@molgenis/vip-report-api/src/Api";
-
-describe("sample utilities", () => {
-  const sample = {
-    person: {
-      familyId: "fam0",
-      individualId: "0",
-      maternalId: "1",
-      paternalId: "2",
-    },
-  } as Sample;
-  const motherSample = {
-    person: {
-      familyId: "fam0",
-      individualId: "1",
-    },
-  } as Sample;
-  const fatherSample = {
-    person: {
-      familyId: "fam0",
-      individualId: "2",
-    },
-  } as Sample;
-  const siblingSample = {
-    person: {
-      familyId: "fam0",
-      individualId: "3",
-      maternalId: "1",
-      paternalId: "2",
-    },
-  } as Sample;
-  const otherMotherSample = {
-    person: {
-      familyId: "fam1",
-      individualId: "1",
-    },
-  } as Sample;
-  const otherFatherSample = {
-    person: {
-      familyId: "fam1",
-      individualId: "2",
-    },
-  } as Sample;
-  const otherSiblingSample = {
-    person: {
-      familyId: "fam1",
-      individualId: "3",
-      maternalId: "1",
-      paternalId: "2",
-    },
-  } as Sample;
-
-  test("getSampleLabel", () => {
-    const individualId = "sample_label";
-    const sample = {
-      person: {
-        individualId: individualId,
-      },
-    } as Sample;
-    expect(getSampleLabel(sample)).toBe(individualId);
-  });
-
-  test("getSampleSexLabel:FEMALE", () => {
-    const sample = {
-      person: {
-        sex: "FEMALE",
-      },
-    } as Sample;
-    expect(getSampleSexLabel(sample)).toBe("female");
-  });
-
-  test("getSampleSexLabel:MALE", () => {
-    const sample = {
-      person: {
-        sex: "MALE",
-      },
-    } as Sample;
-    expect(getSampleSexLabel(sample)).toBe("male");
-  });
-
-  test("getSampleSexLabel:OTHER_SEX", () => {
-    const sample = {
-      person: {
-        sex: "OTHER_SEX",
-      },
-    } as Sample;
-    expect(getSampleSexLabel(sample)).toBe("?");
-  });
-
-  test("getSampleSexLabel:UNKNOWN_SEX", () => {
-    const sample = {
-      person: {
-        sex: "UNKNOWN_SEX",
-      },
-    } as Sample;
-    expect(getSampleSexLabel(sample)).toBe("?");
-  });
-
-  test("getSampleAffectedStatusLabel:AFFECTED", () => {
-    const sample = {
-      person: {
-        affectedStatus: "AFFECTED",
-      },
-    } as Sample;
-    expect(getSampleAffectedStatusLabel(sample)).toBe("affected");
-  });
-
-  test("getSampleAffectedStatusLabel:UNAFFECTED", () => {
-    const sample = {
-      person: {
-        affectedStatus: "UNAFFECTED",
-      },
-    } as Sample;
-    expect(getSampleAffectedStatusLabel(sample)).toBe("unaffected");
-  });
-
-  test("getSampleAffectedStatusLabel:MISSING", () => {
-    const sample = {
-      person: {
-        affectedStatus: "MISSING",
-      },
-    } as Sample;
-    expect(getSampleAffectedStatusLabel(sample)).toBe("?");
-  });
-
-  test("getSampleMother", () => {
-    expect(
-      getSampleMother(sample, [
-        sample,
-        otherSiblingSample,
-        otherFatherSample,
-        otherMotherSample,
-        siblingSample,
-        fatherSample,
-        motherSample,
-      ]),
-    ).toStrictEqual(motherSample);
-  });
-
-  test("getSampleMother:undefined", () => {
-    expect(getSampleMother(sample, [sample, otherSiblingSample, otherFatherSample, otherMotherSample])).toBeUndefined();
-  });
-
-  test("getSampleFather", () => {
-    expect(
-      getSampleFather(sample, [
-        sample,
-        otherSiblingSample,
-        otherMotherSample,
-        otherFatherSample,
-        siblingSample,
-        motherSample,
-        fatherSample,
-      ]),
-    ).toStrictEqual(fatherSample);
-  });
-
-  test("getSampleFather:undefined", () => {
-    expect(getSampleFather(sample, [sample, otherSiblingSample, otherMotherSample, otherFatherSample])).toBeUndefined();
-  });
-
-  test("getSampleFamilyMembersWithoutParents", () => {
-    expect(
-      getSampleFamilyMembersWithoutParents(sample, [
-        sample,
-        otherSiblingSample,
-        otherMotherSample,
-        otherFatherSample,
-        siblingSample,
-        motherSample,
-        fatherSample,
-      ]),
-    ).toStrictEqual([siblingSample]);
-  });
-});

package/src/__tests__/utils.test.ts

@@ -1,24 +0,0 @@
-import { describe, test } from "vitest";
-import { arrayEquals } from "../utils/utils";
-
-describe("utilities", () => {
-  test("array equals", () => {
-    arrayEquals<string>(["a", "b", "c"], ["a", "b", "c"]);
-  });
-
-  test("array equals: empty array", () => {
-    arrayEquals<string>([], []);
-  });
-
-  test("array not equals: order", () => {
-    arrayEquals<string>(["a", "b", "c"], ["c", "b", "a"]);
-  });
-
-  test("array not equals: length left", () => {
-    arrayEquals<string>(["a", "b", "c"], ["a", "b"]);
-  });
-
-  test("array not equals: length right", () => {
-    arrayEquals<string>(["a", "b"], ["a", "b", "c"]);
-  });
-});