@gen-epix/ui 1.14.4 → 1.15.0

package/src/utils/CaseUtil/CaseUtil.ts

@@ -0,0 +1,401 @@
+import { isValid } from 'date-fns';
+import { t } from 'i18next';
+import type { ObjectSchema } from 'yup';
+import {
+  object,
+  string,
+} from 'yup';
+import type { UseQueryResult } from '@tanstack/react-query';
+import difference from 'lodash/difference';
+import intersection from 'lodash/intersection';
+
+import { CaseTypeUtil } from '../CaseTypeUtil';
+import { AbacUtil } from '../AbacUtil';
+import { QueryUtil } from '../QueryUtil';
+import type {
+  CaseDataCollectionLink,
+  CompleteCaseType,
+  Organization,
+  Case,
+  Col,
+  RefCol,
+} from '../../api';
+import {
+  CaseApi,
+  ColType,
+} from '../../api';
+import { ConfigManager } from '../../classes/managers/ConfigManager';
+import { NotificationManager } from '../../classes/managers/NotificationManager';
+import type { CaseTypeRowValue } from '../../models/epi';
+import type { FormFieldDefinition } from '../../models/form';
+import { FORM_FIELD_DEFINITION_TYPE } from '../../models/form';
+import { QUERY_KEY } from '../../models/query';
+import { EpiDataManager } from '../../classes/managers/EpiDataManager';
+
+export class CaseUtil {
+  public static async applyDataCollectionLinks(kwArgs: { caseSetId?: string; caseSetDataCollectionIds: string[]; caseIds?: string[]; caseTypeId: string }): Promise<void> {
+    const { caseSetId, caseSetDataCollectionIds, caseIds, caseTypeId } = kwArgs;
+
+    if (!caseSetId && !caseIds) {
+      throw new Error('Either caseSetId or caseIds must be provided');
+    }
+
+    const notificationKey = NotificationManager.instance.showNotification({
+      message: t('Applying sharing to the cases'),
+      isLoading: true,
+      severity: 'info',
+    });
+
+    try {
+      if (!caseSetDataCollectionIds.length) {
+        NotificationManager.instance.fulfillNotification(notificationKey, t('Sharing has not been applied to the cases because the event is not shared.'), 'info');
+      }
+
+      let normalizedCaseIds: string[] = [];
+      if (caseIds) {
+        normalizedCaseIds = caseIds;
+      } else {
+        normalizedCaseIds = (await CaseApi.instance.caseSetMembersPostQuery({
+          invert: false,
+          key: 'case_set_id',
+          type: 'UUID_SET',
+          members: [caseSetId],
+        })).data.map(x => x.case_id);
+      }
+
+      if (!normalizedCaseIds.length) {
+        NotificationManager.instance.fulfillNotification(notificationKey, t('Sharing has not been applied to the cases because there are no cases in the event.'), 'info');
+      }
+
+      const dataLinksToAdd: CaseDataCollectionLink[] = [];
+      const caseRights = (await CaseApi.instance.retrieveCaseRights({
+        case_ids: normalizedCaseIds,
+        case_type_id: caseTypeId,
+      })).data;
+
+      caseRights.forEach((caseRight) => {
+        const caseId = caseRight.case_id;
+        const caseMissingDataCollectionIds = difference(caseSetDataCollectionIds, caseRight.shared_in_data_collection_ids);
+        if (!caseMissingDataCollectionIds.length) {
+          return;
+        }
+
+        (caseRight.is_full_access ? caseMissingDataCollectionIds : intersection(caseRight.add_data_collection_ids, caseSetDataCollectionIds)).forEach((dataCollectionId) => {
+          const dataLink: CaseDataCollectionLink = {
+            case_id: caseId,
+            data_collection_id: dataCollectionId,
+          };
+          dataLinksToAdd.push(dataLink);
+        });
+      });
+
+      if (!dataLinksToAdd.length) {
+        NotificationManager.instance.fulfillNotification(notificationKey, t('Sharing has not been applied to the cases because sharing has already been applied.'), 'info');
+        return;
+      }
+
+      // Batch add the data collection links
+      await CaseApi.instance.caseDataCollectionLinksPostSome(dataLinksToAdd);
+      await QueryUtil.invalidateQueryKeys(QueryUtil.getQueryKeyDependencies([QUERY_KEY.CASE_DATA_COLLECTION_LINKS], true));
+      NotificationManager.instance.fulfillNotification(notificationKey, t('Sharing has been applied to the cases'), 'success');
+
+    } catch (_error) {
+      NotificationManager.instance.fulfillNotification(notificationKey, t('Sharing could not be applied to selected cases due to an error.'), 'error');
+    }
+  }
+
+  public static createFormFieldDefinitions(completeCaseType: CompleteCaseType, organizationsQueryResult: UseQueryResult<Organization[]>): FormFieldDefinition<Case['content']>[] {
+    const cols = CaseTypeUtil.getCols(completeCaseType);
+    const effectiveColumnAccessRights = AbacUtil.createEffectieveColumnAccessRights(Object.values(completeCaseType.case_type_access_abacs));
+    return cols.reduce((acc, col) => {
+      const hasAccess = effectiveColumnAccessRights.get(col.id)?.write;
+      if (!hasAccess) {
+        return acc;
+      }
+
+      const refCol = completeCaseType.ref_cols[col.ref_col_id];
+      switch (refCol.col_type) {
+        case ColType.TEXT:
+        case ColType.ID_SAMPLE:
+        case ColType.ID_CASE:
+        case ColType.ID_EVENT:
+        case ColType.ID_GENETIC_SEQUENCE:
+        case ColType.ID_PERSON:
+        case ColType.TIME_WEEK:
+        case ColType.TIME_MONTH:
+        case ColType.TIME_QUARTER:
+        case ColType.TIME_YEAR:
+        case ColType.DECIMAL_0:
+        case ColType.DECIMAL_1:
+        case ColType.DECIMAL_2:
+        case ColType.DECIMAL_3:
+        case ColType.DECIMAL_4:
+        case ColType.DECIMAL_5:
+        case ColType.DECIMAL_6:
+          acc.push({
+            definition: FORM_FIELD_DEFINITION_TYPE.TEXTFIELD,
+            name: col.id,
+            label: col.label,
+          } as const satisfies FormFieldDefinition<Case['content']>);
+          break;
+        case ColType.REGULAR_LANGUAGE:
+          try {
+            new RegExp(col.pattern);
+            acc.push({
+              definition: FORM_FIELD_DEFINITION_TYPE.TEXTFIELD,
+              name: col.id,
+              label: col.label,
+            } as const satisfies FormFieldDefinition<Case['content']>);
+          } catch (_error) {
+            acc.push({
+              definition: FORM_FIELD_DEFINITION_TYPE.TEXTFIELD,
+              name: col.id,
+              label: col.label,
+              warningMessage: t`Unable to parse regular expression. You may enter text, but it's not guaranteed to be valid.`,
+            } as const satisfies FormFieldDefinition<Case['content']>);
+          }
+          break;
+        case ColType.NOMINAL:
+        case ColType.ORDINAL:
+        case ColType.INTERVAL:
+          if (EpiDataManager.instance.data.conceptsBySetId[refCol.concept_set_id]) {
+            acc.push({
+              definition: FORM_FIELD_DEFINITION_TYPE.AUTOCOMPLETE,
+              name: col.id,
+              label: col.label,
+              options: EpiDataManager.instance.data.conceptsBySetId[refCol.concept_set_id].map(concept => ({
+                value: concept.id,
+                label: concept.name,
+              })),
+            } as const satisfies FormFieldDefinition<Case['content']>);
+          }
+          break;
+        case ColType.GEO_REGION:
+          if (EpiDataManager.instance.data.regionsByRegionSetId[refCol.region_set_id]) {
+            acc.push({
+              definition: FORM_FIELD_DEFINITION_TYPE.AUTOCOMPLETE,
+              name: col.id,
+              label: col.label,
+              options: EpiDataManager.instance.data.regionsByRegionSetId[refCol.region_set_id].map(region => ({
+                value: region.id,
+                label: EpiDataManager.instance.data.regionSets[refCol.region_set_id].region_code_as_label ? region.code : region.name,
+              })),
+            } as const satisfies FormFieldDefinition<Case['content']>);
+          }
+          break;
+        case ColType.ORGANIZATION:
+          acc.push({
+            definition: FORM_FIELD_DEFINITION_TYPE.AUTOCOMPLETE,
+            name: col.id,
+            label: col.label,
+            loading: organizationsQueryResult.isLoading,
+            options: (organizationsQueryResult.data ?? []).map(organization => ({
+              value: organization.id,
+              label: organization.name,
+            })),
+          } as const satisfies FormFieldDefinition<Case['content']>);
+          break;
+        default:
+          break;
+      }
+
+      return acc;
+    }, [] as FormFieldDefinition<Case['content']>[]);
+  }
+
+  public static createYupSchema(completeCaseType: CompleteCaseType): ObjectSchema<{ [key: string]: string }> {
+    const effectiveColumnAccessRights = AbacUtil.createEffectieveColumnAccessRights(Object.values(completeCaseType.case_type_access_abacs));
+
+    return CaseTypeUtil.getCols(completeCaseType).reduce((s, col) => {
+      const hasAccess = effectiveColumnAccessRights.get(col.id)?.write;
+      if (!hasAccess) {
+        return s;
+      }
+
+      const refCol = completeCaseType.ref_cols[col.ref_col_id];
+      switch (refCol.col_type) {
+        case ColType.TEXT:
+          return s.concat(object().shape({
+            [col.id]: string().nullable().extendedAlphaNumeric().max(65535).transform((_val: unknown, orig: string) => orig || null),
+          }));
+        case ColType.ID_SAMPLE:
+        case ColType.ID_CASE:
+        case ColType.ID_EVENT:
+        case ColType.ID_GENETIC_SEQUENCE:
+        case ColType.ID_PERSON:
+          return s.concat(object().shape({
+            [col.id]: string().nullable().extendedAlphaNumeric().max(255).transform((_val: unknown, orig: string) => orig || null),
+          }));
+        case ColType.NOMINAL:
+        case ColType.ORDINAL:
+        case ColType.INTERVAL:
+        case ColType.GEO_REGION:
+        case ColType.ORGANIZATION:
+          return s.concat(object().shape({
+            [col.id]: string().nullable().uuid4().transform((_val: unknown, orig: string) => orig || null),
+          }));
+        case ColType.GEO_LATLON:
+          return s.concat(object().shape({
+            [col.id]: string().nullable().latLong().transform((_val: unknown, orig: string) => orig || null),
+          }));
+        case ColType.DECIMAL_0:
+          return s.concat(object().shape({
+            [col.id]: string().nullable().decimal0().transform((_val: unknown, orig: string) => orig || null),
+          }));
+        case ColType.DECIMAL_1:
+          return s.concat(object().shape({
+            [col.id]: string().nullable().decimal1().transform((_val: unknown, orig: string) => orig ?? null),
+          }));
+        case ColType.DECIMAL_2:
+          return s.concat(object().shape({
+            [col.id]: string().nullable().decimal2().transform((_val: unknown, orig: string) => orig ?? null),
+          }));
+        case ColType.DECIMAL_3:
+          return s.concat(object().shape({
+            [col.id]: string().nullable().decimal3().transform((_val: unknown, orig: string) => orig ?? null),
+          }));
+        case ColType.DECIMAL_4:
+          return s.concat(object().shape({
+            [col.id]: string().nullable().decimal4().transform((_val: unknown, orig: string) => orig ?? null),
+          }));
+        case ColType.DECIMAL_5:
+          return s.concat(object().shape({
+            [col.id]: string().nullable().decimal5().transform((_val: unknown, orig: string) => orig ?? null),
+          }));
+        case ColType.DECIMAL_6:
+          return s.concat(object().shape({
+            [col.id]: string().nullable().decimal6().transform((_val: unknown, orig: string) => orig ?? null),
+          }));
+        case ColType.TIME_DAY:
+          return s.concat(object().shape({
+            [col.id]: string().nullable().transform((_val: unknown, orig: Date) => isValid(orig) ? orig.toISOString() : null),
+          }));
+        case ColType.TIME_WEEK:
+          return s.concat(object().shape({
+            [col.id]: string().nullable().timeWeek().transform((_val: unknown, orig: string) => orig || null),
+          }));
+        case ColType.TIME_MONTH:
+          return s.concat(object().shape({
+            [col.id]: string().nullable().timeMonth().transform((_val: unknown, orig: string) => orig || null),
+          }));
+        case ColType.TIME_QUARTER:
+          return s.concat(object().shape({
+            [col.id]: string().nullable().timeQuarter().transform((_val: unknown, orig: string) => orig || null),
+          }));
+        case ColType.TIME_YEAR:
+          return s.concat(object().shape({
+            [col.id]: string().nullable().timeYear().transform((_val: unknown, orig: string) => orig || null),
+          }));
+        case ColType.REGULAR_LANGUAGE:
+          try {
+            return s.concat(object().shape({
+              [col.id]: string().nullable().matches(new RegExp(col.pattern), t('Invalid value for pattern "{{pattern}}"', { pattern: col.pattern })),
+            })).transform((_val: unknown, orig: string) => orig || null);
+          } catch (_error) {
+            return s.concat(object().shape({
+              [col.id]: string().nullable().max(col.max_length ?? 65535),
+            })).transform((_val: unknown, orig: string) => orig || null);
+          }
+        case ColType.GENETIC_SEQUENCE:
+        case ColType.GENETIC_DISTANCE:
+          return s;
+        default:
+          console.error(`Unknown column type: ${refCol.col_type}`);
+          return s;
+      }
+    }, object({}));
+  }
+
+  public static getRowValue(content: { [key: string]: string }, col: Col, completeCaseType: CompleteCaseType, machineReadable = false): CaseTypeRowValue {
+    const refCol = completeCaseType.ref_cols[col.ref_col_id];
+    const hasMappedValue = refCol.col_type === ColType.ORGANIZATION || refCol.region_set_id || refCol.concept_set_id;
+    if (hasMappedValue) {
+      return CaseUtil.getMappedValue(content[col.id], col, completeCaseType, machineReadable);
+    }
+
+    const { DATA_MISSING_CHARACTER } = ConfigManager.instance.config.epi;
+    const dataMissingCharacter = machineReadable ? '' : DATA_MISSING_CHARACTER;
+
+    const rowValue: CaseTypeRowValue = {
+      raw: content?.[col.id],
+      isMissing: !content[col.id],
+      short: content[col.id] ?? dataMissingCharacter,
+      long: content[col.id] ?? dataMissingCharacter,
+      full: content[col.id] ?? t('{{dataMissingCharacter}} (missing)', { dataMissingCharacter }),
+    };
+    return rowValue;
+  }
+
+  public static getMissingRowValue(raw: string, machineReadable = true): CaseTypeRowValue {
+    const { DATA_MISSING_CHARACTER } = ConfigManager.instance.config.epi;
+    const dataMissingCharacter = machineReadable ? '' : DATA_MISSING_CHARACTER;
+
+    return {
+      raw,
+      isMissing: true,
+      full: t('{{dataMissingCharacter}} (missing)', { dataMissingCharacter }),
+      long: dataMissingCharacter,
+      short: dataMissingCharacter,
+    };
+  }
+
+  public static getMappedValue(raw: string, col: Col, completeCaseType: CompleteCaseType, machineReadable = false): CaseTypeRowValue {
+    if (!raw) {
+      return CaseUtil.getMissingRowValue(raw, machineReadable);
+    }
+
+    const refCol = completeCaseType.ref_cols[col.ref_col_id];
+
+    if (refCol.col_type === ColType.ORGANIZATION) {
+      return CaseUtil.getOrganizationMappedValue(raw);
+    } else if (refCol.region_set_id) {
+      return CaseUtil.getRegionMappedValue(refCol, raw);
+    } else if (refCol.concept_set_id) {
+      return CaseUtil.getConceptMappedValue(raw);
+    }
+    return CaseUtil.getMissingRowValue(raw, machineReadable);
+  }
+
+  private static getOrganizationMappedValue(raw: string): CaseTypeRowValue {
+    const organization = EpiDataManager.instance.data?.organizationsById?.[raw];
+    if (!organization) {
+      return CaseUtil.getMissingRowValue(raw);
+    }
+    return {
+      raw,
+      isMissing: false,
+      short: organization.name,
+      long: organization.name,
+      full: organization.name,
+    };
+  }
+
+  private static getRegionMappedValue(refCol: RefCol, raw: string): CaseTypeRowValue {
+    const regionSet = EpiDataManager.instance.data.regionSets[refCol.region_set_id];
+    const region = EpiDataManager.instance.data.regionsById?.[raw];
+    if (!region) {
+      return CaseUtil.getMissingRowValue(raw);
+    }
+    return {
+      raw,
+      isMissing: false,
+      full: regionSet.region_code_as_label ? region.code : region.name,
+      long: regionSet.region_code_as_label ? region.code : region.name,
+      short: regionSet.region_code_as_label ? region.code : region.name,
+    };
+  }
+
+  private static getConceptMappedValue(raw: string): CaseTypeRowValue {
+    const concept = EpiDataManager.instance.data.conceptsById?.[raw];
+    if (!concept) {
+      return CaseUtil.getMissingRowValue(raw);
+    }
+    return {
+      raw,
+      isMissing: false,
+      full: `${concept.code} (${concept.name})`,
+      short: concept.code,
+      long: concept.name,
+    };
+  }
+}

