@gen-epix/ui 1.15.1 → 1.16.0

package/src/utils/EpiUploadUtil/index.ts

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

package/src/utils/FileUtil/FileUtil.ts

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

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

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

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

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

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

package/src/utils/MenuDataUtil/MenuDataUtil.ts

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

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

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

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

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

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

package/src/utils/NotificationUtil/NotificationUtil.ts

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

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

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

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

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

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