@thoughtspot/ts-chart-sdk 0.0.2-alpha.8 → 1.0.0

package/src/utils/date-utils.spec.ts

@@ -0,0 +1,93 @@
+import { ChartColumn, ColumnTimeBucket } from '../types/answer-column.types';
+import {
+    getCustomCalendarGuid,
+    getFormatPatternForBucket,
+    showDateFinancialYearFormat,
+} from './date-utils';
+
+describe('getFormatPatternForBucket', () => {
+    const mockDatasourceIdToCustomCalendarMap = {
+        datasource1: {
+            fiscal: 'guid-123',
+            custom: 'guid-456',
+        },
+        datasource2: {
+            fiscal: 'guid-789',
+        },
+    };
+
+    test('should return correct format pattern for YEARLY bucket', () => {
+        const result = getFormatPatternForBucket(ColumnTimeBucket.YEARLY);
+        expect(result).toBe('yyyy');
+    });
+
+    test('should return correct format pattern for MONTHLY bucket', () => {
+        const result = getFormatPatternForBucket(ColumnTimeBucket.MONTHLY);
+        expect(result).toBe('MONTH_WITH_YEAR');
+    });
+
+    test('should return correct format pattern for WEEKLY bucket', () => {
+        const result = getFormatPatternForBucket(ColumnTimeBucket.WEEKLY);
+        expect(result).toBe('DATE_SHORT');
+    });
+
+    test('should handle undefined input gracefully', () => {
+        const result = getFormatPatternForBucket(undefined as any);
+        expect(result).toBeUndefined();
+    });
+
+    test('should return true for QUARTERLY time bucket', () => {
+        const col = { timeBucket: ColumnTimeBucket.QUARTERLY } as ChartColumn;
+        const result = showDateFinancialYearFormat(col);
+
+        expect(result).toBe(true);
+    });
+
+    test('should return true for YEARLY time bucket', () => {
+        const col = { timeBucket: ColumnTimeBucket.YEARLY } as ChartColumn;
+        const result = showDateFinancialYearFormat(col);
+        expect(result).toBe(true);
+    });
+
+    test('should return true for MONTLY time bucket', () => {
+        const col = { timeBucket: ColumnTimeBucket.MONTHLY } as ChartColumn;
+        const result = showDateFinancialYearFormat(col);
+        expect(result).toBe(false);
+    });
+    test('should return the custom calendar GUID when datasourceId and name are valid', () => {
+        const datasourceId = 'datasource1';
+        const name = 'fiscal';
+
+        const result = getCustomCalendarGuid(
+            name,
+            datasourceId,
+            mockDatasourceIdToCustomCalendarMap,
+        );
+
+        expect(result).toBe('guid-123');
+    });
+    test('should return undefined when the datasourceId is valid but the name does not exist', () => {
+        const datasourceId = 'datasource1';
+        const name = 'nonexistent';
+
+        const result = getCustomCalendarGuid(
+            name,
+            datasourceId,
+            mockDatasourceIdToCustomCalendarMap,
+        );
+
+        expect(result).toBeUndefined();
+    });
+    test('should return undefined when the datasourceId does not exist in the map', () => {
+        const datasourceId = 'nonexistentDatasource';
+        const name = 'fiscal';
+
+        const result = getCustomCalendarGuid(
+            name,
+            datasourceId,
+            mockDatasourceIdToCustomCalendarMap,
+        );
+
+        expect(result).toBeUndefined();
+    });
+});

package/src/utils/date-utils.ts

