@gen-epix/ui 1.15.1 → 1.15.2

package/src/stores/epiDashboardStore/epiDashboardStoreContext.tsx

@@ -1,6 +0,0 @@
-import { createContext } from 'react';
-import type { StoreApi } from 'zustand';
-
-import type { EpiDashboardStore } from './epiDashboardStore';
-
-export const EpiDashboardStoreContext = createContext<StoreApi<EpiDashboardStore>>(null);

package/src/stores/epiDashboardStore/index.ts

@@ -1,2 +0,0 @@
-export * from './epiDashboardStore';
-export * from './epiDashboardStoreContext';

package/src/stores/epiUploadStore/epiUploadStore.ts

@@ -1,351 +0,0 @@
-import { createStore } from 'zustand';
-import { t } from 'i18next';
-
-import type {
-  Col,
-  CompleteCaseType,
-  CaseUploadResult,
-} from '../../api';
-import { QueryUtil } from '../../utils/QueryUtil';
-import { StringUtil } from '../../utils/StringUtil';
-import { EpiUploadUtil } from '../../utils/EpiUploadUtil';
-import { QUERY_KEY } from '../../models/query';
-import type {
-  AutoCompleteOption,
-  OptionBase,
-} from '../../models/form';
-import { NotificationManager } from '../../classes/managers/NotificationManager';
-import type {
-  EpiUploadMappedColumn,
-  EpiUploadSequenceMapping,
-  CaseUploadResultWithGeneratedId,
-} from '../../models/epi';
-import { EPI_UPLOAD_STEP } from '../../models/epi';
-
-export const STEP_ORDER = [
-  EPI_UPLOAD_STEP.SELECT_FILE,
-  EPI_UPLOAD_STEP.MAP_COLUMNS,
-  EPI_UPLOAD_STEP.VALIDATE,
-  EPI_UPLOAD_STEP.SELECT_SEQUENCE_FILES,
-  EPI_UPLOAD_STEP.MAP_SEQUENCES,
-  EPI_UPLOAD_STEP.CREATE_CASES,
-];
-
-export interface EpiUploadStoreState {
-  activeStep: EPI_UPLOAD_STEP;
-  cols: Col[];
-  caseTypeId: string;
-  sampleIdColId: string;
-  completeCaseType: CompleteCaseType;
-  createdInDataCollectionId: string;
-  createdInDataCollectionOptions: AutoCompleteOption<string>[];
-  dataCollectionOptions: OptionBase<string>[];
-  fileList: FileList;
-  fileName: string;
-  sequencingProtocolId: string;
-  assemblyProtocolId: string;
-  fileParsingError: string;
-  initError: unknown;
-  isInitLoading: boolean;
-  mappedColumns: EpiUploadMappedColumn[];
-  rawData: string[][];
-  sequenceFilesDataTransfer: DataTransfer;
-  sequenceMapping: EpiUploadSequenceMapping;
-  sheet: string;
-  sheetOptions: AutoCompleteOption<string>[];
-  shouldResetColumnMapping: boolean;
-  shouldResetSequenceMapping: boolean;
-  validateCasesQueryKey: string[];
-  validatedCases: CaseUploadResult[];
-  validatedCasesWithGeneratedId: CaseUploadResultWithGeneratedId[];
-}
-
-export interface EpiUploadStoreActions {
-  setFileList: (fileList: FileList) => Promise<void>;
-  setSequenceFilesDataTransfer: (dataTransfer: DataTransfer) => void;
-  setSequenceMapping: (sequenceMapping: EpiUploadSequenceMapping) => void;
-  setMappedColumns: (mappedColumns: EpiUploadMappedColumn[]) => Promise<void>;
-  setSheet: (sheet: string) => Promise<void>;
-  setCaseTypeId: (caseTypeId: string) => void;
-  setCompleteCaseType: (completeCaseType: CompleteCaseType) => void;
-  setCreatedInDataCollectionId: (createdInDataCollectionId: string) => void;
-  setRawData: (rawData: string[][]) => Promise<void>;
-  setSheetOptions: (sheetOptions: AutoCompleteOption<string>[]) => Promise<void>;
-  setCols: (cols: Col[]) => void;
-  setDataCollectionOptions: (options: OptionBase<string>[]) => void;
-  setValidatedCases: (validatedCases: CaseUploadResult[]) => void;
-
-  goToNextStep: () => Promise<void>;
-  goToPreviousStep: () => void;
-  reset: () => Promise<void>;
-  destroy: () => Promise<void>;
-  invalidateCaseValidationQuery: () => Promise<void>;
-  findNextStep: (currentStep: EPI_UPLOAD_STEP) => EPI_UPLOAD_STEP;
-  findPreviousStep: (currentStep: EPI_UPLOAD_STEP) => EPI_UPLOAD_STEP;
-}
-
-export type EpiUploadStore = EpiUploadStoreState & EpiUploadStoreActions;
-
-
-const createEpiUploadStoreDefaultState: () => EpiUploadStoreState = () => ({
-  activeStep: STEP_ORDER[0],
-  assemblyProtocolId: null,
-  cols: null,
-  caseTypeId: null,
-  completeCaseType: null,
-  sampleIdColId: null,
-  createdInDataCollectionId: null,
-  createdInDataCollectionOptions: [],
-  dataCollectionOptions: [],
-  fileList: null,
-  fileName: null,
-  fileParsingError: null,
-  initError: null,
-  isInitLoading: true,
-  sequencingProtocolId: null,
-  mappedColumns: null,
-  rawData: null,
-  sequenceFilesDataTransfer: new DataTransfer(),
-  sequenceMapping: null,
-  sheet: null,
-  sheetOptions: [],
-  shouldResetColumnMapping: false,
-  shouldResetSequenceMapping: false,
-  validateCasesQueryKey: QueryUtil.getGenericKey(QUERY_KEY.VALIDATE_CASES, StringUtil.createUuid()),
-  validatedCases: [],
-  validatedCasesWithGeneratedId: [],
-});
-
-export const createEpiUploadStore = () => {
-  return createStore<EpiUploadStore>()((set, get) => {
-    return {
-      ...createEpiUploadStoreDefaultState(),
-      setValidatedCases: (validatedCases: CaseUploadResult[]) => {
-        set({
-          validatedCases, validatedCasesWithGeneratedId: (validatedCases || []).map((vc, index) => ({
-            ...vc,
-            generatedId: index.toString(),
-          })),
-        });
-      },
-
-      setCols: (cols: Col[]) => {
-        set({ cols });
-      },
-
-      setDataCollectionOptions: (options: OptionBase<string>[]) => {
-        set({ dataCollectionOptions: options });
-      },
-
-      setRawData: async (rawData: string[][]) => {
-        const { cols, setCaseTypeId, rawData: oldRawData, invalidateCaseValidationQuery } = get();
-        if (JSON.stringify(oldRawData) !== JSON.stringify(rawData)) {
-          set({ shouldResetColumnMapping: true });
-          await invalidateCaseValidationQuery();
-        }
-        set({ rawData });
-        if (!rawData || rawData.length === 0) {
-          return;
-        }
-        const bestMatchingCaseType = EpiUploadUtil.getCaseTypeFromColumnLabels(cols, rawData[0]);
-        if (bestMatchingCaseType) {
-          setCaseTypeId(bestMatchingCaseType.id);
-        }
-      },
-
-      setFileList: async (fileList: FileList) => {
-        const { setSheetOptions, setSheet, setRawData } = get();
-
-        const file = fileList?.length > 0 ? fileList[0] : null;
-        set({ fileParsingError: null, rawData: null, fileName: file?.name ?? null, sheet: null });
-
-        if (!file) {
-          await setSheet(null);
-          await setRawData(null);
-          set({ fileList: null });
-          return;
-        }
-
-        set({ fileList });
-        try {
-          if (!EpiUploadUtil.isXlsxFile(file.name)) {
-            const data = await EpiUploadUtil.readRawData(fileList);
-            await setRawData(data);
-          }
-          const sheetOptions = await EpiUploadUtil.getSheetNameOptions(fileList);
-          await setSheetOptions(sheetOptions);
-        } catch (_error) {
-          await setSheet(null);
-          await setSheetOptions([]);
-          set({ fileList: null, fileParsingError: t('Error reading file') });
-        }
-      },
-
-      setSheetOptions: async (sheetOptions: AutoCompleteOption<string>[]) => {
-        const { setSheet } = get();
-        set({ sheetOptions });
-        if (sheetOptions.length === 1) {
-          await setSheet(sheetOptions[0].value);
-        }
-      },
-
-      setSheet: async (sheet: string) => {
-        const { fileList, setRawData } = get();
-        set({ sheet, fileParsingError: null, rawData: null });
-
-        if (!sheet) {
-          return;
-        }
-        try {
-          // Call the callback with parsed data
-          await setRawData(await EpiUploadUtil.readRawData(fileList, sheet));
-        } catch (error) {
-          console.log('Error reading sheet', error);
-          set({ sheet: null });
-          set({ fileParsingError: t('Error reading sheet') });
-          await setRawData(null);
-          return;
-        }
-      },
-
-      setCaseTypeId: (caseTypeId: string) => {
-        set({ caseTypeId });
-      },
-
-      setCreatedInDataCollectionId: (createdInDataCollectionId: string) => {
-        set({ createdInDataCollectionId });
-      },
-
-      setCompleteCaseType: async (completeCaseType: CompleteCaseType) => {
-        const { completeCaseType: oldCompleteCaseType, dataCollectionOptions, createdInDataCollectionId, invalidateCaseValidationQuery } = get();
-        set({ completeCaseType });
-        if (completeCaseType && completeCaseType.id !== oldCompleteCaseType?.id) {
-          await invalidateCaseValidationQuery();
-          set({ shouldResetColumnMapping: true });
-          const createdInDataCollectionOptions = dataCollectionOptions.filter(option => {
-            const dataCollectionId = option.value;
-            return completeCaseType.case_type_access_abacs[dataCollectionId]?.is_private && completeCaseType.case_type_access_abacs[dataCollectionId]?.add_case_set;
-          });
-          set({ createdInDataCollectionOptions });
-          if (createdInDataCollectionOptions.length === 1) {
-            set({ createdInDataCollectionId: createdInDataCollectionOptions[0].value });
-          }
-
-          // If the current createdInDataCollectionId is not valid for the new completeCaseType, reset it
-          if (createdInDataCollectionId) {
-            const isValid = createdInDataCollectionOptions.some(option => option.value === createdInDataCollectionId);
-            if (!isValid) {
-              set({ createdInDataCollectionId: null });
-            }
-          }
-        }
-      },
-
-      setMappedColumns: async (mappedColumns: EpiUploadMappedColumn[]) => {
-        const { invalidateCaseValidationQuery } = get();
-        await invalidateCaseValidationQuery();
-        set({ mappedColumns });
-      },
-
-      setSequenceFilesDataTransfer: (dataTransfer: DataTransfer) => {
-        const { sequenceMapping, sequenceFilesDataTransfer } = get();
-        if (dataTransfer === sequenceFilesDataTransfer) {
-          return;
-        }
-        set({ sequenceFilesDataTransfer: dataTransfer });
-        if (sequenceMapping) {
-          set({ shouldResetSequenceMapping: true });
-        }
-      },
-
-      setSequenceMapping: (sequenceMapping: EpiUploadSequenceMapping) => {
-        set({ sequenceMapping });
-      },
-
-      goToNextStep: async () => {
-        const { activeStep, shouldResetColumnMapping, shouldResetSequenceMapping, validatedCasesWithGeneratedId, mappedColumns, sequenceFilesDataTransfer, sequenceMapping, setMappedColumns, completeCaseType, rawData } = get();
-
-        let nextStep = get().findNextStep(activeStep);
-
-        if (nextStep === EPI_UPLOAD_STEP.MAP_COLUMNS) {
-          if (shouldResetColumnMapping && mappedColumns) {
-            NotificationManager.instance.showNotification({
-              message: t`Column mappings have been reset due to changes in the selected case type or file.`,
-              severity: 'info',
-              isLoading: false,
-            });
-          }
-          if ((shouldResetColumnMapping && mappedColumns) || !mappedColumns) {
-            await setMappedColumns(EpiUploadUtil.getInitialMappedColumns(completeCaseType, rawData));
-          }
-        }
-
-        if (nextStep === EPI_UPLOAD_STEP.MAP_SEQUENCES) {
-          if (shouldResetSequenceMapping && sequenceMapping) {
-            NotificationManager.instance.showNotification({
-              message: t`Sequence mappings have been reset due to changes in the selected uploaded files.`,
-              severity: 'info',
-              isLoading: false,
-            });
-          }
-          if ((shouldResetSequenceMapping && sequenceMapping) || !sequenceMapping) {
-            set({ sequenceMapping: EpiUploadUtil.getEpiUploadSequenceMapping(completeCaseType, validatedCasesWithGeneratedId, sequenceFilesDataTransfer) });
-          }
-          if (EpiUploadUtil.getSequenceMappingStats(get().sequenceMapping, sequenceFilesDataTransfer).numberOfFilesToMap === 0) {
-            nextStep = get().findNextStep(nextStep);
-          }
-        }
-
-        if (nextStep !== null) {
-          set({ activeStep: nextStep, shouldResetColumnMapping: false, shouldResetSequenceMapping: false });
-        }
-      },
-
-      goToPreviousStep: () => {
-        const { activeStep, sequenceMapping, sequenceFilesDataTransfer } = get();
-        let previousStep = get().findPreviousStep(activeStep);
-        if (previousStep === EPI_UPLOAD_STEP.MAP_SEQUENCES && EpiUploadUtil.getSequenceMappingStats(sequenceMapping, sequenceFilesDataTransfer).numberOfFilesToMap === 0) {
-          previousStep = get().findPreviousStep(previousStep);
-        }
-
-        if (previousStep !== null) {
-          set({ activeStep: previousStep });
-        }
-      },
-
-      reset: async () => {
-        const { invalidateCaseValidationQuery } = get();
-        await invalidateCaseValidationQuery();
-        set(createEpiUploadStoreDefaultState());
-      },
-
-      findNextStep: (currentStep: EPI_UPLOAD_STEP): EPI_UPLOAD_STEP => {
-        const currentIndex = STEP_ORDER.indexOf(currentStep);
-        if (currentIndex === -1 || currentIndex === STEP_ORDER.length - 1) {
-          return null;
-        }
-        return STEP_ORDER[currentIndex + 1];
-      },
-
-      findPreviousStep: (currentStep: EPI_UPLOAD_STEP): EPI_UPLOAD_STEP => {
-        const currentIndex = STEP_ORDER.indexOf(currentStep);
-        if (currentIndex <= 0) {
-          return null;
-        }
-        return STEP_ORDER[currentIndex - 1];
-      },
-
-      invalidateCaseValidationQuery: async () => {
-        const { validateCasesQueryKey } = get();
-
-        await QueryUtil.invalidateQueryKeys([validateCasesQueryKey]);
-        QueryUtil.removeQueries([validateCasesQueryKey]);
-      },
-
-      destroy: async () => {
-        const { invalidateCaseValidationQuery } = get();
-        await invalidateCaseValidationQuery();
-      },
-    };
-  });
-};

