@qrvey/utils 1.3.0-9 → 1.3.2

package/src/filters/services/UChartPaginationApi.ts

@@ -0,0 +1,326 @@
+import { isNumericalColumn } from "../../columns/helpers/isNumericalColumn";
+import { isDateColumn } from "../../columns/helpers/isDateColumn";
+import { getAggFilters } from "../helpers/OLD_getAggFilters";
+import { IFBData } from "../interfaces/backend/IFBData";
+import { IFSValue } from "../interfaces/common/IFSValue";
+import ChartsApi from "../../services/api/Charts.api";
+import { isRangeValidator } from "../helpers/common/isRangeValidator";
+import { getUniqueArray } from "../../general/array/getUniqueArray";
+import { IFilterConfig } from "../interfaces/common/IFilterConfig";
+import { IFUFlattenedFilter } from "../interfaces/ui/IFUFlattenedFilter";
+import { IFBLogic } from "../interfaces/backend/IFBLogic";
+import { isEmpty } from "../../general/mix/isEmpty";
+import { IFUChartSettings } from "../interfaces/ui/IFUChartSettings";
+import { OLD_IFilterData } from "../interfaces/OLD_IFilterData";
+import { getAggFiltersBySummaryIndex } from "../helpers/backend/getAggFiltersBySummaryIndex";
+import { COLUMN } from "../../columns/constants/COLUMN";
+import { _get } from "../../general/object/get";
+import { IFUColumn } from "../interfaces/ui/IFUColumn";
+import { AGGREGATE } from "../../charts/constants/AGGREGATE";
+import { cloneDeep } from "../../general/object/cloneDeep";
+import { FILTER_VALIDATOR } from "../constants/common/FILTER_VALIDATOR";
+import { IFValidator } from "../interfaces/IFValidator";
+import { flatUIToOldLogic } from '../adapters/flatUIToOldLogic';
+
+export default class UChartPaginationApi {
+
+    afterKey: any;
+    uFilter: IFUFlattenedFilter;
+
+    /**
+     * Gets afterKey object
+     * @returns the afterKey object
+     */
+    getAfterKey = (): any => {
+        return this.afterKey;
+    };
+
+    /**
+     * Gets a promise with a resulting data
+     * @param config the config
+     * @param uFilter The filter Builder filter
+     * @param filterLogic Additional filter logic to apply in the preview
+     * @param chartSettings The settings of the chart. For Aggregate Columns.
+     * @returns a promise with a resulting data
+     */
+    getChartResult = (config: IFilterConfig, uFilter: IFUFlattenedFilter, filterLogic: IFBLogic[] = [], chartSettings?: IFUChartSettings, resetApi = false): Promise<IFBData> => {
+        this.refineAfterkey(uFilter, resetApi);
+        this.setProps(uFilter);
+
+        const requestBody = this._getPreviewRequestBody(uFilter, filterLogic, chartSettings, this.afterKey);
+        const customChartApi = new ChartsApi({ ...config, qrvey_id: isEmpty(uFilter.column.aggregate) ? uFilter.column.qrveyid : chartSettings?.qrveyid });
+        return customChartApi.getResultsPagination(requestBody, false).then(response => {
+          return this._getDataFromResponse(response, uFilter);
+        }).catch(_ => {
+          return { data: [], total: 0 };
+        });
+    };
+
+    /**
+     * Gets request body structure
+     * @param uFilter The filter Builder filter
+     * @param filterLogic Additional filter logic to apply in the preview
+     * @param chartSettings The settings of the chart. For Aggregate Columns.
+     * @returns the request body structure
+     */
+    private _getPreviewRequestBody = (uFilter: IFUFlattenedFilter, filterLogic: IFBLogic[] = [], chartSettings?: IFUChartSettings, afterKey?: any) => {
+        const { column, validator } = uFilter;
+        const haveAggFilters = (chartSettings?.aggregateColumns || []).length && (chartSettings?.chart || []).length;
+        let searchLogic: OLD_IFilterData;
+        if (!isEmpty(uFilter.values)) {
+            searchLogic = flatUIToOldLogic([ {
+                ...uFilter,
+                validator: this._getValidationType(column, validator),
+                column: { ...uFilter.column, linkid: undefined } 
+            }]);
+        }
+        let filterCharts = [];
+        if (haveAggFilters) {
+            filterCharts = chartSettings?.chart.map(chart => {
+                const summaryIndex = (chart.summaries || []).findIndex(s => s.questionid === uFilter.column.id && s.aggregate === uFilter.column.aggregate);
+                const summary = summaryIndex !== -1 && chart.summaries[summaryIndex];
+                const chartAggFilters = getAggFiltersBySummaryIndex(chart.aggFilters, summaryIndex);
+                const searchAggFilters = getAggFilters(searchLogic?.logic || [], summary ? [summary] : []);
+
+                return {
+                    ...chart,
+                    aggFilters: searchAggFilters || chartAggFilters,
+                    summaries: summary ? [summary] : []
+                };
+          }).filter(chart => chart.summaries.length);
+        }
+
+        const dimensions = !filterCharts[0] ? this._getDimensionsBody(uFilter) : this._getDimensionsBodyAdapter(filterCharts[0].dimensions);
+        const summaries = !filterCharts[0] ? this._getSummariesBody(uFilter) : filterCharts[0].summaries;
+        const maxDataPoints = this._getMaxDataPoints(column, chartSettings);
+
+        const filters = [
+          ...filterLogic,
+          ...!filterCharts[0] ? searchLogic?.logic || [] : []
+        ];
+        return { dimensions, summaries, maxDataPoints, afterKey, logic: filters };
+    };
+    
+    /**
+     * Gets dimension body structure
+     * @param uFilter The filter Builder filter
+     * @returns the dimension body structure
+     */
+    private _getDimensionsBody = (uFilter: IFUFlattenedFilter) => {
+        const { column, validator } = uFilter;
+
+        let dimensions;
+        if (!isRangeValidator(validator)) {
+            dimensions = [{
+                questionid: column.id,
+                type: column.type,
+                formulaType: column.type === COLUMN.FORMULA ? column.formulaType : undefined,
+                sort: this._getSortOption(column)
+            }];
+            dimensions = this._refineBodies([ ...dimensions ], uFilter);
+        }
+        return dimensions;
+    };
+
+    /**
+     * Get a dimension body structure foor pagination endpoint
+     * @param dimensions 
+     * @returns the dimension body structure
+     */
+    private _getDimensionsBodyAdapter = (dimensions = []) => {
+        return dimensions.map(dimension => ({
+            questionid: dimension.questionid,
+            type: dimension.type,
+            formulaType: dimension.type === COLUMN.FORMULA ? dimension.formulaType : undefined,
+            groupType: dimension.groupType,
+            groupValue: dimension.groupValue,
+            sort: {
+                by: _get(dimension, 'sortOption.sortBy', 'VALUE'),
+                direction: _get(dimension, 'sortOption.sortDirection', 'DESC'),
+            }
+        }));
+    };
+
+    /**
+     * Gets max data point number
+     * @param column The column to filter
+     * @param chartSettings The settings of the chart. For Aggregate Columns.
+     * @returns max data point number
+     */
+    private _getMaxDataPoints = (column: IFUColumn, chartSettings?: IFUChartSettings) => {
+        return !isDateColumn(column) && !isEmpty(column.aggregate) ? _get(chartSettings, 'maxDataPoints.option', 1000) : 1000;
+    };
+
+
+    /**
+     * Gets sort option structure
+     * @param column The column to filter
+     * @returns sort option structure
+     */
+    private _getSortOption = (column: IFUColumn) => {
+        let by = 'CATEGORY';
+        let direction = isNumericalColumn(column) ? 'DESC' : 'ASC';
+        if (!isEmpty(column.sorting)) {
+            by = _get(column.sorting, 'sortBy');
+            direction = _get(column.sorting, 'order');
+            if (by == null) by = 'VALUE';
+            if (direction == null) direction = 'DESC';
+        }
+        return { by, direction };
+    };
+
+    /**
+     * Gets summaries body structure
+     * @param uFilter The filter Builder filter
+     * @returns summaries body structure
+     */
+    private _getSummariesBody = (uFilter: IFUFlattenedFilter) => {
+        const { column, validator } = uFilter;
+
+        const summary = {
+            aggregate: _get(column, 'aggregate.label', AGGREGATE.COUNT),
+            questionid: column.id,
+            property: !isDateColumn(uFilter.column) ? uFilter.property : undefined,
+            type: column.type
+        };
+        let summaries = [ summary ];
+        if (isNumericalColumn(column) || isRangeValidator(validator)) {
+            summaries = [
+            { ...summary, aggregate: AGGREGATE.MIN },
+            { ...summary, aggregate: AGGREGATE.MAX }
+            ];
+        }
+        return summaries;
+    };
+
+    /**
+     * Refines the body structure
+     * @param bodies The body structure
+     * @param uFilter The filter Builder filter
+     * @returns the body structure
+     */
+    private _refineBodies = (bodies: any[], uFilter: IFUFlattenedFilter) => {
+        const _bodies = cloneDeep(bodies);
+        if (uFilter.property != null) {
+            _bodies.forEach(body => {
+                if (isDateColumn(uFilter.column)) {
+                    body['groupType'] = 'DATE';
+                    body['groupValue'] = uFilter.property.toUpperCase();
+                } else {
+                    body['property'] = uFilter.property;
+                }
+            });
+        }
+        return _bodies;
+    };
+
+    /**
+     * Gets the validation type for the preview request
+     * @param column The column to filter
+     * @param vaildator Validator Type
+     * @returns the validator type for the preview request
+     */
+    private _getValidationType = (column: IFUColumn, validator: IFValidator): IFValidator => {
+        if (isDateColumn(column) || column.type === COLUMN.BUCKET || isNumericalColumn(column)) {
+            return FILTER_VALIDATOR.EQUALS;
+        } else {
+            if ([FILTER_VALIDATOR.NOT_CONTAIN, FILTER_VALIDATOR.EQUALS, FILTER_VALIDATOR.NOT_EQUAL].includes(validator)) {
+                return FILTER_VALIDATOR.CONTAINS;
+            } else if (validator === FILTER_VALIDATOR.NOT_END_WITH) {
+                return FILTER_VALIDATOR.ENDS_WITH;
+            } else if (validator === FILTER_VALIDATOR.NOT_START_WITH) {
+                return FILTER_VALIDATOR.STARTS_WITH;
+            } else {
+                return validator;
+            }
+        }
+    };
+
+    /**
+     * Gets the Data from preview Response
+     * @param response The preview presponse
+     * @param uFilter The filter Builder filter
+     * @returns The resulting data
+     */
+    private _getDataFromResponse = (response: any, uFilter: IFUFlattenedFilter): IFBData => {
+        const data = { data: [], total: 0 };
+        if (!this.isResultPaginationEmpty(response)) {
+            const records = _get(response, 'data');
+            data.data = isEmpty(uFilter.column.aggregate)
+                ? records.map(record => ({
+                value: record.key.toString()
+                }))
+                : this._getResponseSummaries(records);
+
+            data.data = getUniqueArray(data.data, 'value');
+            data.total = _get(response, 'totalGroups', 0) ?? 0;
+            this.setAfterKey(_get(response, 'afterKey'));
+        }
+        return data;
+    };
+
+    /**
+     * Gets summaries from preview response
+     * @param records The data from preview response
+     * @param values The values from the preview response
+     * @returns the sumaries
+     */
+    private _getResponseSummaries = (records: any[], values: IFSValue[] = []): IFSValue[] => {
+        records.forEach(record => {
+            const value = record.summaries[0].toString();
+            value && values.push({ value });
+        });
+        return values;
+    };
+
+    /**
+     * Refines the afterKey object
+     * @param props 
+     */
+    private refineAfterkey = (uFilter: IFUFlattenedFilter, forceSet = false): void => {
+        if (forceSet
+            || _get(uFilter, 'values[0].value', '') !==  _get(this.uFilter, 'values[0].value', '')
+            || !this.areColumnsEquals(uFilter.column, _get(this.uFilter, 'column'))
+            || uFilter.validator !== this.uFilter.validator
+            || uFilter.property !== this.uFilter.property
+            || uFilter.extras.scope !== this.uFilter.extras.scope
+        ) this.setAfterKey(undefined);
+    };
+
+    /**
+     * Sets the afterKey object
+     * @param afterKey the afterKey object
+     */
+    setAfterKey = (afterKey: any): void => {
+        this.afterKey = afterKey;
+    };
+
+    /**
+     * Sets the Filter Builder Filter
+     * @param uFilter
+     */
+    setProps = (uFilter: IFUFlattenedFilter): void => {
+        this.uFilter = cloneDeep(uFilter);
+    };
+
+    /**
+     * Checks if two filter columns are the same.
+     * @param column1 
+     * @param column2 
+     * @returns True: Columns are equal; False: Columns are not equal
+     */
+    areColumnsEquals = (column1: IFUColumn, column2: IFUColumn): boolean => {
+        if (isEmpty(column1) || isEmpty(column2)) return false;
+
+        return column1.id === column2.id &&
+            column1.qrveyid === column2.qrveyid &&
+            column1.property === column2.property &&
+            column1.aggregate === column2.aggregate;
+    };
+
+    isResultPaginationEmpty = (resultObject): boolean => {
+        const result = _get(resultObject, 'data');
+        return isEmpty(result);
+      };
+      
+}

