@gen-epix/ui 1.15.0 → 1.15.2

package/src/utils/ObjectUtil/ObjectUtil.test.ts

@@ -1,43 +0,0 @@
-import {
-  describe,
-  it,
-  expect,
-} from 'vitest';
-
-import { ObjectUtil } from './ObjectUtil';
-
-describe('ObjectUtil', () => {
-  describe('getObjectDiff', () => {
-    it('should return the keys that are different between two objects', () => {
-      const obj1 = { a: 1, b: 2, c: 3 };
-      const obj2 = { a: 1, b: 4, d: 5 };
-
-      const diff = ObjectUtil.getObjectDiff(obj1, obj2);
-      expect(diff).toEqual(['b', 'c', 'd']);
-    });
-
-    it('should return an empty array if the objects are equal', () => {
-      const obj1 = { a: 1, b: 2, c: 3 };
-      const obj2 = { a: 1, b: 2, c: 3 };
-
-      const diff = ObjectUtil.getObjectDiff(obj1, obj2);
-      expect(diff).toEqual([]);
-    });
-
-    it('should return all keys if one object is empty', () => {
-      const obj1 = { a: 1, b: 2, c: 3 };
-      const obj2 = {};
-
-      const diff = ObjectUtil.getObjectDiff(obj1, obj2);
-      expect(diff).toEqual(['a', 'b', 'c']);
-    });
-
-    it('should return all keys if the other object is empty', () => {
-      const obj1 = {};
-      const obj2 = { a: 1, b: 2, c: 3 };
-
-      const diff = ObjectUtil.getObjectDiff(obj1, obj2);
-      expect(diff).toEqual(['a', 'b', 'c']);
-    });
-  });
-});

package/src/utils/ObjectUtil/ObjectUtil.ts

@@ -1,28 +0,0 @@
-import isEqual from 'lodash/isEqual';
-
-export class ObjectUtil {
-  public static getObjectDiff(obj1: Record<string, unknown>, obj2: Record<string, unknown>) {
-    const diff = Object.keys(obj2).reduce((result, key) => {
-      if (!Object.prototype.hasOwnProperty.call(obj1, key)) {
-        result.push(key);
-      } else if (isEqual(obj1[key], obj2[key])) {
-        result.splice(result.indexOf(key), 1);
-      }
-      return result;
-    }, Object.keys(obj1));
-    return diff;
-  }
-
-  public static mergeWithUndefined<T extends { [key: string]: unknown }>(obj1: T, obj2: T): T {
-    const final = {
-      ...obj1,
-      ...obj2,
-    };
-    Object.keys(obj2).forEach((key) => {
-      if (obj2[key] === undefined || obj2[key] === null) {
-        delete final[key];
-      }
-    });
-    return final;
-  }
-}

package/src/utils/ObjectUtil/index.ts

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

package/src/utils/OutageUtil/OutageUtil.test.ts