package/src/stores/epiUploadStore/epiUploadStoreContext.tsx

@@ -1,6 +0,0 @@
-import { createContext } from 'react';
-import type { StoreApi } from 'zustand';
-
-import type { EpiUploadStore } from './epiUploadStore';
-
-export const EpiUploadStoreContext = createContext<StoreApi<EpiUploadStore>>(null);

package/src/stores/epiUploadStore/index.ts

@@ -1,2 +0,0 @@
-export * from './epiUploadStore';
-export * from './epiUploadStoreContext';

package/src/stores/oidcStore/index.ts

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

package/src/stores/oidcStore/oidcStore.ts

@@ -1,43 +0,0 @@
-import { createStore } from 'zustand';
-import {
-  persist,
-  createJSONStorage,
-} from 'zustand/middleware';
-
-import type { IdentityProvider } from '../../api';
-
-
-export interface OidcStoreState {
-  configuration: IdentityProvider;
-}
-
-export interface OidcStoreActions {
-  setConfiguration: (configuration: IdentityProvider) => void;
-}
-
-export type OidcStore = OidcStoreState & OidcStoreActions;
-
-export const createOidcStoreInitialState: () => OidcStoreState = () => ({
-  configuration: undefined,
-});
-
-export const oidcStore = createStore<OidcStore>()(
-  persist(
-    (set) => {
-      return {
-        ...createOidcStoreInitialState(),
-        setConfiguration: (configuration: IdentityProvider) => {
-          set({ configuration });
-        },
-      };
-    },
-    {
-      name: 'GENEPIX-OIDC-Configuration',
-      storage: createJSONStorage(() => sessionStorage),
-      partialize: (state) => ({
-        configuration: state.configuration,
-      }),
-      version: 1,
-    },
-  ),
-);