package/src/filters/services/index.ts

@@ -0,0 +1,3 @@
+export * from './Filters.api';
+export * from './UChartApi';
+export * from './UChartPaginationApi';

package/src/format/definition.ts

@@ -105,3 +105,22 @@ export const LANG_DEFAULT = 'en-US';
 export const CURRENCY_DEFAULT = { text: '$ (USD)', label: 'USD' };
 export const DATETIME_OPTIONS = { year: 'numeric', month: 'numeric', day: 'numeric', hour: 'numeric', minute: 'numeric', second: 'numeric' };
 
+export const PARTS_REGEX = /\[([^\]]+)]|Y{1,2}|M{1,2}|W{1,2}|D{1,2}|h{1,2}|H{1,2}|m{1,2}|s{1,2}|S{1,3}/g;
+
+export const DURATION_PARTS = {
+  S: { order: 1, symbol: "S", name: "milliseconds", ms: 1 },
+  s: { order: 2, symbol: "s", name: "seconds", ms: 1000 },
+  m: { order: 3, symbol: "m", name: "minutes", ms: 1000 * 60 },
+  h: { order: 4, symbol: "h", name: "hours", ms: 1000 * 60 * 60 },
+  H: { order: 5, symbol: "H", name: "hours", ms: 1000 * 60 * 60 },
+  D: { order: 6, symbol: "D", name: "days", ms: 1000 * 60 * 60 * 24 },
+  W: { order: 7, symbol: "W", name: "weeks", ms: 1000 * 60 * 60 * 24 * 7 },
+  M: { order: 8, symbol: "M", name: "months", ms: 1000 * 60 * 60 * 24 * 30 },
+  Y: { order: 9, symbol: "Y", name: "years", ms: 1000 * 60 * 60 * 24 * 365 },
+};
+
+export const DEFAULT_OPTIONS = {
+  unit: "seconds",
+  locale: "en-EN",
+  fractionDigits: 0
+};