@@ -0,0 +1,69 @@
+import _ from 'lodash';
+import { ChartColumn, ColumnTimeBucket } from '../types/answer-column.types';
+import { bucketizationToDatePreset, timeBuckets } from './date-formatting';
+
+/**
+ * Retrieves the date format pattern associated with a specific time bucket.
+ *
+ * This function maps a `ColumnTimeBucket` value to its corresponding date format
+ * pattern using a predefined configuration (`bucketizationToDatePreset`). It is used
+ * to ensure that date formatting aligns with the granularity defined by the bucket type.
+ *
+ * @param bucket - The time bucket (`ColumnTimeBucket`) for which the format pattern is needed.
+ *
+ * @returns The date format pattern associated with the provided bucket, or `undefined`
+ *          if no format pattern exists for the specified bucket.
+ *
+ * @example
+ * const formatPattern = getFormatPatternForBucket(ColumnTimeBucket.DAY_OF_WEEK);
+ */
+
+export function getFormatPatternForBucket(bucket: ColumnTimeBucket): any {
+    return bucketizationToDatePreset[
+        ColumnTimeBucket[bucket] as keyof typeof bucketizationToDatePreset
+    ];
+}
+
+export const getTimeBucket = (col: ChartColumn): string =>
+    _.get(timeBuckets, ColumnTimeBucket[col.timeBucket], timeBuckets.NO_BUCKET);
+
+export const showDateFinancialYearFormat = (col: ChartColumn) => {
+    const supportedBucketizations = [timeBuckets.QUARTERLY, timeBuckets.YEARLY];
+    const currentBucketization = getTimeBucket(col);
+    return supportedBucketizations.some((supportedBucketization) => {
+        return supportedBucketization === currentBucketization;
+    });
+};
+
+/**
+ * Retrieves the GUID (Globally Unique Identifier) for a custom calendar based on
+ * the calendar name and data source ID.
+ *
+ * This function looks up a custom calendar GUID from a mapping that associates
+ * data source IDs with calendar names. If the specified data source ID and calendar
+ * name exist in the provided map, it returns the corresponding GUID; otherwise,
+ * it returns `undefined`. This is used because we have some TS defined custom calender
+ * such as fiscal, geogrian,etc. We apply some custom formatting for those.
+ * to see where we are getting this refer-
+ * @link AppConfig
+ * @param name - The name of the custom calendar to look up.
+ * @param datasourceId - The ID of the data source associated with the custom calendar.
+ * @param datsourceIdToCustomCalendarMap - A mapping object where each data source ID
+ *        maps to another object that associates calendar names with their GUIDs.
+ *
+ * @returns The GUID for the custom calendar associated with the given `name` and
+ *          `datasourceId`, or `undefined` if no matching GUID is found.
+ *
+ * @example
+ * const calendarGuid = getCustomCalendarGuid('fiscal', 'dataSource1', calendarMap);
+ */
+
+export function getCustomCalendarGuid(
+    name: string,
+    datasourceId: string,
+    datsourceIdToCustomCalendarMap: any,
+) {
+    return datsourceIdToCustomCalendarMap[datasourceId]
+        ? datsourceIdToCustomCalendarMap[datasourceId][name]
+        : undefined;
+}

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

