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

package/src/utils/optionalArray.ts

@@ -1,19 +1,13 @@
-export const toOptionalArrayEntry = <T>(
-    data: T,
-    condition: boolean,
-): [T] | [] => (condition ? [data] : []);
+export const toOptionalArrayEntry = <T>(data: T, condition: boolean): [T] | [] => (condition ? [data] : []);
 
-export const toOptionalArrayEntries = <T>(
-    data: T | T[],
-    condition: boolean,
-): T[] => (condition ? (Array.isArray(data) ? data : [data]) : []);
+export const toOptionalArrayEntries = <T>(data: T | T[], condition: boolean): T[] =>
+  condition ?
+    Array.isArray(data) ?
+      data
+    : [data]
+  : [];
 
-export const optionalArrayMapper = <T, U>(
-    data: T[] | undefined = [],
-    mapper: (input: T) => U,
-): U[] => data.map(mapper);
+export const optionalArrayMapper = <T, U>(data: T[] | undefined = [], mapper: (input: T) => U): U[] => data.map(mapper);
 
-export const toOptionalObjectProperty = <T extends object>(
-    entries: T,
-    condition: boolean,
-): T | object => (condition ? entries : {});
+export const toOptionalObjectProperty = <T extends object>(entries: T, condition: boolean): T | object =>
+  condition ? entries : {};

package/src/utils/resultFlattener.spec.ts

@@ -1,51 +1,48 @@
-import {
-    getConcatenatedPagedResult,
-    getConcatenatedResult,
-} from './resultFlattener';
+import { getConcatenatedPagedResult, getConcatenatedResult } from './resultFlattener';
 
 describe('pagedResultFlattener', () => {
-    it('returns an empty string when the paged result is empty', () => {
-        const pagedResult = { page: [] };
-        const fields = ['name', 'age'];
+  it('returns an empty string when the paged result is empty', () => {
+    const pagedResult = { page: [] };
+    const fields = ['name', 'age'];
 
-        const result = getConcatenatedPagedResult(pagedResult, fields);
+    const result = getConcatenatedPagedResult(pagedResult, fields);
 
-        expect(result).toBe('');
-    });
+    expect(result).toBe('');
+  });
 });
 
 describe('resultFlattener', () => {
-    it('returns a flattened string of the specified fields', () => {
-        type TestItem = {
-            name: string;
-            age: number;
-        };
-        const results = [
-            { name: 'John', age: 25 },
-            { name: 'Jane', age: 30 },
-            { name: 'Bob', age: 40 },
-        ];
-        const fields: Array<keyof TestItem> = ['name', 'age'];
-        const result = getConcatenatedResult<TestItem>(results, fields);
-        expect(result).toBe('John: 25 - Jane: 30 - Bob: 40');
-    });
-
-    it('returns a flattened string with selected fields only', () => {
-        type TestItem = {
-            name: string;
-            age: number;
-            city: string;
-        };
-        const results: TestItem[] = [
-            { name: 'John', age: 25, city: 'New York' },
-            { name: 'Jane', age: 30, city: 'London' },
-            { name: 'Bob', age: 40, city: 'Paris' },
-        ];
-
-        const fields: Array<keyof TestItem> = ['name', 'city'];
-
-        const result = getConcatenatedResult(results, fields);
-
-        expect(result).toBe('John: New York - Jane: London - Bob: Paris');
-    });
+  it('returns a flattened string of the specified fields', () => {
+    type TestItem = {
+      name: string;
+      age: number;
+    };
+    const results = [
+      { name: 'John', age: 25 },
+      { name: 'Jane', age: 30 },
+      { name: 'Bob', age: 40 },
+    ];
+    const fields: Array<keyof TestItem> = ['name', 'age'];
+    const result = getConcatenatedResult<TestItem>(results, fields);
+    expect(result).toBe('John: 25 - Jane: 30 - Bob: 40');
+  });
+
+  it('returns a flattened string with selected fields only', () => {
+    type TestItem = {
+      name: string;
+      age: number;
+      city: string;
+    };
+    const results: TestItem[] = [
+      { name: 'John', age: 25, city: 'New York' },
+      { name: 'Jane', age: 30, city: 'London' },
+      { name: 'Bob', age: 40, city: 'Paris' },
+    ];
+
+    const fields: Array<keyof TestItem> = ['name', 'city'];
+
+    const result = getConcatenatedResult(results, fields);
+
+    expect(result).toBe('John: New York - Jane: London - Bob: Paris');
+  });
 });