package/src/stores/outagesStore/index.ts

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

package/src/stores/outagesStore/outagesStore.ts

@@ -1,31 +0,0 @@
-import { createStore } from 'zustand';
-
-import type { Outage } from '../../api';
-import type { CategorizedOutages } from '../../models/outage';
-
-export interface OutagesStoreState {
-  visibleOutages: Outage[];
-  activeOutages: Outage[];
-  soonActiveOutages: Outage[];
-}
-
-export interface OutagesStoreActions {
-  setCategorizedOutages: (categorizedOutages: CategorizedOutages) => void;
-}
-
-export type OutagesStore = OutagesStoreState & OutagesStoreActions;
-
-const createOutagesStoreDefaultState: () => OutagesStoreState = () => ({
-  visibleOutages: [],
-  activeOutages: [],
-  soonActiveOutages: [],
-});
-
-export const outagesStore = createStore<OutagesStore>()((set) => {
-  return {
-    ...createOutagesStoreDefaultState(),
-    setCategorizedOutages: (categorizedOutages: CategorizedOutages) => {
-      set(categorizedOutages);
-    },
-  };
-});

package/src/stores/tableStore/TableStoreContext.tsx

@@ -1,6 +0,0 @@
-import { createContext } from 'react';
-import type { StoreApi } from 'zustand';
-
-import type { TableStore } from './tableStore';
-
-export const TableStoreContext = createContext<StoreApi<TableStore<unknown>>>(null);

package/src/stores/tableStore/TableStoreContextProvider.tsx

@@ -1,20 +0,0 @@
-import type { StoreApi } from 'zustand';
-import type { PropsWithChildren } from 'react';
-
-import type { TableStore } from './tableStore';
-import { TableStoreContext } from './TableStoreContext';
-
-export type TableStoreContextProviderProps<TData> = PropsWithChildren<{
-  readonly store: StoreApi<TableStore<TData>>;
-}>;
-
-export const TableStoreContextProvider = <TData,>(
-  props: TableStoreContextProviderProps<TData>,
-) => {
-  const { children, store } = props;
-  return (
-    <TableStoreContext.Provider value={store as StoreApi<TableStore<unknown>>}>
-      {children}
-    </TableStoreContext.Provider>
-  );
-};

package/src/stores/tableStore/index.ts

@@ -1,4 +0,0 @@
-export * from './tableStore';
-export * from './useTableStoreContext';
-export * from './TableStoreContextProvider';
-export * from './TableStoreContext';