@gen-epix/ui 1.14.4 → 1.15.0

package/src/utils/DataUtil/DataUtil.ts

@@ -0,0 +1,84 @@
+import type { TFunction } from 'i18next';
+import { format } from 'date-fns';
+
+import type {
+  CaseSet,
+  Col,
+  Dim,
+  RefCol,
+  RefColValidationRulesResponseBody,
+  RefDim,
+  User,
+} from '../../api';
+import { ColType } from '../../api';
+import type { OptionBase } from '../../models/form';
+import { DATE_FORMAT } from '../../data/date';
+
+export class DataUtil {
+  public static getGeneticSequenceColOptionsForCaseTypeId(kwArgs: { caseTypeId: string; refColMap: Map<string, RefCol>; colMap: Map<string, Col>; colOptions: OptionBase<string>[] }): OptionBase<string>[] {
+    if (!kwArgs.caseTypeId) {
+      return [];
+    }
+    return kwArgs.colOptions.filter((option) => {
+      const col = kwArgs.colMap.get(option.value);
+      if (col?.case_type_id !== kwArgs.caseTypeId) {
+        return false;
+      }
+      const refCol = kwArgs.refColMap.get(col.ref_col_id);
+      return refCol?.col_type === ColType.GENETIC_SEQUENCE;
+    });
+  }
+
+
+  public static getDimOptionsForCaseTypeId(kwArgs: { caseTypeId: string; dimOptions: OptionBase<string>[]; dimMap: Map<string, Dim> }): OptionBase<string>[] {
+    if (!kwArgs.caseTypeId) {
+      return [];
+    }
+
+    return kwArgs.dimOptions.filter((option) => {
+      const dim = kwArgs.dimMap.get(option.value);
+      return dim?.case_type_id === kwArgs.caseTypeId;
+    });
+  }
+
+  public static getRefColOptionsForDimId(kwArgs: { dimId: string; dimMap: Map<string, Dim>; refDimMap: Map<string, RefDim>; refColOptions: OptionBase<string>[]; refColMap: Map<string, RefCol>; colsValidationRules: RefColValidationRulesResponseBody['valid_col_types_by_dim_type'] }): OptionBase<string>[] {
+    const dim = kwArgs.dimMap.get(kwArgs.dimId);
+    if (!dim) {
+      return [];
+    }
+    const refDim = kwArgs.refDimMap.get(dim.ref_dim_id);
+    return kwArgs.refColOptions.filter((option) => {
+      const refCol = kwArgs.refColMap.get(option.value);
+      if (refCol.ref_dim_id !== dim.ref_dim_id) {
+        return false;
+      }
+      const colType = refCol.col_type;
+      return kwArgs.colsValidationRules[refDim.dim_type].includes(colType);
+    });
+  }
+
+  public static getColTypeOptionsForRefDimId(kwArgs: { refDimId: string; refDimMap: Map<string, RefDim>; colTypeOptions: OptionBase<string>[]; colsValidationRules: RefColValidationRulesResponseBody['valid_col_types_by_dim_type'] }): OptionBase<string>[] {
+    const refDim = kwArgs.refDimMap.get(kwArgs.refDimId);
+    if (!refDim) {
+      return [];
+    }
+    return kwArgs.colTypeOptions.filter((option) => {
+      const colType = option.value as ColType;
+      return kwArgs.colsValidationRules[refDim.dim_type].includes(colType);
+    });
+  }
+
+
+  public static getUserDisplayValue(user: User, t: TFunction<'translation', undefined>): string {
+    if (!user) {
+      return t`Unknown user`;
+    }
+    return `${user.name} (${user.key})`;
+  }
+
+  public static getCaseSetName(caseSet: CaseSet): string {
+    return `${caseSet.name} (${format(caseSet.created_at, DATE_FORMAT.DATE)})`;
+  }
+
+
+}

package/src/utils/DataUtil/index.ts

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

package/src/utils/DownloadUtil/DownloadUtil.ts