package/src/utils/CaseUtil/index.ts

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

package/src/utils/DashboardUtil/DashboardUtil.ts

@@ -0,0 +1,46 @@
+import intersection from 'lodash/intersection';
+
+import { ConfigManager } from '../../classes/managers/ConfigManager';
+import type {
+  EpiDashboardLayoutUserConfig,
+  EpiDashboardLayoutConfig,
+  EpiDashboardLayout,
+} from '../../models/epi';
+import { EPI_ZONE } from '../../models/epi';
+
+
+export class DashboardUtil {
+  public static readonly dashboardLayoutStorageKey = 'GENEPIX-EpiDashboard-Layout-v1.3';
+
+  public static isSingleWidget(userConfig: EpiDashboardLayoutUserConfig, zone: EPI_ZONE): boolean {
+    const enabledZones = DashboardUtil.getEnabledZones(userConfig);
+    return enabledZones.length === 1 && enabledZones[0] === zone;
+  }
+
+  public static getEnabledZones(userConfig: EpiDashboardLayoutUserConfig): EPI_ZONE[] {
+    return Object.entries(userConfig.zones).filter(([_name, value]) => value).map(([name]) => name) as EPI_ZONE[];
+  }
+
+  public static getDashboardLayoutConfig(userConfig: EpiDashboardLayoutUserConfig): EpiDashboardLayoutConfig {
+    const enabledZones = DashboardUtil.getEnabledZones(userConfig);
+    return ConfigManager.instance.config.epiDashboard.LAYOUTS.find(epiDashboardLayout => epiDashboardLayout.zones.length === enabledZones.length && intersection(enabledZones, epiDashboardLayout.zones).length === enabledZones.length);
+  }
+
+  public static getDashboardLayout(userConfig: EpiDashboardLayoutUserConfig): EpiDashboardLayout {
+    const layoutConfig = DashboardUtil.getDashboardLayoutConfig(userConfig);
+
+    return layoutConfig?.layouts?.[userConfig.arrangement] ?? layoutConfig?.layouts?.[0];
+  }
+
+  public static createDashboardLayoutUserConfigInitialState(): EpiDashboardLayoutUserConfig {
+    return {
+      arrangement: 0,
+      zones: {
+        [EPI_ZONE.EPI_CURVE]: true,
+        [EPI_ZONE.LINE_LIST]: true,
+        [EPI_ZONE.MAP]: true,
+        [EPI_ZONE.TREE]: true,
+      },
+    };
+  }
+}