@@ -1,108 +0,0 @@
-import {
-  describe,
-  it,
-  expect,
-  vi,
-  beforeAll,
-  afterAll,
-  afterEach,
-} from 'vitest';
-
-import { ConfigManager } from '../../classes/managers/ConfigManager';
-import type { Config } from '../../models/config';
-
-import { OutageUtil } from './OutageUtil';
-
-describe('OutageUtil', () => {
-  describe('filterOutages', () => {
-    beforeAll(() => {
-      const date = new Date(2020, 5, 1, 10, 0, 0);
-      vi.useFakeTimers();
-      vi.setSystemTime(date);
-      vi.spyOn(ConfigManager.instance, 'config', 'get').mockReturnValue({
-        outages: {
-          NUM_HOURS_TO_SHOW_SOON_ACTIVE_OUTAGES: 8,
-        },
-      } as Config);
-    });
-    afterAll(() => {
-      vi.restoreAllMocks();
-    });
-    afterEach(() => {
-      vi.useRealTimers();
-    });
-    it('should split outages into visibleOutages, activeOutages, and soonActiveOutages', () => {
-
-      // Sample data
-      const outages = [
-        {
-          id: '1',
-          is_active: false,
-          is_visible: false,
-        },
-
-        // Test active
-        {
-          id: '2',
-          is_active: true,
-          is_visible: false,
-        },
-        {
-          id: '3',
-          is_active: false,
-          is_visible: false,
-          active_from: '2020-04-01T00:00:00Z',
-        },
-        {
-          id: '4',
-          is_active: false,
-          is_visible: false,
-          active_from: '2020-04-01T00:00:00Z',
-          active_to: '2020-05-02T00:00:00Z',
-        },
-
-        // Test visible
-        {
-          id: '5',
-          is_active: false,
-          is_visible: true,
-        },
-        {
-          id: '6',
-          is_active: false,
-          is_visible: false,
-          visible_from: '2020-04-01T00:00:00Z',
-        },
-        {
-          id: '7',
-          is_active: false,
-          is_visible: false,
-          visible_from: '2020-04-01T00:00:00Z',
-          visible_to: '2020-05-02T00:00:00Z',
-        },
-
-        // Test soon active
-        {
-          id: '8',
-          is_active: false,
-          is_visible: false,
-          active_from: '2020-06-01T11:00:00Z',
-        },
-      ];
-
-      const { visibleOutages, activeOutages, soonActiveOutages } = OutageUtil.getCategorizedOutages(outages);
-
-      // Assertions
-      expect(visibleOutages).toHaveLength(2);
-      expect(visibleOutages.map(x => x.id)).toContain('5');
-      expect(visibleOutages.map(x => x.id)).toContain('6');
-
-      expect(activeOutages).toHaveLength(2);
-      expect(activeOutages.map(x => x.id)).toContain('2');
-      expect(activeOutages.map(x => x.id)).toContain('3');
-
-      expect(soonActiveOutages).toHaveLength(1);
-      expect(soonActiveOutages[0].id).toBe('8');
-    });
-  });
-});

package/src/utils/OutageUtil/OutageUtil.ts

@@ -1,81 +0,0 @@
-import { addHours } from 'date-fns';
-
-import type { Outage } from '../../api';
-import { ConfigManager } from '../../classes/managers/ConfigManager';
-import type { CategorizedOutages } from '../../models/outage';
-
-export class OutageUtil {
-  public static getCategorizedOutages(outages: Outage[]): CategorizedOutages {
-
-    const activeOutages = outages.filter((outage) => {
-      if (outage.is_active) {
-        return true;
-      }
-      if (outage.active_from || outage.active_to) {
-        const now = new Date();
-        if (outage.active_from && outage.active_to) {
-          return now >= new Date(outage.active_from) && now < new Date(outage.active_to);
-        }
-        if (outage.active_from && now >= new Date(outage.active_from)) {
-          return true;
-        }
-        if (outage.active_to && now < new Date(outage.active_to)) {
-          return true;
-        }
-        return false;
-      }
-    });
-    const activeOutageIds = activeOutages.map((outage) => outage.id);
-
-    const visibleOutages = outages.filter((outage) => {
-      if (activeOutageIds.includes(outage.id)) {
-        return false;
-      }
-      if (outage.is_visible) {
-        return true;
-      }
-      if (outage.visible_from || outage.visible_to) {
-        const now = new Date();
-        if (outage.visible_from && outage.visible_to) {
-          return now >= new Date(outage.visible_from) && now < new Date(outage.visible_to);
-        }
-        if (outage.visible_from && now >= new Date(outage.visible_from)) {
-          return true;
-        }
-        if (outage.visible_to && now < new Date(outage.visible_to)) {
-          return true;
-        }
-        return false;
-      }
-    });
-
-    const soonActiveOutages = outages.filter((outage) => {
-      if (activeOutageIds.includes(outage.id)) {
-        return false;
-      }
-      if (outage.is_active) {
-        return true;
-      }
-      if (outage.active_from || outage.active_to) {
-        const now = new Date();
-        const soon = addHours(now, ConfigManager.instance.config.outages.NUM_HOURS_TO_SHOW_SOON_ACTIVE_OUTAGES);
-        if (outage.active_from && outage.active_to) {
-          return soon >= new Date(outage.active_from) && now < new Date(outage.active_to);
-        }
-        if (outage.active_from && soon >= new Date(outage.active_from)) {
-          return true;
-        }
-        if (outage.active_to && now < new Date(outage.active_to)) {
-          return true;
-        }
-        return false;
-      }
-    });
-
-    return {
-      visibleOutages,
-      activeOutages,
-      soonActiveOutages,
-    };
-  }
-}