@@ -0,0 +1,237 @@
+import { type TFunction } from 'i18next';
+import { format } from 'date-fns';
+import type { ECharts } from 'echarts';
+import writeXlsxFile from 'write-excel-file/browser';
+import { stringify } from 'csv/browser/esm/sync';
+
+import {
+  CaseApi,
+  LogLevel,
+  type Case,
+  type Col,
+  type CompleteCaseType,
+} from '../../api';
+import { ConfigManager } from '../../classes/managers/ConfigManager';
+import { DATE_FORMAT } from '../../data/date';
+import { StringUtil } from '../StringUtil';
+import { CaseTypeUtil } from '../CaseTypeUtil';
+import { CaseUtil } from '../CaseUtil';
+import { AuthenticationManager } from '../../classes/managers/AuthenticationManager';
+import { QueryClientManager } from '../../classes/managers/QueryClientManager';
+import { QueryUtil } from '../QueryUtil';
+import { QUERY_KEY } from '../../models/query';
+import { NotificationManager } from '../../classes/managers/NotificationManager';
+import { LogManager } from '../../classes/managers/LogManager';
+
+export class DownloadUtil {
+  public static async downloadExcelTemplate(caseTypeId: string, t: TFunction<'translation', undefined>): Promise<void> {
+    const queryClient = QueryClientManager.instance.queryClient;
+    try {
+      const completeCaseType = await queryClient.fetchQuery({
+        queryKey: QueryUtil.getGenericKey(QUERY_KEY.COMPLETE_CASE_TYPES, caseTypeId),
+        queryFn: async ({ signal }) => {
+          return (await CaseApi.instance.completeCaseTypesGetOne(caseTypeId, { signal })).data;
+        },
+      });
+
+      const headers = DownloadUtil.getColumnHeadersForImport(
+        CaseTypeUtil.getWritableImportExportColIds(completeCaseType)
+          .sort((a, b) => completeCaseType.ordered_col_ids.indexOf(a) - completeCaseType.ordered_col_ids.indexOf(b))
+        , completeCaseType,
+      );
+      const data = [
+        headers.map(header => ({ type: String, value: header })),
+      ];
+      const fileName = `${DownloadUtil.getTemplateFileName(completeCaseType)}.xlsx`;
+
+      // Generate Excel file as a Blob and download it
+      const blob = await writeXlsxFile(data, {
+        columns: headers.map(() => ({ width: 20 })),
+        stickyRowsCount: 1,
+        showGridLines: true,
+      });
+
+      // Convert blob to base64 and download
+      const arrayBuffer = await blob.arrayBuffer();
+      const base64 = DownloadUtil.arrayBufferToBase64(arrayBuffer);
+      DownloadUtil.createDownloadUrl(`data:application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;base64,${base64}`, fileName);
+    } catch (error) {
+      LogManager.instance.log([{
+        detail: {
+          error,
+          stack: (error as Error)?.stack,
+        },
+        level: LogLevel.ERROR,
+        topic: (error as Error)?.message ? `Error: ${(error as Error)?.message}` : 'Error',
+      }]);
+      NotificationManager.instance.showNotification({
+        message: t('Excel template could not be created'),
+        severity: 'error',
+      });
+    }
+  }
+
+
+  public static createDownloadUrl(url: string, name: string): void {
+    const link = document.createElement('a');
+    link.download = name;
+    link.href = url;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+  }
+
+  public static downloadAsMultiPartForm(kwArgs: { action: string; data: Record<string, string | string[]> }): void {
+    const formElement = document.createElement('form');
+    formElement.method = 'POST';
+    formElement.action = kwArgs.action;
+    formElement.style.display = 'none';
+    formElement.target = '_blank';
+
+    Object.entries(kwArgs.data).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.forEach((v) => {
+          const input = document.createElement('input');
+          input.name = key;
+          input.value = v;
+          formElement.appendChild(input);
+        });
+        return;
+      }
+
+      const input = document.createElement('input');
+      input.name = key;
+      input.value = value;
+      formElement.appendChild(input);
+    });
+    const input = document.createElement('input');
+    input.name = 'token';
+    input.value = AuthenticationManager.instance.authContextProps?.user?.access_token ?? '';
+    formElement.appendChild(input);
+
+    document.body.appendChild(formElement);
+    formElement.submit();
+    document.body.removeChild(formElement);
+  }
+
+  public static getExportFileName(baseName: string, completeCaseType: CompleteCaseType, t: TFunction<'translation', undefined>): string {
+    return t('{{date}}--{{applicationName}}--{{caseTypeName}}--{{baseName}}', {
+      applicationName: StringUtil.createSlug(ConfigManager.instance.config.applicationName),
+      baseName: StringUtil.createSlug(baseName),
+      date: format(new Date(), DATE_FORMAT.DATE),
+      caseTypeName: StringUtil.createSlug(completeCaseType.name),
+    });
+  }
+
+  public static getTemplateFileName(completeCaseType: CompleteCaseType): string {
+    return `${StringUtil.createSlug(ConfigManager.instance.config.applicationName)}--${StringUtil.createSlug(completeCaseType.name)}--template`;
+  }
+
+  public static downloadEchartsImage(baseName: string, instance: ECharts, type: 'jpeg' | 'png', completeCaseType: CompleteCaseType, t: TFunction<'translation', undefined>): void {
+    const url = instance.getDataURL({
+      type,
+      pixelRatio: 2,
+      backgroundColor: '#fff',
+    });
+    const fileName = `${DownloadUtil.getExportFileName(baseName, completeCaseType, t)}.${type.toLowerCase()}`;
+    DownloadUtil.createDownloadUrl(url, fileName);
+  }
+
+  public static downloadCanvasImage(baseName: string, canvas: HTMLCanvasElement, type: 'jpeg' | 'png', completeCaseType: CompleteCaseType, t: TFunction<'translation', undefined>): void {
+    const dataUrl = canvas.toDataURL(type === 'jpeg' ? 'image/jpeg' : 'image/png');
+    const fileName = `${DownloadUtil.getExportFileName(baseName, completeCaseType, t)}.${type}`;
+    DownloadUtil.createDownloadUrl(dataUrl, fileName);
+  }
+
+  public static downloadNewick(baseName: string, newick: string, completeCaseType: CompleteCaseType, t: TFunction<'translation', undefined>): void {
+    const fileName = `${DownloadUtil.getExportFileName(baseName, completeCaseType, t)}.txt`;
+    DownloadUtil.createDownloadUrl(`data:text/x-nh;base64,${btoa(newick)}`, fileName);
+  }
+
+  public static downloadAsCsv(cases: Case[], colIds: string[], completeCaseType: CompleteCaseType, t: TFunction<'translation', undefined>): void {
+    const data = [
+      DownloadUtil.getColumnHeadersForExport(colIds, completeCaseType),
+      ...DownloadUtil.getRowsForExport(cases, colIds, completeCaseType),
+    ];
+    const csv = stringify(data, {
+      defaultEncoding: 'utf-8',
+    });
+    const fileName = `${DownloadUtil.getExportFileName(t`Line list`, completeCaseType, t)}.csv`;
+    DownloadUtil.createDownloadUrl(`data:text/csv;base64,${btoa(csv)}`, fileName);
+  }
+
+  public static async downloadAsExcel(cases: Case[], colIds: string[], completeCaseType: CompleteCaseType, t: TFunction<'translation', undefined>): Promise<void> {
+    // Prepare headers
+    const headers = DownloadUtil.getColumnHeadersForExport(colIds, completeCaseType);
+
+    // Prepare data rows
+    const rows = DownloadUtil.getRowsForExport(cases, colIds, completeCaseType);
+
+    // Convert data to the format expected by write-excel-file (SheetData)
+    // Each row is an array of Cell objects
+    const data = [
+      // Header row
+      headers.map(header => ({ type: String, value: header })),
+      // Data rows
+      ...rows.map(row => row.map(cell => ({ type: String, value: cell }))),
+    ];
+
+    const fileName = `${DownloadUtil.getExportFileName(t`Line list`, completeCaseType, t)}.xlsx`;
+
+    // Generate Excel file as a Blob and download it
+    const blob = await writeXlsxFile(data, {
+      columns: headers.map(() => ({ width: 20 })),
+      stickyRowsCount: 1,
+    });
+
+    // Convert blob to base64 and download
+    const arrayBuffer = await blob.arrayBuffer();
+    const base64 = DownloadUtil.arrayBufferToBase64(arrayBuffer);
+    DownloadUtil.createDownloadUrl(`data:application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;base64,${base64}`, fileName);
+  }
+
+  private static getColumnHeadersForImport(colIds: string[], completeCaseType: CompleteCaseType): string[] {
+    return [
+      '_case_id',
+      '_case_date',
+      ...DownloadUtil.getColsForImportExport(colIds, completeCaseType).map(col => col.label),
+    ];
+  }
+
+  private static getColumnHeadersForExport(colIds: string[], completeCaseType: CompleteCaseType): string[] {
+    return [
+      '_case_id',
+      '_case_type',
+      '_case_date',
+      ...DownloadUtil.getColsForImportExport(colIds, completeCaseType).map(col => col.label),
+    ];
+  }
+
+  private static getRowsForExport(cases: Case[], colIds: string[], completeCaseType: CompleteCaseType): string[][] {
+    const cols = DownloadUtil.getColsForImportExport(colIds, completeCaseType);
+    return cases.map(row => [
+      row.id,
+      completeCaseType.name,
+      row.case_date ? format(row.case_date, DATE_FORMAT.DATE) : '',
+      ...cols.map(col => CaseUtil.getRowValue(row.content, col, completeCaseType, true).long),
+    ]);
+  }
+
+  private static getColsForImportExport(colIds: string[], completeCaseType: CompleteCaseType): Col[] {
+    return CaseTypeUtil.getCols(completeCaseType)
+      .filter(x => colIds.includes(x.id))
+      .sort((a, b) => {
+        return colIds.indexOf(a.id) - colIds.indexOf(b.id);
+      });
+  }
+
+  private static arrayBufferToBase64(buffer: ArrayBuffer) {
+    let binary = '';
+    const bytes = new Uint8Array(buffer);
+    const len = bytes.byteLength;
+    for (let i = 0; i < len; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return window.btoa(binary);
+  }
+}

