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

package/src/utils/getQueryParams.spec.ts

@@ -1,43 +1,40 @@
 import { WfoQueryParams, getUrlWithQueryParams } from './getQueryParams';
 
 describe('getUrlWithQueryParams', () => {
-    it('should build URL with one query param', () => {
-        const url = '/api/list';
-        const params = { [WfoQueryParams.ACTIVE_TAB]: 'ALL' };
-        expect(getUrlWithQueryParams(url, params)).toBe(
-            '/api/list?activeTab=ALL',
-        );
-    });
+  it('should build URL with one query param', () => {
+    const url = '/api/list';
+    const params = { [WfoQueryParams.ACTIVE_TAB]: 'ALL' };
+    expect(getUrlWithQueryParams(url, params)).toBe('/api/list?activeTab=ALL');
+  });
 
-    it('should build URL with multiple params', () => {
-        const url = '/api/list';
-        const params = {
-            [WfoQueryParams.ACTIVE_TAB]: 'ALL',
-            [WfoQueryParams.PAGE]: '2',
-            [WfoQueryParams.SORT_BY]: 'field-startDate_order-ASC',
-        };
-        const result = getUrlWithQueryParams(url, params);
+  it('should build URL with multiple params', () => {
+    const url = '/api/list';
+    const params = {
+      [WfoQueryParams.ACTIVE_TAB]: 'ALL',
+      [WfoQueryParams.PAGE]: '2',
+      [WfoQueryParams.SORT_BY]: 'field-startDate_order-ASC',
+    };
+    const result = getUrlWithQueryParams(url, params);
 
-        expect(result).toContain('/api/list?');
-        expect(result).toContain('activeTab=ALL');
-        expect(result).toContain('page=2');
-        expect(result).toContain('sortBy=field-startDate_order-ASC');
-    });
+    expect(result).toContain('/api/list?');
+    expect(result).toContain('activeTab=ALL');
+    expect(result).toContain('page=2');
+    expect(result).toContain('sortBy=field-startDate_order-ASC');
+  });
 
-    it('should encode params properly', () => {
-        const url = '/items';
-        const params = {
-            [WfoQueryParams.QUERY_STRING]:
-                'status:(provisioning|active) insync:false',
-        };
+  it('should encode params properly', () => {
+    const url = '/items';
+    const params = {
+      [WfoQueryParams.QUERY_STRING]: 'status:(provisioning|active) insync:false',
+    };
 
-        expect(getUrlWithQueryParams(url, params)).toBe(
-            '/items?queryString=status%3A%28provisioning%7Cactive%29+insync%3Afalse',
-        );
-    });
+    expect(getUrlWithQueryParams(url, params)).toBe(
+      '/items?queryString=status%3A%28provisioning%7Cactive%29+insync%3Afalse',
+    );
+  });
 
-    it('should handle empty params object', () => {
-        const url = '/no-params';
-        expect(getUrlWithQueryParams(url, {})).toBe('/no-params?');
-    });
+  it('should handle empty params object', () => {
+    const url = '/no-params';
+    expect(getUrlWithQueryParams(url, {})).toBe('/no-params?');
+  });
 });

package/src/utils/getQueryParams.ts

@@ -1,16 +1,13 @@
 export enum WfoQueryParams {
-    ACTIVE_TAB = 'activeTab',
-    PAGE = 'page',
-    PAGE_SIZE = 'pageSize',
-    SORT_BY = 'sortBy',
-    FILTER_BY = 'filterBy',
-    QUERY_STRING = 'queryString',
+  ACTIVE_TAB = 'activeTab',
+  PAGE = 'page',
+  PAGE_SIZE = 'pageSize',
+  SORT_BY = 'sortBy',
+  FILTER_BY = 'filterBy',
+  QUERY_STRING = 'queryString',
 }
 
