@thoughtspot/ts-chart-sdk 0.0.2-alpha.24 → 0.0.2-alpha.26

package/src/utils/globalize-Initializer/globalize-utils.spec.ts

@@ -0,0 +1,192 @@
+import Globalize from 'globalize';
+import {
+    formatNumberSafely,
+    getCountryCode,
+    getCurrentCurrencyFormat,
+    getDefaultCurrencyCode,
+    getGlobalizeLocale,
+    globalizeCurrencyFormatter,
+    globalizeNumberFormatter,
+    initGlobalize,
+    loadCurrencyData,
+    loadGlobalizeData,
+    sanitizeFormat,
+    setCurrentCurrencyFormat,
+    setGlobalizeLocale,
+    validateNumberFormat,
+} from './globalize-utils';
+
+describe('Initialize Globalize', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        initGlobalize('en-US');
+    });
+
+    describe('getCountryCode', () => {
+        it('should extract country code from locale with underscore', () => {
+            expect(getCountryCode('en_US')).toBe('US');
+        });
+
+        it('should extract country code from locale with hyphen', () => {
+            expect(getCountryCode('en-US')).toBe('US');
+        });
+
+        it('should return the input locale if no delimiter is found', () => {
+            expect(getCountryCode('en')).toBe('en');
+        });
+    });
+
+    describe('getDefaultCurrencyCode', () => {
+        it('should return the current currency format if set', () => {
+            setCurrentCurrencyFormat('EUR');
+            expect(getDefaultCurrencyCode()).toBe('EUR');
+        });
+
+        it('should return GBP if no currency data is found', () => {
+            setCurrentCurrencyFormat(null);
+            loadCurrencyData({});
+            expect(getDefaultCurrencyCode()).toBe('GBP');
+        });
+
+        it('should retrieve the default currency code from supplemental data', () => {
+            loadCurrencyData({
+                supplemental: {
+                    currencyData: {
+                        region: {
+                            US: [{ USD: {} }],
+                        },
+                    },
+                },
+            });
+            setGlobalizeLocale('en-US');
+            expect(getDefaultCurrencyCode()).toBe('USD');
+        });
+    });
+
+    describe('setGlobalizeLocale', () => {
+        it('should set the Globalize locale', () => {
+            setGlobalizeLocale('fr-FR');
+            expect(getGlobalizeLocale()).toBe('fr-FR');
+        });
+    });
+
+    describe('getGlobalizeLocale', () => {
+        it('should return the current locale', () => {
+            expect(getGlobalizeLocale()).toBe('en-US');
+        });
+    });
+
+    describe('setCurrentCurrencyFormat', () => {
+        it('should set the current currency format', () => {
+            setCurrentCurrencyFormat('JPY');
+            expect(getCurrentCurrencyFormat()).toBe('JPY');
+        });
+    });
+
+    describe('loadCurrencyData', () => {
+        it('should load supplemental currency data', () => {
+            const data = {
+                supplemental: {
+                    currencyData: {
+                        region: {
+                            US: [{ USD: {} }],
+                        },
+                    },
+                },
+            };
+            setCurrentCurrencyFormat(null);
+            loadCurrencyData(data);
+            expect(getDefaultCurrencyCode()).toBe('USD');
+        });
+    });
+
+    describe('loadGlobalizeData', () => {
+        it('should load CLDR data', () => {
+            jest.spyOn(Globalize, 'load').mockImplementationOnce((data) => {
+                return data;
+            });
+            const data = { key: 'value' };
+            loadGlobalizeData(data);
+            expect(Globalize.load).toHaveBeenCalledWith(data);
+            jest.clearAllMocks();
+        });
+    });
+
+    describe('globalizeNumberFormatter', () => {
+        it('should create a number formatter', () => {
+            const formatter = globalizeNumberFormatter({
+                minimumFractionDigits: 2,
+            });
+            expect(typeof formatter).toBe('function');
+        });
+    });
+
+    describe('globalizeCurrencyFormatter', () => {
+        it('should create a currency formatter', () => {
+            const formatter = globalizeCurrencyFormatter('USD', {
+                style: 'symbol',
+            });
+            expect(typeof formatter).toBe('function');
+        });
+    });
+
+    describe('formatNumberSafely', () => {
+        it('should format numbers safely', () => {
+            const formattedNumber = formatNumberSafely(
+                { maximumFractionDigits: 2, minimumFractionDigits: 2 },
+                123.456,
+            );
+            expect(formattedNumber).toBe('123.46');
+        });
+
+        it('should return 0 for very small numbers', () => {
+            jest.spyOn(Globalize, 'numberFormatter').mockImplementationOnce(
+                () => {
+                    throw new Error('Test Error');
+                },
+            );
+            const formattedNumber = formatNumberSafely({}, 1e-8);
+            expect(formattedNumber).toBe('0');
+            jest.clearAllMocks();
+        });
+
+        it('should return the string representation for errors', () => {
+            jest.spyOn(Globalize, 'numberFormatter').mockImplementationOnce(
+                () => {
+                    throw new Error('Test Error');
+                },
+            );
+            const formattedNumber = formatNumberSafely({}, 123);
+            expect(formattedNumber).toBe('123');
+            jest.clearAllMocks();
+        });
+    });
+
+    describe('sanitizeFormat', () => {
+        it('should add zero before decimal point', () => {
+            expect(sanitizeFormat('#.##')).toBe('0.##');
+        });
+
+        it('should add zero at the end if no decimal point', () => {
+            expect(sanitizeFormat('#%')).toBe('0%');
+        });
+
+        it('should return the same format if no changes are needed', () => {
+            expect(sanitizeFormat('0.##')).toBe('0.##');
+        });
+    });
+
+    describe('validateNumberFormat', () => {
+        it('should return true for valid number formats', () => {
+            expect(validateNumberFormat('#.##')).toBe(true);
+        });
+
+        it('should return false for invalid number formats', () => {
+            jest.spyOn(Globalize, 'numberFormatter').mockImplementation(() => {
+                throw new Error('Test Error');
+            });
+            expect(validateNumberFormat('#.#')).toBe(false);
+            jest.clearAllMocks();
+        });
+    });
+});

