@gen-epix/ui 1.15.1 → 1.16.0

package/src/utils/EpiFilterUtil/EpiFilterUtil.ts

@@ -1,232 +0,0 @@
-import {
-  subYears,
-  parseISO,
-  parse,
-} from 'date-fns';
-import { t } from 'i18next';
-
-import {
-  CaseTypeUtil,
-  SELECTION_FILTER_GROUP,
-  TREE_FILTER_GROUP,
-} from '../CaseTypeUtil';
-import type {
-  CompleteCaseType,
-  Col,
-  RefCol,
-} from '../../api';
-import {
-  DimType,
-  ColType,
-} from '../../api';
-import {
-  FILTER_MODE,
-  DEFAULT_FILTER_GROUP,
-} from '../../classes/abstracts/FilterAbstract';
-import { DateFilter } from '../../classes/filters/DateFilter';
-import { GeoFilter } from '../../classes/filters/GeoFilter';
-import { MultiSelectFilter } from '../../classes/filters/MultiSelectFilter';
-import { NumberRangeFilter } from '../../classes/filters/NumberRangeFilter';
-import { SelectionFilter } from '../../classes/filters/SelectionFilter';
-import { TextFilter } from '../../classes/filters/TextFilter';
-import { TreeFilter } from '../../classes/filters/TreeFilter';
-import type {
-  FilterDimension,
-  Filters,
-} from '../../models/filter';
-import type { AutoCompleteOption } from '../../models/form';
-import { DATE_FORMAT } from '../../data/date';
-import { EpiDataManager } from '../../classes/managers/EpiDataManager';
-
-export class EpiFilterUtil {
-  private static readonly colTypeBlackList = new Set<ColType>([ColType.GENETIC_DISTANCE, ColType.GENETIC_SEQUENCE, ColType.GENETIC_READS]);
-
-  public static createFilterDimensions(completeCaseType: CompleteCaseType): FilterDimension[] {
-    const filterDimensions: FilterDimension[] = [];
-
-    completeCaseType.ordered_dim_ids.forEach(dimId => {
-      const dim = completeCaseType.dims[dimId];
-      const refDim = completeCaseType.ref_dims[dim.ref_dim_id];
-      const colIds = completeCaseType.ordered_col_ids_by_dim[dimId];
-      const refCols = colIds.map(id => completeCaseType.ref_cols[completeCaseType.cols[id].ref_col_id]);
-
-      if (CaseTypeUtil.isGeneticDistanceDim(refDim, refCols)) {
-        return;
-      }
-      if (refCols.every(refCol => EpiFilterUtil.colTypeBlackList.has(refCol.col_type))) {
-        return;
-      }
-
-      const filterDimension: Omit<FilterDimension, 'preferredFilterId' | 'allowMultipleVisibleFilters' | 'allowOnlyPreferredFilter'> = {
-        id: dimId,
-        label: dim.label,
-        filterIds: colIds,
-        description: completeCaseType.ref_dims[dim.ref_dim_id].description,
-      };
-      const cols = colIds.map(id => completeCaseType.cols[id]);
-      if (!cols.length) {
-        return null;
-      }
-
-      let preferredFilterId: string;
-      let allowMultipleVisibleFilters = false;
-      let allowOnlyPreferredFilter = false;
-
-      if (refDim.dim_type === DimType.TIME) {
-        const preferredCol = CaseTypeUtil.getPreferredColInDimHavingHighestRank(cols, completeCaseType);
-        preferredFilterId = preferredCol.id;
-        allowOnlyPreferredFilter = true;
-      } else if (refDim.dim_type === DimType.GEO) {
-        const preferredCol = CaseTypeUtil.getPreferredGEOCol(cols);
-        preferredFilterId = preferredCol.id;
-      } else {
-        const preferredCol = CaseTypeUtil.getPreferredColInDimHavingHighestRank(cols, completeCaseType);
-        preferredFilterId = preferredCol.id;
-        allowMultipleVisibleFilters = refDim.dim_type !== DimType.NUMBER;
-      }
-
-      filterDimensions.push({
-        ...filterDimension,
-        preferredFilterId,
-        allowMultipleVisibleFilters,
-        allowOnlyPreferredFilter,
-      });
-    });
-    return filterDimensions;
-  }
-
-  public static createFilters(completeCaseType: CompleteCaseType): Filters {
-    const filters: Filters = [];
-    filters.push(new SelectionFilter({
-      id: 'selected',
-      label: t`Selected rows`,
-      filterMode: FILTER_MODE.FRONTEND,
-      filterPriority: SELECTION_FILTER_GROUP,
-    }));
-    filters.push(new TreeFilter({
-      id: 'sequence_id',
-      label: t`Tree`,
-      filterMode: FILTER_MODE.FRONTEND,
-      filterPriority: TREE_FILTER_GROUP,
-    }));
-
-    completeCaseType.ordered_dim_ids.forEach((dimId) => {
-      const dim = completeCaseType.dims[dimId];
-      const refDim = completeCaseType.ref_dims[dim.ref_dim_id];
-      const cols = completeCaseType.ordered_col_ids_by_dim[dimId].map(id => completeCaseType.cols[id]);
-      cols.forEach(col => {
-        const refCol = completeCaseType.ref_cols[col.ref_col_id];
-        if (EpiFilterUtil.colTypeBlackList.has(refCol.col_type)) {
-          return;
-        }
-
-        if (refDim.dim_type === DimType.TIME) {
-          const today = new Date();
-          const todayMinus20Years = subYears(today, 20);
-          filters.push(
-            new DateFilter({
-              id: col.id,
-              label: col.label,
-              filterMode: FILTER_MODE.BACKEND,
-              filterPriority: DEFAULT_FILTER_GROUP,
-              filterDimensionId: dimId,
-              dateParser: EpiFilterUtil.getDateParser(refCol),
-              minDate: todayMinus20Years,
-              maxDate: new Date(),
-              backendFilterType: refCol.col_type === ColType.TIME_DAY ? 'DATE_RANGE' : 'PARTIAL_DATE_RANGE',
-            }),
-          );
-        } else if (refDim.dim_type === DimType.GEO) {
-          const regionSet = EpiDataManager.instance.data.regionSets[refCol.region_set_id];
-          const options = (EpiDataManager.instance.data.regionsByRegionSetId[refCol.region_set_id]?.map<AutoCompleteOption>(region => {
-            return {
-              value: region.id,
-              label: regionSet.region_code_as_label ? region.code : region.name,
-            };
-          }) ?? []).sort((a, b) => a.label.localeCompare(b.label));
-          filters.push(new GeoFilter({
-            id: col.id,
-            label: col.label,
-            filterMode: FILTER_MODE.BACKEND,
-            filterPriority: DEFAULT_FILTER_GROUP,
-            filterDimensionId: dimId,
-            options,
-          }));
-        } else if (refDim.dim_type === DimType.TEXT) {
-          filters.push(EpiFilterUtil.createCategoricalFilter(col, dimId, completeCaseType));
-        } else if (refDim.dim_type === DimType.NUMBER) {
-          if (([ColType.DECIMAL_0, ColType.DECIMAL_1, ColType.DECIMAL_2, ColType.DECIMAL_3, ColType.DECIMAL_4, ColType.DECIMAL_5, ColType.DECIMAL_6] as ColType[]).includes(refCol.col_type)) {
-            filters.push(new NumberRangeFilter({
-              id: col.id,
-              label: col.label,
-              filterMode: FILTER_MODE.BACKEND,
-              filterPriority: DEFAULT_FILTER_GROUP,
-              filterDimensionId: dimId,
-              min: col.min_value ?? -Infinity,
-              max: col.max_value ?? Infinity,
-            }));
-          } else {
-            filters.push(EpiFilterUtil.createCategoricalFilter(col, dimId, completeCaseType));
-          }
-        } else if (refDim.dim_type === DimType.ORGANIZATION) {
-          // organizations are already sorted
-          const options = EpiDataManager.instance.data.organizations.map<AutoCompleteOption>(organization => {
-            return {
-              value: organization.id,
-              label: organization.name,
-            };
-          });
-          filters.push(new MultiSelectFilter({
-            id: col.id,
-            label: col.label,
-            filterMode: FILTER_MODE.BACKEND,
-            filterPriority: DEFAULT_FILTER_GROUP,
-            filterDimensionId: dimId,
-            options,
-          }));
-        } else {
-          filters.push(new TextFilter({
-            id: col.id,
-            label: col.label,
-            filterMode: FILTER_MODE.BACKEND,
-            filterPriority: DEFAULT_FILTER_GROUP,
-            filterDimensionId: dimId,
-          }));
-        }
-      });
-    });
-    return filters;
-  }
-
-  public static createCategoricalFilter(col: Col, dimId: string, completeCaseType: CompleteCaseType): MultiSelectFilter | TextFilter {
-    const refCol = completeCaseType.ref_cols[col.ref_col_id];
-    if ((refCol.col_type === ColType.NOMINAL || refCol.col_type === ColType.ORDINAL || refCol.col_type === ColType.INTERVAL) && EpiDataManager.instance.data.conceptsBySetId[refCol.concept_set_id]) {
-      const options = EpiDataManager.instance.data.conceptsBySetId[refCol.concept_set_id].map<AutoCompleteOption>(concept => ({
-        value: concept.id,
-        label: `${concept.code} (${concept.name})`,
-      }));
-      return new MultiSelectFilter({
-        id: col.id,
-        label: col.label,
-        filterMode: FILTER_MODE.BACKEND,
-        filterPriority: DEFAULT_FILTER_GROUP,
-        filterDimensionId: dimId,
-        options,
-      });
-    }
-    return new TextFilter({
-      id: col.id,
-      label: col.label,
-      filterMode: FILTER_MODE.BACKEND,
-      filterPriority: DEFAULT_FILTER_GROUP,
-      filterDimensionId: dimId,
-    });
-  }
-
-  public static getDateParser(refCol: RefCol): (date: string) => Date {
-    if (refCol.col_type === ColType.TIME_QUARTER) {
-      return (date: string) => parse(date, DATE_FORMAT.YEAR_QUARTER, new Date());
-    }
-    return (date: string) => parseISO(date);
-  }
-}