package/src/utils/OutageUtil/index.ts

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

package/src/utils/QueryUtil/QueryUtil.test.ts

@@ -1,42 +0,0 @@
-import {
-  describe,
-  it,
-  expect,
-} from 'vitest';
-
-
-import { QueryClientManager } from '../../classes/managers/QueryClientManager';
-import { QUERY_KEY } from '../../models/query';
-
-import { QueryUtil } from './QueryUtil';
-
-describe('QueryUtil', () => {
-  describe('getQueryKeyDependencies', () => {
-    it('should return a collection of keys', () => {
-      expect(QueryUtil.getQueryKeyDependencies([QUERY_KEY.CASES])).toEqual([
-        [QUERY_KEY.CASE_TYPE_STATS],
-        [QUERY_KEY.CASE_SET_STATS],
-        [QUERY_KEY.CASES_LAZY],
-        [QUERY_KEY.PHYLOGENETIC_TREE],
-        [QUERY_KEY.CASE_IDS_BY_QUERY],
-        [QUERY_KEY.CASE_SET_MEMBERS],
-        [QUERY_KEY.XXX_CASE_ID_HAS_CASE_SET],
-        [QUERY_KEY.CASE_DATA_COLLECTION_LINKS],
-        [QUERY_KEY.CASE_RIGHTS],
-      ]);
-    });
-  });
-
-  describe('try invalidating query behavior', () => {
-    it('should invalidate queries', () => {
-      const queryClient = QueryClientManager.instance.queryClient;
-      queryClient.setQueryData(['foo'], 'foo');
-      queryClient.setQueryData(['foo', 'bar'], 'bar');
-      queryClient.removeQueries({
-        queryKey: ['foo'],
-      });
-      expect(queryClient.getQueryData(['foo'])).toBeUndefined();
-      expect(queryClient.getQueryData(['foo', 'bar'])).toBeUndefined();
-    });
-  });
-});

package/src/utils/QueryUtil/QueryUtil.ts

