feat : Add Currency Module : [ATLAS-26, ATLAS-27, ATLAS-28]

src/common/errorBoundary/__tests__/index.test.ts

@@ -3,7 +3,8 @@ import { withErrorBoundary, I18nifyError } from '../';
 describe('withErrorBoundary', () => {
   it('should call the wrapped function and not throw an error if there are no exceptions', () => {
     const wrappedFunction = jest.fn();
-    const wrappedUtilityFn = withErrorBoundary(wrappedFunction);
+    const wrappedUtilityFn =
+      withErrorBoundary<typeof wrappedFunction>(wrappedFunction);
 
     wrappedUtilityFn('arg1', 'arg2');
 
@@ -17,7 +18,8 @@ describe('withErrorBoundary', () => {
       throw new Error(exceptionMessage);
     };
 
-    const wrappedUtilityFn = withErrorBoundary(throwingFunction);
+    const wrappedUtilityFn =
+      withErrorBoundary<typeof throwingFunction>(throwingFunction);
 
     expect(() => wrappedUtilityFn()).toThrow(I18nifyError);
   });

src/common/errorBoundary/index.ts

@@ -18,12 +18,12 @@ export class I18nifyError extends Error {
  * @param fn utility that is wrapped in error boundary
  * @returns {Function} returns the function wrapped in try/catch block
  */
-export const withErrorBoundary = <T extends (...args: unknown[]) => void>(
+export const withErrorBoundary = <T extends (...args: unknown[]) => unknown>(
   fn: T,
-): ((...args: Parameters<T>) => void) => {
+): ((...args: Parameters<T>) => ReturnType<T>) => {
   return function (...rest: Parameters<T>) {
     try {
-      fn.call(this, ...rest);
+      return fn.call(this, ...rest);
     } catch (err) {
       // Currently, we are throwing the error as it is to consumers.
       // In the future, this can be modified as per our requirement, like an error logging service.

src/modules/currency/__tests__/formatNumber.test.ts

@@ -0,0 +1,120 @@
+import { getLocale } from '../../shared/utils/getLocale';
+import formatNumber from '../formatNumber';
+
+const nbsp = String.fromCharCode(160);
+const nnsp = String.fromCharCode(8239);
+
+describe('formatNumber', () => {
+  it('should format the amount with default options', () => {
+    const result = formatNumber('1000.5', { currency: 'USD' });
+    expect(result).toBe('$1,000.50');
+  });
+
+  it('should format the amount with custom locale and currency display', () => {
+    const result = formatNumber('1500', {
+      currency: 'EUR',
+      locale: 'fr-FR',
+      intlOptions: {
+        currencyDisplay: 'code',
+      },
+    });
+
+    expect(result).toBe(`1${nnsp}500,00${nbsp}EUR`);
+  });
+
+  it('should format the amount without currency symbol', () => {
+    const result = formatNumber('750.75');
+    expect(result).toBe('750.75');
+  });
+
+  it('should format the amount with narrow currency symbol', () => {
+    const result = formatNumber('5000', {
+      currency: 'JPY',
+      intlOptions: {
+        currencyDisplay: 'narrowSymbol',
+      },
+    });
+    expect(result).toBe('¥5,000');
+  });
+
+  it('should format the amount using the browser locale when no custom locale is provided', () => {
+    const result = formatNumber('2000', {
+      currency: 'CAD',
+    });
+    const expectedLocale = getLocale();
+    const formattedAmount = new Intl.NumberFormat(expectedLocale, {
+      style: 'currency',
+      currency: 'CAD',
+    }).format(2000);
+    expect(result).toBe(formattedAmount);
+  });
+
+  it('should handle invalid inputs gracefully', () => {
+    expect(() =>
+      formatNumber('invalid-amount', {
+        currency: 'USD',
+      }),
+    ).toThrow('Parameter `amount` is not a number!');
+  });
+
+  it('should format a negative amount', () => {
+    const result = formatNumber('-500', { currency: 'USD' });
+    expect(result).toBe('-$500.00');
+  });
+
+  it('should format zero as "0.00"', () => {
+    const result = formatNumber(0, { currency: 'USD' });
+    expect(result).toBe('$0.00');
+  });
+
+  it('should format with custom minimum and maximum fraction digits', () => {
+    const result = formatNumber('42.12345', {
+      currency: 'USD',
+      intlOptions: {
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 3,
+      },
+    });
+    expect(result).toBe('$42.123');
+  });
+
+  it('should format with all default options', () => {
+    const result = formatNumber(12345.6789);
+    expect(result).toBe('12,345.679');
+  });
+
+  it('should throw error with thousands separators', () => {
+    expect(() => formatNumber('1,234,567.89', { currency: 'USD' })).toThrow(
+      'Parameter `amount` is not a number!',
+    );
+  });
+
+  it('should throw error with a different decimal separator', () => {
+    expect(() =>
+      formatNumber('1000,5', {
+        currency: 'USD',
+        intlOptions: { useGrouping: false },
+      }),
+    ).toThrow('Parameter `amount` is not a number!');
+  });
+
+  it('should handle extremely large numbers with precision', () => {
+    const input = '1234567890123456.7890123456789012345678901234567890123456';
+    const result = formatNumber(input, { currency: 'USD' });
+    expect(result).toBe('$1,234,567,890,123,456.80');
+  });
+
+  it('should handle custom currency symbol and placement', () => {
+    const result = formatNumber('1000', {
+      currency: 'XYZ',
+      intlOptions: {
+        style: 'currency',
+        currencyDisplay: 'symbol',
+        currencySign: 'accounting',
+      },
+    });
+
+    const expected = `XYZ${nbsp}1,000.00`;
+    expect(result).toBe(expected);
+  });
+});

src/modules/currency/__tests__/formatNumberByParts.test.ts

@@ -0,0 +1,94 @@
+import formatNumberByParts from '../formatNumberByParts';
+
+describe('formatNumberByParts', () => {
+  it('should format the amount correctly for a given currency', () => {
+    const result = formatNumberByParts(12345.67, {
+      currency: 'USD',
+      locale: 'en-US',
+    });
+
+    expect(result).toEqual({
+      currencySymbol: '$',
+      integerValue: '12,345',
+      decimalValue: '67',
+      separator: '.',
+      symbolAtFirst: true,
+    });
+  });
+
+  it('should throw error for non-numeric input', () => {
+    expect(() =>
+      formatNumberByParts('not a number', {
+        currency: 'USD',
+        locale: 'en-US',
+      }),
+    ).toThrow('Error: Parameter `amount` is not a number!');
+  });
+
+  it('should use the default locale if locale is not provided', () => {
+    const result = formatNumberByParts(12345.67, {
+      currency: 'USD',
+    });
+
+    expect(result).toBeDefined();
+  });
+
+  it('should handle invalid currency code', () => {
+    const result = formatNumberByParts(12345.67, {
+      currency: 'XYZ',
+      locale: 'en-US',
+    });
+    expect(result).toEqual({
+      currencySymbol: 'XYZ',
+      decimalValue: '67',
+      integerValue: '12,345',
+      separator: '.',
+      symbolAtFirst: true,
+    });
+  });
+
+  it('should handle different locales', () => {
+    const result = formatNumberByParts(12345.67, {
+      currency: 'EUR',
+      locale: 'fr-FR',
+    });
+
+    expect(result).toEqual({
+      currencySymbol: '€',
+      decimalValue: '67',
+      integerValue: '12 345',
+      separator: ',',
+      symbolAtFirst: false,
+    });
+  });
+
+  it('should handle a currency with symbol at the beginning', () => {
+    const result = formatNumberByParts(12345.67, {
+      currency: 'JPY',
+      locale: 'ja-JP',
+    });
+
+    expect(result).toEqual({
+      currencySymbol: '￥',
+      decimalValue: '',
+      integerValue: '12,346',
+      separator: '',
+      symbolAtFirst: true,
+    });
+  });
+
+  it('should handle a currency with decimal value and symbol at the end', () => {
+    const result = formatNumberByParts(12345.67, {
+      currency: 'OMR',
+      locale: 'ar-OM',
+    });
+
+    expect(result).toEqual({
+      currencySymbol: 'ر.ع.',
+      decimalValue: '٦٧٠',
+      integerValue: '١٢٬٣٤٥',
+      separator: '٫',
+      symbolAtFirst: false,
+    });
+  });
+});

src/modules/currency/__tests__/getCurrencyList.test.ts

@@ -0,0 +1,26 @@
+import getCurrencyList from '../getCurrencyList';
+import { CURRENCIES } from '../data/currencies';
+describe('getCurrencyList', () => {
+  it('should return the correct currency list', () => {
+    const currencyList = getCurrencyList();
+    expect(currencyList).toEqual(CURRENCIES);
+  });
+
+  it("check properties 'symbol' and 'name' for a sample currency", () => {
+    const currencyList = getCurrencyList();
+    const sampleCurrencyCode = 'USD';
+
+    expect(currencyList[sampleCurrencyCode]).toHaveProperty('symbol');
+    expect(currencyList[sampleCurrencyCode]).toHaveProperty('name');
+  });
+
+  it("check the values of 'symbol' and 'name' properties for a sample currency", () => {
+    const currencyList = getCurrencyList();
+    const sampleCurrencyCode = 'USD';
+    const sampleCurrency = currencyList[sampleCurrencyCode];
+
+    // Assert that the 'symbol' and 'name' properties have the expected values
+    expect(sampleCurrency.symbol).toBe(CURRENCIES[sampleCurrencyCode].symbol);
+    expect(sampleCurrency.name).toBe(CURRENCIES[sampleCurrencyCode].name);
+  });
+});

src/modules/currency/__tests__/getCurrencySymbol.test.ts

@@ -0,0 +1,24 @@
+import getCurrencySymbol from '../getCurrencySymbol';
+
+describe('getCurrencySymbol', () => {
+  it('should return the correct symbol for a valid currency code', () => {
+    const currencyCode = 'USD';
+    const expectedSymbol = '$';
+    const symbol = getCurrencySymbol(currencyCode);
+    expect(symbol).toBe(expectedSymbol);
+  });
+
+  it('should throw Error for an invalid currency code', () => {
+    const currencyCode = 'XYZ'; // An invalid code
+    expect(() => getCurrencySymbol(currencyCode)).toThrow(
+      'Invalid currencyCode!',
+    );
+  });
+
+  it('should throw Error for an empty string', () => {
+    const currencyCode = '';
+    expect(() => getCurrencySymbol(currencyCode)).toThrow(
+      'Invalid currencyCode!',
+    );
+  });
+});