@molgenis/vip-report-template 6.2.0 → 7.0.0

package/src/store/app.ts

@@ -0,0 +1,30 @@
+import { createStore, produce } from "solid-js/store";
+import { AppActions, AppState, AppStore } from "../types/store";
+
+const defaultState: AppState = { variants: {}, sampleVariants: {}, samples: {} };
+
+export function createAppStore(): AppStore {
+  const [state, setState] = createStore(defaultState);
+
+  const actions: AppActions = {
+    reset() {
+      setState(
+        produce((state) => {
+          state.variants = {};
+          state.sampleVariants = {};
+          state.samples = {};
+        }),
+      );
+    },
+    setSamplePage(page: number) {
+      setState({ samples: { ...(state.samples || {}), page } });
+    },
+    setSampleSearchQuery(searchQuery: string) {
+      setState({ samples: { ...(state.samples || {}), searchQuery, page: undefined } });
+    },
+    setSampleProbandFilterValue(probandFilterValue: boolean) {
+      setState({ samples: { ...(state.samples || {}), probandFilterValue, page: undefined } });
+    },
+  };
+  return [state, actions, setState];
+}

package/src/store/index.tsx

@@ -1,176 +1,11 @@
 import { Context, createContext, ParentComponent, useContext } from "solid-js";