@@ -1,105 +0,0 @@
-import uniq from 'lodash/uniq';
-import remove from 'lodash/remove';
-import uniqBy from 'lodash/uniqBy';
-
-import type {
-  CaseQuery,
-  RetrievePhylogeneticTreeRequestBody,
-} from '../../api';
-import { QueryClientManager } from '../../classes/managers/QueryClientManager';
-import type { GenericData } from '../../models/data';
-import { QUERY_KEY } from '../../models/query';
-import { QUERY_DEPENDENCIES } from '../../data/queryDependencies';
-
-export class QueryUtil {
-  public static getRetrieveCaseIdsByQueryKey(completeCaseTypeId: string, caseQuery: CaseQuery) {
-    const key: string[] = [QUERY_KEY.CASE_IDS_BY_QUERY, completeCaseTypeId, JSON.stringify(caseQuery)];
-    return key;
-  }
-
-  public static getRetrievePhylogeneticTreeKey(requestBody: RetrievePhylogeneticTreeRequestBody) {
-    const key: string[] = [QUERY_KEY.PHYLOGENETIC_TREE, JSON.stringify(requestBody)];
-    return key;
-  }
-
-  public static getUserRegistrationsKey(token: string) {
-    return QueryUtil.getGenericKey(QUERY_KEY.USER_INVITATIONS, token);
-  }
-
-  public static getGenericKey(key: QUERY_KEY, arg?: unknown) {
-    const keyArray: string[] = [key];
-    if (arg) {
-      if (typeof arg === 'string') {
-        keyArray.push(arg);
-      } else {
-        keyArray.push(JSON.stringify(arg));
-      }
-    }
-    return keyArray;
-  }
-
-  public static getQueryKeyDependencies(queryKeys: QUERY_KEY[], includeSelf = false): string[][] {
-    const keys: QUERY_KEY[][] = [];
-
-    queryKeys.forEach(key => {
-      keys.push(...QueryUtil.getQueryKeyDependenciesInternal(key).map(k => [k]));
-      if (includeSelf) {
-        keys.unshift([key]);
-      }
-    });
-    return QueryUtil.getUniqueQueryKeys(keys);
-  }
-
-  private static getQueryKeyDependenciesInternal(key: QUERY_KEY, currentKeys: QUERY_KEY[] = [], originalKey?: QUERY_KEY): QUERY_KEY[] {
-    const keys: QUERY_KEY[] = [...currentKeys];
-    QUERY_DEPENDENCIES[key].forEach(subKey => {
-      if (!keys.includes(subKey)) {
-        keys.push(subKey);
-        keys.push(...QueryUtil.getQueryKeyDependenciesInternal(subKey, [...keys], originalKey ?? key));
-      }
-    });
-    return remove(uniq(keys), x => x !== originalKey);
-  }
-
-  public static async cancelQueries(queryKeys: string[][]) {
-    const queryClient = QueryClientManager.instance.queryClient;
-    for (const queryKey of QueryUtil.getUniqueQueryKeys(queryKeys ?? [])) {
-      await queryClient.cancelQueries({ queryKey });
-    }
-  }
-
-  public static async invalidateQueryKeys(queryKeys: string[][]) {
-    const queryClient = QueryClientManager.instance.queryClient;
-    for (const queryKey of QueryUtil.getUniqueQueryKeys(queryKeys ?? [])) {
-      await queryClient.cancelQueries({ queryKey });
-      await queryClient.invalidateQueries({ queryKey });
-    }
-  }
-
-  public static removeQueries(queryKeys: string[][]) {
-    const queryClient = QueryClientManager.instance.queryClient;
-    for (const queryKey of QueryUtil.getUniqueQueryKeys(queryKeys ?? [])) {
-      queryClient.removeQueries({ queryKey });
-    }
-  }
-
-  public static getUniqueQueryKeys<T>(queryKeys: T[][]): T[][] {
-    return uniqBy(queryKeys, x => x.join('-'));
-  }
-
-  public static getItemFromCache<T extends GenericData>(queryKey: QUERY_KEY, itemId: string): T {
-    const items = QueryUtil.getValidQueryData<T[]>([queryKey]);
-    return items?.find(item => item.id === itemId);
-  }
-
-  public static getValidQueryData<T>(queryKey: string[]): T {
-    const { queryClient, queryCache } = QueryClientManager.instance;
-    const cache = queryCache.find({
-      queryKey,
-    });
-    if (cache?.state?.isInvalidated) {
-      return undefined;
-    }
-    return queryClient.getQueryData<T>(queryKey);
-  }
-}

package/src/utils/QueryUtil/index.ts

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

package/src/utils/StringUtil/StringUtil.test.ts

@@ -1,61 +0,0 @@
-import { StringUtil } from './StringUtil';
-
-describe('StringUtil', () => {
-  describe('clean', () => {
-    it('does not fail', () => {
-      expect(StringUtil.clean(null)).toBeNull();
-      expect(StringUtil.clean('')).toBe('');
-      expect(StringUtil.clean(undefined)).toBe(undefined);
-    });
-    it('returns a cleaned value', () => {
-      expect(StringUtil.clean('A A')).toBe('AA');
-      expect(StringUtil.clean('A💊A')).toBe('AA');
-      expect(StringUtil.clean('!@#$%&*()AA)(*&%$#@!')).toBe('AA');
-      expect(StringUtil.clean('^AA^')).toBe('^AA^');
-      expect(StringUtil.clean('_AA_')).toBe('_AA_');
-    });
-  });
-
-  describe('createUuid', () => {
-    it('returns a unique uuid', () => {
-      const testSize = 100000;
-      const ids: string[] = [];
-      for (let i = 0; i < testSize; i++) {
-        ids.push(StringUtil.createUuid());
-      }
-      expect([...new Set(ids)].length).toBe(testSize);
-    });
-  });
-
-  describe('createHash', () => {
-    it('returns a unique hash', () => {
-      const testSize = 100000;
-      const hashes: string[] = [];
-      for (let i = 0; i < testSize; i++) {
-        hashes.push(StringUtil.createHash(StringUtil.createUuid()));
-      }
-      expect([...new Set(hashes)].length).toBe(testSize);
-      expect(StringUtil.createHash('foo')).toEqual(StringUtil.createHash('foo'));
-      expect(StringUtil.createHash('foo')).not.toEqual(StringUtil.createHash('bar'));
-    });
-  });
-
-  describe('toString', () => {
-    it('converts to string', () => {
-      expect(StringUtil.toString(undefined)).toEqual('');
-      expect(StringUtil.toString(null)).toEqual('');
-      expect(StringUtil.toString('')).toEqual('');
-      expect(StringUtil.toString('foo')).toEqual('foo');
-      expect(StringUtil.toString(1)).toEqual('1');
-    });
-  });
-
-  describe('advancedSortComperator', () => {
-    it('sorts correctly', () => {
-      expect(['Lab2', 'Lab11', 'Lab1'].sort(StringUtil.advancedSortComperator)).toEqual(['Lab1', 'Lab2', 'Lab11']);
-      expect(['A1', 'Lab11', 'Lab1'].sort(StringUtil.advancedSortComperator)).toEqual(['A1', 'Lab1', 'Lab11']);
-      expect(() => [null, undefined, 'Lab11', 'Lab1'].sort(StringUtil.advancedSortComperator)).not.toThrow();
-      expect([null, undefined, 'Lab11', 'Lab1'].sort(StringUtil.advancedSortComperator)).toEqual(['Lab1', 'Lab11', null, undefined]);
-    });
-  });
-});