package/src/utils/EpiFilterUtil/index.ts

@@ -1 +0,0 @@
-export * from './EpiFilterUtil';

package/src/utils/EpiLineListUtil/EpiLineListUtil.ts

@@ -1,15 +0,0 @@
-import sumBy from 'lodash/sumBy';
-
-import type { Case } from '../../api';
-
-
-export class EpiLineListUtil {
-  public static getCaseCount(cases: Case[]): number {
-    // when count is null, 1 should be assumed
-    return sumBy(cases, (row) => (row.count ?? 1));
-  }
-
-  public static getSelectedRows(cases: Case[], selectedIds: string[]): Case[] {
-    return cases.filter(row => selectedIds.includes(row.id));
-  }
-}

package/src/utils/EpiLineListUtil/index.ts

@@ -1 +0,0 @@
-export * from './EpiLineListUtil';

package/src/utils/EpiMapUtil/EpiMapUtil.test.ts

@@ -1,54 +0,0 @@
-import {
-  describe,
-  it,
-  expect,
-  vi,
-  beforeAll,
-  afterAll,
-} from 'vitest';
-
-import { ConfigManager } from '../../classes/managers/ConfigManager';
-import type { Config } from '../../models/config';
-
-import type { RegionStatistics } from './EpiMapUtil';
-import { EpiMapUtil } from './EpiMapUtil';
-
-describe('EpiMapUtil', () => {
-  describe('getPieChartRadius', () => {
-    beforeAll(() => {
-      vi.spyOn(ConfigManager.instance, 'config', 'get').mockReturnValue({
-        epiMap: {
-          MIN_PIE_CHART_RADIUS: 4,
-        },
-      } as Config);
-    });
-
-    afterAll(() => {
-      vi.restoreAllMocks();
-    });
-
-    it('determines the pie chart radius', () => {
-      const statisticsBase: RegionStatistics = {
-        maxNumCases: 0,
-        minNumCases: 0,
-        numCases: 200,
-        statisticsPerRegion: {},
-      };
-
-      const testCases: Array<[[number, number, RegionStatistics], number]> = [
-        // test where minNumCases === maxNumCases (result should be maxArea)
-        [[1, 1487, { ...statisticsBase, minNumCases: 1, maxNumCases: 1 }], 21.76],
-        // test where numCases === minNumCases (result should be minArea)
-        [[1, 1487, { ...statisticsBase, minNumCases: 1, maxNumCases: 9 }], ConfigManager.instance.config.epiMap.MIN_PIE_CHART_RADIUS],
-        // test where numCases === maxNumCases (result should be maxArea
-        [[9, 1487, { ...statisticsBase, minNumCases: 1, maxNumCases: 9 }], 21.76],
-        // test where numCases is some where in between minNumCases and maxNumCases (area should be proportional)
-        [[6, 1487, { ...statisticsBase, minNumCases: 1, maxNumCases: 9 }], 17.37],
-      ];
-
-      testCases.forEach(([input, expectedOutput]) => {
-        expect(EpiMapUtil.getPieChartRadius(...input)).toEqual(expectedOutput);
-      });
-    });
-  });
-});