-import { createStore } from "solid-js/store";
-import { Item, Query, Sample, SortOrder } from "@molgenis/vip-report-api/src/Api";
-
-export type FilterQueries = { [key: string]: Query | undefined };
-
-type AppStateVariants = {
-  page?: number;
-  pageSize?: number;
-  searchQuery?: string;
-  filterQueries?: FilterQueries;
-  sort?: SortOrder | null; // null: do not sort. undefined: sort undefined
-};
-
-type AppStateSamples = {
-  page?: number;
-  searchQuery?: string;
-  probandFilterValue?: boolean;
-};
-
-export type AppState = {
-  variants?: AppStateVariants;
-  sampleVariants?: {
-    [key: number]: { variants: AppStateVariants };
-  };
-  samples?: AppStateSamples;
-};
-
-export type AppActions = {
-  reset(): void;
-  setVariantsPage(page: number): void;
-  setVariantsPageSize(pageSize: number): void;
-  setVariantsSearchQuery(searchQuery: string): void;
-  setVariantsFilterQuery(query: Query, key: string): void;
-  clearVariantsFilterQuery(key: string): void;
-  setVariantsSort(sort: SortOrder | null): void;
-  setSampleVariantsPage(sample: Item<Sample>, page: number): void;
-  setSampleVariantsPageSize(sample: Item<Sample>, pageSize: number): void;
-  setSampleVariantsSearchQuery(sample: Item<Sample>, searchQuery: string): void;
-  setSampleVariantsFilterQuery(sample: Item<Sample>, query: Query, key: string): void;
-  clearSampleVariantsFilterQuery(sample: Item<Sample>, key: string): void;
-  setSampleVariantsSort(sample: Item<Sample>, sort: SortOrder | null): void;
-  setSamplePage(page: number): void;
-  setSampleSearchQuery(searchQuery: string): void;
-  setSampleProbandFilterValue(probandFilterValue: boolean): void;
-};
-
-export type AppStore = [state: AppState, actions: AppActions];
-
-const defaultState: AppState = { variants: {}, sampleVariants: {} };
+import { AppStore } from "../types/store";
+import { createAppStore } from "./app.ts";
 
 const StoreContext = createContext<AppStore>() as Context<AppStore>;
 
 export const Provider: ParentComponent = (props) => {
-  const [state, setState] = createStore(defaultState);
-
-  function getVariants(sample: Item<Sample>) {
-    return state.sampleVariants ? state.sampleVariants[sample.id]?.variants || {} : {};
-  }
-
-  const actions: AppActions = {
-    reset() {
-      setState({ variants: undefined, sampleVariants: undefined, samples: undefined });
-    },
-    setVariantsPage(page: number) {
-      setState({ variants: { ...(state.variants || {}), page } });
-    },
-    setVariantsPageSize(pageSize: number) {
-      setState({ variants: { ...(state.variants || {}), pageSize, page: undefined } });
-    },
-    setVariantsSearchQuery(searchQuery: string) {
-      setState({ variants: { ...(state.variants || {}), searchQuery, page: undefined } });
-    },
-    setVariantsFilterQuery(query: Query, key: string) {
-      setState({
-        variants: {
-          ...(state.variants || {}),
-          filterQueries: { ...(state.variants?.filterQueries || {}), [key]: query },
-          page: undefined,
-        },
-      });
-    },
-    clearVariantsFilterQuery(key: string) {
-      setState({
-        variants: {
-          ...(state.variants || {}),
-          filterQueries: { ...(state.variants?.filterQueries || {}), [key]: undefined },
-          page: undefined,
-        },
-      });
-    },
-    setVariantsSort(sort: SortOrder | null) {
-      setState({
-        variants: {
-          ...(state.variants || {}),
-          sort,
-        },
-      });
-    },
-    setSampleVariantsPage(sample: Item<Sample>, page: number) {
-      setState({
-        sampleVariants: {
-          ...(state.sampleVariants || {}),
-          [sample.id]: { variants: { ...getVariants(sample), page } },
-        },
-      });
-    },
-    setSampleVariantsPageSize(sample: Item<Sample>, pageSize: number) {
-      setState({
-        sampleVariants: {
-          ...(state.sampleVariants || {}),
-          [sample.id]: { variants: { ...getVariants(sample), pageSize, page: undefined } },
-        },
-      });
-    },
-    setSampleVariantsSearchQuery(sample: Item<Sample>, searchQuery: string) {
-      setState({
-        sampleVariants: {
-          ...(state.sampleVariants || {}),
-          [sample.id]: { variants: { ...getVariants(sample), searchQuery, page: undefined } },
-        },
-      });
-    },
-    setSampleVariantsFilterQuery(sample: Item<Sample>, query: Query, key: string) {
-      const variants = getVariants(sample);
-      setState({
-        sampleVariants: {
-          ...(state.sampleVariants || {}),
-          [sample.id]: {
-            variants: {
-              ...variants,
-              filterQueries: { ...(variants.filterQueries || {}), [key]: query },
-              page: undefined,
-            },
-          },
-        },
-      });
-    },
-    clearSampleVariantsFilterQuery(sample: Item<Sample>, key: string) {
-      const variants = getVariants(sample);
-      setState({
-        sampleVariants: {
-          ...(state.sampleVariants || {}),
-          [sample.id]: {
-            variants: {
-              ...getVariants(sample),
-              filterQueries: { ...(variants.filterQueries || {}), [key]: undefined },
-              page: undefined,
-            },
-          },
-        },
-      });
-    },
-    setSampleVariantsSort(sample: Item<Sample>, sort: SortOrder | null) {
-      setState({
-        sampleVariants: {
-          ...(state.sampleVariants || {}),
-          [sample.id]: { variants: { ...getVariants(sample), sort } },
-        },
-      });
-    },
-    setSamplePage(page: number) {
-      setState({ samples: { ...(state.samples || {}), page } });
-    },
-    setSampleSearchQuery(searchQuery: string) {
-      setState({ samples: { ...(state.samples || {}), searchQuery, page: undefined } });
-    },
-    setSampleProbandFilterValue(probandFilterValue: boolean) {
-      setState({ samples: { ...(state.samples || {}), probandFilterValue, page: undefined } });
-    },
-  };
-  const store: AppStore = [state, actions];
-
+  const store = createAppStore();
   return <StoreContext.Provider value={store}>{props.children}</StoreContext.Provider>;
 };
 

package/src/store/variants.ts