package/src/utils/resultFlattener.ts

@@ -1,27 +1,16 @@
 import { GraphQlSinglePage } from '@/types';
 
-export const getConcatenatedPagedResult = <T>(
-    pagedResult: GraphQlSinglePage<T>,
-    fields: Array<keyof T>,
-): string => {
-    const results = pagedResult.page || [];
-    return getConcatenatedResult(results, fields);
+export const getConcatenatedPagedResult = <T>(pagedResult: GraphQlSinglePage<T>, fields: Array<keyof T>): string => {
+  const results = pagedResult.page || [];
+  return getConcatenatedResult(results, fields);
 };
 
-export const getConcatenatedResult = <T>(
-    results: T[],
-    fields: Array<keyof T>,
-): string => {
-    return results.reduce((accumulator, result, index) => {
-        const resultFields = fields.reduce((accumulator, field, index) => {
-            return (
-                accumulator +
-                `${result[field]}${index !== fields.length - 1 ? ': ' : ''}`
-            );
-        }, '');
-
-        return `${accumulator}${resultFields}${
-            index !== results.length - 1 ? ' - ' : ''
-        }`;
+export const getConcatenatedResult = <T>(results: T[], fields: Array<keyof T>): string => {
+  return results.reduce((accumulator, result, index) => {
+    const resultFields = fields.reduce((accumulator, field, index) => {
+      return accumulator + `${result[field]}${index !== fields.length - 1 ? ': ' : ''}`;
     }, '');
+
+    return `${accumulator}${resultFields}${index !== results.length - 1 ? ' - ' : ''}`;
+  }, '');
 };

package/src/utils/string.spec.ts

@@ -1,161 +1,161 @@
 import {
-    camelToHuman,
-    isAllUpperCase,
-    isNullOrEmpty,
-    removeSuffix,
-    snakeToHuman,
-    snakeToKebab,
-    upperCaseFirstChar,
+  camelToHuman,
+  isAllUpperCase,
+  isNullOrEmpty,
+  removeSuffix,
+  snakeToHuman,
+  snakeToKebab,
+  upperCaseFirstChar,
 } from './strings';
 
 describe('upperCaseFirstChar()', () => {
-    it("Doesn't crash on an empty string but returns empty string", () => {
-        const result = upperCaseFirstChar('');
-        expect(result).toEqual('');
-    });
-    it('Uppercases strings of length 1', () => {
-        const result = upperCaseFirstChar('a');
-        expect(result).toEqual('A');
-    });
-    it('Uppercases strings simple strings', () => {
-        const result = upperCaseFirstChar('subscriptions');
-        expect(result).toEqual('Subscriptions');
-    });
-    it('Uppercases strings simple strings and spaces', () => {
-        const result = upperCaseFirstChar('subscriptions are ok');
-        expect(result).toEqual('Subscriptions are ok');
-    });
-    it('Uppercases / lowercases strings with all caps', () => {
-        const result = upperCaseFirstChar('ALL');
-        expect(result).toEqual('All');
-    });
+  it("Doesn't crash on an empty string but returns empty string", () => {
+    const result = upperCaseFirstChar('');
+    expect(result).toEqual('');
+  });
+  it('Uppercases strings of length 1', () => {
+    const result = upperCaseFirstChar('a');
+    expect(result).toEqual('A');
+  });
+  it('Uppercases strings simple strings', () => {
+    const result = upperCaseFirstChar('subscriptions');
+    expect(result).toEqual('Subscriptions');
+  });
+  it('Uppercases strings simple strings and spaces', () => {
+    const result = upperCaseFirstChar('subscriptions are ok');
+    expect(result).toEqual('Subscriptions are ok');
+  });
+  it('Uppercases / lowercases strings with all caps', () => {
+    const result = upperCaseFirstChar('ALL');
+    expect(result).toEqual('All');
+  });
 });
 
 describe('removeSuffix()', () => {
-    it("Doesn't crash on an empty string but returns empty string", () => {
-        const result = removeSuffix('');
-        expect(result).toEqual('');
-    });
-    it('Works ok for strings with length 1', () => {
-        const result = removeSuffix('a');
-        expect(result).toEqual('a');
-    });
-    it('Works ok for strings with default splitChar', () => {
-        const result = removeSuffix('a?b');
-        expect(result).toEqual('a');
-    });
-    it('Works ok for strings with specified splitChar', () => {
-        const result = removeSuffix('a=b', '=');
-        expect(result).toEqual('a');
-    });
-    it('Works ok for strings without splitChar', () => {
-        const result = removeSuffix('a=b');
-        expect(result).toEqual('a=b');
-    });
+  it("Doesn't crash on an empty string but returns empty string", () => {
+    const result = removeSuffix('');
+    expect(result).toEqual('');
+  });
+  it('Works ok for strings with length 1', () => {
+    const result = removeSuffix('a');
+    expect(result).toEqual('a');
+  });
+  it('Works ok for strings with default splitChar', () => {
+    const result = removeSuffix('a?b');
+    expect(result).toEqual('a');
+  });
+  it('Works ok for strings with specified splitChar', () => {
+    const result = removeSuffix('a=b', '=');
+    expect(result).toEqual('a');
+  });
+  it('Works ok for strings without splitChar', () => {
+    const result = removeSuffix('a=b');
+    expect(result).toEqual('a=b');
+  });
 });
 
 describe('camelToHuman()', () => {
-    it("Doesn't crash on an empty string but returns empty string", () => {
-        const result = camelToHuman('');
-        expect(result).toEqual('');
-    });
-    it('Works ok for lowercase strings with length 1', () => {
-        const result = camelToHuman('a');
-        expect(result).toEqual('A');
-    });
-    it('Works ok for uppercase strings with length 1', () => {
-        const result = camelToHuman('A');
-        expect(result).toEqual('A');
-    });
-    it('Works ok for strings starting with an lowercase char', () => {
-        const result = camelToHuman('aQuickBrownFox');
-        expect(result).toEqual('A Quick Brown Fox');
-    });
-    it('Works ok for strings starting with an uppercase char', () => {
-        const result = camelToHuman('AQuickBrownFox');
-        expect(result).toEqual('A Quick Brown Fox');
-    });
+  it("Doesn't crash on an empty string but returns empty string", () => {
+    const result = camelToHuman('');
+    expect(result).toEqual('');
+  });
+  it('Works ok for lowercase strings with length 1', () => {
+    const result = camelToHuman('a');
+    expect(result).toEqual('A');
+  });
+  it('Works ok for uppercase strings with length 1', () => {
+    const result = camelToHuman('A');
+    expect(result).toEqual('A');
+  });
+  it('Works ok for strings starting with an lowercase char', () => {
+    const result = camelToHuman('aQuickBrownFox');
+    expect(result).toEqual('A Quick Brown Fox');
+  });
+  it('Works ok for strings starting with an uppercase char', () => {
+    const result = camelToHuman('AQuickBrownFox');
+    expect(result).toEqual('A Quick Brown Fox');
+  });
 });
 
 describe('snakeToHuman()', () => {
-    it('Returns an empty string when input is an empty string', () => {
-        const result = snakeToHuman('');
-        expect(result).toEqual('');
-    });
-    it('Returns two words from a single underscore snake case word', () => {
-        const result = snakeToHuman('hello_world');
-        expect(result).toEqual('hello world');
-    });
-    it('Returns multiple words from a multiple underscore snake case word', () => {
-        const result = snakeToHuman('quick_brown_fox');
-        expect(result).toEqual('quick brown fox');
-    });
+  it('Returns an empty string when input is an empty string', () => {
+    const result = snakeToHuman('');
+    expect(result).toEqual('');
+  });
+  it('Returns two words from a single underscore snake case word', () => {
+    const result = snakeToHuman('hello_world');
+    expect(result).toEqual('hello world');
+  });
+  it('Returns multiple words from a multiple underscore snake case word', () => {
+    const result = snakeToHuman('quick_brown_fox');
+    expect(result).toEqual('quick brown fox');
+  });
 });
 
 describe('snakeToKebab()', () => {
-    it('Returns an empty string when input is an empty string', () => {
-        const result = snakeToKebab('');
-        expect(result).toEqual('');
-    });
-    it('Returns kebab case word from a single underscore snake case word', () => {
-        const result = snakeToKebab('hello_world');
-        expect(result).toEqual('hello-world');
-    });
-    it('Returns kebab case word from a multiple underscore snake case word', () => {
-        const result = snakeToKebab('quick_brown_fox');
-        expect(result).toEqual('quick-brown-fox');
-    });
+  it('Returns an empty string when input is an empty string', () => {
+    const result = snakeToKebab('');
+    expect(result).toEqual('');
+  });
+  it('Returns kebab case word from a single underscore snake case word', () => {
+    const result = snakeToKebab('hello_world');
+    expect(result).toEqual('hello-world');
+  });
+  it('Returns kebab case word from a multiple underscore snake case word', () => {
+    const result = snakeToKebab('quick_brown_fox');
+    expect(result).toEqual('quick-brown-fox');
+  });
 });
 
 describe('isAllUpperCase()', () => {
-    it('Returns true for an empty string', () => {
-        const result = isAllUpperCase('');
-        expect(result).toBe(true);
-    });
-    it('Returns true for a string with all uppercase letters', () => {
-        const result = isAllUpperCase('HELLO');
-        expect(result).toBe(true);
-    });
-    it('Returns false for a string with all lowercase letters', () => {
-        const result = isAllUpperCase('hello');
-        expect(result).toBe(false);
-    });
-    it('Returns false for a string with mixed case letters', () => {
-        const result = isAllUpperCase('Hello');
-        expect(result).toBe(false);
-    });
-    it('Returns true for a string with uppercase letters and non-letter characters', () => {
-        const result = isAllUpperCase('HELLO123!');
-        expect(result).toBe(true);
-    });
-    it('Returns false for a string with mixed case letters and non-letter characters', () => {
-        const result = isAllUpperCase('Hello123!');
-        expect(result).toBe(false);
-    });
+  it('Returns true for an empty string', () => {
+    const result = isAllUpperCase('');
+    expect(result).toBe(true);
+  });
+  it('Returns true for a string with all uppercase letters', () => {
+    const result = isAllUpperCase('HELLO');
+    expect(result).toBe(true);
+  });
+  it('Returns false for a string with all lowercase letters', () => {
+    const result = isAllUpperCase('hello');
+    expect(result).toBe(false);
+  });
+  it('Returns false for a string with mixed case letters', () => {
+    const result = isAllUpperCase('Hello');
+    expect(result).toBe(false);
+  });
+  it('Returns true for a string with uppercase letters and non-letter characters', () => {
+    const result = isAllUpperCase('HELLO123!');
+    expect(result).toBe(true);
+  });
+  it('Returns false for a string with mixed case letters and non-letter characters', () => {
+    const result = isAllUpperCase('Hello123!');
+    expect(result).toBe(false);
+  });
 });
 
 describe('isNullOrEmpty', () => {
-    it('should return true for null', () => {
-        expect(isNullOrEmpty(null)).toBe(true);
-    });
+  it('should return true for null', () => {
+    expect(isNullOrEmpty(null)).toBe(true);
+  });
 
-    it('should return true for undefined', () => {
-        expect(isNullOrEmpty(undefined)).toBe(true);
-    });
+  it('should return true for undefined', () => {
+    expect(isNullOrEmpty(undefined)).toBe(true);
+  });
 
-    it('should return true for an empty string', () => {
-        expect(isNullOrEmpty('')).toBe(true);
-    });
+  it('should return true for an empty string', () => {
+    expect(isNullOrEmpty('')).toBe(true);
+  });
 
-    it('should return true for a string with only spaces', () => {
-        expect(isNullOrEmpty('   ')).toBe(true);
-    });
+  it('should return true for a string with only spaces', () => {
+    expect(isNullOrEmpty('   ')).toBe(true);
+  });
 
-    it('should return false for a non-empty string', () => {
-        expect(isNullOrEmpty('Hello')).toBe(false);
-    });
+  it('should return false for a non-empty string', () => {
+    expect(isNullOrEmpty('Hello')).toBe(false);
+  });
 
-    it('should return false for a string with spaces and text', () => {
-        expect(isNullOrEmpty('  Hello  ')).toBe(false);
-    });
+  it('should return false for a string with spaces and text', () => {
+    expect(isNullOrEmpty('  Hello  ')).toBe(false);
+  });
 });

package/src/utils/strings.ts

@@ -1,32 +1,32 @@
 export const upperCaseFirstChar = (value: string): string => {
-    if (value.length === 0) return value;
-    if (value.length === 1) return value.charAt(0).toUpperCase();
-    return value.charAt(0).toUpperCase() + value.slice(1).toLowerCase();
+  if (value.length === 0) return value;
+  if (value.length === 1) return value.charAt(0).toUpperCase();
+  return value.charAt(0).toUpperCase() + value.slice(1).toLowerCase();
 };
 
 export const removeSuffix = (value: string, splitChar = '?'): string => {
-    if (value.length <= 1 || !value.includes(splitChar)) return value;
-    return value.split(splitChar).slice(0, -1).join();
+  if (value.length <= 1 || !value.includes(splitChar)) return value;
+  return value.split(splitChar).slice(0, -1).join();
 };
 
 export const camelToHuman = (value: string): string => {
-    const result = value.replace(/([A-Z])/g, ' $1').trimStart();
-    return result.charAt(0).toUpperCase() + result.slice(1);
+  const result = value.replace(/([A-Z])/g, ' $1').trimStart();
+  return result.charAt(0).toUpperCase() + result.slice(1);
 };
 
 export const snakeToHuman = (value: string): string => {
-    const result = value.replace(/_/g, ' ');
-    return result.charAt(0) + result.slice(1);
+  const result = value.replace(/_/g, ' ');
+  return result.charAt(0) + result.slice(1);
 };
 
 export const snakeToKebab = (value: string): string => {
-    return value.replace(/_/g, '-');
+  return value.replace(/_/g, '-');
 };
 
 export const isAllUpperCase = (str: string) => str === str.toUpperCase();
 
 export const isNullOrEmpty = (str: string | null | undefined): boolean => {
-    return str === null || str === undefined || str.trim() === '';
+  return str === null || str === undefined || str.trim() === '';
 };
 
 export const INVISIBLE_CHARACTER = '‎';

package/src/utils/toObjectWithSerializedValues.spec.ts

@@ -1,36 +1,36 @@
 import { toObjectWithSerializedValues } from '@/utils/toObjectWithSerializedValues';
 
 describe('toObjectWithSerializedValues()', () => {
-    it('should serialize object fields', () => {
-        const input = {
-            testObject: { foo: 'bar' },
-        };
+  it('should serialize object fields', () => {
+    const input = {
+      testObject: { foo: 'bar' },
+    };
 
-        const result = toObjectWithSerializedValues(input);
+    const result = toObjectWithSerializedValues(input);
 
-        expect(result.testObject).toEqual(`{"foo":"bar"}`);
-    });
+    expect(result.testObject).toEqual(`{"foo":"bar"}`);
+  });
 
-    it('should not serialize date fields', () => {
-        const testDate = new Date();
-        const input = {
-            date: testDate,
-        };
+  it('should not serialize date fields', () => {
+    const testDate = new Date();
+    const input = {
+      date: testDate,
+    };
 
-        const result = toObjectWithSerializedValues(input);
+    const result = toObjectWithSerializedValues(input);
 
-        expect(result.date).toEqual(testDate);
-    });
+    expect(result.date).toEqual(testDate);
+  });
 
-    it('should not serialize non-date and non-object fields', () => {
-        const input = {
-            string: 'string',
-            number: 1,
-            boolean: true,
-        };
+  it('should not serialize non-date and non-object fields', () => {
+    const input = {
+      string: 'string',
+      number: 1,
+      boolean: true,
+    };
 
-        const result = toObjectWithSerializedValues(input);
+    const result = toObjectWithSerializedValues(input);
 
-        expect(result).toEqual(input);
-    });
+    expect(result).toEqual(input);
+  });
 });

package/src/utils/toObjectWithSerializedValues.ts

@@ -1,17 +1,11 @@
-export const toObjectWithSerializedValues = <T extends object>(
-    inputObject: T,
-) => {
-    const entries = Object.entries(inputObject);
-    const mappedEntries = entries.map(([key, value]) => {
-        if (
-            value !== null &&
-            value.constructor !== Date &&
-            typeof value === 'object'
-        ) {
-            return [key, JSON.stringify(value)];
-        }
-        return [key, value];
-    });
+export const toObjectWithSerializedValues = <T extends object>(inputObject: T) => {
+  const entries = Object.entries(inputObject);
+  const mappedEntries = entries.map(([key, value]) => {
+    if (value !== null && value.constructor !== Date && typeof value === 'object') {
+      return [key, JSON.stringify(value)];
+    }
+    return [key, value];
+  });
 
-    return Object.fromEntries(mappedEntries);
+  return Object.fromEntries(mappedEntries);
 };

package/src/utils/toObjectWithSortedKeys.ts

@@ -1,33 +1,30 @@
 // Some components in this project need the keys of an object to be in a certain order
 // This function sorts the keys of an object based on an array of strings
 // Keys that do not exist in the object will be ignored
-export const toObjectWithSortedKeys = <T extends object>(
-    inputObject: T,
-    keyOrder: string[],
-): T => {
-    const allInputObjectKeys = Object.keys(inputObject) as Array<keyof T>;
-    allInputObjectKeys.sort((left, right) => {
-        const leftIndex = keyOrder.indexOf(left.toString());
-        const rightIndex = keyOrder.indexOf(right.toString());
+export const toObjectWithSortedKeys = <T extends object>(inputObject: T, keyOrder: string[]): T => {
+  const allInputObjectKeys = Object.keys(inputObject) as Array<keyof T>;
+  allInputObjectKeys.sort((left, right) => {
+    const leftIndex = keyOrder.indexOf(left.toString());
+    const rightIndex = keyOrder.indexOf(right.toString());
 
-        if (leftIndex === -1 && rightIndex === -1) {
-            return 0;
-        }
+    if (leftIndex === -1 && rightIndex === -1) {
+      return 0;
+    }
 
-        if (leftIndex === -1) {
-            return 1;
-        }
+    if (leftIndex === -1) {
+      return 1;
+    }
 
-        if (rightIndex === -1) {
-            return -1;
-        }
+    if (rightIndex === -1) {
+      return -1;
+    }
 
-        return leftIndex - rightIndex;
-    });
+    return leftIndex - rightIndex;
+  });
 
-    // Using all keys from the input object means the result will contain all keys of T, meaning the type is T
-    return allInputObjectKeys.reduce((acc, key) => {
-        acc[key] = inputObject[key];
-        return acc;
-    }, {} as T);
+  // Using all keys from the input object means the result will contain all keys of T, meaning the type is T
+  return allInputObjectKeys.reduce((acc, key) => {
+    acc[key] = inputObject[key];
+    return acc;
+  }, {} as T);
 };