@gen-epix/ui 1.14.4 → 1.15.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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