package/src/format/duration/addDurationFormat.ts

@@ -0,0 +1,17 @@
+import { DurationFormatter } from "./durationFormatter";
+
+/**[TODO: The decimals dots are not working correctly, we need to reviewing (fractionDigits)]
+ * "Convert a number of seconds to a human readable string."
+ * 
+ * `addDurationFormat` is a function that takes a number, a format, an optional locale, and an optional
+ * number of fraction digits, and returns a string
+ * @param {number} number - The number of milliseconds to format.
+ * @param {string} format - The format string.
+ * @param {string} [locale] - The locale to use for formatting. If not specified, the default locale is
+ * used.
+ * @param {number} [fractionDigits] - The number of digits to show after the decimal point.
+ * @returns A string
+ */
+export function addDurationFormat(number: number, format: string, locale?: string, fractionDigits?: number): string {
+  return new DurationFormatter( { template: format, options: { locale: locale, fractionDigits: fractionDigits } }).format(number);
+}

package/src/format/duration/durationFormatter.ts

@@ -0,0 +1,169 @@
+import { isEmpty } from "../../general/mix/isEmpty";
+import { DEFAULT_OPTIONS, DURATION_PARTS, PARTS_REGEX } from "../definition";
+
+/* It takes a template string and a number of milliseconds and returns a string that is formatted to
+the user's preference 
+this class is based on moment format:
+     years:   Y or y
+     months:  M
+     weeks:   W or w
+     days:    D or d
+     hours:   H or h
+     minutes: m
+     seconds: s
+     ms:      S
+*/
+export class DurationFormatter {
+    
+  private options: { unit?: string; locale?: string; fractionDigits?: number; };
+  private parts: any;
+  private valueFormatter: Intl.NumberFormat;
+  private numberFactor: number;
+  private template: string;
+  private numberFormatOptions = {
+    minimumFractionDigits: DEFAULT_OPTIONS.fractionDigits,
+    maximumFractionDigits: DEFAULT_OPTIONS.fractionDigits 
+  };
+
+  /**
+   * The constructor function takes in a template string and an options object. It then sets the
+   * options object to the default options object if no options object is passed in. It then parses
+   * the template string and sets the parts to the parsed template string. It then tries to set the
+   * valueFormatter to a new Intl.NumberFormat object with the locale and fractionDigits options. If
+   * it fails, it sets the valueFormatter to a new Intl.NumberFormat object with the default locale
+   * and fractionDigits options. It then sets the numberFactor to the duration parts object with the
+   * name of the unit option. If it can't find the unit option, it sets the numberFactor to 1
+   * @param [template] - The template string that will be used to format the duration.
+   * @param options - This is an object that contains the following properties: unit, locale and fractionDigits
+   */
+  constructor(options:{ template: string, options?: { unit?: string; locale?: string; fractionDigits?: number; }, intlNumberFormat?: Intl.NumberFormat }) {
+    this.setOptions(options.options);
+    this.setParts(options.template);
+    this.setLocaleFormatter(options.intlNumberFormat);
+    this.setNumberFactor();
+  }
+
+  private setOptions(options: { unit?: string; locale?: string; fractionDigits?: number; }){
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+
+  /**
+   * It sets the locale formatter for the number.
+   */
+  private setLocaleFormatter(intlNumberFormat: Intl.NumberFormat){
+    
+    try{
+      if(intlNumberFormat){
+        console.log(intlNumberFormat.resolvedOptions());
+        this.valueFormatter =  intlNumberFormat;
+      }else{
+        this.valueFormatter = this.getNewNumberFormat(this.options.locale);
+      }
+    }catch(e){
+      if(intlNumberFormat){
+        this.valueFormatter =  intlNumberFormat;
+      }else{
+        this.valueFormatter = this.getNewNumberFormat(DEFAULT_OPTIONS.locale);
+      }
+      
+    }
+  }
+
+  /**
+   * It returns a new instance of the Intl.NumberFormat class, which is a built-in JavaScript class
+   * that formats numbers
+   * @param {string | string[]} locale - string | string[]
+   * @returns A new instance of the Intl.NumberFormat class.
+   */
+  private getNewNumberFormat(locale: string | string[]){
+    return new Intl.NumberFormat(locale, this.numberFormatOptions);
+  }
+
+  /**
+   * It takes a template string and sets the parts property to the result of calling the
+   * parseFormatTemplate function with the template string as an argument
+   * @param {string} template - The format template string.
+   */
+  private setParts(template: string){
+    this.template = this.matchFormatsReplace(template);
+    this.parts = this.parseFormatTemplate(template);
+  }
+
+  /**
+   * It replaces the H and D characters in the template with h and d respectively
+   * @param {string} template - The template string to be used for the date format.
+   * @returns The template string with all instances of H replaced with h and all instances of D
+   * replaced with d.
+   */
+  private matchFormatsReplace(template: string){
+    return isEmpty(template) ? template: template.replace(/H/g, 'h');
+  }
+  
+  /**
+   * It sets the numberFactor to the value of the duration part that matches the unit.
+   */
+  private setNumberFactor(){
+    this.numberFactor = Object.values(DURATION_PARTS).find((d) => d.name === this.options.unit)?.ms || 1;
+  }
+  
+  /**
+   * It takes a string, splits it into an array of strings, then maps each string to a config object,
+   * then filters out any falsy values, then reverses the array
+   * @param {string} template - string - the template string that we want to parse
+   * @returns An array of objects that have the order and the name of the part of the duration.
+   */
+   private parseFormatTemplate(template: string) {
+    this.template = isEmpty(template)? '': template;
+    return (this.template.match(PARTS_REGEX) || [])
+      .reduce((store, part) => {
+        const config = DURATION_PARTS[part[0]];
+        if (config) store[config.order] = config;
+        return store;
+      }, [])
+      .filter(Boolean)
+      .reverse();
+  }
+
+ 
+  
+   /**
+    * It takes a number, multiplies it by a factor, then uses the parts array to calculate the number
+    * of each part in the number, then uses the template to format the number
+    * @param {number} number - The number of milliseconds to format.
+    * @returns The template string with the values replaced.
+    */
+   public format(number: number): string {
+    if(number === null) return null;
+    if(number === undefined || this.template === undefined || isNaN(number)) return undefined;
+    if(isEmpty(number)) return "";
+
+    number *= this.numberFactor;
+
+    const durationParts = this.parts.reduce((store, part) => {
+      store[part.symbol] = number / part.ms;
+      number %= part.ms;
+      return store;
+    }, {});
+
+    if(!Number.isInteger(number)) return number === null? null: this.valueFormatter.format(number).padStart(this.parts.length, "0");
+    if(isEmpty(this.template)) return this.valueFormatter.format(number).padStart(this.parts.length, "0");
+
+    return this.template.replace(PARTS_REGEX, (match, $1) => {
+      return $1 || this.formatValue(durationParts, match);
+    });
+  }
+
+ 
+  
+   /**
+    * It takes a dictionary of values and a list of keys, and returns a formatted string
+    * @param parts - { [x: string]: any; }
+    * @param {string | (string | number)[]} part - This is the part of the date that we're
+    * formatting.
+    * @returns The value of the part of the date that is being formatted.
+    */
+   private formatValue(parts: { [x: string]: any; }, part: string | (string | number)[]): string {
+    const value = parts[part[0]];
+    return this.valueFormatter.format(value).padStart(part.length, "0");
+  }
+}

package/src/format/duration/index.ts

@@ -0,0 +1,2 @@
+export * from './durationFormatter';
+export * from './addDurationFormat';

package/src/format/index.ts

@@ -1,2 +1,3 @@
 export * from './format';
 export * from './localization';
+export * from './duration/index';

package/src/general/array/getArrayByProperty.ts

@@ -0,0 +1,14 @@
+import { isEmpty } from "../mix/isEmpty";
+
+/**
+ * Gets a collection of object values by the given property
+ * @param arr An array
+ * @param property the property to get the value collection
+ * @returns a collection of values by property
+ */
+export function getArrayByProperty<T = any>(arr: T[], property: string): T[] {
+    if (!Array.isArray(arr)) return arr;
+    return (arr as any).map(a => {
+        if (!isEmpty(a)) return a[property];
+    }).filter(Boolean);
+}

package/src/general/array/getUniqueArray.ts

@@ -0,0 +1,11 @@
+/**
+ * Remove duplicated items from a given array by property name
+ * // 1. Store the keys of the unique objects
+ * // 2. Eliminate the dead keys & store unique objects
+ * @param arr The array
+ * @param prop Property name to search duplicated values
+ * @return Array without duplicated items.
+ */
+export function getUniqueArray(arr: any[], prop: string): any[] {
+    return arr.map(e => e[prop]).map((e, i, final) => final.indexOf(e) === i && i).filter(e => arr[e]).map(e => arr[e]);
+}

package/src/general/array/index.ts

@@ -1,6 +1,7 @@
 export * from './addPropertyToArrayOfObjects';
 export * from './delete';
 export * from './flattenDeep';
+export * from './getArrayByProperty';
 export * from './filterNestedTree';
 export * from './getFirstIndexFromArray';
 export * from './getLastIndexFromArray';

package/src/general/object/get.ts

@@ -42,25 +42,3 @@ function validateToReturnDefaultValue(baseObject: any, path: string | string[]):
     path == null ||
     (typeof path !== 'string' && !Array.isArray(path));
 }
