@gen-epix/ui 1.15.1 → 1.15.2

package/src/utils/CaseUtil/CaseUtil.ts

@@ -1,401 +0,0 @@
-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

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

package/src/utils/DashboardUtil/DashboardUtil.ts

@@ -1,46 +0,0 @@
-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

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

package/src/utils/DataHookUtil/DataHookUtil.ts

@@ -1,137 +0,0 @@
-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

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

package/src/utils/DataSetUtil/DataSetUtil.ts

@@ -1,70 +0,0 @@
-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

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