@orchestrator-ui/orchestrator-ui-components 7.4.1 → 7.5.1

package/src/utils/date.spec.ts

@@ -1,191 +1,154 @@
 import {
-    calculateTimeDifference,
-    getCurrentBrowserLocale,
-    parseDate,
-    parseDateOrTimeRelativeToToday,
-    parseDateRelativeToToday,
-    parseDateToLocaleDateTimeString,
-    parseIsoString,
+  calculateTimeDifference,
+  getCurrentBrowserLocale,
+  parseDate,
+  parseDateOrTimeRelativeToToday,
+  parseDateRelativeToToday,
+  parseDateToLocaleDateTimeString,
+  parseIsoString,
 } from './date';
 
 const testDateIsoString = '2023-04-27T10:00:00.000Z';
 const testDate = new Date(testDateIsoString);
 const testDateEpoch = testDate.valueOf();
-const testDateDateString = testDate.toLocaleDateString(
-    getCurrentBrowserLocale(),
-);
-const testDateTimeString = testDate.toLocaleTimeString(
-    getCurrentBrowserLocale(),
-);
+const testDateDateString = testDate.toLocaleDateString(getCurrentBrowserLocale());
+const testDateTimeString = testDate.toLocaleTimeString(getCurrentBrowserLocale());
 
 describe('date', () => {
-    describe('parseDate()', () => {
-        it('returns null if the date is null', () => {
-            const result = parseDate(null);
-            expect(result).toBeNull();
-        });
-        it('returns null if the date is undefined', () => {
-            const result = parseDate(undefined);
-            expect(result).toBeNull();
-        });
-
-        it('returns null if the date is an empty string', () => {
-            const result = parseDate('');
-            expect(result).toBeNull();
-        });
-
-        it('returns a date object if the date is a valid date string', () => {
-            const result = parseDate('2022-01-02');
-
-            expect(result).toBeInstanceOf(Date);
-        });
-    });
-    describe('parseDateTimeToLocaleString()', () => {
-        it('returns an empty string if the date is null', () => {
-            const result = parseDateToLocaleDateTimeString(null);
-            expect(result).toEqual('');
-        });
-
-        it('returns a date string if the date is a valid date string', () => {
-            const testDate = new Date('2022-01-02');
-
-            const result = parseDateToLocaleDateTimeString(testDate);
-
-            expect(result).toContain('1/2/2022');
-        });
-    });
-
-    describe('parseDateRelativeToToday()', () => {
-        it('returns an empty string if the date is null', () => {
-            const result = parseDateRelativeToToday(null);
-            expect(result).toEqual('');
-        });
-        it('returns only time when date is today', () => {
-            const now = new Date();
-
-            const result = parseDateRelativeToToday(now);
-
-            const expectedResult = now.toLocaleTimeString(
-                getCurrentBrowserLocale(),
-            );
-            expect(result).toEqual(expectedResult);
-        });
-        it('returns date and time when date is not today', () => {
-            const result = parseDateRelativeToToday(testDate);
-
-            const expectedDateTime = `${testDateDateString}, ${testDateTimeString}`;
-            expect(result).toEqual(expectedDateTime);
-        });
-    });
-
-    describe('parseDateOrTimeRelativeToToday()', () => {
-        it('returns time only when date is today', () => {
-            const now = new Date();
-
-            const result = parseDateOrTimeRelativeToToday(now);
-
-            const expectedResult = now.toLocaleTimeString(
-                getCurrentBrowserLocale(),
-            );
-            expect(result).toEqual(expectedResult);
-        });
-        it('returns only the date when that date is not today', () => {
-            const result = parseDateOrTimeRelativeToToday(testDate);
-
-            expect(result).toEqual(testDateDateString);
-        });
-        it('returns date only when date is not today and requesting "short notation"', () => {
-            const result = parseDateOrTimeRelativeToToday(testDate);
-
-            expect(result).toEqual(testDateDateString);
-        });
-    });
-
-    describe('calculateTimeDifference()', () => {
-        it('returns message with one of the dates missing', () => {
-            expect(calculateTimeDifference('', '')).toEqual('');
-        });
-
-        it('returns appropriate string if the times are the same', () => {
-            expect(
-                calculateTimeDifference(testDateIsoString, testDateIsoString),
-            ).toEqual('00:00:00');
-        });
-
-        it('returns appropriate string if the timedifference is 1 second', () => {
-            const laterTestDateIsoString = new Date(
-                testDateEpoch + 1000,
-            ).toISOString();
-
-            const result = calculateTimeDifference(
-                testDateIsoString,
-                laterTestDateIsoString,
-            );
-
-            expect(result).toEqual('00:00:01');
-        });
-        it('returns appropriate string if the timedifference is 1 minute', () => {
-            const laterTestDateIsoString = new Date(
-                testDateEpoch + 60000 + 1000,
-            ).toISOString();
-
-            const result = calculateTimeDifference(
-                testDateIsoString,
-                laterTestDateIsoString,
-            );
+  describe('parseDate()', () => {
+    it('returns null if the date is null', () => {
+      const result = parseDate(null);
+      expect(result).toBeNull();
+    });
+    it('returns null if the date is undefined', () => {
+      const result = parseDate(undefined);
+      expect(result).toBeNull();
+    });
+
+    it('returns null if the date is an empty string', () => {
+      const result = parseDate('');
+      expect(result).toBeNull();
+    });
+
+    it('returns a date object if the date is a valid date string', () => {
+      const result = parseDate('2022-01-02');
+
+      expect(result).toBeInstanceOf(Date);
+    });
+  });
+  describe('parseDateTimeToLocaleString()', () => {
+    it('returns an empty string if the date is null', () => {
+      const result = parseDateToLocaleDateTimeString(null);
+      expect(result).toEqual('');
+    });
+
+    it('returns a date string if the date is a valid date string', () => {
+      const testDate = new Date('2022-01-02');
+
+      const result = parseDateToLocaleDateTimeString(testDate);
+
+      expect(result).toContain('1/2/2022');
+    });
+  });
+
+  describe('parseDateRelativeToToday()', () => {
+    it('returns an empty string if the date is null', () => {
+      const result = parseDateRelativeToToday(null);
+      expect(result).toEqual('');
+    });
+    it('returns only time when date is today', () => {
+      const now = new Date();
+
+      const result = parseDateRelativeToToday(now);
+
+      const expectedResult = now.toLocaleTimeString(getCurrentBrowserLocale());
+      expect(result).toEqual(expectedResult);
+    });
+    it('returns date and time when date is not today', () => {
+      const result = parseDateRelativeToToday(testDate);
+
+      const expectedDateTime = `${testDateDateString}, ${testDateTimeString}`;
+      expect(result).toEqual(expectedDateTime);
+    });
+  });
+
+  describe('parseDateOrTimeRelativeToToday()', () => {
+    it('returns time only when date is today', () => {
+      const now = new Date();
+
+      const result = parseDateOrTimeRelativeToToday(now);
+
+      const expectedResult = now.toLocaleTimeString(getCurrentBrowserLocale());
+      expect(result).toEqual(expectedResult);
+    });
+    it('returns only the date when that date is not today', () => {
+      const result = parseDateOrTimeRelativeToToday(testDate);
+
+      expect(result).toEqual(testDateDateString);
+    });
+    it('returns date only when date is not today and requesting "short notation"', () => {
+      const result = parseDateOrTimeRelativeToToday(testDate);
+
+      expect(result).toEqual(testDateDateString);
+    });
+  });
+
+  describe('calculateTimeDifference()', () => {
+    it('returns message with one of the dates missing', () => {
+      expect(calculateTimeDifference('', '')).toEqual('');
+    });
+
+    it('returns appropriate string if the times are the same', () => {
+      expect(calculateTimeDifference(testDateIsoString, testDateIsoString)).toEqual('00:00:00');
+    });
+
+    it('returns appropriate string if the timedifference is 1 second', () => {
+      const laterTestDateIsoString = new Date(testDateEpoch + 1000).toISOString();
+
+      const result = calculateTimeDifference(testDateIsoString, laterTestDateIsoString);
+
+      expect(result).toEqual('00:00:01');
+    });
+    it('returns appropriate string if the timedifference is 1 minute', () => {
+      const laterTestDateIsoString = new Date(testDateEpoch + 60000 + 1000).toISOString();
+
+      const result = calculateTimeDifference(testDateIsoString, laterTestDateIsoString);
+
+      expect(result).toEqual('00:01:01');
+    });
+    it('returns appropriate string if the timedifference is 1 hour', () => {
+      const laterTestDateIsoString = new Date(testDateEpoch + 3600000 + 60000 + 1000).toISOString();
+
+      const result = calculateTimeDifference(testDateIsoString, laterTestDateIsoString);
+
+      expect(result).toEqual('01:01:01');
+    });
+
+    it('returns appropriate string if the timedifference is 10 hour', () => {
+      const laterTestDateIsoString = new Date(testDateEpoch + 36000000 + 60000 + 1000).toISOString();
+
+      const result = calculateTimeDifference(testDateIsoString, laterTestDateIsoString);
+
+      expect(result).toEqual('10:01:01');
+    });
+
+    it('returns empty string when time difference is invalid', () => {
+      const laterDateIsoString = new Date(testDateEpoch + 3600000 + 60000 + 1000).toISOString();
+
+      const result = calculateTimeDifference(laterDateIsoString, testDateIsoString);
+
+      expect(result).toEqual('');
+    });
+  });
+
+  describe('parseIsoString()', () => {
+    it('returns the result of the function passed', () => {
+      const dateToStringTestFunction = (testDate: Date | null) =>
+        testDate?.toISOString().concat('-TEST') ?? 'empty-TEST';
 
-            expect(result).toEqual('00:01:01');
-        });
-        it('returns appropriate string if the timedifference is 1 hour', () => {
-            const laterTestDateIsoString = new Date(
-                testDateEpoch + 3600000 + 60000 + 1000,
-            ).toISOString();
-
-            const result = calculateTimeDifference(
-                testDateIsoString,
-                laterTestDateIsoString,
-            );
+      const result = parseIsoString(dateToStringTestFunction)(testDateIsoString);
 
-            expect(result).toEqual('01:01:01');
-        });
-
-        it('returns appropriate string if the timedifference is 10 hour', () => {
-            const laterTestDateIsoString = new Date(
-                testDateEpoch + 36000000 + 60000 + 1000,
-            ).toISOString();
-
-            const result = calculateTimeDifference(
-                testDateIsoString,
-                laterTestDateIsoString,
-            );
-
-            expect(result).toEqual('10:01:01');
-        });
-
-        it('returns empty string when time difference is invalid', () => {
-            const laterDateIsoString = new Date(
-                testDateEpoch + 3600000 + 60000 + 1000,
-            ).toISOString();
-
-            const result = calculateTimeDifference(
-                laterDateIsoString,
-                testDateIsoString,
-            );
-
-            expect(result).toEqual('');
-        });
-    });
-
-    describe('parseIsoString()', () => {
-        it('returns the result of the function passed', () => {
-            const dateToStringTestFunction = (testDate: Date | null) =>
-                testDate?.toISOString().concat('-TEST') ?? 'empty-TEST';
-
-            const result = parseIsoString(dateToStringTestFunction)(
-                testDateIsoString,
-            );
-
-            expect(result).toEqual(`${testDateIsoString}-TEST`);
-        });
+      expect(result).toEqual(`${testDateIsoString}-TEST`);
     });
+  });
 });

package/src/utils/date.ts

@@ -2,123 +2,103 @@ import { Locale } from '../types/types';
 
 export const getCurrentBrowserLocale = () => window.navigator.language;
 
-export const parseDate = (
-    date: string | null | undefined | number,
-): Date | null => {
-    if (date === null || date === undefined || date === '') {
-        return null;
-    }
+export const parseDate = (date: string | null | undefined | number): Date | null => {
+  if (date === null || date === undefined || date === '') {
+    return null;
+  }
 
-    return new Date(date);
+  return new Date(date);
 };
 
 export const calculateTimeDifference = (from: string, to: string): string => {
-    const fromDate = parseDate(from);
-    const toDate = parseDate(to);
+  const fromDate = parseDate(from);
+  const toDate = parseDate(to);
 
-    if (!fromDate || !toDate) return '';
+  if (!fromDate || !toDate) return '';
 
-    const timeDifference: number =
-        (toDate.getTime() - fromDate.getTime()) / 1000;
+  const timeDifference: number = (toDate.getTime() - fromDate.getTime()) / 1000;
 
-    if (timeDifference < 0) return '';
+  if (timeDifference < 0) return '';
 
-    const seconds = Math.floor(timeDifference);
-    const minutes = Math.floor(seconds / 60);
-    const hours = Math.floor(minutes / 60);
+  const seconds = Math.floor(timeDifference);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
 
-    return `${hours.toString().padStart(2, '0')}:${(minutes % 60)
-        .toString()
-        .padStart(2, '0')}:${((seconds % 60) % 3600)
-        .toString()
-        .padStart(2, '0')}`;
+  return `${hours.toString().padStart(2, '0')}:${(minutes % 60).toString().padStart(2, '0')}:${((seconds % 60) % 3600)
+    .toString()
+    .padStart(2, '0')}`;
 };
 
 export const formatDate = (dateString: string | undefined | null) => {
-    if (!dateString) return '';
+  if (!dateString) return '';
 
-    const date = parseDate(dateString);
-    return parseDateToLocaleDateTimeString(date);
+  const date = parseDate(dateString);
+  return parseDateToLocaleDateTimeString(date);
 };
 
-export const parseIsoString =
-    (dateToStringParser: (date: Date | null) => string) =>
-    (date: string | null) =>
-        dateToStringParser(parseDate(date));
+export const parseIsoString = (dateToStringParser: (date: Date | null) => string) => (date: string | null) =>
+  dateToStringParser(parseDate(date));
 
 export const parseDateToLocaleDateTimeString = (value: Date | null) =>
-    value?.toLocaleString(getCurrentBrowserLocale()) ?? '';
+  value?.toLocaleString(getCurrentBrowserLocale()) ?? '';
 
 export const parseDateToLocaleDateString = (value: Date | null) =>
-    value?.toLocaleDateString(getCurrentBrowserLocale()) ?? '';
+  value?.toLocaleDateString(getCurrentBrowserLocale()) ?? '';
 
 export const parseDateToLocaleTimeString = (value: Date | null) =>
-    value?.toLocaleTimeString(getCurrentBrowserLocale()) ?? '';
+  value?.toLocaleTimeString(getCurrentBrowserLocale()) ?? '';
 
-export const isToday = (date: Date) =>
-    date.toLocaleDateString() === new Date().toLocaleDateString();
+export const isToday = (date: Date) => date.toLocaleDateString() === new Date().toLocaleDateString();
 
 export const parseDateOrTimeRelativeToToday = (date: Date | null) => {
-    if (!date) {
-        return '';
-    }
+  if (!date) {
+    return '';
+  }
 
-    return isToday(date)
-        ? parseDateToLocaleTimeString(date)
-        : parseDateToLocaleDateString(date);
+  return isToday(date) ? parseDateToLocaleTimeString(date) : parseDateToLocaleDateString(date);
 };
 
 export const parseDateRelativeToToday = (date: Date | null) => {
-    if (!date) {
-        return '';
-    }
+  if (!date) {
+    return '';
+  }
 
-    return isToday(date)
-        ? parseDateToLocaleTimeString(date)
-        : parseDateToLocaleDateTimeString(date);
+  return isToday(date) ? parseDateToLocaleTimeString(date) : parseDateToLocaleDateTimeString(date);
 };
 
-export const formatDateCetWithUtc = (
-    inputDateString: string | null | undefined,
-) => {
-    const inputDate = parseDate(inputDateString);
-    if (!inputDate) {
-        return '';
-    }
-    const options: Intl.DateTimeFormatOptions = {
-        day: '2-digit',
-        month: 'short',
-        year: 'numeric',
-        hour: '2-digit',
-        minute: '2-digit',
-        timeZoneName: 'short',
-        timeZone: 'Europe/Amsterdam',
-    };
-
-    const optionsShort: Intl.DateTimeFormatOptions = {
-        hour: '2-digit',
-        minute: '2-digit',
-        timeZoneName: 'short',
-        timeZone: 'UTC',
-    };
-    const formattedDateCET = new Intl.DateTimeFormat(
-        Locale.nlNL,
-        options,
-    ).format(inputDate);
-
-    options.timeZoneName = 'short';
-    const formattedDateUTC = new Intl.DateTimeFormat(
-        Locale.nlNL,
-        optionsShort,
-    ).format(inputDate);
-
-    return `${formattedDateCET} (${formattedDateUTC})`;
+export const formatDateCetWithUtc = (inputDateString: string | null | undefined) => {
+  const inputDate = parseDate(inputDateString);
+  if (!inputDate) {
+    return '';
+  }
+  const options: Intl.DateTimeFormatOptions = {
+    day: '2-digit',
+    month: 'short',
+    year: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+    timeZoneName: 'short',
+    timeZone: 'Europe/Amsterdam',
+  };
+
+  const optionsShort: Intl.DateTimeFormatOptions = {
+    hour: '2-digit',
+    minute: '2-digit',
+    timeZoneName: 'short',
+    timeZone: 'UTC',
+  };
+  const formattedDateCET = new Intl.DateTimeFormat(Locale.nlNL, options).format(inputDate);
+
+  options.timeZoneName = 'short';
+  const formattedDateUTC = new Intl.DateTimeFormat(Locale.nlNL, optionsShort).format(inputDate);
+
+  return `${formattedDateCET} (${formattedDateUTC})`;
 };
 
 export const getDate = (date: Date | string | null) => {
-    if (typeof date === 'string') {
-        return new Date(date);
-    }
+  if (typeof date === 'string') {
+    return new Date(date);
+  }
 
-    return date;
+  return date;
 };

package/src/utils/environmentVariables.spec.ts

@@ -1,17 +1,17 @@
 import { getNumberValueFromEnvironmentVariable } from './environmentVariables';
 
 describe('getNumberValueFromEnvironmentVariable', () => {
-    it('returns the string as a number if it is a number', () => {
-        const result = getNumberValueFromEnvironmentVariable('123', 987);
-        expect(result).toBe(123);
-    });
+  it('returns the string as a number if it is a number', () => {
+    const result = getNumberValueFromEnvironmentVariable('123', 987);
+    expect(result).toBe(123);
+  });
 
-    it('returns the default value if the environment variable is not defined', () => {
-        const result = getNumberValueFromEnvironmentVariable(undefined, 987);
-        expect(result).toBe(987);
-    });
-    it('returns the default value if the environment variable is not a number', () => {
-        const result = getNumberValueFromEnvironmentVariable('abc', 987);
-        expect(result).toBe(987);
-    });
+  it('returns the default value if the environment variable is not defined', () => {
+    const result = getNumberValueFromEnvironmentVariable(undefined, 987);
+    expect(result).toBe(987);
+  });
+  it('returns the default value if the environment variable is not a number', () => {
+    const result = getNumberValueFromEnvironmentVariable('abc', 987);
+    expect(result).toBe(987);
+  });
 });

package/src/utils/environmentVariables.ts

@@ -1,12 +1,12 @@
 export const getNumberValueFromEnvironmentVariable = (
-    environmentVariable: string | undefined,
-    defaultValue: number,
+  environmentVariable: string | undefined,
+  defaultValue: number,
 ) => {
-    if (!environmentVariable) {
-        return defaultValue;
-    }
+  if (!environmentVariable) {
+    return defaultValue;
+  }
 
-    const valueAsNumber = parseInt(environmentVariable);
+  const valueAsNumber = parseInt(environmentVariable);
 
-    return isNaN(valueAsNumber) ? defaultValue : valueAsNumber;
+  return isNaN(valueAsNumber) ? defaultValue : valueAsNumber;
 };

package/src/utils/filterData.spec.ts

@@ -3,30 +3,28 @@ import { GraphqlFilter } from '@/types';
 import { filterDataByCriteria } from './filterData';
 
 describe('filterDataByCriteria', () => {
-    const testData = [
-        { id: 1, name: 'John' },
-        { id: 2, name: 'Doe' },
-        { id: 3, name: 'Jane' },
+  const testData = [
+    { id: 1, name: 'John' },
+    { id: 2, name: 'Doe' },
+    { id: 3, name: 'Jane' },
+  ];
+
+  it('should filter data by criteria', () => {
+    const filterCriteria: GraphqlFilter<(typeof testData)[0]>[] = [
+      { field: 'name', value: 'John' },
+      { field: 'id', value: '3' },
     ];
 
-    it('should filter data by criteria', () => {
-        const filterCriteria: GraphqlFilter<(typeof testData)[0]>[] = [
-            { field: 'name', value: 'John' },
-            { field: 'id', value: '3' },
-        ];
+    const filteredData = filterDataByCriteria(testData, filterCriteria);
 
-        const filteredData = filterDataByCriteria(testData, filterCriteria);
+    expect(filteredData).toEqual([{ id: 1, name: 'John' }]);
+  });
 
-        expect(filteredData).toEqual([{ id: 1, name: 'John' }]);
-    });
+  it('should return empty array if no match found', () => {
+    const filterCriteria: GraphqlFilter<(typeof testData)[0]>[] = [{ field: 'name', value: 'Nonexistent' }];
 
-    it('should return empty array if no match found', () => {
-        const filterCriteria: GraphqlFilter<(typeof testData)[0]>[] = [
-            { field: 'name', value: 'Nonexistent' },
-        ];
+    const filteredData = filterDataByCriteria(testData, filterCriteria);
 
-        const filteredData = filterDataByCriteria(testData, filterCriteria);
-
-        expect(filteredData).toEqual([]);
-    });
+    expect(filteredData).toEqual([]);
+  });
 });

package/src/utils/filterData.ts

@@ -1,14 +1,11 @@
 import { GraphqlFilter } from '@/types';
 
-export const filterDataByCriteria = <Type>(
-    data: Type[],
-    filterCriteria: GraphqlFilter<Type>[],
-): Type[] => {
-    return data.filter((dataItem) => {
-        return filterCriteria.some((filter) => {
-            const dataValue = dataItem[filter.field] as unknown as string;
-            const filterValue = filter.value;
-            return dataValue === filterValue;
-        });
+export const filterDataByCriteria = <Type>(data: Type[], filterCriteria: GraphqlFilter<Type>[]): Type[] => {
+  return data.filter((dataItem) => {
+    return filterCriteria.some((filter) => {
+      const dataValue = dataItem[filter.field] as unknown as string;
+      const filterValue = filter.value;
+      return dataValue === filterValue;
     });
+  });
 };