-
-
-/**
- * 
- * /**
- * Like lodash _.get.
- * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place.
- * @param baseObject The object to query
- * @param path The path of the property to get.
- * @param defaultValue The value returned for undefined resolved values.
- * @returns the resolved value.
- export function get(baseObject: any, path: string, defaultValue?: any): any {
-  function fn() {
-    try {
-      const value = eval(`this.${path}`.replace('.[', '['));
-      return typeof value !== 'undefined' ? value : defaultValue;
-    } catch (e) { return defaultValue; }
-  }
-  return fn.apply(baseObject, null);
-}
-
- */

package/src/globalization/helpers/getI18nDateGroupLabel.ts

@@ -30,7 +30,7 @@ function getI18nMonthLabel(label: string, translate?: II18nServiceTranslate): st
 
 function getI18nYearMonthLabel(label: string, translate?: II18nServiceTranslate): string {
     if (!isTokenLabel(label) && !isEmpty(translate)) {
-        const month = getI18nMonthPropertyByIndex(DATE_YEAR_MONTHS.findIndex(month => month === label));
+        const month = getI18nMonthPropertyByIndex(DATE_YEAR_MONTHS.findIndex(_month => _month === label));
         if (!isEmpty(month)) label = translate('common.date_grouping.' + month + '_mmm');
     }
     return label;

package/src/globalization/interfaces/chart_builder/II18nChartBuilderStyleOptions.ts

@@ -11,6 +11,16 @@ export interface II18nChartBuilderStyleOptions {
     chart_type_disabled_message: string;
     comparision_color: string;
     data_labels_check: string;
+    data_labels_clustering: string;
+    data_labels_format: string;
+    data_labels_position: string;
+    data_labels_position_inside: string;
+    data_labels_position_outside: string;
+    data_labels_show_as: string;
+    data_labels_show_as_category: string;
+    data_labels_show_as_percentage: string;
+    data_labels_show_as_placeholder: string;
+    data_labels_show_as_value: string;
     default_format_title: string;
     display_outliers_check: string;
     line_opacity: string;

package/src/globalization/interfaces/filters/II18nFilterPanel.ts

@@ -9,6 +9,9 @@ export interface II18nFilterPanel {
     aggregated_filters_label: string;
     aggregated_filters_tooltip: string;
     card_action: II18nFilterPanelCardAction;
+    card_all_except: string;
+    card_all_selected: string;
+    card_none_selected: string;
     collapsed_title: string;
     delete_dialog: II18nFilterPanelDeleteDialog;
     empty_state: II18nFilterPanelEmptyState;

package/src/globalization/interfaces/filters/II18nValueContainer.ts

@@ -1,8 +1,9 @@
 import { II18nValueContainerSearchInput } from "./II18nValueContainerSearchInput";
 
 export interface II18nValueContainer {
-    search_input: II18nValueContainerSearchInput;
+    all_except: string;
+    all_selected: string;
     no_label: string;
     no_records_message: string;
-    select_all: string;
+    search_input: II18nValueContainerSearchInput;
 }

package/src/globalization/interfaces/style_themes/II18nStyleThemesTheme.ts

@@ -18,6 +18,7 @@ export interface II18nStyleThemesTheme {
     qrvey_theme: string;
     restore_to_default: string;
     save_theme: string;
+    show_header: string;
     show_title: string;
     table_header_styles: string;
     text_styles: string;