package/src/utils/StringUtil/StringUtil.ts

@@ -1,91 +0,0 @@
-import { v4 } from 'uuid';
-
-export class StringUtil {
-  public static clean(value: string): string {
-    if (!value) {
-      return value;
-    }
-    return value.replace(/[^\dA-zÀ-ú]/g, '');
-  }
-
-  public static toString(value: string | number): string {
-    if (typeof value === 'number') {
-      return value.toString();
-    }
-    return value ?? '';
-  }
-
-  public static createUuid(): string {
-    return v4();
-  }
-
-  public static createHash(str: string, seed = 0): string {
-    let h1 = 0xdeadbeef ^ seed, h2 = 0x41c6ce57 ^ seed;
-    for (let i = 0, ch; i < str.length; i++) {
-      ch = str.charCodeAt(i);
-      h1 = Math.imul(h1 ^ ch, 2654435761);
-      h2 = Math.imul(h2 ^ ch, 1597334677);
-    }
-    h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507);
-    h1 ^= Math.imul(h2 ^ (h2 >>> 13), 3266489909);
-    h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507);
-    h2 ^= Math.imul(h1 ^ (h1 >>> 13), 3266489909);
-
-    return String(4294967296 * (2097151 & h2) + (h1 >>> 0));
-  }
-
-  public static sortComperator(a: string, b: string): number {
-    return a.localeCompare(b);
-  }
-
-  public static advancedSortComperator(a: string, b: string): number {
-    if (a === b) {
-      return 0;
-    }
-    if (!a) {
-      return 1;
-    }
-    if (!b) {
-      return -1;
-    }
-
-    const regex = /\d+|\D+/g;
-    const aParts = (a || '').match(regex);
-    const bParts = (b || '').match(regex);
-
-    for (let i = 0; i < Math.min(aParts.length, bParts.length); i++) {
-      const aValue = aParts[i];
-      const bValue = bParts[i];
-
-      if (aValue === bValue) {
-        continue;
-      }
-      const isAFinite = isFinite(+aValue);
-      const isBFinite = isFinite(+bValue);
-      if (isAFinite && isBFinite) {
-        return +aValue - +bValue;
-      }
-      if (isAFinite) {
-        return -1;
-      }
-      if (isBFinite) {
-        return 1;
-      }
-      return aValue.localeCompare(bValue);
-    }
-    return aParts.length > bParts.length ? 1 : -1;
-
-  }
-
-  public static createSlug(input: string): string {
-    return input
-      .toString()
-      .normalize('NFD')
-      .replace(/[\u0300-\u036f]/g, '')
-      .toLowerCase()
-      .trim()
-      .replace(/\s+/g, '-')
-      .replace(/[^\w-]+/g, '')
-      .replace(/--+/g, '-');
-  }
-}

package/src/utils/StringUtil/index.ts

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