@@ -0,0 +1,182 @@
+import { VariantType } from "../utils/variantType.ts";
+import { SampleContainer } from "../utils/api.ts";
+import { FilterValueMap } from "../types/filter";
+import { FilterId, FilterValue } from "../types/configFilter";
+import { produce } from "solid-js/store";
+import { AppState, AppStateVariantType, AppStateVariantTypes, AppStore, Page, Sort } from "../types/store";
+
+export type VariantStore = {
+  getFilterValues(): FilterValueMap;
+  setFilterValue(id: FilterId, value: FilterValue): void;
+  clearFilter(id: FilterId): void;
+  getPageNumber(): number | null;
+  setPageNumber(pageNumber: number): void;
+  getPageSize(): number | null;
+  setPageSize(pageSize: number): void;
+  /**
+   * null:      do not sort,                the caller of this function should not fall back to a default sort
+   * undefined: sort behavior is undefined, the caller of this function could fall back to a default sort
+   */
+  getSort(): Sort | null | undefined;
+  setSort(sort: Sort): void;
+  clearSort(): void;
+};
+
+export function wrapStore(store: AppStore, sample: SampleContainer | null, variantType: VariantType) {
+  const [state, , setState] = store;
+
+  function getVariantsState(state: AppState): AppStateVariantType {
+    let stateVariantTypes: AppStateVariantTypes;
+
+    if (sample !== null) {
+      const sampleVariantsState = state.sampleVariants;
+
+      // get sample
+      const sampleKey = sample.item.id.toString();
+      if (sampleKey in sampleVariantsState) {
+        stateVariantTypes = sampleVariantsState[sampleKey]!;
+      } else {
+        stateVariantTypes = {};
+      }
+    } else {
+      stateVariantTypes = state.variants;
+    }
+
+    // get variant type
+    let stateVariantType: AppStateVariantType;
+    const variantTypeKey = variantType.id;
+    if (variantTypeKey in stateVariantTypes) {
+      stateVariantType = stateVariantTypes[variantTypeKey]!;
+    } else {
+      stateVariantType = {};
+    }
+
+    return stateVariantType;
+  }
+
+  function getCreateVariantsState(state: AppState): AppStateVariantType {
+    let stateVariantTypes: AppStateVariantTypes;
+
+    if (sample !== null) {
+      const sampleVariantsState = state.sampleVariants;
+
+      // get/create sample
+      const sampleKey = sample.item.id.toString();
+      if (sampleKey in sampleVariantsState) {
+        stateVariantTypes = sampleVariantsState[sampleKey]!;
+      } else {
+        stateVariantTypes = {};
+        sampleVariantsState[sampleKey] = stateVariantTypes;
+      }
+    } else {
+      stateVariantTypes = state.variants;
+    }
+
+    // get/create variant type
+    let stateVariantType: AppStateVariantType;
+    const variantTypeKey = variantType.id;
+    if (variantTypeKey in stateVariantTypes) {
+      stateVariantType = stateVariantTypes[variantTypeKey]!;
+    } else {
+      stateVariantType = {};
+      stateVariantTypes[variantTypeKey] = stateVariantType;
+    }
+
+    return stateVariantType;
+  }
+
+  function getCreateVariantsStatePage(state: AppState): Page {
+    const stateVariantType: AppStateVariantType = getCreateVariantsState(state);
+    let page = stateVariantType.page;
+    if (page === undefined) {
+      page = { number: 0 };
+      stateVariantType.page = page;
+    }
+    return page;
+  }
+
+  function getCreateVariantsStateFilterValues(state: AppState): FilterValueMap {
+    const stateVariantType: AppStateVariantType = getCreateVariantsState(state);
+    let filterValues = stateVariantType.filterValues;
+    if (filterValues === undefined) {
+      filterValues = {};
+      stateVariantType.filterValues = filterValues;
+    }
+    return filterValues;
+  }
+
+  return {
+    getFilterValues(): FilterValueMap {
+      return getVariantsState(state).filterValues || {};
+    },
+    setFilterValue(id: FilterId, value: FilterValue) {
+      setState(
+        produce((state) => {
+          const filterValueMap = getCreateVariantsStateFilterValues(state);
+          filterValueMap[id] = value;
+
+          const page = getCreateVariantsStatePage(state);
+          page.number = 0;
+        }),
+      );
+      console.log("state change", JSON.stringify(state));
+    },
+    clearFilter(id: FilterId) {
+      setState(
+        produce((state) => {
+          const filterValueMap = getCreateVariantsStateFilterValues(state);
+          delete filterValueMap[id];
+
+          const page = getCreateVariantsStatePage(state);
+          page.number = 0;
+        }),
+      );
+    },
+    getPageNumber(): number | null {
+      const page = getVariantsState(state).page;
+      return page ? page.number : null;
+    },
+    setPageNumber(pageNumber: number) {
+      setState(
+        produce((state) => {
+          const page = getCreateVariantsStatePage(state);
+          page.number = pageNumber;
+        }),
+      );
+      console.log("state change", JSON.stringify(state));
+    },
+    getPageSize(): number | null {
+      const page = getVariantsState(state).page;
+      return page ? (page.size !== undefined ? page.size : null) : null;
+    },
+    setPageSize(pageSize: number) {
+      setState(
+        produce((state) => {
+          const variantsState = getCreateVariantsState(state);
+          variantsState.page = { number: 0, size: pageSize };
+        }),
+      );
+      console.log("state change", JSON.stringify(state));
+    },
+    getSort(): Sort | null | undefined {
+      return getVariantsState(state).sort;
+    },
+    setSort(sort: Sort) {
+      setState(
+        produce((state) => {
+          const variantsState = getCreateVariantsState(state);
+          variantsState.sort = sort;
+        }),
+      );
+      console.log("state change", JSON.stringify(state));
+    },
+    clearSort() {
+      setState(
+        produce((state) => {
+          const variantsState = getCreateVariantsState(state);
+          variantsState.sort = null;
+        }),
+      );
+    },
+  };
+}