package/src/utils/globalize-Initializer/globalize-utils.ts

@@ -0,0 +1,216 @@
+/**
+ * @file: Initialize Globalize
+ *
+ * @author Yashvardhan Nehra <yashvardhan.nehra@thoughtspot.com>
+ *
+ * Copyright: ThoughtSpot Inc. 2024
+ */
+
+/* eslint-disable import/no-extraneous-dependencies */
+import enCaGregorian from 'cldr-data/main/en/ca-gregorian.json';
+import enCurrencies from 'cldr-data/main/en/currencies.json';
+import enNumbers from 'cldr-data/main/en/numbers.json';
+import currencyData from 'cldr-data/supplemental/currencyData.json';
+import supplemental from 'cldr-data/supplemental/likelySubtags.json';
+import enpluralJson from 'cldr-data/supplemental/plurals.json';
+import Globalize from 'globalize';
+import _ from 'lodash';
+import { create } from '../../main/logger';
+
+const logger = create('globalize-initializer');
+
+let currentLocale: string;
+let currentCurrencyFormat: any;
+let supplementalCurrencyDataJson: any;
+
+/**
+ * Extracts the country code from a locale string.
+ *
+ * @param locale - The locale string (e.g., 'en-US', 'en_US').
+ * @returns The country code (e.g., 'US') or the input locale if no delimiter is found.
+ */
+export const getCountryCode = (locale: string): string => {
+    let parts = locale.split('_'); //  // Split by '_'
+    if (parts.length === 2) {
+        return parts[1].toUpperCase();
+    }
+    parts = locale.split('-'); //  // Split by '-'
+    if (parts.length === 2) {
+        return parts[1].toUpperCase();
+    }
+    return locale;
+};
+
+/**
+ * Retrieves the default currency code for the current locale.
+ *
+ * @returns The default currency code (e.g., 'USD') or GBP if not found.
+ */
+export const getDefaultCurrencyCode = (): string => {
+    if (currentCurrencyFormat) {
+        return currentCurrencyFormat;
+    }
+
+    const countryCode = getCountryCode(currentLocale);
+    const regionData =
+        supplementalCurrencyDataJson?.supplemental?.currencyData?.region[
+            countryCode.toUpperCase()
+        ];
+    if (!regionData || regionData.length === 0) {
+        logger.warn('No currency data found for country:', countryCode);
+        return 'GBP';
+    }
+    return Object.keys(regionData[regionData.length - 1])[0];
+};
+
+/**
+ * Sets the current locale for Globalize and updates the global state.
+ *
+ * @param locale - The locale string to set (e.g., 'en-US').
+ */
+export const setGlobalizeLocale = (locale: string): void => {
+    Globalize.locale(locale);
+    currentLocale = locale;
+};
+
+/**
+ * Retrieves the current locale set in Globalize.
+ *
+ * @returns The current locale string (e.g., 'en-US').
+ */
+export const getGlobalizeLocale = () => currentLocale;
+
+/**
+ * Updates the current currency format.
+ *
+ * @param currencyFormat - The currency format to set.
+ */
+export const setCurrentCurrencyFormat = (currencyFormat: any): void => {
+    currentCurrencyFormat = currencyFormat;
+};
+
+/**
+ * Retrieves the current currency format.
+ *
+ * @returns The current currency format.
+ */
+export const getCurrentCurrencyFormat = () => currentCurrencyFormat;
+
+/**
+ * Loads supplemental currency data for Globalize.
+ *
+ * @param data - The supplemental currency data to load.
+ */
+export const loadCurrencyData = (data: any) => {
+    supplementalCurrencyDataJson = data;
+};
+
+/**
+ * Loads CLDR data into Globalize.
+ *
+ * @param data - The CLDR data to load.
+ */
+export const loadGlobalizeData = (data: any) => {
+    Globalize.load(data);
+};
+
+/**
+ * Initializes Globalize with CLDR data and sets the default locale.
+ *
+ * @param locale - The locale to initialize Globalize with (default: 'en-GB').
+ */
+export const initGlobalize = (locale = 'en-GB') => {
+    loadGlobalizeData(enNumbers);
+    loadGlobalizeData(enCaGregorian);
+    loadGlobalizeData(supplemental);
+    loadGlobalizeData(currencyData);
+    loadGlobalizeData(enpluralJson);
+    loadGlobalizeData(enCurrencies);
+
+    loadCurrencyData(currencyData);
+
+    setGlobalizeLocale(locale);
+};
+
+/**
+ * Creates a number formatter with the given options.
+ *
+ * @param format - The Globalize number formatter options.
+ * @returns A formatter function for numbers.
+ */
+export function globalizeNumberFormatter(
+    format: Globalize.NumberFormatterOptions,
+): (num: number) => string {
+    return Globalize.numberFormatter(format);
+}
+
+/**
+ * Creates a currency formatter with the given options.
+ *
+ * @param currencyCode - The ISO currency code (e.g., 'USD').
+ * @param format - The Globalize currency formatter options.
+ * @returns A formatter function for currency values.
+ */
+export function globalizeCurrencyFormatter(
+    currencyCode: string,
+    format: Globalize.CurrencyFormatterOptions,
+): (num: number) => string {
+    return Globalize.currencyFormatter(currencyCode, format);
+}
+
+/**
+ * Formats a number using Globalize, handling errors gracefully.
+ *
+ * @param format - Globalize number formatter options.
+ * @param num - The number to format.
+ * @returns The formatted number as a string.
+ */
+export function formatNumberSafely<
+    FormatOptions extends Globalize.NumberFormatterOptions,
+>(format: FormatOptions, num: number): string {
+    try {
+        const formatter = globalizeNumberFormatter(format);
+        const formattedNumber = formatter(num);
+        return formattedNumber;
+    } catch (e) {
+        logger.error('Error formatting pattern: ', format, num, e);
+        if (Math.abs(num) < 1e-7) {
+            return '0';
+        }
+        return String(num);
+    }
+}
+
+/**
+ * Sanitizes a number format to ensure compatibility with Globalize.
+ *
+ * @param format - The raw format string (e.g., '#.##').
+ * @returns A sanitized format string (e.g., '0.##').
+ */
+export const sanitizeFormat = (format: string): string => {
+    // Globalize needs to have a zero before the decimal point
+    // or at the end of format if no decimal point
+    let sanitizedFormat = format.replace(/#\./, '0.');
+    if (!sanitizedFormat.includes('.')) {
+        sanitizedFormat = sanitizedFormat.replace(/#(%?)$/, '0$1');
+    }
+    return sanitizedFormat;
+};
+
+/**
+ * Validates if a given number format is compatible with Globalize.
+ *
+ * @param format - The raw format string.
+ * @returns True if the format is valid; otherwise, false.
+ */
+export const validateNumberFormat = (format: string): boolean => {
+    try {
+        Globalize.numberFormatter({
+            ...({ raw: sanitizeFormat(format) } as any),
+        })(123); // Test the formatter with a dummy value
+    } catch (e) {
+        logger.error('Invalid number format:', format, e);
+        return false;
+    }
+    return true;
+};

package/src/utils/number-formatting/number-formatting-utils.spec.ts

@@ -0,0 +1,296 @@
+import {
+    ColumnFormat,
+    CurrencyFormat,
+    CurrencyFormatType,
+    FormatType,
+} from '../../types/answer-column.types';
+import {
+    CategoryType,
+    CurrencyFormatConfig,
+    NegativeValueFormat,
+    NumberFormatConfig,
+    Unit,
+} from '../../types/number-formatting.types';
+import * as globalizeUtils from '../globalize-Initializer/globalize-utils';
+import {
+    defaultFormatConfig,
+    formatNegativeValue,
+    formatSpecialDataValue,
+    getAutoUnit,
+    getLocaleBasedStringFormats,
+    getLocaleName,
+    mapFormatterConfig,
+    setLocaleBasedStringFormats,
+    UNITS_TO_DIVIDING_FACTOR,
+} from './number-formatting-utils';
+
+describe('formatNegativeValue', () => {
+    it('should format with prefix dash', () => {
+        const result = formatNegativeValue(
+            '100',
+            NegativeValueFormat.PrefixDash,
+        );
+        expect(result).toBe('-100');
+    });
+
+    it('should format with suffix dash', () => {
+        const result = formatNegativeValue(
+            '100',
+            NegativeValueFormat.SuffixDash,
+        );
+        expect(result).toBe('100-');
+    });
+
+    it('should format with braces without dash', () => {
+        const result = formatNegativeValue(
+            '100',
+            NegativeValueFormat.BracesNodash,
+        );
+        expect(result).toBe('(100)');
+    });
+
+    it('should default to prefix dash if no format is provided', () => {
+        const result = formatNegativeValue('100');
+        expect(result).toBe('-100');
+    });
+});
+
+describe('getAutoUnit', () => {
+    it('should return Trillion for values above 1 Trillion', () => {
+        const result = getAutoUnit(1e12);
+        expect(result).toBe(Unit.Trillion);
+    });
+
+    it('should return Billion for values above 1 Billion', () => {
+        const result = getAutoUnit(1e9);
+        expect(result).toBe(Unit.Billion);
+    });
+
+    it('should return Million for values above 1 Million', () => {
+        const result = getAutoUnit(1e6);
+        expect(result).toBe(Unit.Million);
+    });
+
+    it('should return Thousands for values above 1 Thousand', () => {
+        const result = getAutoUnit(1e3);
+        expect(result).toBe(Unit.Thousands);
+    });
+
+    it('should return None for values below 1000', () => {
+        const result = getAutoUnit(500);
+        expect(result).toBe(Unit.None);
+    });
+});
+
+describe('getLocaleName', () => {
+    it('should return default locale if currency format is not ISO_CODE', () => {
+        jest.spyOn(
+            globalizeUtils,
+            'getDefaultCurrencyCode',
+        ).mockReturnValueOnce('GBP');
+        const currencyFormat: CurrencyFormat = {
+            type: CurrencyFormatType.USER_LOCALE,
+            column: '',
+            isoCode: '',
+        };
+        const result = getLocaleName(currencyFormat);
+        expect(result).toBe('GBP'); // Default locale
+    });
+
+    it('should return ISO code if currency format is ISO_CODE', () => {
+        const currencyFormat: CurrencyFormat = {
+            type: CurrencyFormatType.ISO_CODE,
+            column: '',
+            isoCode: 'USD',
+        };
+        const result = getLocaleName(currencyFormat);
+        expect(result).toBe('USD');
+    });
+});
+
+describe('defaultFormatConfig', () => {
+    it('should return custom format config for a pattern', () => {
+        const columnFormatConfig: ColumnFormat = {
+            type: FormatType.PATTERN,
+            pattern: '###,###',
+        };
+        const result = defaultFormatConfig(columnFormatConfig);
+        expect(result.category).toBe(CategoryType.Custom);
+        expect(result.customFormatConfig?.format).toBe('###,###');
+    });
+
+    it('should return currency format config if currencyFormat is defined', () => {
+        const columnFormatConfig: ColumnFormat = {
+            type: FormatType.CURRENCY,
+            currencyFormat: {
+                type: CurrencyFormatType.ISO_CODE,
+                column: '',
+                isoCode: 'USD',
+            },
+        };
+        const result = defaultFormatConfig(columnFormatConfig);
+        expect(result.category).toBe(CategoryType.Currency);
+        expect(result.currencyFormatConfig?.locale).toBe('USD');
+    });
+
+    it('should return number format config by default', () => {
+        const result = defaultFormatConfig();
+        expect(result.category).toBe(CategoryType.Number);
+        expect(result.numberFormatConfig?.decimals).toBe(0);
+    });
+});
+
+describe('mapFormatterConfig', () => {
+    it('should return correct formatter config for a number format', () => {
+        const absFloatValue = 1000;
+        const configDetails: NumberFormatConfig = {
+            decimals: 2,
+            negativeValueFormat: NegativeValueFormat.PrefixDash,
+            removeTrailingZeroes: false,
+            toSeparateThousands: true,
+            unit: Unit.Million,
+        };
+
+        const result = mapFormatterConfig(absFloatValue, configDetails);
+        expect(result.unitDetails).toBe(Unit.Million); // Unit: Million
+        expect(result.decimalDetails).toBe(2);
+        expect(result.shouldRemoveTrailingZeros).toBe(false);
+    });
+
+    it('should return auto unit and decimal precision for large value', () => {
+        const absFloatValue = 1e9; // 1 Billion
+        const configDetails: NumberFormatConfig = {
+            decimals: 0,
+            negativeValueFormat: NegativeValueFormat.PrefixDash,
+            removeTrailingZeroes: false,
+            toSeparateThousands: true,
+            unit: Unit.Auto, // Auto
+        };
+
+        const result = mapFormatterConfig(absFloatValue, configDetails);
+        expect(result.unitDetails).toBe(Unit.Billion);
+        expect(result.decimalDetails).toBe(2); // Default decimal precision for auto
+    });
+
+    it('should return correct config for currency formatting', () => {
+        const absFloatValue = 1000;
+        const configDetails: CurrencyFormatConfig = {
+            decimals: 2,
+            locale: 'en',
+            removeTrailingZeroes: false,
+            toSeparateThousands: true,
+            unit: Unit.Auto,
+        };
+
+        const result = mapFormatterConfig(absFloatValue, configDetails);
+        expect(result.unitDetails).toBe(Unit.Thousands); // Automatically chosen unit
+        expect(result.decimalDetails).toBe(2);
+    });
+
+    it('should correctly map valid unit numbers to the corresponding unit', () => {
+        const input = { unit: Unit.None };
+        const result = mapFormatterConfig(1000, input);
+
+        // Assert that the unit has been correctly mapped to the corresponding
+        // value in PROTO_TO_UNITS
+        expect(result.unitDetails).toBe(Unit.None);
+    });
+});
+
+describe('formatSpecialDataValue', () => {
+    it('should return {Null} for {Null} values', () => {
+        const result = formatSpecialDataValue('{Null}');
+        expect(result).toBe('{Null}');
+    });
+
+    it('should return {Null} for null values', () => {
+        const result = formatSpecialDataValue(null);
+        expect(result).toBe('{Null}');
+    });
+
+    it('should return {Empty} for empty string', () => {
+        const result = formatSpecialDataValue('');
+        expect(result).toBe('{Empty}');
+    });
+
+    it('should return {Null} for undefined values', () => {
+        const result = formatSpecialDataValue(undefined);
+        expect(result).toBe('{Null}');
+    });
+
+    it('should return NaN for string "NaN"', () => {
+        const result = formatSpecialDataValue(['NaN']);
+        expect(result).toBe('NaN');
+    });
+
+    it('should return {Null} for empty array', () => {
+        const result = formatSpecialDataValue([]);
+        expect(result).toBe('{Null}');
+    });
+
+    it('should return Null for array', () => {
+        const result = formatSpecialDataValue(['Test']);
+        expect(result).toBe(null);
+    });
+
+    it('should return Infinity for string "Infinity"', () => {
+        const result = formatSpecialDataValue(['Infinity']);
+        expect(result).toBe('Infinity');
+    });
+
+    it('should return null for non-special values', () => {
+        const result = formatSpecialDataValue('Test');
+        expect(result).toBeNull();
+    });
+
+    it('should return Infinity for Infinity', () => {
+        const result = formatSpecialDataValue(Infinity);
+        expect(result).toBe('Infinity');
+    });
+});
+
+describe('Unit constants', () => {
+    it('should map unit to correct dividing factor', () => {
+        expect(UNITS_TO_DIVIDING_FACTOR[Unit.Thousands]).toBe(1000);
+        expect(UNITS_TO_DIVIDING_FACTOR[Unit.Million]).toBe(1000000);
+        expect(UNITS_TO_DIVIDING_FACTOR[Unit.Billion]).toBe(1000000000);
+    });
+});
+
+describe('Locale String Formats', () => {
+    const strings: Record<string, string> = {
+        NULL_VALUE_PLACEHOLDER_LABEL: '{Null}',
+        EMPTY_VALUE_PLACEHOLDER_LABEL: '{Empty}',
+    };
+
+    it('should return an default object if setLocaleBasedStringFormats is not called', () => {
+        const result = getLocaleBasedStringFormats();
+        expect(result).toEqual(strings);
+    });
+
+    it('should set and get locale-based string formats correctly', () => {
+        const testLocaleStrings = {
+            greeting: 'Hello',
+            farewell: 'Goodbye',
+        };
+
+        setLocaleBasedStringFormats(testLocaleStrings);
+
+        const result = getLocaleBasedStringFormats();
+
+        expect(result).toEqual(testLocaleStrings);
+    });
+
+    it('should update the string formats when setLocaleBasedStringFormats is called multiple times', () => {
+        const firstSet = { greeting: 'Hola' };
+        const secondSet = { greeting: 'Bonjour' };
+
+        // Set first locale-based string formats
+        setLocaleBasedStringFormats(firstSet);
+        expect(getLocaleBasedStringFormats()).toEqual(firstSet);
+
+        // Set second locale-based string formats
+        setLocaleBasedStringFormats(secondSet);
+        expect(getLocaleBasedStringFormats()).toEqual(secondSet);
+    });
+});