@@ -0,0 +1,312 @@
+import {
+    ChartColumn,
+    ChartSpecificColumnType,
+    ColumnTimeBucket,
+    ColumnType,
+    DataType,
+} from '../types/answer-column.types';
+import * as DateFormatting from './date-formatting';
+import {
+    getFormatPatternForBucket,
+    showDateFinancialYearFormat,
+} from './date-utils';
+import {
+    generateMapOptions,
+    getBaseTypeFormatterInstance,
+    getDataFormatter,
+    getFormatPattern,
+} from './formatting-util';
+
+jest.mock('./date-utils', () => ({
+    getFormatPatternForBucket: jest.fn(),
+    showDateFinancialYearFormat: jest.fn(),
+    getCustomCalendarGuid: jest
+        .fn()
+        .mockReturnValue('7573c08b-753b-478b-84fd-6e702d481ff6'),
+}));
+
+describe('formatting utils', () => {
+    const mockOptions = {
+        quarterStartMonth: 1,
+        tsLocaleBasedStringsFormats: {
+            null_value_placeholder_label: '{Null}',
+            empty_value_placeholder_label: '{Empty}',
+            other_value_placeholder_label: '{Other}',
+            unavailabe_column_sample_value: '{Unavailable}',
+            weekOfDay: {
+                Friday: 'Friday',
+                Monday: 'Monday',
+                Saturday: 'Saturday',
+                Sunday: 'Sunday',
+                Thursday: 'Thursday',
+                Tuesday: 'Tuesday',
+                Wednesday: 'Wednesday',
+            },
+            monthOfYear: {
+                April: 'April',
+                August: 'August',
+                December: 'December',
+                February: 'February',
+                January: 'January',
+                July: 'July',
+                June: 'June',
+                March: 'March',
+                May: 'May',
+                November: 'November',
+                October: 'October',
+                September: 'September',
+            },
+            quarter_of_year: 'Q{1}',
+        },
+        tsDateConstants: {
+            day_in_month_format: 'e',
+            day_in_quarter_format: 'e',
+            day_in_year_format: 'j',
+            day_of_week_format: 'e',
+            month_in_quarter_format: 'm',
+            month_in_year_format: 'm',
+            special_value_unavailable: 'N/A',
+            week_in_year_format: 'V',
+        },
+        tsLocaleBasedDateFormats: {
+            DATE_SHORT: 'y',
+        },
+        quarter_of_year: 'Q{1}',
+        tsDefinedCustomCalenders: {
+            '43121d86-347a-4dbb-bea8-5e5bb899e427': {
+                calendar: '7573c08b-753b-478b-84fd-6e702d481ff6',
+                fiscal: 'bfa39848-ba4f-46d8-80fd-b695064e61b7',
+                french: 'a7316e8d-d4dd-4eaf-9294-396db951b422',
+            },
+        },
+        displayToCustomCalendarValueMap: {
+            '1234567891': {
+                v: {
+                    s: 'start',
+                    e: 'end',
+                },
+                d: 'custom Date',
+            },
+            '1234567892': {
+                v: {
+                    s: '1234567890',
+                    e: 'end',
+                },
+            },
+        },
+    };
+    test('getFormatPattern should call getFormatPatternForBucket with bucket and return pattern', () => {
+        const column = {
+            id: 'testId',
+            name: 'test',
+            type: ColumnType.MEASURE,
+            chartSpecificColumnType: ChartSpecificColumnType.UNKNOWN,
+            timeBucket: ColumnTimeBucket.YEARLY,
+            dataType: DataType.DATE,
+            calenderGuid: '12345',
+        } as ChartColumn;
+
+        expect(getFormatPattern(column)).toBe(undefined);
+        expect(getFormatPatternForBucket).toHaveBeenCalledWith(
+            column.timeBucket,
+        );
+    });
+    test('should return date formatter if column is date', () => {
+        const column = {
+            id: 'testId',
+            name: 'test',
+            type: ColumnType.MEASURE,
+            chartSpecificColumnType: ChartSpecificColumnType.UNKNOWN,
+            timeBucket: ColumnTimeBucket.YEARLY,
+            dataType: DataType.DATE,
+            calenderGuid: '12345',
+        } as ChartColumn;
+        const options = { isMillisIncluded: true };
+
+        const formatter = getBaseTypeFormatterInstance(column, options);
+
+        expect(typeof formatter).toBe('function');
+        const formattedDate = formatter(1234567890, mockOptions);
+        expect(formattedDate).toBe('2009');
+        const customFormattedDate = formatter(1234567891, mockOptions);
+        const customFormattedDateWithoutDisplayValue = formatter(
+            1234567892,
+            mockOptions,
+        );
+        expect(customFormattedDateWithoutDisplayValue).toBe('2009');
+        expect(customFormattedDate).toBe('custom Date');
+        expect(showDateFinancialYearFormat).toHaveBeenCalledWith(column);
+    });
+    test('should return dateNum formatter if column is dateNum', () => {
+        const column = {
+            id: 'testId',
+            name: 'test',
+            type: ColumnType.ATTRIBUTE,
+            chartSpecificColumnType: ChartSpecificColumnType.UNKNOWN,
+            timeBucket: ColumnTimeBucket.HOUR_OF_DAY,
+            dataType: DataType.INT64,
+            calenderGuid: '12345',
+        } as ChartColumn;
+        const options = { isMillisIncluded: true };
+        const formatter = getBaseTypeFormatterInstance(column, options);
+
+        expect(typeof formatter).toBe('function');
+        const formattedDate = formatter(1234567890, mockOptions);
+        expect(formattedDate).toBe(1234567890);
+        const customFormattedDate = formatter(1234567891, mockOptions);
+        const customFormattedDateWithoutDisplayValue = formatter(
+            1234567892,
+            mockOptions,
+        );
+        expect(customFormattedDateWithoutDisplayValue).toBe(1234567892);
+        expect(customFormattedDate).toBe('custom Date');
+    });
+    test('should return a default formatter for non-date types', () => {
+        const column = {
+            id: 'testId',
+            name: 'test',
+            type: ColumnType.MEASURE,
+            chartSpecificColumnType: ChartSpecificColumnType.UNKNOWN,
+            timeBucket: ColumnTimeBucket.HOUR_OF_DAY,
+            dataType: DataType.INT64,
+            calenderGuid: '12345',
+        } as ChartColumn;
+        const options = { isMillisIncluded: true };
+        const formatter = getBaseTypeFormatterInstance(column, options);
+
+        expect(formatter('test')).toBe('test');
+    });
+    test('getDataFormatter should return appropriate formatter based on column type', () => {
+        const column = {
+            id: 'testId',
+            name: 'test',
+            type: ColumnType.ATTRIBUTE,
+            chartSpecificColumnType: ChartSpecificColumnType.UNKNOWN,
+            timeBucket: ColumnTimeBucket.YEARLY,
+            dataType: DataType.DATE,
+            calenderGuid: '12345',
+        } as ChartColumn;
+        const options = { isMillisIncluded: true };
+
+        const formatter = getDataFormatter(column, options);
+
+        expect(typeof formatter).toBe('function');
+        const formattedDate = formatter(1234567890, mockOptions);
+        expect(formattedDate).toBe('2009');
+        const customFormattedDate = formatter(1234567891, mockOptions);
+        const customFormattedDateWithoutDisplayValue = formatter(
+            1234567892,
+            mockOptions,
+        );
+        expect(customFormattedDateWithoutDisplayValue).toBe('2009');
+        expect(customFormattedDate).toBe('custom Date');
+        expect(showDateFinancialYearFormat).toHaveBeenCalledWith(column);
+    });
+    test('generateMapOptions should return map options based on appConfig and column', () => {
+        const column = {
+            id: 'testId',
+            name: 'test',
+            type: ColumnType.ATTRIBUTE,
+            chartSpecificColumnType: ChartSpecificColumnType.UNKNOWN,
+            timeBucket: ColumnTimeBucket.YEARLY,
+            dataType: DataType.DATE,
+            calenderGuid: '12345',
+        } as ChartColumn;
+
+        const appConfig = {
+            localeOptions: { locale: 'en-US', quarterStartMonth: 1 },
+            dateFormatsConfig: {
+                tsLocaleBasedDateFormats: 'MM-DD-YYYY',
+                tsLocaleBasedStringsFormats: 'YYYY/MM/DD',
+                tsDateConstants: {},
+                tsDefinedCustomCalenders: {},
+                DEFAULT_DATASOURCE_ID: 'source1',
+            },
+        };
+        const data = [{ v: { s: 'key1' } }, { v: { s: 'key2' } }];
+
+        const mapOptions = generateMapOptions(appConfig, column, data);
+
+        expect(mapOptions.locale).toBe('en-US');
+        expect(mapOptions.quarterStartMonth).toBe(1);
+        expect(mapOptions.displayToCustomCalendarValueMap).toEqual({
+            key1: data[0],
+            key2: data[1],
+        });
+    });
+    test('should have format pattern as DATETIME_SHORT_WITH_MILLIS when format pattern is null', () => {
+        const column = {
+            id: 'testId',
+            name: 'test',
+            type: ColumnType.VIRTUAL,
+            chartSpecificColumnType: ChartSpecificColumnType.UNKNOWN,
+            timeBucket: ColumnTimeBucket.MONTHLY,
+            dataType: DataType.DATE_TIME,
+            calenderGuid: '12345',
+        } as ChartColumn;
+        const options = { isMillisIncluded: true };
+        const formatter = getBaseTypeFormatterInstance(column, options);
+        expect(typeof formatter).toBe('function');
+    });
+    test('should correctly set format pattern for date-time column with and without milliseconds', () => {
+        jest.spyOn(DateFormatting, 'formatDate').mockImplementation(jest.fn());
+        const column = {
+            id: 'testId',
+            name: 'test',
+            type: ColumnType.MEASURE,
+            chartSpecificColumnType: ChartSpecificColumnType.UNKNOWN,
+            timeBucket: ColumnTimeBucket.MONTHLY,
+            dataType: DataType.DATE_TIME, // Indicates it's a date-time column
+            calenderGuid: '12345',
+        } as ChartColumn;
+
+        const optionsWithMillis = { isMillisIncluded: true };
+        const optionsWithoutMillis = { isMillisIncluded: false };
+
+        const formatterWithMillis = getBaseTypeFormatterInstance(
+            column,
+            optionsWithMillis,
+        );
+        const formatterWithoutMillis = getBaseTypeFormatterInstance(
+            column,
+            optionsWithoutMillis,
+        );
+
+        expect(typeof formatterWithMillis).toBe('function');
+        expect(typeof formatterWithoutMillis).toBe('function');
+
+        // Mock dateFormatPresets to test the format patterns
+        const dateFormatPresetsMock = {
+            DATETIME_SHORT_WITH_MILLIS: 'DATETIME_SHORT_WITH_MILLIS',
+            DATETIME_SHORT_WITH_SECONDS: 'DATETIME_SHORT_WITH_SECONDS',
+        };
+
+        // Mock formatted dates based on dateFormatPresets
+        const formattedDateWithMillis = formatterWithMillis(
+            1234567890,
+            mockOptions,
+        );
+        expect(DateFormatting.formatDate).toHaveBeenCalledWith(
+            1234567890,
+            dateFormatPresetsMock.DATETIME_SHORT_WITH_MILLIS,
+            true,
+            {
+                ...mockOptions,
+                customCalendarOverridesFiscalOffset: true,
+            },
+        );
+        const formattedDateWithoutMillis = formatterWithoutMillis(
+            1234567890,
+            mockOptions,
+        );
+        expect(DateFormatting.formatDate).toHaveBeenCalledWith(
+            1234567890,
+            dateFormatPresetsMock.DATETIME_SHORT_WITH_SECONDS,
+            true,
+            {
+                ...mockOptions,
+                customCalendarOverridesFiscalOffset: true,
+            },
+        );
+    });
+});