package/src/types/config.d.ts

@@ -0,0 +1,190 @@
+import { ConfigFilter } from "./configFilter";
+import { ConfigCell } from "./configCells";
+import { ConfigSort } from "./configSort";
+import { FieldMetadataWrapper } from "../utils/vcf.ts";
+
+export interface Describable {
+  // overwrites existing label
+  label?: string;
+  // overwrites existing description
+  description?: string;
+}
+
+export interface ConfigJsonFieldFixed extends Describable {
+  type: "fixed";
+  name: "chrom" | "pos" | "id" | "ref" | "alt" | "qual" | "filter";
+}
+
+export interface ConfigJsonFieldInfo extends Describable {
+  type: "info";
+  name: string;
+}
+
+export interface ConfigJsonFieldFormat extends Describable {
+  type: "format";
+  name: string;
+}
+
+export interface ConfigJsonFieldGenotype extends Describable {
+  type: "genotype";
+  name: string;
+}
+
+export interface ConfigJsonFieldComposed extends Describable {
+  type: "composed";
+  name:
+    | "clinVar"
+    | "gene"
+    | "genotype"
+    | "genotype_maternal"
+    | "genotype_paternal"
+    | "gnomAdAf"
+    | "hpo"
+    | "inheritancePattern"
+    | "locus"
+    | "ref"
+    | "vipC"
+    | "vipCS"
+    | "vkgl";
+}
+
+export interface ConfigJsonSort {
+  selected: boolean;
+  orders: ConfigJsonSortOrder[];
+}
+
+export interface ConfigJsonSortOrder {
+  direction: "desc" | "asc";
+  field: ConfigJsonFieldItem;
+}
+
+export interface ConfigJsonRecordsPerPageOption {
+  selected?: boolean;
+  number: number;
+}
+
+export type ConfigJsonFieldItem =
+  | ConfigJsonFieldFixed
+  | ConfigJsonFieldInfo
+  | ConfigJsonFieldFormat
+  | ConfigJsonFieldGenotype
+  | ConfigJsonFieldComposed;
+
+export type ConfigJsonFieldItemGroup = { type: "group"; fields: ConfigJsonFieldItem[] };
+export type ConfigJsonField = ConfigJsonFieldItem | ConfigJsonFieldItemGroup;
+
+export interface ConfigJsonFilterFixed extends Describable {
+  type: "fixed";
+  name: "chrom" | "pos" | "id" | "ref" | "alt" | "qual" | "filter";
+}
+
+export interface ConfigJsonFilterInfo extends Describable {
+  type: "info";
+  name: string;
+}
+
+export interface ConfigJsonFilterFormat extends Describable {
+  type: "format";
+  name: string;
+}
+
+export interface ConfigJsonFilterGenotype extends Describable {
+  type: "genotype";
+  name: string;
+}
+
+export interface ConfigJsonFilterComposed extends Describable {
+  type: "composed";
+  name: "allelicImbalance" | "deNovo" | "hpo" | "inheritanceMatch" | "locus" | "vipC" | "vipCS";
+}
+
+export type ConfigJsonFilter =
+  | ConfigJsonFilterFixed
+  | ConfigJsonFilterInfo
+  | ConfigJsonFilterFormat
+  | ConfigJsonFilterGenotype
+  | ConfigJsonFilterComposed;
+
+export type ConfigJsonVariantType = "all" | "str" | "snv" | "sv";
+export type ConfigJsonVariantTypeFields = { [key in ConfigJsonVariantType]?: ConfigJsonField[] };
+export type ConfigJsonVariantTypeFilters = { [key in ConfigJsonVariantType]?: ConfigJsonFilter[] };
+export type ConfigJsonSorts = { [key in ConfigJsonVariantType]?: ConfigJsonSort[] };
+export type ConfigJsonRecordsPerPage = { [key in ConfigJsonVariantType]?: ConfigJsonRecordsPerPageOption[] };
+
+export type ConfigJsonVipParamsCram = { call_snv: boolean; call_str: boolean; call_sv: boolean; call_cnv: boolean };
+
+export type ConfigJsonVipParamsVcf = {
+  filter: { classes: string; consequences: boolean };
+  filter_samples: { classes: string };
+};
+
+export type ConfigJsonVipParams = {
+  cram?: ConfigJsonVipParamsCram;
+  vcf: ConfigJsonVipParamsVcf;
+};
+
+export type ConfigJsonVip = {
+  filter_field: ConfigJsonFieldGenotype;
+  params: ConfigJsonVipParams;
+};
+
+export type ConfigJsonVariants = {
+  cells: ConfigJsonVariantTypeFields;
+  filters?: ConfigJsonVariantTypeFilters;
+  sorts?: ConfigJsonSorts;
+  recordsPerPage?: ConfigJsonRecordsPerPage;
+};
+
+export type ConfigJsonVariant = {
+  cells: ConfigJsonVariantTypeFields;
+  sample_cells?: ConfigJsonVariantTypeFields;
+};
+
+export type ConfigJsonVariantConsequence = {
+  sample_cells?: ConfigJsonVariantTypeFields;
+};
+
+export type ConfigJson = {
+  vip: ConfigJsonVip;
+  sample_variants: ConfigJsonVariants;
+  variants: ConfigJsonVariants;
+  sample_variant: ConfigJsonVariant;
+  variant: ConfigJsonVariant;
+  sample_variant_consequence: ConfigJsonVariantConsequence;
+  variant_consequence: ConfigJsonVariantConsequence;
+};
+
+export type Config = {
+  vip: ConfigVip;
+  variants: ConfigVariants;
+  variant: ConfigVariant;
+  variantConsequence: ConfigVariantConsequence;
+};
+
+export type ConfigFilters = ConfigFilter[];
+export type ConfigCells = ConfigCell[];
+export type ConfigSorts = ConfigSort[];
+export type ConfigRecordsPerPageOption = ConfigJsonRecordsPerPageOption;
+export type ConfigRecordsPerPage = ConfigRecordsPerPageOption[];
+
+export type ConfigVariants = {
+  cells: ConfigCells;
+  filters: ConfigFilters;
+  sorts: ConfigSorts;
+  recordsPerPage: ConfigRecordsPerPage;
+};
+
+export type ConfigSamplesCells = { [key: string]: ConfigCells };
+export type ConfigVariant = {
+  cells: ConfigCells;
+  samplesCells?: ConfigSamplesCells;
+};
+export type ConfigVariantConsequence = {
+  samplesCells?: ConfigSamplesCells;
+};
+export type ConfigVipParams = ConfigJsonVipParams;
+
+export type ConfigVip = {
+  filter_field: FieldMetadataWrapper;
+  params: ConfigVipParams;
+};

