@gen-epix/ui 1.14.4 → 1.15.0

package/src/utils/EpiUploadUtil/index.ts

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

package/src/utils/FileUtil/FileUtil.ts

@@ -0,0 +1,22 @@
+import { FileCompression } from '../../api';
+
+export class FileUtil {
+  public static getReadableFileSize(sizeInBytes: number): string {
+    if (sizeInBytes < 1024) {
+      return `${sizeInBytes} B`;
+    } else if (sizeInBytes < 1024 * 1024) {
+      return `${(sizeInBytes / 1024).toFixed(2)} KB`;
+    } else if (sizeInBytes < 1024 * 1024 * 1024) {
+      return `${(sizeInBytes / (1024 * 1024)).toFixed(2)} MB`;
+    }
+    return `${(sizeInBytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+  }
+
+  public static getFileCompressionFromFileName(fileName: string): FileCompression {
+    const lowerFileName = fileName.toLowerCase();
+    if (lowerFileName.endsWith('.gz') || lowerFileName.endsWith('.gzip')) {
+      return FileCompression.GZIP;
+    }
+    return FileCompression.NONE;
+  }
+}

package/src/utils/FileUtil/index.ts

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

package/src/utils/FormUtil/FormUtil.test.ts

@@ -0,0 +1,36 @@
+import {
+  describe,
+  it,
+  expect,
+} from 'vitest';
+import type {
+  FieldErrorsImpl,
+  DeepRequired,
+} from 'react-hook-form';
+
+import { FormUtil } from './FormUtil';
+
+describe('FormUtil', () => {
+  describe('getFieldErrorMessage', () => {
+    it('should return the error message for the given field name', () => {
+      const fieldErrors: Partial<FieldErrorsImpl<DeepRequired<{ name: string }>>> = {
+        name: { message: 'Name is required', type: 'required' },
+      };
+
+      const errorMessage = FormUtil.getFieldErrorMessage(fieldErrors, 'name');
+      expect(errorMessage).toBe('Name is required');
+    });
+
+    it('should return null if there is no error message for the given field name', () => {
+      const fieldErrors: Partial<FieldErrorsImpl<DeepRequired<{ name: string }>>> = {};
+
+      const errorMessage = FormUtil.getFieldErrorMessage(fieldErrors, 'name');
+      expect(errorMessage).toBeNull();
+    });
+
+    it('should return null if the fieldErrors object is undefined', () => {
+      const errorMessage = FormUtil.getFieldErrorMessage(undefined, 'name');
+      expect(errorMessage).toBeNull();
+    });
+  });
+});

package/src/utils/FormUtil/FormUtil.ts

@@ -0,0 +1,63 @@
+import type {
+  FieldValues,
+  FieldErrorsImpl,
+  DeepRequired,
+} from 'react-hook-form';
+import {
+  parseISO,
+  isValid,
+} from 'date-fns';
+import type { TFunction } from 'i18next';
+
+import type { FormFieldDefinition } from '../../models/form';
+import { FORM_FIELD_DEFINITION_TYPE } from '../../models/form';
+
+export class FormUtil {
+  public static getFieldErrorMessage<TFormFields extends FieldValues>(fieldErrors: Partial<FieldErrorsImpl<DeepRequired<TFormFields>>>, fieldName: string): string {
+    const fieldError = fieldErrors?.[fieldName];
+    return fieldError?.message as string || null;
+  }
+
+  public static createBooleanOptions(t: TFunction<'translation', undefined>): { label: string; value: boolean }[] {
+    return [
+      { value: true, label: t`Yes` }, // t`Yes`
+      { value: false, label: t`No` }, // t`No`
+    ];
+  }
+
+  public static createFormValues<TFormFields extends FieldValues, TData = TFormFields>(formFieldDefinitions: FormFieldDefinition<TFormFields>[], item: TData): TFormFields {
+    const itemValues: { [key: string]: unknown } = {};
+    formFieldDefinitions.forEach(formFieldDefinition => {
+      switch (formFieldDefinition.definition) {
+        case FORM_FIELD_DEFINITION_TYPE.TEXTFIELD:
+        case FORM_FIELD_DEFINITION_TYPE.RICH_TEXT:
+        case FORM_FIELD_DEFINITION_TYPE.BOOLEAN:
+          itemValues[formFieldDefinition.name] = item?.[formFieldDefinition.name as unknown as keyof typeof item] ?? '';
+          break;
+        case FORM_FIELD_DEFINITION_TYPE.TRANSFER_LIST:
+          itemValues[formFieldDefinition.name] = item?.[formFieldDefinition.name as unknown as keyof typeof item] ?? [] as TFormFields[keyof TFormFields];
+          break;
+        case FORM_FIELD_DEFINITION_TYPE.AUTOCOMPLETE:
+        case FORM_FIELD_DEFINITION_TYPE.SELECT:
+          if (formFieldDefinition.multiple) {
+            itemValues[formFieldDefinition.name] = item?.[formFieldDefinition.name as unknown as keyof typeof item] ?? [] as TFormFields[keyof TFormFields];
+          } else {
+            itemValues[formFieldDefinition.name] = item?.[formFieldDefinition.name as unknown as keyof typeof item] ?? null;
+          }
+          break;
+        case FORM_FIELD_DEFINITION_TYPE.DATE:
+          try {
+            const dateValue = parseISO(item?.[formFieldDefinition.name as unknown as keyof typeof item] as string);
+            itemValues[formFieldDefinition.name] = isValid(dateValue) ? dateValue as TFormFields[keyof TFormFields] : null;
+          } catch (_error) {
+            itemValues[formFieldDefinition.name] = null;
+          }
+          break;
+        default:
+          break;
+      }
+    });
+    return itemValues as unknown as TFormFields;
+  }
+
+}

package/src/utils/FormUtil/index.ts

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

package/src/utils/MenuDataUtil/MenuDataUtil.ts

@@ -0,0 +1,54 @@
+import type { MenuItemData } from '../../models/nestedMenu';
+
+export class MenuDataUtil {
+
+  public static isMenuItemData(value: unknown): value is MenuItemData {
+    if (typeof value !== 'object' || value === null) {
+      return false;
+    }
+
+    const item = value as Record<string, unknown>;
+
+    if (item.uid !== undefined && typeof item.uid !== 'string') {
+      return false;
+    }
+
+    if (item.label !== undefined && typeof item.label !== 'string') {
+      return false;
+    }
+
+    if (item.callback !== undefined && typeof item.callback !== 'function') {
+      return false;
+    }
+
+    if (item.items !== undefined && (!Array.isArray(item.items) || !item.items.every(MenuDataUtil.isMenuItemData))) {
+      return false;
+    }
+
+    if (item.disabled !== undefined && typeof item.disabled !== 'boolean') {
+      return false;
+    }
+
+    if (item.divider !== undefined && typeof item.divider !== 'boolean') {
+      return false;
+    }
+
+    if (item.autoCloseDisabled !== undefined && typeof item.autoCloseDisabled !== 'boolean') {
+      return false;
+    }
+
+    if (item.active !== undefined && typeof item.active !== 'boolean') {
+      return false;
+    }
+
+    if (item.checked !== undefined && !['true', 'false', 'mixed'].includes(item.checked as string)) {
+      return false;
+    }
+
+    return true;
+  }
+
+  public static isMenuItemDataArray(value: unknown): value is MenuItemData[] {
+    return Array.isArray(value) && value.every(MenuDataUtil.isMenuItemData);
+  }
+}

package/src/utils/MenuDataUtil/index.ts

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

package/src/utils/NewickUtil/NewickUtil.test.ts

@@ -0,0 +1,187 @@
+import {
+  describe,
+  it,
+  expect,
+} from 'vitest';
+import Decimal from 'decimal.js';
+
+import type { TreeNode } from '../../models/tree';
+
+import { NewickUtil } from './NewickUtil';
+
+describe('NewickUtil', () => {
+  describe('parseNewick', () => {
+    it('should parse a simple Newick string', () => {
+      const newick = '(A,B,(C,D));';
+      const expectedTree: Partial<TreeNode> = {
+        children: [
+          {
+            name: 'A',
+            size: 1,
+            maxBranchLength: new Decimal(0),
+            subTreeNames: [],
+            subTreeLeaveNames: [
+              'A',
+            ],
+          },
+          {
+            name: 'B',
+            size: 1,
+            maxBranchLength: new Decimal(0),
+            subTreeNames: [],
+            subTreeLeaveNames: [
+              'B',
+            ],
+          },
+          {
+            children: [
+              {
+                name: 'C',
+                size: 1,
+                maxBranchLength: new Decimal(0),
+                subTreeNames: [],
+                subTreeLeaveNames: [
+                  'C',
+                ],
+              },
+              {
+                name: 'D',
+                size: 1,
+                maxBranchLength: new Decimal(0),
+                subTreeNames: [],
+                subTreeLeaveNames: [
+                  'D',
+                ],
+              },
+            ],
+            size: 2,
+            subTreeNames: [],
+            subTreeLeaveNames: [
+              'C',
+              'D',
+            ],
+            maxBranchLength: new Decimal(0),
+          },
+        ],
+        size: 4,
+        subTreeNames: [],
+        subTreeLeaveNames: [
+          'A',
+          'B',
+          'C',
+          'D',
+        ],
+        name: 'Root',
+        branchLength: new Decimal(0),
+        maxBranchLength: new Decimal(0),
+      };
+
+      const tree = NewickUtil.parse(newick);
+      expect(tree).toEqual(expectedTree);
+    });
+
+    it('should handle branch lengths', () => {
+      const newick = '(A:0.1,B:0.2,(C:0.3,D:0.4):0.5);';
+      const expectedTree: Partial<TreeNode> = {
+        children: [
+          {
+            name: 'A',
+            branchLength: new Decimal('0.1'),
+            subTreeNames: [],
+            subTreeLeaveNames: [
+              'A',
+            ],
+            maxBranchLength: new Decimal('0.1'),
+            size: 1,
+          },
+          {
+            name: 'B',
+            branchLength: new Decimal('0.2'),
+            subTreeNames: [],
+            subTreeLeaveNames: [
+              'B',
+            ],
+            maxBranchLength: new Decimal('0.2'),
+            size: 1,
+          },
+          {
+            children: [
+              {
+                name: 'C',
+                branchLength: new Decimal('0.3'),
+                subTreeNames: [],
+                subTreeLeaveNames: [
+                  'C',
+                ],
+                maxBranchLength: new Decimal('0.3'),
+                size: 1,
+              },
+              {
+                name: 'D',
+                branchLength: new Decimal('0.4'),
+                subTreeNames: [],
+                subTreeLeaveNames: [
+                  'D',
+                ],
+                maxBranchLength: new Decimal('0.4'),
+                size: 1,
+              },
+            ],
+            size: 2,
+            subTreeNames: [
+              'C',
+              'D',
+            ],
+            subTreeLeaveNames: [
+              'C',
+              'D',
+            ],
+            branchLength: new Decimal('0.5'),
+            maxBranchLength: new Decimal('0.9'),
+            name: 'Generated-7225787341756924',
+          },
+        ],
+        size: 4,
+        subTreeNames: [
+          'C',
+          'D',
+        ],
+        subTreeLeaveNames: [
+          'A',
+          'B',
+          'C',
+          'D',
+        ],
+        name: 'Root',
+        branchLength: new Decimal('0'),
+        maxBranchLength: new Decimal('0.9'),
+      };
+      const tree = NewickUtil.parse(newick);
+      expect(tree).toEqual(expectedTree);
+    });
+
+    it('should handle a single leaf (no parentheses)', () => {
+      const newick = 'A;';
+      const expectedTree: Partial<TreeNode> = {
+        branchLength: new Decimal(0),
+        maxBranchLength: new Decimal(0),
+        name: 'Root',
+      };
+
+      const tree = NewickUtil.parse(newick);
+      expect(tree).toEqual(expectedTree);
+    });
+  });
+
+  describe('getSortedNames', () => {
+    it('should return the name for a leaf node', () => {
+      const leaf: TreeNode = { name: 'A' };
+      expect(NewickUtil.getSortedNames(leaf)).toEqual(['A']);
+    });
+
+    it('should return leaf names in depth-first order for a tree', () => {
+      const tree = NewickUtil.parse('(A,B,(C,D));');
+      expect(NewickUtil.getSortedNames(tree)).toEqual(['A', 'B', 'C', 'D']);
+    });
+  });
+});

package/src/utils/NewickUtil/NewickUtil.ts

@@ -0,0 +1,69 @@
+import Decimal from 'decimal.js';
+import sum from 'lodash/sum';
+
+import { StringUtil } from '../StringUtil';
+import type { TreeNode } from '../../models/tree';
+
+export class NewickUtil {
+  public static parse(newick: string): TreeNode {
+    const ancestors: Array<Partial<TreeNode>> = [];
+    let tree: Partial<TreeNode> = {};
+    const tokens = newick.split(/(;|\(|\)|,|:)/).map(x => x.trim()).filter(x => x);
+    for (let i = 0; i < tokens.length; i++) {
+      const token = tokens[i];
+      const subtree: Partial<TreeNode> = {};
+      const x = tokens[i - 1];
+      switch (token) {
+        case '(': // new children
+          tree.children = [subtree];
+          ancestors.push(tree);
+          tree = subtree;
+          break;
+        case ',': // another branch
+          ancestors[ancestors.length - 1].children.push(subtree);
+          tree = subtree;
+          break;
+        case ')': // optional name next
+          tree = ancestors.pop();
+          tree.children.forEach(child => {
+            if (!child.children) {
+              child.size = 1;
+              child.maxBranchLength = new Decimal(child.branchLength ?? 0);
+              child.subTreeLeaveNames = [child.name];
+              child.subTreeNames = child.subTreeNames ?? [];
+            }
+          });
+          tree.size = sum(tree.children.map(child => child.size));
+          tree.subTreeNames = tree.children.map(child => child.subTreeNames).flat().filter(n => n);
+          tree.subTreeLeaveNames = tree.children.map(child => child.subTreeLeaveNames).flat().filter(n => n);
+          tree.maxBranchLength = Decimal.max(...tree.children.map(child => child.maxBranchLength));
+          break;
+        case ':': // optional length next
+          break;
+        case ';': // end of tree, nothing to do
+          break;
+        default:
+          if (x === ')' || x === '(' || x === ',') {
+            tree.name = token;
+          } else if (x === ':') {
+            tree.branchLength = new Decimal(token);
+            tree.subTreeNames = (tree.children ?? []).map(child => [child.name, ...child.subTreeNames]).flat().filter(n => n);
+            tree.subTreeLeaveNames = (tree.children ?? []).map(child => child.subTreeLeaveNames).flat().filter(n => n);
+            tree.maxBranchLength = tree.branchLength.add(tree.children?.length ? Decimal.max(...tree.children.map(child => child.maxBranchLength)) : 0);
+            tree.name = tree.name || `Generated-${StringUtil.createHash(tree.subTreeNames.join(','))}`;
+          }
+      }
+    }
+    tree.branchLength = tree.branchLength ?? new Decimal(0);
+    tree.maxBranchLength = tree.children?.length ? Decimal.max(...tree.children.map(child => child.maxBranchLength)) : new Decimal(0);
+    tree.name = 'Root';
+    return tree;
+  }
+
+  public static getSortedNames(node: TreeNode): string[] {
+    return [
+      ...(node.children ?? []).map(child => NewickUtil.getSortedNames(child)).flat(),
+      ...(!node.children ? [node.name] : []),
+    ];
+  }
+}

package/src/utils/NewickUtil/index.ts

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

package/src/utils/NotificationUtil/NotificationUtil.ts

@@ -0,0 +1,28 @@
+import { t } from 'i18next';
+import type { ReactElement } from 'react';
+
+import { AxiosUtil } from '../AxiosUtil';
+
+export class NotificationUtil {
+  public static wrapErrorNotificationMessage(message: string | ReactElement, error: unknown): string | ReactElement {
+    if (AxiosUtil.isAxiosForbiddenError(error)) {
+      message = t('{{message}} - You do not have permission to perform this action.', { message });
+    }
+    if (AxiosUtil.isAxiosUnauthorizedError(error)) {
+      message = t('{{message}} - You are not logged in.', { message });
+    }
+    if (AxiosUtil.isAxiosNotFoundError(error)) {
+      message = t('{{message}} - The item does not exist.', { message });
+    }
+    if (AxiosUtil.isAxiosBadRequestError(error)) {
+      message = t('{{message}} - Bad request. The input data was not correct.', { message });
+    }
+    if (AxiosUtil.isAxiosConflictError(error)) {
+      message = t('{{message}} - Conflict. The request could not be completed due to a conflict with the current state of the resource.', { message });
+    }
+    if (AxiosUtil.isAxiosInternalServerError(error)) {
+      message = t('{{message}} - Internal Server Error. Please try again later.', { message });
+    }
+    return message;
+  }
+}

package/src/utils/NotificationUtil/index.ts

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

package/src/utils/NumberUtil/NumberUtil.test.ts

@@ -0,0 +1,113 @@
+import {
+  describe,
+  it,
+  expect,
+} from 'vitest';
+
+import { NumberUtil } from './NumberUtil';
+
+describe('NumberUtil', () => {
+  describe('toStringWithPrecision', () => {
+    it('should return a string with the correct precision', () => {
+      expect(NumberUtil.toStringWithPrecision(123.456, 0.01)).toBe('123.45');
+      expect(NumberUtil.toStringWithPrecision(123.4, 0.01)).toBe('123.40');
+      expect(NumberUtil.toStringWithPrecision(123, 0.01)).toBe('123.00');
+      expect(NumberUtil.toStringWithPrecision(123.456, 0.1)).toBe('123.4');
+      expect(NumberUtil.toStringWithPrecision(123.456, 1)).toBe('123');
+    });
+
+    it('should return an empty string if the value is not a number', () => {
+      expect(NumberUtil.toStringWithPrecision(NaN, 0.01)).toBe('');
+      expect(NumberUtil.toStringWithPrecision(undefined as unknown as number, 0.01)).toBe('');
+      expect(NumberUtil.toStringWithPrecision(null as unknown as number, 0.01)).toBe('');
+    });
+
+    it('should handle cases where the base has no decimal part', () => {
+      expect(NumberUtil.toStringWithPrecision(123.456, 1)).toBe('123');
+      expect(NumberUtil.toStringWithPrecision(123.456, 10)).toBe('123');
+    });
+  });
+
+
+  describe('parse', () => {
+    it('should parse decimal formats with dots', () => {
+      expect(NumberUtil.parse('1.0')).toBe(1.0);
+      expect(NumberUtil.parse('1.5')).toBe(1.5);
+      expect(NumberUtil.parse('0.001')).toBe(0.001);
+    });
+
+    it('should parse decimal formats with commas', () => {
+      expect(NumberUtil.parse('1,0')).toBe(1.0);
+      expect(NumberUtil.parse('1,5')).toBe(1.5);
+      expect(NumberUtil.parse('123,456')).toBe(123.456);
+      expect(NumberUtil.parse('0,001')).toBe(0.001);
+    });
+
+    it('should parse thousands separators correctly', () => {
+      expect(NumberUtil.parse('1.000')).toBe(1);
+      expect(NumberUtil.parse('1,000')).toBe(1);
+      expect(NumberUtil.parse('123,456')).toBe(123.456);
+      expect(NumberUtil.parse('1.234.567')).toBe(1234567);
+      expect(NumberUtil.parse('1,234,567')).toBe(1234567);
+      expect(NumberUtil.parse('1,234,567.5')).toBe(1234567.5);
+      expect(NumberUtil.parse('1 234.567')).toBe(1234.567);
+      expect(NumberUtil.parse('1 234 567')).toBe(1234567);
+      expect(NumberUtil.parse('1 234 567.5')).toBe(1234567.5);
+    });
+
+    it('should parse mixed formats with thousands and decimals', () => {
+      expect(NumberUtil.parse('1,234.56')).toBe(1234.56);
+      expect(NumberUtil.parse('1.234,56')).toBe(1234.56);
+      expect(NumberUtil.parse('123,456.789')).toBe(123456.789);
+      expect(NumberUtil.parse('123.456,789')).toBe(123456.789);
+      expect(NumberUtil.parse('123 456.789')).toBe(123456.789);
+      expect(NumberUtil.parse('123 456,789')).toBe(123456.789);
+    });
+
+    it('should parse negative numbers', () => {
+      expect(NumberUtil.parse('-1.0')).toBe(-1.0);
+      expect(NumberUtil.parse('-1,0')).toBe(-1.0);
+      expect(NumberUtil.parse('-123.456')).toBe(-123.456);
+      expect(NumberUtil.parse('-1,234.56')).toBe(-1234.56);
+      expect(NumberUtil.parse('-1,000')).toBe(-1);
+    });
+
+    it('should parse whole numbers without separators', () => {
+      expect(NumberUtil.parse('123')).toBe(123);
+      expect(NumberUtil.parse('0')).toBe(0);
+      expect(NumberUtil.parse('999')).toBe(999);
+      expect(NumberUtil.parse('-456')).toBe(-456);
+    });
+
+    it('should handle whitespace', () => {
+      expect(NumberUtil.parse(' 123.45 ')).toBe(123.45);
+      expect(NumberUtil.parse('  1,234.56  ')).toBe(1234.56);
+      expect(NumberUtil.parse('\t123\t')).toBe(123);
+    });
+
+    it('should handle edge cases and invalid inputs', () => {
+      expect(NumberUtil.parse('')).toBeNaN();
+      expect(NumberUtil.parse('   ')).toBeNaN();
+      expect(NumberUtil.parse('abc')).toBeNaN();
+      expect(NumberUtil.parse('12.34.56.78')).toBe(12345678);
+      expect(NumberUtil.parse('1,2,3,4')).toBe(1234);
+    });
+
+    it('should handle type safety', () => {
+      expect(NumberUtil.parse(null)).toBeNaN();
+      expect(NumberUtil.parse(undefined)).toBeNaN();
+      expect(NumberUtil.parse(123)).toBe(123);
+    });
+
+    it('should handle precision edge cases', () => {
+      expect(NumberUtil.parse('1.1234')).toBe(1.1234);
+      expect(NumberUtil.parse('1,1234')).toBe(1.1234);
+      expect(NumberUtil.parse('123.45,67')).toBe(12345.67);
+      expect(NumberUtil.parse('0.0')).toBe(0.0);
+      expect(NumberUtil.parse('0,0')).toBe(0.0);
+      expect(NumberUtil.parse(' ')).toBe(NaN);
+      expect(NumberUtil.parse('')).toBe(NaN);
+
+    });
+  });
+});

package/src/utils/NumberUtil/NumberUtil.ts

@@ -0,0 +1,67 @@
+import { number } from 'yup';
+
+export class NumberUtil {
+  public static get yup() {
+    return number().typeError('');
+  }
+
+  public static toStringWithPrecision(value: number, base: number): string {
+    if (typeof value !== 'number' || !isFinite(value)) {
+      return '';
+    }
+    const precision = base.toString().split('.')?.[1]?.length ?? 0;
+    const splitValue = value.toString().split('.');
+
+    let stringValue = splitValue[0];
+    if (precision > 0) {
+      stringValue = `${stringValue}.${(splitValue[1] ?? '').padEnd(precision, '0').slice(0, precision)}`;
+    }
+    return stringValue;
+  }
+
+
+  public static parse(value: string | number): number {
+    if (typeof value === 'number') {
+      return value;
+    }
+
+    if (typeof value !== 'string' || value.trim() === '') {
+      return NaN;
+    }
+
+    let sanitizedValue = value
+      .trim()
+      .replace(/[^0-9,.-\s]/g, ''); // Remove all except digits, commas, periods, minus signs, and whitespace
+
+    // if multiple commas or periods exist, assume they are thousands separators and remove them
+    const periodMatchesLength = (sanitizedValue.match(/[.]/g) || []).length;
+    const commaMatchesLength = (sanitizedValue.match(/[,]/g) || []).length;
+    const spaceMatchesLength = (sanitizedValue.match(/[\s]/g) || []).length;
+
+    if ([periodMatchesLength, commaMatchesLength, spaceMatchesLength].filter(count => count > 1).length > 1) {
+      return NaN;
+    }
+
+    if (commaMatchesLength > 1) {
+      // Remove all commas if there are multiple, assuming they are thousands separators
+      // Note: remaining periods are treated as decimal separators
+      return parseFloat(sanitizedValue.replace(/[,\s]/g, ''));
+    }
+    if (spaceMatchesLength > 1) {
+      // Remove all whitespace if there are multiple, assuming they are thousands separators
+      sanitizedValue = sanitizedValue.replace(/\s/g, '');
+      // Note: remaining commas or periods are treated as decimal separators
+      return parseFloat(sanitizedValue.replace(',', '.'));
+    }
+    if (periodMatchesLength > 1) {
+      // Remove all periods if there are multiple, assuming they are thousands separators
+      sanitizedValue = sanitizedValue.replace(/[.\s]/g, '').replace(',', '.'); // Replace remaining comma with period for decimal
+      return parseFloat(sanitizedValue);
+    }
+
+    sanitizedValue = sanitizedValue.replace(/[,.\s](?=.*[,.\s])/g, '')
+      .replace(',', '.');                  // Replace remaining comma with period for decimal
+
+    return parseFloat(sanitizedValue);
+  }
+}

package/src/utils/NumberUtil/index.ts

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