package/src/utils/DownloadUtil/index.ts

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

package/src/utils/EffectiveRightsUtil/EffectiveRightsUtil.ts

@@ -0,0 +1,142 @@
+import type {
+  User,
+  ColSetMember,
+  CaseTypeSetMember,
+  OrganizationAccessCasePolicy,
+  OrganizationShareCasePolicy,
+  UserAccessCasePolicy,
+  UserShareCasePolicy,
+} from '../../api';
+import type { UserEffectiveRight } from '../../models/caseAccess';
+import { DataSetUtil } from '../DataSetUtil';
+
+type AssembleUserEffectiveRightsKwArgs = {
+  user: User;
+  organizationAccessCasePolicies: OrganizationAccessCasePolicy[];
+  organizationShareCasePolicies: OrganizationShareCasePolicy[];
+  userAccessCasePolicies: UserAccessCasePolicy[];
+  userShareCasePolicies: UserShareCasePolicy[];
+  caseTypeSetMembers: CaseTypeSetMember[];
+  colSetMembers: ColSetMember[];
+};
+
+export class EffectiveRightsUtil {
+  public static assembleUserEffectiveRights({
+    user,
+    organizationAccessCasePolicies,
+    organizationShareCasePolicies,
+    userAccessCasePolicies,
+    userShareCasePolicies,
+    caseTypeSetMembers,
+    colSetMembers,
+  }: AssembleUserEffectiveRightsKwArgs): UserEffectiveRight[] {
+    if (!user) {
+      return [];
+    }
+
+    if (!organizationAccessCasePolicies || !organizationShareCasePolicies || !userAccessCasePolicies || !userShareCasePolicies || !caseTypeSetMembers || !colSetMembers) {
+      return [];
+    }
+
+    const mappedCaseTypeSetMembers = DataSetUtil.getMappedSetMembers({
+      items: caseTypeSetMembers,
+      setProperty: 'case_type_set_id',
+      memberProperty: 'case_type_id',
+    });
+
+    const mappedColSetMembers = DataSetUtil.getMappedSetMembers({
+      items: colSetMembers,
+      setProperty: 'col_set_id',
+      memberProperty: 'col_id',
+    });
+
+    return organizationAccessCasePolicies.map(organizationPolicy => {
+      const userPolicy = userAccessCasePolicies.find(p => p.data_collection_id === organizationPolicy.data_collection_id);
+      const organizationSharePolicy = organizationShareCasePolicies.filter(p => p.data_collection_id === organizationPolicy.data_collection_id);
+      const userSharePolicy = userShareCasePolicies.filter(p => p.data_collection_id === organizationPolicy.data_collection_id);
+
+      const effectiveShareCaseRights: UserEffectiveRight['effective_share_case_rights'] = [];
+      organizationSharePolicy.forEach(organizationShareCasePolicy => {
+        const userShareCasePolicy = userSharePolicy.find(p => p.from_data_collection_id === organizationShareCasePolicy.from_data_collection_id);
+        const organizationShareCaseTypeIds = caseTypeSetMembers.filter(member => member.case_type_set_id === organizationShareCasePolicy.case_type_set_id).map(member => member.case_type_id);
+        const userShareCaseTypeIds = caseTypeSetMembers.filter(member => member.case_type_set_id === userShareCasePolicy?.case_type_set_id).map(member => member.case_type_id);
+        const { setIds: case_type_set_ids, categorizedMemberIds: categorized_case_type_ids, uncategorizedMemberIds: uncategorized_case_type_ids } = DataSetUtil.getCategorizedSetMembers({
+          mappedSetMembers: mappedCaseTypeSetMembers,
+          parentSetId: organizationShareCasePolicy.case_type_set_id,
+          parentMemberIds: organizationShareCaseTypeIds,
+          childMemberIds: userShareCaseTypeIds,
+        });
+
+        const add_case = organizationShareCasePolicy.add_case && userShareCasePolicy?.add_case;
+        const remove_case = organizationShareCasePolicy.remove_case && userShareCasePolicy?.remove_case;
+        const add_case_set = organizationShareCasePolicy.add_case_set && userShareCasePolicy?.add_case_set;
+        const remove_case_set = organizationShareCasePolicy.remove_case_set && userShareCasePolicy?.remove_case_set;
+
+        if ([add_case, remove_case, add_case_set, remove_case_set].some(x => x)) {
+          effectiveShareCaseRights.push({
+            add_case,
+            remove_case,
+            add_case_set,
+            remove_case_set,
+            from_data_collection_id: organizationShareCasePolicy.from_data_collection_id,
+            case_type_set_ids,
+            categorized_case_type_ids,
+            uncategorized_case_type_ids,
+          } satisfies UserEffectiveRight['effective_share_case_rights'][number]);
+        }
+      });
+
+
+      const organizationCaseTypeIds = caseTypeSetMembers.filter(member => member.case_type_set_id === organizationPolicy.case_type_set_id).map(member => member.case_type_id);
+      const userCaseTypeIds = caseTypeSetMembers.filter(member => member.case_type_set_id === userPolicy?.case_type_set_id).map(member => member.case_type_id);
+      const { setIds: case_type_set_ids, categorizedMemberIds: categorized_case_type_ids, uncategorizedMemberIds: uncategorized_case_type_ids } = DataSetUtil.getCategorizedSetMembers({
+        mappedSetMembers: mappedCaseTypeSetMembers,
+        parentSetId: organizationPolicy.case_type_set_id,
+        parentMemberIds: organizationCaseTypeIds,
+        childMemberIds: userCaseTypeIds,
+      });
+
+      const organizationReadColIds = colSetMembers.filter(member => member.col_set_id === organizationPolicy.read_col_set_id).map(member => member.col_id);
+      const userReadColIds = colSetMembers.filter(member => member.col_set_id === userPolicy?.read_col_set_id).map(member => member.col_id);
+      const { setIds: read_col_set_ids, categorizedMemberIds: categorized_read_col_ids, uncategorizedMemberIds: uncategorized_read_col_ids } = DataSetUtil.getCategorizedSetMembers({
+        mappedSetMembers: mappedColSetMembers,
+        parentSetId: organizationPolicy.read_col_set_id,
+        parentMemberIds: organizationReadColIds,
+        childMemberIds: userReadColIds,
+      });
+
+      const organizationWriteColIds = colSetMembers.filter(member => member.col_set_id === organizationPolicy.write_col_set_id).map(member => member.col_id);
+      const userWriteColIds = colSetMembers.filter(member => member.col_set_id === userPolicy?.write_col_set_id).map(member => member.col_id);
+      const { setIds: write_col_set_ids, categorizedMemberIds: categorized_write_col_ids, uncategorizedMemberIds: uncategorized_write_col_ids } = DataSetUtil.getCategorizedSetMembers({
+        mappedSetMembers: mappedColSetMembers,
+        parentSetId: organizationPolicy.write_col_set_id,
+        parentMemberIds: organizationWriteColIds,
+        childMemberIds: userWriteColIds,
+      });
+
+      return {
+        add_case: organizationPolicy.add_case && userPolicy?.add_case,
+        add_case_set: organizationPolicy.add_case_set && userPolicy?.add_case_set,
+        data_collection_id: organizationPolicy.data_collection_id,
+        is_private: organizationPolicy.is_private,
+        organization_id: organizationPolicy.organization_id,
+        read_case_set: organizationPolicy.read_case_set && userPolicy?.read_case_set,
+        remove_case: organizationPolicy.remove_case && userPolicy?.remove_case,
+        remove_case_set: organizationPolicy.remove_case_set && userPolicy?.remove_case_set,
+        write_case_set: organizationPolicy.write_case_set && userPolicy?.write_case_set,
+        write_col_set_id: organizationPolicy.write_col_set_id,
+        read_col_set_id: organizationPolicy.read_col_set_id,
+        case_type_set_ids,
+        categorized_case_type_ids,
+        uncategorized_case_type_ids,
+        read_col_set_ids,
+        categorized_read_col_ids,
+        uncategorized_read_col_ids,
+        write_col_set_ids,
+        categorized_write_col_ids,
+        uncategorized_write_col_ids,
+        effective_share_case_rights: effectiveShareCaseRights,
+      } satisfies UserEffectiveRight;
+    }).filter((policy => !!policy));
+  }
+}