package/src/utils/EpiMapUtil/EpiMapUtil.ts

@@ -1,80 +0,0 @@
-import max from 'lodash/max';
-import min from 'lodash/min';
-import round from 'lodash/round';
-
-import type {
-  Case,
-  Region,
-} from '../../api';
-import { ConfigManager } from '../../classes/managers/ConfigManager';
-
-export type RegionStatistics = {
-  statisticsPerRegion: Record<string, { rows: Case[]; region: Region; numCases: number }>;
-  minNumCases: number;
-  maxNumCases: number;
-  numCases: number;
-};
-
-export class EpiMapUtil {
-  public static getRegionStatistics(cases: Case[], columnId: string, regions: Region[]): RegionStatistics {
-    if (!cases.length || !columnId || !regions?.length) {
-      return {
-        maxNumCases: 0,
-        minNumCases: 0,
-        numCases: 0,
-        statisticsPerRegion: {},
-      };
-    }
-
-    let numCases = 0;
-    const statisticsPerRegion: Record<string, {
-      rows: Case[];
-      region: Region;
-      numCases: number;
-    }> = {};
-    cases.forEach(row => {
-      const regionId = row.content[columnId];
-      if (!regionId) {
-        return;
-      }
-      if (!statisticsPerRegion[regionId]) {
-        statisticsPerRegion[regionId] = {
-          rows: [],
-          region: regions.find(region => region.id === regionId),
-          numCases: 0,
-        };
-      }
-      statisticsPerRegion[regionId].rows.push(row);
-      // when count is null, 1 should be assumed
-      statisticsPerRegion[regionId].numCases += (row.count ?? 1);
-      // when count is null, 1 should be assumed
-      numCases += (row.count ?? 1);
-    });
-    const maxNumCases = max(Object.values(statisticsPerRegion).map(region => region.numCases));
-    const minNumCases = min(Object.values(statisticsPerRegion).map(region => region.numCases));
-
-    return {
-      statisticsPerRegion,
-      minNumCases,
-      maxNumCases,
-      numCases,
-    };
-  }
-
-  public static getPieChartRadius(numCases: number, maxPieChartArea: number, statistics: RegionStatistics) {
-    const { maxNumCases, minNumCases } = statistics;
-    const { MIN_PIE_CHART_RADIUS } = ConfigManager.instance.config.epiMap;
-    const MIN_PIE_CHART_AREA = MIN_PIE_CHART_RADIUS ** 2 * Math.PI;
-
-    let area: number;
-
-    if (maxNumCases > minNumCases) {
-      const slope = Math.max(MIN_PIE_CHART_AREA, (maxPieChartArea - MIN_PIE_CHART_AREA)) / (maxNumCases - minNumCases);
-      area = (slope * (numCases - minNumCases)) + MIN_PIE_CHART_AREA;
-    } else {
-      area = maxPieChartArea;
-    }
-    const radius = round(Math.sqrt(area / Math.PI), 2);
-    return Math.max(MIN_PIE_CHART_RADIUS, radius);
-  }
-}

package/src/utils/EpiMapUtil/index.ts

@@ -1 +0,0 @@
-export * from './EpiMapUtil';