package/src/utils/DashboardUtil/index.ts

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

package/src/utils/DataHookUtil/DataHookUtil.ts

@@ -0,0 +1,137 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+
+import type {
+  Loadable,
+  UseMap,
+  UseOptions,
+  UseNameFactory,
+} from '../../models/dataHooks';
+import { StringUtil } from '../StringUtil';
+
+export class DataHookUtil {
+  private static isResponse<TValue>(response: unknown): response is UseQueryResult<TValue> {
+    if (!response) {
+      return false;
+    }
+    if (typeof response !== 'object') {
+      return false;
+    }
+    if (!('isLoading' in response)) {
+      return false;
+    }
+    return true;
+  }
+
+  public static createUseMapDataHook<TValue>(
+    response: UseQueryResult<TValue[]> | TValue[],
+    getId: (item: TValue) => string,
+    loadables: Loadable[] = [],
+  ): UseMap<TValue> {
+    if (DataHookUtil.isResponse(response) && response.error) {
+      return {
+        isLoading: false,
+        error: response.error,
+        map: new Map(),
+      };
+    }
+    if (loadables?.some(obj => obj.error)) {
+      return {
+        isLoading: false,
+        error: loadables.find(obj => obj.error).error,
+        map: new Map(),
+      };
+    }
+
+    const isLoadings = [DataHookUtil.isResponse(response) ? (response.isLoading || response.isPending || response.isFetching) : false];
+    if (loadables) {
+      isLoadings.push(...loadables.map(obj => obj.isLoading));
+    }
+    const isLoading = isLoadings.some(x => x);
+    let map: Map<string, TValue> = new Map();
+    if (!isLoading) {
+      const items = DataHookUtil.isResponse(response) ? response.data : response;
+      map = new Map(items?.map(item => [getId(item), item]));
+    }
+
+    return {
+      isLoading,
+      map,
+      error: null,
+    };
+  }
+
+  public static createUseOptionsDataHook<TValue>(
+    response: UseQueryResult<TValue[]> | TValue[],
+    getId: (item: TValue) => string,
+    createLabel: (item: TValue) => string,
+    loadables?: Loadable[],
+    sortComperator?: (a: string, b: string) => number,
+  ): UseOptions<string> {
+    if (DataHookUtil.isResponse(response) && response.error) {
+      return {
+        isLoading: false,
+        error: response.error,
+        options: [],
+      };
+    }
+    if (loadables?.some(obj => obj.error)) {
+      return {
+        isLoading: false,
+        error: loadables.find(obj => obj.error).error,
+        options: [],
+      };
+    }
+
+    const isLoading = [
+      DataHookUtil.isResponse(response) ? (response.isLoading || response.isPending) : false,
+      ...loadables?.map(obj => obj.isLoading) ?? [],
+    ].some(Boolean);
+    const sort = sortComperator ?? StringUtil.sortComperator;
+
+    let options: {
+      value: string;
+      label: string;
+    }[] = [];
+    if (!isLoading) {
+      const items = DataHookUtil.isResponse(response) ? response.data : response;
+      options = items?.map(item => ({ value: getId(item), label: createLabel(item) })).sort((a, b) => {
+        return sort(a.label, b.label);
+      }) ?? [];
+    }
+
+    return {
+      isLoading,
+      options,
+      error: null,
+    };
+  }
+
+  public static createUseNameFactoryHook<TValue>(
+    getName: (item: TValue) => string,
+    loadables?: Loadable[],
+  ): UseNameFactory<TValue> {
+    if (loadables?.some(obj => obj.error)) {
+      return {
+        isLoading: false,
+        error: loadables.find(obj => obj.error).error,
+        getName,
+      };
+    }
+
+    const isLoading = loadables ? loadables.some(obj => obj.isLoading) : false;
+    if (isLoading) {
+      return {
+        isLoading,
+        error: null,
+        getName: () => '',
+      };
+    }
+
+    return {
+      isLoading,
+      error: null,
+      getName,
+    };
+
+  }
+}