package/src/utils/EffectiveRightsUtil/index.ts

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

package/src/utils/EpiCurveUtil/EpiCurveUtil.ts

@@ -0,0 +1,180 @@
+import type { Duration } from 'date-fns';
+import {
+  eachDayOfInterval,
+  eachMonthOfInterval,
+  eachQuarterOfInterval,
+  eachWeekOfInterval,
+  eachYearOfInterval,
+  format,
+  intervalToDuration,
+  isAfter,
+  isBefore,
+  isEqual,
+  isValid,
+} from 'date-fns';
+
+import { CaseTypeUtil } from '../CaseTypeUtil';
+import { EpiFilterUtil } from '../EpiFilterUtil';
+import type {
+  Case,
+  CompleteCaseType,
+  Col,
+} from '../../api';
+import { ColType } from '../../api';
+import { DATE_FORMAT } from '../../data/date';
+
+interface Item {
+  date: Date;
+  value: number;
+  row: Case;
+}
+
+export class EpiCurveUtil {
+  /**
+   * Gets rows sorted by time
+   * @param completeCaseType
+   * @param lineList
+   * @param cols
+   * @returns
+   */
+  public static getSortedItems(completeCaseType: CompleteCaseType, cases: Case[], cols: Col[]): Item[] {
+    if (!cols.length || !cases.length || !completeCaseType) {
+      return [];
+    }
+
+    // cache the parsers
+    const dateParsers: { [key: string]: (date: string) => Date } = {};
+    cols.forEach(col => {
+      dateParsers[col.id] = EpiFilterUtil.getDateParser(completeCaseType.ref_cols[col.ref_col_id]);
+    });
+
+    const items: Item[] = cases.map(row => {
+      const dates = cols.map(col => {
+        const columnDate = row.content[col.id];
+        if (!columnDate) {
+          return null;
+        }
+        const parsedColumnDate = dateParsers[col.id](columnDate);
+        if (!isValid(parsedColumnDate)) {
+          return null;
+        }
+        return parsedColumnDate;
+      }).filter(d => !!d);
+
+      return {
+        date: dates[0] ?? null,
+        // when count is null, 1 should be assumed
+        value: row.count ?? 1,
+        row,
+      };
+    }).filter(item => !!item.date);
+
+    return items.sort((a, b) => {
+      const aData = a.date;
+      const bData = b.date;
+
+      if (isAfter(aData, bData)) {
+        return 1;
+      }
+      if (isBefore(aData, bData)) {
+        return -1;
+      }
+      return 0;
+    });
+  }
+
+  /**
+   * Finds the initial column (resolution) for the given dimensionId in the given lineList
+   * @param completeCaseType
+   * @param lineList
+   * @param cols
+   * @returns
+   */
+  public static getPreferredTimeColumn(completeCaseType: CompleteCaseType, cases: Case[], cols: Col[]): Col {
+    const items = EpiCurveUtil.getSortedItems(completeCaseType, cases, cols);
+
+    if (!items?.length) {
+      return cols?.[0] ?? null;
+    }
+
+    const duration: Duration = {
+      years: 0,
+      ...intervalToDuration({
+        start: items[0].date,
+        end: items[items.length - 1].date,
+      }),
+    };
+
+    const dayCol = cols.find(col => completeCaseType.ref_cols[col.ref_col_id].col_type === ColType.TIME_DAY);
+    if (dayCol && (duration.years ?? 0) === 0 && duration.months <= 3) {
+      return dayCol;
+    }
+    const weekCol = cols.find(col => completeCaseType.ref_cols[col.ref_col_id].col_type === ColType.TIME_WEEK);
+    if (weekCol && (duration.years ?? 0) <= 1) {
+      return weekCol;
+    }
+    const monthCol = cols.find(col => completeCaseType.ref_cols[col.ref_col_id].col_type === ColType.TIME_MONTH);
+    if (monthCol && (duration.years ?? 0) <= 2) {
+      return monthCol;
+    }
+    const quarterCol = cols.find(col => completeCaseType.ref_cols[col.ref_col_id].col_type === ColType.TIME_QUARTER);
+    if (quarterCol && (duration.years ?? 0) <= 5) {
+      return quarterCol;
+    }
+    const yearCol = cols.find(col => completeCaseType.ref_cols[col.ref_col_id].col_type === ColType.TIME_QUARTER);
+    if (yearCol) {
+      return yearCol;
+    }
+
+    return CaseTypeUtil.getPreferredColInDimHavingHighestRank(cols, completeCaseType);
+  }
+
+  public static getXAxisLabel(colType: ColType, value: Date): string {
+    switch (colType) {
+      case ColType.TIME_DAY:
+        return format(value, DATE_FORMAT.DATE);
+      case ColType.TIME_WEEK:
+        return format(value, DATE_FORMAT.YEAR_WEEK, { useAdditionalWeekYearTokens: true });
+      case ColType.TIME_MONTH:
+        return format(value, DATE_FORMAT.YEAR_MONTH);
+      case ColType.TIME_QUARTER:
+        return format(value, DATE_FORMAT.YEAR_QUARTER);
+      case ColType.TIME_YEAR:
+        return format(value, DATE_FORMAT.YEAR);
+      default:
+        throw Error(`unknown col_type ${colType}`);
+    }
+  }
+
+  public static getXAxisIntervals(colType: ColType, items: Item[]): Date[] {
+    if (items.length === 0) {
+      return [];
+    }
+
+    const start = items[0].date;
+    const end = items[items.length - 1].date;
+
+    switch (colType) {
+      case ColType.TIME_DAY:
+        return eachDayOfInterval({ start, end });
+      case ColType.TIME_WEEK:
+        return eachWeekOfInterval({ start, end });
+      case ColType.TIME_MONTH:
+        return eachMonthOfInterval({ start, end });
+      case ColType.TIME_QUARTER:
+        return eachQuarterOfInterval({ start, end });
+      case ColType.TIME_YEAR:
+        return eachYearOfInterval({ start, end });
+      default:
+        throw Error(`unknown col_type ${colType}`);
+    }
+  }
+
+  public static getItemsWithinInterval(items: Item[], intervals: Date[], index: number): Item[] {
+    return items.filter(item => {
+      const nextInterval = intervals[index + 1];
+      const itemDate = item.date;
+      return isEqual(itemDate, intervals[index]) || (isAfter(itemDate, intervals[index]) && (!nextInterval || isBefore(itemDate, nextInterval)));
+    });
+  }
+}

package/src/utils/EpiCurveUtil/index.ts

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