-export const getUrlWithQueryParams = (
-    url: string,
-    params: Partial<Record<WfoQueryParams, string>>,
-) => {
-    const queryString = new URLSearchParams(params).toString() ?? '';
-    return `${url}?${queryString}`;
+export const getUrlWithQueryParams = (url: string, params: Partial<Record<WfoQueryParams, string>>) => {
+  const queryString = new URLSearchParams(params).toString() ?? '';
+  return `${url}?${queryString}`;
 };

package/src/utils/getQueryUrl.spec.ts

@@ -1,9 +1,9 @@
 import { getQueryUrl } from './getQueryUrl';
 
 describe('getQueryUrl', () => {
-    it('returns a url with the specified query', () => {
-        const result = getQueryUrl('/sample-page/sub-page', 'testQuery');
+  it('returns a url with the specified query', () => {
+    const result = getQueryUrl('/sample-page/sub-page', 'testQuery');
 
-        expect(result).toEqual('/sample-page/sub-page?queryString=testQuery');
-    });
+    expect(result).toEqual('/sample-page/sub-page?queryString=testQuery');
+  });
 });

package/src/utils/getQueryUrl.ts

@@ -1,8 +1,8 @@
 import { DataDisplayParams } from '@/hooks';
 
 export const getQueryUrl = (pageUrl: string, queryString: string) => {
-    // Prevents silently breaking functionality when the DataDisplayParams type changes
-    const queryKey: keyof DataDisplayParams<object> = 'queryString';
+  // Prevents silently breaking functionality when the DataDisplayParams type changes
+  const queryKey: keyof DataDisplayParams<object> = 'queryString';
 
-    return `${pageUrl}?${queryKey}=${queryString}`;
+  return `${pageUrl}?${queryKey}=${queryString}`;
 };

package/src/utils/getQueryVariablesForExport.spec.ts

@@ -1,19 +1,19 @@
 import { getQueryVariablesForExport } from './getQueryVariablesForExport';
 
 describe('getQueryVariablesForExport', () => {
-    it('returns queryVariables with first and after property set to 1000 and 0', () => {
-        const queryVariables = {
-            first: 10,
-            after: 20,
-            otherField: 'test',
-        };
+  it('returns queryVariables with first and after property set to 1000 and 0', () => {
+    const queryVariables = {
+      first: 10,
+      after: 20,
+      otherField: 'test',
+    };
 
-        const result = getQueryVariablesForExport(queryVariables);
+    const result = getQueryVariablesForExport(queryVariables);
 
-        expect(result).toEqual({
-            first: 1000,
-            after: 0,
-            otherField: 'test',
-        });
+    expect(result).toEqual({
+      first: 1000,
+      after: 0,
+      otherField: 'test',
     });
+  });
 });

package/src/utils/getQueryVariablesForExport.ts

@@ -2,10 +2,8 @@ import type { GraphqlQueryVariables } from '@/types';
 
 import { MAXIMUM_ITEMS_FOR_BULK_FETCHING } from '../configuration/constants';
 
-export const getQueryVariablesForExport = <T extends object>(
-    queryVariables: GraphqlQueryVariables<T>,
-) => ({
-    ...queryVariables,
-    first: MAXIMUM_ITEMS_FOR_BULK_FETCHING,
-    after: 0,
+export const getQueryVariablesForExport = <T extends object>(queryVariables: GraphqlQueryVariables<T>) => ({
+  ...queryVariables,
+  first: MAXIMUM_ITEMS_FOR_BULK_FETCHING,
+  after: 0,
 });

package/src/utils/getStatusBadgeColor.ts

@@ -1,15 +1,15 @@
 export const getStatusBadgeColor = (status: string) => {
-    const statusColors = {
-        terminated: 'danger',
-        active: 'success',
-        provisioning: 'primary',
-        migrating: 'primary',
-        initial: 'danger',
-    };
-    // eslint-disable-next-line no-prototype-builtins
-    return statusColors.hasOwnProperty(status)
-        ? // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-          // @ts-ignore
-          statusColors[status]
-        : 'primary';
+  const statusColors = {
+    terminated: 'danger',
+    active: 'success',
+    provisioning: 'primary',
+    migrating: 'primary',
+    initial: 'danger',
+  };
+  // eslint-disable-next-line no-prototype-builtins
+  return statusColors.hasOwnProperty(status) ?
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      statusColors[status]
+    : 'primary';
 };

package/src/utils/getToastMessage.spec.ts

@@ -2,27 +2,27 @@ import { ToastTypes } from '../types';
 import { getToastMessage } from './getToastMessage';
 
 describe('getToastMessage()', () => {
-    it('returns message object with title, text and passed in type', () => {
-        const result = getToastMessage(ToastTypes.ERROR, 'text', 'title');
-        expect(result.title).toBe('title');
-        expect(result.text).toBe('text');
-    });
+  it('returns message object with title, text and passed in type', () => {
+    const result = getToastMessage(ToastTypes.ERROR, 'text', 'title');
+    expect(result.title).toBe('title');
+    expect(result.text).toBe('text');
+  });
 
-    it('returns message object with random integer id', () => {
-        const result = getToastMessage(ToastTypes.ERROR, 'text', 'title');
-        const result2 = getToastMessage(ToastTypes.ERROR, 'text', 'title');
-        expect(result.id).not.toBe(result2.id);
-    });
+  it('returns message object with random integer id', () => {
+    const result = getToastMessage(ToastTypes.ERROR, 'text', 'title');
+    const result2 = getToastMessage(ToastTypes.ERROR, 'text', 'title');
+    expect(result.id).not.toBe(result2.id);
+  });
 
-    it('returns message object with ToastTypes.Error to color danger and iconType warning', () => {
-        const result = getToastMessage(ToastTypes.ERROR, 'text', 'title');
-        expect(result.color).toBe('danger');
-        expect(result.iconType).toBe('warning');
-    });
+  it('returns message object with ToastTypes.Error to color danger and iconType warning', () => {
+    const result = getToastMessage(ToastTypes.ERROR, 'text', 'title');
+    expect(result.color).toBe('danger');
+    expect(result.iconType).toBe('warning');
+  });
 
-    it('returns message object with ToastTypes.Error to color success and iconType check', () => {
-        const result = getToastMessage(ToastTypes.SUCCESS, 'text', 'title');
-        expect(result.color).toBe('success');
-        expect(result.iconType).toBe('check');
-    });
+  it('returns message object with ToastTypes.Error to color success and iconType check', () => {
+    const result = getToastMessage(ToastTypes.SUCCESS, 'text', 'title');
+    expect(result.color).toBe('success');
+    expect(result.iconType).toBe('check');
+  });
 });

package/src/utils/getToastMessage.ts

@@ -3,35 +3,31 @@ import { ReactNode } from 'react';
 import { ToastTypes } from '@/types';
 import type { Toast } from '@/types';
 
-export const getToastMessage = (
-    type: ToastTypes,
-    text: ReactNode,
-    title: string,
-) => {
-    const getTypeProps = (type: ToastTypes): Partial<Toast> => {
-        switch (type) {
-            case ToastTypes.ERROR:
-                return {
-                    color: 'danger',
-                    iconType: 'warning',
-                };
-            case ToastTypes.SUCCESS:
-                return {
-                    color: 'success',
-                    iconType: 'check',
-                };
-        }
-    };
+export const getToastMessage = (type: ToastTypes, text: ReactNode, title: string) => {
+  const getTypeProps = (type: ToastTypes): Partial<Toast> => {
+    switch (type) {
+      case ToastTypes.ERROR:
+        return {
+          color: 'danger',
+          iconType: 'warning',
+        };
+      case ToastTypes.SUCCESS:
+        return {
+          color: 'success',
+          iconType: 'check',
+        };
+    }
+  };
 
-    const id = Math.floor(Math.random() * 10000000).toString();
-    const typeProps = getTypeProps(type);
+  const id = Math.floor(Math.random() * 10000000).toString();
+  const typeProps = getTypeProps(type);
 
-    const toast: Toast = {
-        id,
-        text,
-        title,
-        ...typeProps,
-    };
+  const toast: Toast = {
+    id,
+    text,
+    title,
+    ...typeProps,
+  };
 
-    return toast;
+  return toast;
 };

package/src/utils/getTokenName.spec.ts

@@ -1,20 +1,20 @@
 import { getTokenName } from './getTokenName';
 
 describe('getTokenName()', () => {
-    it('returns "tokenNamespace" when name is "Node"', () => {
-        const result = getTokenName('Node');
-        expect(result).toEqual('tokenNamespace');
-    });
-    it('returns "tokenEnumMember" when name is "IP BGP Service Settings"', () => {
-        const result = getTokenName('IP BGP Service Settings');
-        expect(result).toEqual('tokenEnumMember');
-    });
-    it('returns "tokenIP" when name is "IP_PREFIX"', () => {
-        const result = getTokenName('IP_PREFIX');
-        expect(result).toEqual('tokenIP');
-    });
-    it('returns "tokenConstant" when name does not exists', () => {
-        const result = getTokenName('NOT_EXISTING_NAME');
-        expect(result).toEqual('tokenConstant');
-    });
+  it('returns "tokenNamespace" when name is "Node"', () => {
+    const result = getTokenName('Node');
+    expect(result).toEqual('tokenNamespace');
+  });
+  it('returns "tokenEnumMember" when name is "IP BGP Service Settings"', () => {
+    const result = getTokenName('IP BGP Service Settings');
+    expect(result).toEqual('tokenEnumMember');
+  });
+  it('returns "tokenIP" when name is "IP_PREFIX"', () => {
+    const result = getTokenName('IP_PREFIX');
+    expect(result).toEqual('tokenIP');
+  });
+  it('returns "tokenConstant" when name does not exists', () => {
+    const result = getTokenName('NOT_EXISTING_NAME');
+    expect(result).toEqual('tokenConstant');
+  });
 });

package/src/utils/getTokenName.ts

@@ -1,12 +1,12 @@
 export function getTokenName(name: string | number | boolean): string {
-    if (typeof name === 'boolean') return 'tokenConstant';
-    const icons: { [key: string]: string } = {
-        Node: 'tokenNamespace',
-        'IP BGP Service Settings': 'tokenEnumMember',
-        IP_PREFIX: 'tokenIP',
-    };
-    if (name in icons) {
-        return icons[name];
-    }
-    return 'tokenConstant';
+  if (typeof name === 'boolean') return 'tokenConstant';
+  const icons: { [key: string]: string } = {
+    Node: 'tokenNamespace',
+    'IP BGP Service Settings': 'tokenEnumMember',
+    IP_PREFIX: 'tokenIP',
+  };
+  if (name in icons) {
+    return icons[name];
+  }
+  return 'tokenConstant';
 }

package/src/utils/getTypedFieldFromObject.spec.ts

@@ -1,19 +1,19 @@
 import { getTypedFieldFromObject } from './getTypedFieldFromObject';
 
 describe('getTypedFieldFromObject', () => {
-    const test_object = {
-        name: 'test',
-        description: 'test description',
-        number: 1,
-    };
+  const test_object = {
+    name: 'test',
+    description: 'test description',
+    number: 1,
+  };
 
-    it('should get field from object when it exists', () => {
-        const field = getTypedFieldFromObject('name', test_object);
-        expect(field).toEqual('name');
-    });
+  it('should get field from object when it exists', () => {
+    const field = getTypedFieldFromObject('name', test_object);
+    expect(field).toEqual('name');
+  });
 
-    it('should return null when field does not exist in object', () => {
-        const field_value = getTypedFieldFromObject('test', test_object);
-        expect(field_value).toBeNull();
-    });
+  it('should return null when field does not exist in object', () => {
+    const field_value = getTypedFieldFromObject('test', test_object);
+    expect(field_value).toBeNull();
+  });
 });

package/src/utils/getTypedFieldFromObject.ts

@@ -1,9 +1,6 @@
-export function getTypedFieldFromObject<T extends object>(
-    field: string | undefined,
-    object: T,
-): null | keyof T {
-    if (field === undefined || !Object.keys(object).includes(field)) {
-        return null;
-    }
-    return field as keyof T;
+export function getTypedFieldFromObject<T extends object>(field: string | undefined, object: T): null | keyof T {
+  if (field === undefined || !Object.keys(object).includes(field)) {
+    return null;
+  }
+  return field as keyof T;
 }

package/src/utils/onlyUnique.spec.ts

@@ -1,19 +1,19 @@
 import { onlyUnique } from './onlyUnique';
 
 describe('onlyUnique()', () => {
-    it('returns array as array with only unique values', () => {
-        const test1 = ['SP', 'SP', 'FW', 'SP', 'FW', 'LP'];
-        const result = test1?.filter(onlyUnique);
-        expect(result).toEqual(['SP', 'FW', 'LP']);
-    });
-    it('returns array as array with only single value', () => {
-        const test2 = ['SP', 'SP', 'SP'];
-        const result = test2?.filter(onlyUnique);
-        expect(result).toEqual(['SP']);
-    });
-    it('returns array as empty array', () => {
-        const test3 = [''];
-        const result = test3?.filter(onlyUnique);
-        expect(result).toEqual(['']);
-    });
+  it('returns array as array with only unique values', () => {
+    const test1 = ['SP', 'SP', 'FW', 'SP', 'FW', 'LP'];
+    const result = test1?.filter(onlyUnique);
+    expect(result).toEqual(['SP', 'FW', 'LP']);
+  });
+  it('returns array as array with only single value', () => {
+    const test2 = ['SP', 'SP', 'SP'];
+    const result = test2?.filter(onlyUnique);
+    expect(result).toEqual(['SP']);
+  });
+  it('returns array as empty array', () => {
+    const test3 = [''];
+    const result = test3?.filter(onlyUnique);
+    expect(result).toEqual(['']);
+  });
 });

package/src/utils/onlyUnique.ts

@@ -1,3 +1,3 @@
 export const onlyUnique = (value: string, index: number, array: string[]) => {
-    return array.indexOf(value) === index;
+  return array.indexOf(value) === index;
 };

package/src/utils/optionalArray.spec.ts

@@ -1,99 +1,86 @@
 import { toOptionalObjectProperty } from 'pydantic-forms';
 
-import {
-    optionalArrayMapper,
-    toOptionalArrayEntries,
-    toOptionalArrayEntry,
-} from './optionalArray';
+import { optionalArrayMapper, toOptionalArrayEntries, toOptionalArrayEntry } from './optionalArray';
 
 describe('toOptionalArrayEntry', () => {
-    const testInput = { testField: 'testValue' };
+  const testInput = { testField: 'testValue' };
 
-    it('returns an array with the data if the condition is true', () => {
-        const result = toOptionalArrayEntry(testInput, true);
+  it('returns an array with the data if the condition is true', () => {
+    const result = toOptionalArrayEntry(testInput, true);
 
-        expect(result).toEqual([testInput]);
-    });
+    expect(result).toEqual([testInput]);
+  });
 
-    it('returns an empty array if the condition is false', () => {
-        const result = toOptionalArrayEntry(testInput, false);
+  it('returns an empty array if the condition is false', () => {
+    const result = toOptionalArrayEntry(testInput, false);
 
-        expect(result).toEqual([]);
-    });
+    expect(result).toEqual([]);
+  });
 });
 
 describe('toOptionalArrayEntries', () => {
-    test('returns data as an array when condition is true and data is not an array', () => {
-        const result = toOptionalArrayEntries('singleItem', true);
-        expect(result).toEqual(['singleItem']);
-    });
-
-    test('returns data as it is when condition is true and data is already an array', () => {
-        const result = toOptionalArrayEntries(['item1', 'item2'], true);
-        expect(result).toEqual(['item1', 'item2']);
-    });
-
-    test('returns an empty array when condition is false regardless of data type', () => {
-        const resultWithSingleItem = toOptionalArrayEntries(
-            'singleItem',
-            false,
-        );
-        const resultWithArray = toOptionalArrayEntries(
-            ['item1', 'item2'],
-            false,
-        );
-
-        expect(resultWithSingleItem).toEqual([]);
-        expect(resultWithArray).toEqual([]);
-    });
-
-    test('does not mutate the original data', () => {
-        const singleItem = 'singleItem';
-        const arrayData = ['item1', 'item2'];
-        toOptionalArrayEntries(singleItem, true);
-        toOptionalArrayEntries(arrayData, true);
-
-        expect(singleItem).toBe('singleItem');
-        expect(arrayData).toEqual(['item1', 'item2']);
-    });
+  test('returns data as an array when condition is true and data is not an array', () => {
+    const result = toOptionalArrayEntries('singleItem', true);
+    expect(result).toEqual(['singleItem']);
+  });
+
+  test('returns data as it is when condition is true and data is already an array', () => {
+    const result = toOptionalArrayEntries(['item1', 'item2'], true);
+    expect(result).toEqual(['item1', 'item2']);
+  });
+
+  test('returns an empty array when condition is false regardless of data type', () => {
+    const resultWithSingleItem = toOptionalArrayEntries('singleItem', false);
+    const resultWithArray = toOptionalArrayEntries(['item1', 'item2'], false);
+
+    expect(resultWithSingleItem).toEqual([]);
+    expect(resultWithArray).toEqual([]);
+  });
+
+  test('does not mutate the original data', () => {
+    const singleItem = 'singleItem';
+    const arrayData = ['item1', 'item2'];
+    toOptionalArrayEntries(singleItem, true);
+    toOptionalArrayEntries(arrayData, true);
+
+    expect(singleItem).toBe('singleItem');
+    expect(arrayData).toEqual(['item1', 'item2']);
+  });
 });
 
 describe('optionalArrayMapper', () => {
-    it('applies the mapper when data is defined', () => {
-        const testData = [{ testField: 'testValue' }];
+  it('applies the mapper when data is defined', () => {
+    const testData = [{ testField: 'testValue' }];
 
-        const result = optionalArrayMapper(testData, () => 'mappedValue');
+    const result = optionalArrayMapper(testData, () => 'mappedValue');
 
-        expect(result).toEqual(['mappedValue']);
-    });
-    it('returns an empty array when data is undefined', () => {
-        const result = optionalArrayMapper(undefined, () => 'test');
+    expect(result).toEqual(['mappedValue']);
+  });
+  it('returns an empty array when data is undefined', () => {
+    const result = optionalArrayMapper(undefined, () => 'test');
 
-        expect(result).toEqual([]);
-    });
+    expect(result).toEqual([]);
+  });
 });
 
 describe('toOptionalObjectProperty', () => {
-    const flatSchema = { const: 'CONST_VAL' };
-    function withSpread(addConstValue: boolean) {
-        return {
-            ...(addConstValue && { const: flatSchema.const }),
-        };
-    }
-    function withHelper(addConstValue: boolean) {
-        return {
-            ...toOptionalObjectProperty(
-                { const: flatSchema.const },
-                addConstValue,
-            ),
-        };
-    }
-    it('adds const when addConstValue = true', () => {
-        expect(withSpread(true)).toEqual(withHelper(true));
-        expect(withSpread(true)).toHaveProperty('const', 'CONST_VAL');
-    });
-    it('omits const when addConstValue = false', () => {
-        expect(withSpread(false)).toEqual(withHelper(false));
-        expect(withSpread(false)).not.toHaveProperty('const');
-    });
+  const flatSchema = { const: 'CONST_VAL' };
+  function withSpread(addConstValue: boolean) {
+    return {
+      ...(addConstValue && { const: flatSchema.const }),
+    };
+  }
+  function withHelper(addConstValue: boolean) {
+    return {
+      ...toOptionalObjectProperty({ const: flatSchema.const }, addConstValue),
+    };
+  }
+  it('adds const when addConstValue = true', () => {
+    expect(withSpread(true)).toEqual(withHelper(true));
+    expect(withSpread(true)).toHaveProperty('const', 'CONST_VAL');
+  });
+  it('omits const when addConstValue = false', () => {
+    expect(withSpread(false)).toEqual(withHelper(false));
+    expect(withSpread(false)).not.toHaveProperty('const');
+  });
 });