package/src/types/configCellComposed.d.ts

@@ -0,0 +1,86 @@
+import { Genotype, InfoMetadata, ValueFlag, ValueFloat, ValueString } from "@molgenis/vip-report-vcf";
+import { ValueCategorical } from "../utils/vcf.ts";
+
+export type CellValueClinVar = {
+  clnSigs: ValueCategorical[];
+  clnIds: number[] | undefined;
+  clnRevStats: ValueCategorical[] | undefined;
+};
+
+export type CellValueGene = {
+  geneIdentifier: ValueString | undefined;
+  incompletePenetrance: ValueCategorical | undefined;
+  symbol: ValueString;
+  symbolSource: ValueString | undefined;
+};
+
+export type CellValueGnomAd = {
+  c: string;
+  p: number;
+  r: string;
+  a: (string | null)[];
+  gnomAdAf: ValueFloat;
+  gnomAdCov: ValueFloat | undefined;
+  gnomAdQcs: string[] | undefined;
+  alleleNum: number | undefined;
+};
+
+export type CellValueGenotype = {
+  refAllele: string;
+  altAlleles: (string | null)[];
+  genotype: Genotype;
+  svType: ValueString | undefined;
+  repeatCount: ValueString | undefined;
+  repeatUnitValue: ValueString | undefined;
+  repeatUnitMatch: ValueFlag | undefined;
+  displayRepeatUnit: ValueString | undefined;
+  viab: number | null | undefined;
+};
+
+export type CellValueHpo = {
+  hpos: ValueCategorical[];
+  gadoPd: ValueCategorical | undefined;
+};
+
+export type CellValueInheritanceModes = {
+  fieldInheritanceModesGene: InfoMetadata;
+  inheritanceModesGene: ValueCategorical[];
+  isPossibleCompound: ValueFlag | undefined;
+};
+
+export type CellValueLocus = { c: string; p: number; href: string };
+
+export type CellValueVipC = {
+  href: string;
+  vipC: ValueCategorical;
+  vipP: string[] | undefined;
+};
+
+export type CellValueVipCS = {
+  vipCS: ValueCategorical;
+  vipPS: string[] | undefined;
+};
+
+export type CellValueVkgl = {
+  vkglCl: ValueCategorical;
+  vkglAmc: ValueCategorical | undefined;
+  vkglErasmus: ValueCategorical | undefined;
+  vkglLumc: ValueCategorical | undefined;
+  vkglNki: ValueCategorical | undefined;
+  vkglRadboudMumc: ValueCategorical | undefined;
+  vkglUmcg: ValueCategorical | undefined;
+  vkglUmcu: ValueCategorical | undefined;
+  vkglVumc: ValueCategorical | undefined;
+};
+
+export type CellValueCustom =
+  | CellValueClinVar
+  | CellValueGene
+  | CellValueGnomAd
+  | CellValueGenotype
+  | CellValueHpo
+  | CellValueInheritanceModes
+  | CellValueLocus
+  | CellValueVipC
+  | CellValueVipCS
+  | CellValueVkgl;