package/src/utils/DataHookUtil/index.ts

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

package/src/utils/DataSetUtil/DataSetUtil.ts

@@ -0,0 +1,70 @@
+import intersection from 'lodash/intersection';
+
+export class DataSetUtil {
+  public static getMappedSetMembers<T>(kwArgs: { items: T[]; setProperty: keyof T & string; memberProperty: keyof T & string }): Map<string, string[]> {
+    const { items, setProperty, memberProperty } = kwArgs;
+    const mappedSets = new Map<string, string[]>();
+    items.forEach(member => {
+      if (!mappedSets.has(member[setProperty] as string)) {
+        mappedSets.set(member[setProperty] as string, []);
+      }
+      mappedSets.get(member[setProperty] as string)?.push(member[memberProperty] as string);
+    });
+    return mappedSets;
+  }
+
+  public static getCategorizedSetMembers(kwArgs: { mappedSetMembers: Map<string, string[]>; parentSetId: string; parentMemberIds: string[]; childMemberIds: string[] }): { setIds: string[]; categorizedMemberIds: string[]; uncategorizedMemberIds: string[] } {
+    const { mappedSetMembers, parentSetId, parentMemberIds, childMemberIds } = kwArgs;
+    const intersectedMemberIds = intersection(parentMemberIds, childMemberIds);
+    let uncategorizedMemberIds: string[] = [];
+    const categorizedMemberIds: string[] = [];
+
+    const setIds: string[] = [];
+    if (intersectedMemberIds.length) {
+      if (intersectedMemberIds.length === parentMemberIds.length && intersectedMemberIds.length === childMemberIds.length) {
+        // all members are in the parent set and child set, so we can use the parent set id (optimization)
+        setIds.push(parentSetId);
+        categorizedMemberIds.push(...intersectedMemberIds);
+      } else {
+        mappedSetMembers.forEach((memberIds, setId) => {
+          const setIntersectedMemberIds = intersection(memberIds, intersectedMemberIds);
+          if (setIntersectedMemberIds.length === memberIds.length) {
+            setIds.push(setId);
+            categorizedMemberIds.push(...setIntersectedMemberIds);
+          }
+        });
+        uncategorizedMemberIds = intersectedMemberIds.filter(id => !categorizedMemberIds.includes(id));
+      }
+    }
+
+    // sanitize setIds (remove duplicates, larger sets containing smaller sets)
+    const sanitizedSetIds: string[] = [];
+    if (setIds.length <= 1) {
+      sanitizedSetIds.push(...setIds);
+    } else {
+      const sortedSetsIdsBySize = Array.from(mappedSetMembers.entries()).filter(([setId]) => setIds.includes(setId)).sort((a, b) => b[1].length - a[1].length).map(x => x[0]);
+      setIds.forEach(setId => {
+        const setIdIndex = sortedSetsIdsBySize.indexOf(setId);
+        for (let i = 0; i < setIdIndex; i++) {
+          const otherSetId = sortedSetsIdsBySize[i];
+          if (mappedSetMembers.get(otherSetId)?.length && mappedSetMembers.get(setId)?.length) {
+            const otherSetMemberIds = mappedSetMembers.get(otherSetId) || [];
+            const setMemberIds = mappedSetMembers.get(setId) || [];
+            if (intersection(otherSetMemberIds, setMemberIds).length === setMemberIds.length) {
+              // other set contains current set, do not add current set
+              return;
+            }
+          }
+        }
+        sanitizedSetIds.push(setId);
+      });
+    }
+
+    return {
+      setIds: sanitizedSetIds,
+      uncategorizedMemberIds,
+      categorizedMemberIds,
+    };
+
+  }
+}

package/src/utils/DataSetUtil/index.ts

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