@qrvey/utils 1.2.7 → 1.2.9-2

package/src/dates/constants/DATE_YEAR_QUARTERS_RANGE.ts

@@ -0,0 +1,18 @@
+export const DATE_YEAR_QUARTERS_RANGE = {
+    Q1: {
+      initial: 0,
+      final: 2
+    },
+    Q2: {
+      initial: 3,
+      final: 5
+    },
+    Q3: {
+      initial: 6,
+      final: 8
+    },
+    Q4: {
+      initial: 9,
+      final: 11
+    }
+};

package/src/dates/constants/index.ts

@@ -37,4 +37,6 @@ export * from './DATE_REGULAR_EXPRESSION';
 export * from './DATE_WEEK_DAYS';
 export * from './DATE_YEAR_DAYS';
 export * from './DATE_YEAR_MONTHS';
+export * from './DATE_YEAR_MONTHS_MMMM';
 export * from './DATE_YEAR_QUARTERS';
+export * from './DATE_YEAR_QUARTERS_RANGE';

package/src/dates/helpers/getDateByDateFormat.ts

@@ -0,0 +1,34 @@
+import { DATE_FORMAT } from "../constants/DATE_FORMAT";
+import { IDateFormat } from "../interfaces/IDateFormat";
+import { yearToDate } from "../adapters/yearToDate";
+import { monthYearToDate } from "../adapters/monthYearToDate";
+import { quarterYearToDate } from "../adapters/quarterYearToDate";
+import { weekYearToDate } from "../adapters/weekYearToDate";
+import { mdyDateToDate } from "../adapters/mdyDateToDate";
+
+/**
+ * Gets a Date Object instance by a Date format
+ * @param date String with a formatted date
+ * @param format The date format
+ * @param time flag to convert the formatted date to miliseconds
+ * @returns a Date object, milisecond time or the same value if date format does not match.
+ */
+export function getDateByDateFormat(date: string, format: IDateFormat, time = false) {
+    switch (format) {
+        case DATE_FORMAT.YEAR:
+            return yearToDate(date, time);
+        case DATE_FORMAT.MONTH:
+            return monthYearToDate(date, time);
+        case DATE_FORMAT.QUARTER:
+            return quarterYearToDate(date, time);
+        case DATE_FORMAT.WEEK:
+            return weekYearToDate(date, time);
+        case DATE_FORMAT.DAY:
+        case DATE_FORMAT.HOUR:
+        case DATE_FORMAT.MINUTE:
+        case DATE_FORMAT.SECOND:
+            return mdyDateToDate(date, time);
+        default:
+            return date;
+    }
+}

package/src/dates/helpers/getDateFormatByProperty.ts

@@ -0,0 +1,26 @@
+import { COLUMN_PROPERTY } from "../../columns/constants/COLUMN_PROPERTY";
+import { IColumnPropertyType } from "../../columns/interfaces/IColumnPropertyType";
+import { DATE_FORMAT } from "../constants/DATE_FORMAT";
+import { IDateFormat } from "../interfaces/IDateFormat";
+
+/**
+ * Gets the date format by the given property
+ * @param property The Column Property
+ * @returns The date format
+ */
+export function getDateFormatByProperty(property: IColumnPropertyType): IDateFormat {
+    return property === COLUMN_PROPERTY.YEAR ? DATE_FORMAT.YEAR :
+        property === COLUMN_PROPERTY.MONTH ? DATE_FORMAT.MONTH :
+      property === COLUMN_PROPERTY.QUARTER ? DATE_FORMAT.QUARTER :
+      property === COLUMN_PROPERTY.WEEK ? DATE_FORMAT.WEEK :
+      property === COLUMN_PROPERTY.DAY ? DATE_FORMAT.DAY :
+      property === COLUMN_PROPERTY.HOUR ? DATE_FORMAT.HOUR :
+      property === COLUMN_PROPERTY.MINUTE ? DATE_FORMAT.MINUTE :
+      property === COLUMN_PROPERTY.SECOND ? DATE_FORMAT.SECOND :
+      property === COLUMN_PROPERTY.MONTH_DAY ? DATE_FORMAT.MONTH_DAY :
+      property === COLUMN_PROPERTY.YEAR_MONTH ? DATE_FORMAT.YEAR_MONTH :
+      property === COLUMN_PROPERTY.YEAR_QUARTER ? DATE_FORMAT.YEAR_QUARTER :
+      property === COLUMN_PROPERTY.DAY_HOUR ? DATE_FORMAT.DAY_HOUR :
+      property === COLUMN_PROPERTY.HOUR_MINUTE ? DATE_FORMAT.HOUR_MINUTE :
+      property === COLUMN_PROPERTY.MINUTE_SECOND ? DATE_FORMAT.MINUTE_SECOND : undefined;
+}

package/src/dates/helpers/getDateFormatRegularExpressionInArray.ts

@@ -0,0 +1,45 @@
+import { DATE_FORMAT } from "../constants/DATE_FORMAT";
+import { DATE_REGULAR_EXPRESSION } from "../constants/DATE_REGULAR_EXPRESSION";
+import { IDateFormat } from "../interfaces/IDateFormat";
+
+/**
+ * Gets an array of regular expressions by the given date format
+ * @param dateFormat the date format
+ * @returns an array of regular expressions
+ */
+export function getDateFormatRegularExpressionInArray(dateFormat: IDateFormat = DATE_FORMAT.DAY): string[] {
+    switch (dateFormat) {
+        case DATE_FORMAT.YEAR: 
+            return [DATE_REGULAR_EXPRESSION.YEAR];
+        case DATE_FORMAT.MONTH:
+            return [DATE_REGULAR_EXPRESSION.YEAR_MONTH, DATE_REGULAR_EXPRESSION.YEAR];
+        case DATE_FORMAT.QUARTER:
+            return [DATE_REGULAR_EXPRESSION.YEAR_QUARTER, DATE_REGULAR_EXPRESSION.YEAR];
+        case DATE_FORMAT.WEEK:
+            return [DATE_REGULAR_EXPRESSION.YEAR_WEEK, DATE_REGULAR_EXPRESSION.YEAR];
+        case DATE_FORMAT.DAY:
+            return [DATE_REGULAR_EXPRESSION.YEAR_MONTH_NUMBER, DATE_REGULAR_EXPRESSION.MONTH_DAY, DATE_REGULAR_EXPRESSION.YEAR];
+        case DATE_FORMAT.DAY_TIME:
+            return [DATE_REGULAR_EXPRESSION.DAY_TIME];
+        case DATE_FORMAT.HOUR:
+        case DATE_FORMAT.MINUTE:
+        case DATE_FORMAT.SECOND:
+            return [DATE_REGULAR_EXPRESSION.DAY, DATE_REGULAR_EXPRESSION.DAY_TIME];
+        case DATE_FORMAT.MONTH_DAY:
+            return [DATE_REGULAR_EXPRESSION.MONTH_DAY];
+        case DATE_FORMAT.YEAR_MONTH:
+            return [DATE_REGULAR_EXPRESSION.YEAR_MONTH];
+        case DATE_FORMAT.YEAR_QUARTER:
+            return [DATE_REGULAR_EXPRESSION.YEAR_QUARTER];
+        case DATE_FORMAT.YEAR_WEEK:
+            return [DATE_REGULAR_EXPRESSION.YEAR_WEEK];
+        case DATE_FORMAT.DAY_HOUR:
+            return [DATE_REGULAR_EXPRESSION.DAY_HOUR];
+        case DATE_FORMAT.HOUR_MINUTE:
+            return [DATE_REGULAR_EXPRESSION.HOUR_MINUTE];
+        case DATE_FORMAT.MINUTE_SECOND:
+            return [DATE_REGULAR_EXPRESSION.MINUTE_SECOND];
+      default:
+        return [DATE_REGULAR_EXPRESSION.YEAR_MONTH_NUMBER, DATE_REGULAR_EXPRESSION.MONTH_DAY, DATE_REGULAR_EXPRESSION.YEAR];
+    }
+}

package/src/dates/helpers/getSeparatorByDateFormat.ts

@@ -0,0 +1,13 @@
+import { DATE_FORMAT } from "../constants/DATE_FORMAT";
+import { IDateFormat } from "../interfaces/IDateFormat";
+
+/**
+ * Gets the separator of the date format
+ * @param format the date format
+ * @returns a separator string
+ */
+export function getSeparatorByDateFormat(format: IDateFormat = DATE_FORMAT.DAY): string {
+    return format === DATE_FORMAT.YEAR || format === DATE_FORMAT.DAY_TIME || format === DATE_FORMAT.MONTH_DAY || format === DATE_FORMAT.YEAR_MONTH || format === DATE_FORMAT.YEAR_QUARTER || format === DATE_FORMAT.YEAR_WEEK || format === DATE_FORMAT.DAY_HOUR|| format === DATE_FORMAT.HOUR_MINUTE || format === DATE_FORMAT.MINUTE_SECOND ? '' :
+        format === DATE_FORMAT.MONTH || format === DATE_FORMAT.QUARTER || format === DATE_FORMAT.WEEK || format === DATE_FORMAT.HOUR || format === DATE_FORMAT.MINUTE || format === DATE_FORMAT.SECOND ? ' ' :
+            '/';
+}

package/src/dates/helpers/getWeek.ts

@@ -0,0 +1,21 @@
+/**
+ * Gets the week number of the year
+ * Additionally, the month and the year
+ * @param date the date object
+ * @returns an object with the week, month and year.
+ */
+export function getWeek (date: Date) {
+    const target = new Date(date.valueOf());
+    const dayNr = (date.getDay() + 6) % 7;
+    target.setDate(target.getDate() - dayNr + 3);
+    const firstThursday = target.valueOf();
+    target.setMonth(0, 1);
+    if (target.getDay() !== 4) {
+      target.setMonth(0, 1 + ((4 - target.getDay()) + 7) % 7);
+    }
+    return {
+      week: 1 + Math.ceil((firstThursday - +target) / 604800000),
+      month: target.getMonth() + 1,
+      year: target.getFullYear()
+    };
+}

package/src/dates/helpers/index.ts

@@ -0,0 +1,6 @@
+export * from './getDateFormatByProperty';
+export * from './getDateFormatRegularExpressionInArray';
+export * from './getSeparatorByDateFormat';
+export * from './getWeek';
+export * from './validateDate';
+export * from './validateDateByDateFormat';

package/src/dates/helpers/validateDate.ts

@@ -0,0 +1,22 @@
+
+import { isEmpty } from "../../general/mix/isEmpty";
+import { isTokenLabel } from "../../tokens/isTokenLabel";
+import { DATE_FORMAT } from "../constants/DATE_FORMAT";
+import { IDateFormat } from "../interfaces/IDateFormat";
+import { validateDateByDateFormat } from "./validateDateByDateFormat";
+
+/**
+ * Validate a string date depending on giving format
+ * - If the string is a token label, the function lets it pass.
+ * - Otherwise depends of the format
+ * - Some escenarios the string is a mix of token labels and dates
+ * @param date String of date
+ * @param format String of the format to validate
+ * @returns True if it is valid or not. Undefined if date is undefined
+ */
+ export function validateDate(date: string, format: IDateFormat = DATE_FORMAT.DAY): boolean {
+    if (isEmpty(date)) return false;
+    if (isTokenLabel(date)) return true;
+
+    return validateDateByDateFormat(date, format);
+}

package/src/dates/helpers/validateDateByDateFormat.ts

@@ -0,0 +1,25 @@
+import { isTokenLabel } from "../../tokens/isTokenLabel";
+import { DATE_FORMAT } from "../constants/DATE_FORMAT";
+import { IDateFormat } from "../interfaces/IDateFormat";
+import { getDateFormatRegularExpressionInArray } from "./getDateFormatRegularExpressionInArray";
+import { getSeparatorByDateFormat } from "./getSeparatorByDateFormat";
+
+/**
+ * Validates the given string as Date by its date format.
+ * @param date a string to validate as date form
+ * @param dateForma the format of the date to validate the string
+ * @returns true: the string is a valida date
+ */
+export function validateDateByDateFormat(date: string, dateFormat: IDateFormat = DATE_FORMAT.DAY): boolean {
+    const resultValidation: boolean[] = [];
+    const separator = getSeparatorByDateFormat(dateFormat);
+    const separatedDate = date.split(separator);
+    const regularExpression = getDateFormatRegularExpressionInArray(dateFormat);
+  
+    if (regularExpression.length !== separatedDate.length) return false;
+  
+    for (let i = 0; i < separatedDate.length; i++) {
+        resultValidation.push(isTokenLabel(separatedDate[i]) || new RegExp(regularExpression[i], 'g').test(separatedDate[i]));
+    }
+    return resultValidation.every(validValue => validValue);
+}

package/src/dates/index.ts

@@ -1,4 +1,5 @@
 export * from './constants/index';
+export * from './helpers/index';
 export * from './interfaces/index';
 export * from './range/index';
 export * from './relative/index';

package/src/dates/relative/constants/RELATIVE_CURSOR_INFO.ts

@@ -1,7 +1,10 @@
+import { IRelativeCursorInfo } from "../interfaces/IRelativeCursorInfo";
+import { RelativeCursor } from "../interfaces/RelativeCursor";
 import { RELATIVE_CURSOR } from "./RELATIVE_CURSOR";
+import { RELATIVE_CURSOR_LABEL } from "./RELATIVE_CURSOR_LABEL";
 
-export const RELATIVE_CURSOR_INFO = {
-    [RELATIVE_CURSOR.THIS]: { label: 'This', value: 'this' },
-    [RELATIVE_CURSOR.NEXT]: { label: 'The next', value: 'the next' },
-    [RELATIVE_CURSOR.LAST]: { label: 'The last', value: 'the last' },
+export const RELATIVE_CURSOR_INFO: { [key in RelativeCursor]: IRelativeCursorInfo } = {
+    [RELATIVE_CURSOR.THIS]: { abbrLabel: 'This', shortLabel: 'This', label: RELATIVE_CURSOR_LABEL.THIS, value: RELATIVE_CURSOR.THIS, displayed: true, i18nLabelPath: 'filter.relative_container.cursors.this_label' },
+    [RELATIVE_CURSOR.NEXT]: { abbrLabel: 'Next', shortLabel: 'Next', label: RELATIVE_CURSOR_LABEL.NEXT, value: RELATIVE_CURSOR.NEXT, displayed: true, i18nLabelPath: 'filter.relative_container.cursors.the_next_label' },
+    [RELATIVE_CURSOR.LAST]: { abbrLabel: 'Last', shortLabel: 'Last', label: RELATIVE_CURSOR_LABEL.LAST, value: RELATIVE_CURSOR.LAST, displayed: true, i18nLabelPath: 'filter.relative_container.cursors.the_last_label' },
 };

package/src/dates/relative/constants/RELATIVE_CURSOR_INFO_LIST.ts

@@ -0,0 +1,11 @@
+import { RELATIVE_CURSOR_INFO } from "./RELATIVE_CURSOR_INFO";
+import { IRelativeCursorInfo } from "..";
+import { RELATIVE_CURSOR } from "./RELATIVE_CURSOR";
+/**
+ * @description Key/array of compound relative cursor info
+ */
+export const RELATIVE_CURSOR_INFO_LIST: IRelativeCursorInfo[] = [
+    RELATIVE_CURSOR_INFO[RELATIVE_CURSOR.THIS],
+    RELATIVE_CURSOR_INFO[RELATIVE_CURSOR.LAST],
+    RELATIVE_CURSOR_INFO[RELATIVE_CURSOR.NEXT],
+];

package/src/dates/relative/constants/RELATIVE_CURSOR_LABEL.ts

@@ -0,0 +1,5 @@
+export enum RELATIVE_CURSOR_LABEL {
+    THIS = 'This',
+    NEXT = 'The next',
+    LAST = 'The last',
+}

package/src/dates/relative/constants/index.ts

@@ -1,6 +1,8 @@
 export * from './COMMON';
 export * from './DATE_FORMATS';
 export * from './RELATIVE_CURSOR';
+export * from './RELATIVE_CURSOR_INFO_LIST';
 export * from './RELATIVE_CURSOR_INFO';
+export * from './RELATIVE_CURSOR_LABEL';
 
 export * from './ui/index';

package/src/dates/relative/interfaces/IRelativeCursorInfo.ts

@@ -0,0 +1,6 @@
+import { IGeneralInfo } from "../../../interfaces/general/IGeneralInfo";
+import { RelativeCursor } from "./RelativeCursor";
+
+export interface IRelativeCursorInfo extends IGeneralInfo {
+	value: RelativeCursor;
+}

package/src/dates/relative/interfaces/index.ts

@@ -1,6 +1,7 @@
 export * from './AbsoluteStatement';
 export * from './Anchor';
 export * from './RelativeCursor';
+export * from './IRelativeCursorInfo';
 export * from './RelativeInput';
 export * from './RelativeStatement';
 export * from './RelativeToAbsoluteStruct';

package/src/filters/classes/FilterInputErrorHandler.ts

@@ -0,0 +1,213 @@
+// import { isDateColumn } from "../../columns/helpers/isDateColumn";
+// import { isNumericalColumn } from "../../columns/helpers/isNumericalColumn";
+import { IColumn } from "../../columns/interfaces/IColumn";
+// import { getDateByDateFormat } from "../../dates/helpers/getDateByDateFormat";
+// import { getDateFormatByProperty } from "../../dates/helpers/getDateFormatByProperty";
+// import { validateDate } from "../../dates/helpers/validateDate";
+import { IDateFormat } from "../../dates/interfaces/IDateFormat";
+// import { isEmpty } from "../../general/mix/isEmpty";
+// import { isNaNV2 } from "../../general/mix/isNaNV2";
+import { I18nService } from "../../globalization/service/i18nextBuilder";
+// import { isTokenLabel } from "../../tokens/isTokenLabel";
+// import { FILTER_VALIDATOR } from "../constants/common/FILTER_VALIDATOR";
+// import { isRangeValidator } from "../helpers/common/isRangeValidator";
+// import { IFSValueRange } from "../interfaces/common/IFSValueRange";
+import { IFProperty } from "../interfaces/IFProperty";
+import { IFValidator } from "../interfaces/IFValidator";
+import { IFValue } from "../interfaces/IFValue";
+
+interface IFilterErrorHandlerConfig {
+    column: IColumn;
+    locale: I18nService;
+    property: IFProperty;
+    validator: IFValidator;
+    value: IFValue[]
+}
+
+interface IFilterErrorHandlerError{
+    searcherInput: IFilterErrorHandlerErrorInfo[];
+    minInput: IFilterErrorHandlerErrorInfo[];
+    maxInput: IFilterErrorHandlerErrorInfo[];
+    range: IFilterErrorHandlerErrorInfo[];
+}
+
+interface IFilterErrorHandlerErrorInfo {
+    message: string;
+    type: IFilterErrorHandlerType;
+}
+
+type IFilterErrorHandlerType = FILTER_ERROR_TYPE;
+
+const enum FILTER_ERROR_TYPE {
+    REPEATED_VALUE = 'REPEATED_VALUE',
+    INVALID_INPUT = 'INVALID_INPUT',
+    INVALID_INPUT_DATE_QUARTER = 'INVALID_INPUT_DATE_QUARTER',
+    INVALID_INPUT_DATE_YEAR = 'INVALID_INPUT_DATE_YEAR',
+    INVALID_INPUT_DATE_DAY = 'INVALID_INPUT_DATE_DAY',
+    INVALID_INPUT_DATE_MONTH = 'INVALID_INPUT_DATE_MONTH',
+    INVALID_INPUT_DATE_WEEK = 'INVALID_INPUT_DATE_WEEK',
+    INVALID_INPUT_NUMERIC = 'INVALID_INPUT_NUMERIC',
+    MIN_LIMIT = 'MIN_LIMIT',
+    MAX_LIMIT = 'MAX_LIMIT'
+}
+
+/**
+ * @ignore
+ */
+export class FilterInputErrorHandler {
+    private _column: IColumn;
+    private _locale: I18nService;
+    private _property: IFProperty;
+    private _validator: IFValidator;
+    private _value: IFValue[];
+
+    private _dateFormat: IDateFormat;
+    private _valueKeys: string[];
+
+    private _error: IFilterErrorHandlerError;
+
+    constructor(config: IFilterErrorHandlerConfig) {
+        this._column = config.column;
+        this._locale = config.locale;
+        this._property = config.property;
+        this._validator = config.validator;
+    }
+
+    // protected set column(column: IColumn) {
+    //     this.column = column;
+    //     this.validate();
+    // }
+
+    // protected set property(property: IFProperty) {
+    //     this._property = property;
+    //     this._dateFormat = getDateFormatByProperty(this._property);
+    //     this.validate();
+    // }
+
+    // protected set validator(validator: IFValidator) {
+    //     this._validator = validator;
+    //     this._valueKeys = this.getValueKeysToValidate();
+    //     this.validate();
+    // }
+
+    // public set value(value: IFValue[]) {
+    //     this._value = value;
+    //     this.validate();
+    // }
+
+    // public get error(): IFilterErrorHandlerError {
+    //     return this._error;
+    // }
+
+    // private validate() {
+    //     if (isRangeValidator(this._validator)) {
+    //         this.validateRangeValues();
+    //     } else {
+    //         this.validateValues();
+    //     }
+    // }
+
+
+    // /**
+    //  * Returns the range type by the given validator. This function is useful in slidebar component
+    //  * @param validator The filter validator
+    //  * @returns the range type
+    //  */
+    // private getValueKeysToValidate(): string[] {
+    //     switch (this._validator) {
+    //         case FILTER_VALIDATOR.BETWEEN_INCLUSIVE:
+    //         case FILTER_VALIDATOR.BETWEEN_EXCLUSIVE:
+    //             return ['MIN', 'MAX'];
+    //         case FILTER_VALIDATOR.LESS_THAN:
+    //         case FILTER_VALIDATOR.LESS_THAN_EQUAL:
+    //         case FILTER_VALIDATOR.BEFORE:
+    //         case FILTER_VALIDATOR.BEFORE_ON:
+    //             return ['MAX'];
+    //             break;
+    //         case FILTER_VALIDATOR.GREATER_THAN:
+    //         case FILTER_VALIDATOR.GREATER_THAN_EQUAL:
+    //         case FILTER_VALIDATOR.AFTER:
+    //         case FILTER_VALIDATOR.AFTER_ON:
+    //             return ['MIN'];
+    //         default:
+    //             return ['MIN', 'MAX'];
+    //     }
+    // }
+
+    // private validateRangeValues() {
+    //     (this._value as IFSValueRange[]).forEach(value => {
+    //         if (this._valueKeys.length > 2) {
+    //             if (!this.validateValue(value.min)) this.error.minInput.push(this.getErrorInfo(value, 'minInput'));
+    //             if (this.validateValue(value.max)) this.error.maxInput.push(this.getErrorInfo(value, 'maxInput'));
+    //             if (this.validateRange(value.min, value.max)) this.error.range.push(this.getErrorInfo(value, 'range'));
+    //         }
+    //         return value;
+    //     });
+    // }
+
+    // private getErrorInfo(value: IFValue, infoKey: keyof IFilterErrorHandlerError): IFilterErrorHandlerErrorInfo {
+    //     switch (infoKey) {
+    //         case 'minInput':
+    //             return {
+                    
+
+    //             }
+    //     }
+    // }
+
+    // public validateValue(value: string): IFilterErrorHandlerErrorInfo {
+    //     if (isTokenLabel(value)) return;
+
+    //     if ((isNumericalColumn(this._column) || !isEmpty(this._column.aggregate)) && isNaNV2(value)) {
+    //         return {
+    //             type: FILTER_ERROR_TYPE.INVALID_INPUT_NUMERIC,
+    //             message: this.getErrorMessage(FILTER_ERROR_TYPE.INVALID_INPUT_NUMERIC),
+    //         };
+    //     } else if (isDateColumn(this._column)) {
+    //         return validateDate(value, this._dateFormat);
+    //     }
+    //     return;
+    // }
+
+    // public validateRange(minValue: string, maxValue: string): boolean {
+    //     if (isTokenLabel(minValue) || isTokenLabel(maxValue)) return true;
+
+    //     if (isNumericalColumn(this._column) || !isEmpty(this._column.aggregate) ) {
+    //         return minValue < maxValue;
+    //     } else  if (isDateColumn(this._column)) {
+    //         const formattedValue1 = getDateByDateFormat(minValue, this._dateFormat);
+    //         const formattedValue2 = getDateByDateFormat(maxValue, this._dateFormat);
+
+    //         return formattedValue1 < formattedValue2;
+    //     }
+    // }
+
+    // private validValue(value: string): boolean {
+        
+    // }
+
+    // private getErrorMessage(type: IInputErrorType, config?: { values?: string[], plural?: boolean, isDate?: boolean, dateFormat: IDateFormat }) {
+    //     let message = '', values;
+    //     config = { values: _get(config, 'values', []), plural: _get(config, 'plural', false), isDate: _get(config, 'isDate', false), dateFormat: _get(config, 'dateFormat') };
+    //     if (config.values.length) {
+    //       values = '"' + config.values.join('", "') + '"';
+    //       config.plural = config.values.length > 1;
+    //     }
+    //     const valueTypeMessage = config.isDate ? 'date' : 'value';
+    //     if (type === ERROR_TYPE.INVALID_INPUT) {
+    //       message = getInvalidInputErrorMessage(values, config.plural);
+    //     } else if (INVALID_INPUT_DATE.includes(type)) {
+    //       message = getInvalidInputDateErrorMessage(config.dateFormat, values, config.plural); 
+    //     } else if (type === ERROR_TYPE.INVALID_INPUT_NUMERIC) {
+    //       message = getInvalidInputErrorMessage(values, config.plural).concat(config.plural ? ' They ' : ' It ').concat('should be numeric format.');
+    //     } else if (type === ERROR_TYPE.MAX_LIMIT) {
+    //       message = 'Max '.concat(valueTypeMessage).concat(' should be ').concat(config.isDate ? 'after' : 'greater than').concat(' the Min ').concat(valueTypeMessage);
+    //     } else if (type === ERROR_TYPE.MIN_LIMIT) {
+    //       message = 'Min '.concat(valueTypeMessage).concat(' should be ').concat(config.isDate ? 'before' : 'less than').concat(' the Max ').concat(valueTypeMessage);
+    //     } else if (type === ERROR_TYPE.REPEATED_VALUE) {
+    //       message = values ? values.concat(' already exist').concat(config.plural ? '' : 's') : config.plural ? 'These filters already exist.' : 'This filter already exists.';
+    //     }
+    //     return message;
+    //   }
+      
+}

package/src/filters/classes/index.ts

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

package/src/filters/constants/builder/FILTER_BUILDER_SCOPE_LABEL.ts

@@ -0,0 +1,7 @@
+import { FILTER_SCOPE } from "..";
+
+export const FILTER_BUILDER_SCOPE_LABEL = {
+    [FILTER_SCOPE.GLOBAL]: 'All pages',
+    [FILTER_SCOPE.PAGE]: 'Current page',
+    [FILTER_SCOPE.TAB]: 'Current tab',
+};

package/src/filters/constants/common/FILTER_DATE_SECTION_INFO.ts

@@ -3,6 +3,6 @@ import { FILTER_DATE_SECTION } from "./FILTER_DATE_SECTION";
 import { FILTER_DATE_SECTION_LABEL } from "./FILTER_DATE_SECTION_LABEL";
 
 export const FILTER_DATE_SECTION_INFO: IFDateSectionInfo[] = [
-  { label: FILTER_DATE_SECTION_LABEL.RELATIVE, shortLabel: 'Relative', abbrLabel: 'REL', value: FILTER_DATE_SECTION.RELATIVE, displayed: true },
-  { label: FILTER_DATE_SECTION_LABEL.ABSOLUTE, shortLabel: 'Absolute', abbrLabel: 'ABS', value: FILTER_DATE_SECTION.ABSOLUTE, displayed: true },
+  { label: FILTER_DATE_SECTION_LABEL.RELATIVE, shortLabel: 'Relative', abbrLabel: 'REL', value: FILTER_DATE_SECTION.RELATIVE, displayed: true, i18nLabelPath: 'filter.date_sections.relative' },
+  { label: FILTER_DATE_SECTION_LABEL.ABSOLUTE, shortLabel: 'Absolute', abbrLabel: 'ABS', value: FILTER_DATE_SECTION.ABSOLUTE, displayed: true, i18nLabelPath: 'filter.date_sections.absolute' },
 ];

package/src/filters/constants/common/FILTER_SCOPE_INFO.ts

@@ -3,12 +3,12 @@ import { FILTER_SCOPE } from "./FILTER_SCOPE";
 import { FILTER_SCOPE_LABEL } from "./FILTER_SCOPE_LABEL";
 
 export const FILTER_SCOPE_INFO: IFScopeInfo[] = [
-    { label: FILTER_SCOPE_LABEL.ADMIN, shortLabel: 'Admin', abbrLabel: 'ADM', value: FILTER_SCOPE.ADMIN, displayed: true },
-    { label: FILTER_SCOPE_LABEL.DATA, shortLabel: 'Data', abbrLabel: 'DAT', value: FILTER_SCOPE.DATA, displayed: true },
-    { label: FILTER_SCOPE_LABEL.GLOBAL, shortLabel: 'Global', abbrLabel: 'GLB', value: FILTER_SCOPE.GLOBAL, displayed: true },
-    { label: FILTER_SCOPE_LABEL.PAGE, shortLabel: 'Page', abbrLabel: 'PAG', value: FILTER_SCOPE.PAGE, displayed: true },
-    { label: FILTER_SCOPE_LABEL.TAB, shortLabel: 'Tab', abbrLabel: 'TAB', value: FILTER_SCOPE.TAB, displayed: true },
-    { label: FILTER_SCOPE_LABEL.DEFAULT, shortLabel: 'Default', abbrLabel: 'DEF', value: FILTER_SCOPE.DEFAULT, displayed: true },
-    { label: FILTER_SCOPE_LABEL.CHART, shortLabel: 'Chart', abbrLabel: 'CRT', value: FILTER_SCOPE.CHART, displayed: true },
-    { label: FILTER_SCOPE_LABEL.ACTION, shortLabel: 'Action', abbrLabel: 'ACT', value: FILTER_SCOPE.ACTION, displayed: true },
+    { label: FILTER_SCOPE_LABEL.ADMIN, shortLabel: 'Admin', abbrLabel: 'ADM', value: FILTER_SCOPE.ADMIN, displayed: true, i18nLabelPath: 'filter.scopes.admin' },
+    { label: FILTER_SCOPE_LABEL.DATA, shortLabel: 'Data', abbrLabel: 'DAT', value: FILTER_SCOPE.DATA, displayed: true, i18nLabelPath: 'filter.scopes.data' },
+    { label: FILTER_SCOPE_LABEL.GLOBAL, shortLabel: 'Global', abbrLabel: 'GLB', value: FILTER_SCOPE.GLOBAL, displayed: true, i18nLabelPath: 'filter.scopes.global' },
+    { label: FILTER_SCOPE_LABEL.PAGE, shortLabel: 'Page', abbrLabel: 'PAG', value: FILTER_SCOPE.PAGE, displayed: true, i18nLabelPath: 'filter.scopes.page' },
+    { label: FILTER_SCOPE_LABEL.TAB, shortLabel: 'Tab', abbrLabel: 'TAB', value: FILTER_SCOPE.TAB, displayed: true, i18nLabelPath: 'filter.scopes.tab' },
+    { label: FILTER_SCOPE_LABEL.DEFAULT, shortLabel: 'Default', abbrLabel: 'DEF', value: FILTER_SCOPE.DEFAULT, displayed: true, i18nLabelPath: 'filter.scopes.default' },
+    { label: FILTER_SCOPE_LABEL.CHART, shortLabel: 'Chart', abbrLabel: 'CRT', value: FILTER_SCOPE.CHART, displayed: true, i18nLabelPath: 'filter.scopes.chart' },
+    { label: FILTER_SCOPE_LABEL.ACTION, shortLabel: 'Action', abbrLabel: 'ACT', value: FILTER_SCOPE.ACTION, displayed: true, i18nLabelPath: 'filter.scopes.action' },
 ];

package/src/filters/constants/common/FILTER_VALIDATOR_INFO.ts

@@ -4,25 +4,25 @@ import { FILTER_VALIDATOR } from "./FILTER_VALIDATOR";
 import { FILTER_VALIDATOR_LABEL } from "./FILTER_VALIDATOR_LABEL";
 
 export const FILTER_VALIDATOR_INFO: { [key in IFValidator]: IFValidatorInfo } = {
-    [FILTER_VALIDATOR.EQUALS]: { label: FILTER_VALIDATOR_LABEL.EQUALS, shortLabel: 'Equals', abbrLabel: 'EQL', value: FILTER_VALIDATOR.EQUALS, displayed: true },
-    [FILTER_VALIDATOR.NOT_EQUAL]: { label: FILTER_VALIDATOR_LABEL.NOT_EQUAL, shortLabel: 'Not Equal', abbrLabel: 'NEQL', value: FILTER_VALIDATOR.NOT_EQUAL, displayed: true },
-    [FILTER_VALIDATOR.BEFORE]: { label: FILTER_VALIDATOR_LABEL.BEFORE, shortLabel: 'Before', abbrLabel: 'BFR', value: FILTER_VALIDATOR.BEFORE, displayed: true },
-    [FILTER_VALIDATOR.AFTER]: { label: FILTER_VALIDATOR_LABEL.AFTER, shortLabel: 'After', abbrLabel: 'AFT', value: FILTER_VALIDATOR.AFTER, displayed: true },
-    [FILTER_VALIDATOR.BEFORE_ON]: { label: FILTER_VALIDATOR_LABEL.BEFORE_ON, shortLabel: 'Before on', abbrLabel: 'BFRON', value: FILTER_VALIDATOR.BEFORE_ON, displayed: true },
-    [FILTER_VALIDATOR.AFTER_ON]: { label: FILTER_VALIDATOR_LABEL.AFTER_ON, shortLabel: 'After on', abbrLabel: 'AFTON', value: FILTER_VALIDATOR.AFTER_ON, displayed: true },
-    [FILTER_VALIDATOR.BETWEEN_INCLUSIVE]: { label: FILTER_VALIDATOR_LABEL.BETWEEN_INCLUSIVE, shortLabel: 'Between inclusive', abbrLabel: 'BTWIN', value: FILTER_VALIDATOR.BETWEEN_INCLUSIVE, displayed: true },
-    [FILTER_VALIDATOR.BETWEEN_EXCLUSIVE]: { label: FILTER_VALIDATOR_LABEL.BETWEEN_EXCLUSIVE, shortLabel: 'Between exclusive', abbrLabel: 'BTWEX', value: FILTER_VALIDATOR.BETWEEN_EXCLUSIVE, displayed: true },
-    [FILTER_VALIDATOR.IS_NULL]: { label: FILTER_VALIDATOR_LABEL.IS_NULL, shortLabel: 'Null', abbrLabel: 'NLL', value: FILTER_VALIDATOR.IS_NULL, displayed: true },
-    [FILTER_VALIDATOR.IS_NOT_NULL]: { label: FILTER_VALIDATOR_LABEL.IS_NOT_NULL, shortLabel: 'Not Null', abbrLabel: 'NNLL', value: FILTER_VALIDATOR.IS_NOT_NULL, displayed: true },
-    [FILTER_VALIDATOR.LESS_THAN]: { label: FILTER_VALIDATOR_LABEL.LESS_THAN, shortLabel: 'Less than', abbrLabel: 'LSS', value: FILTER_VALIDATOR.LESS_THAN, displayed: true },
-    [FILTER_VALIDATOR.LESS_THAN_EQUAL]: { label: FILTER_VALIDATOR_LABEL.LESS_THAN_EQUAL, shortLabel: 'Less equal', abbrLabel: 'LSSEQL', value: FILTER_VALIDATOR.LESS_THAN_EQUAL, displayed: true },
-    [FILTER_VALIDATOR.GREATER_THAN]: { label: FILTER_VALIDATOR_LABEL.GREATER_THAN, shortLabel: 'Greater than', abbrLabel: 'GRT', value: FILTER_VALIDATOR.GREATER_THAN, displayed: true },
-    [FILTER_VALIDATOR.GREATER_THAN_EQUAL]: { label: FILTER_VALIDATOR_LABEL.GREATER_THAN_EQUAL, shortLabel: 'Greater equal', abbrLabel: 'GRTEQL', value: FILTER_VALIDATOR.GREATER_THAN_EQUAL, displayed: true },
-    [FILTER_VALIDATOR.STARTS_WITH]: { label: FILTER_VALIDATOR_LABEL.STARTS_WITH, shortLabel: 'Starts with', abbrLabel: 'STR', value: FILTER_VALIDATOR.STARTS_WITH, displayed: true },
-    [FILTER_VALIDATOR.ENDS_WITH]: { label: FILTER_VALIDATOR_LABEL.ENDS_WITH, shortLabel: 'Ends with', abbrLabel: 'END', value: FILTER_VALIDATOR.ENDS_WITH, displayed: true },
-    [FILTER_VALIDATOR.CONTAINS]: { label: FILTER_VALIDATOR_LABEL.CONTAINS, shortLabel: 'Contains', abbrLabel: 'CTNS', value: FILTER_VALIDATOR.CONTAINS, displayed: true },
-    [FILTER_VALIDATOR.NOT_START_WITH]: { label: FILTER_VALIDATOR_LABEL.NOT_START_WITH, shortLabel: 'Not start', abbrLabel: 'NSTR', value: FILTER_VALIDATOR.NOT_START_WITH, displayed: true },
-    [FILTER_VALIDATOR.NOT_END_WITH]: { label: FILTER_VALIDATOR_LABEL.NOT_END_WITH, shortLabel: 'Not end', abbrLabel: 'NEND', value: FILTER_VALIDATOR.NOT_END_WITH, displayed: true },
-    [FILTER_VALIDATOR.NOT_CONTAIN]: { label: FILTER_VALIDATOR_LABEL.NOT_CONTAIN, shortLabel: 'Not contain', abbrLabel: 'NCTNS', value: FILTER_VALIDATOR.NOT_CONTAIN, displayed: true },
-    [FILTER_VALIDATOR.IN] : { label: FILTER_VALIDATOR_LABEL.IN, shortLabel: 'In', abbrLabel: 'IN', value: FILTER_VALIDATOR.IN, displayed: true }
+    [FILTER_VALIDATOR.EQUALS]: { label: FILTER_VALIDATOR_LABEL.EQUALS, shortLabel: 'Equals', abbrLabel: 'EQL', value: FILTER_VALIDATOR.EQUALS, displayed: true, i18nLabelPath: 'filter.validators.equals_label' },
+    [FILTER_VALIDATOR.NOT_EQUAL]: { label: FILTER_VALIDATOR_LABEL.NOT_EQUAL, shortLabel: 'Not Equal', abbrLabel: 'NEQL', value: FILTER_VALIDATOR.NOT_EQUAL, displayed: true, i18nLabelPath: 'filter.validators.not_equal_label' },
+    [FILTER_VALIDATOR.BEFORE]: { label: FILTER_VALIDATOR_LABEL.BEFORE, shortLabel: 'Before', abbrLabel: 'BFR', value: FILTER_VALIDATOR.BEFORE, displayed: true, i18nLabelPath: 'filter.validators.before_label' },
+    [FILTER_VALIDATOR.AFTER]: { label: FILTER_VALIDATOR_LABEL.AFTER, shortLabel: 'After', abbrLabel: 'AFT', value: FILTER_VALIDATOR.AFTER, displayed: true, i18nLabelPath: 'filter.validators.after_label' },
+    [FILTER_VALIDATOR.BEFORE_ON]: { label: FILTER_VALIDATOR_LABEL.BEFORE_ON, shortLabel: 'Before on', abbrLabel: 'BFRON', value: FILTER_VALIDATOR.BEFORE_ON, displayed: true, i18nLabelPath: 'filter.validators.before_on_label' },
+    [FILTER_VALIDATOR.AFTER_ON]: { label: FILTER_VALIDATOR_LABEL.AFTER_ON, shortLabel: 'After on', abbrLabel: 'AFTON', value: FILTER_VALIDATOR.AFTER_ON, displayed: true, i18nLabelPath: 'filter.validators.after_on_label' },
+    [FILTER_VALIDATOR.BETWEEN_INCLUSIVE]: { label: FILTER_VALIDATOR_LABEL.BETWEEN_INCLUSIVE, shortLabel: 'Between inclusive', abbrLabel: 'BTWIN', value: FILTER_VALIDATOR.BETWEEN_INCLUSIVE, displayed: true, i18nLabelPath: 'filter.validators.between_inclusive_label' },
+    [FILTER_VALIDATOR.BETWEEN_EXCLUSIVE]: { label: FILTER_VALIDATOR_LABEL.BETWEEN_EXCLUSIVE, shortLabel: 'Between exclusive', abbrLabel: 'BTWEX', value: FILTER_VALIDATOR.BETWEEN_EXCLUSIVE, displayed: true, i18nLabelPath: 'filter.validators.between_exclusive_label' },
+    [FILTER_VALIDATOR.IS_NULL]: { label: FILTER_VALIDATOR_LABEL.IS_NULL, shortLabel: 'Null', abbrLabel: 'NLL', value: FILTER_VALIDATOR.IS_NULL, displayed: true, i18nLabelPath: 'filter.validators.is_null_label' },
+    [FILTER_VALIDATOR.IS_NOT_NULL]: { label: FILTER_VALIDATOR_LABEL.IS_NOT_NULL, shortLabel: 'Not Null', abbrLabel: 'NNLL', value: FILTER_VALIDATOR.IS_NOT_NULL, displayed: true, i18nLabelPath: 'filter.validators.is_not_null_label' },
+    [FILTER_VALIDATOR.LESS_THAN]: { label: FILTER_VALIDATOR_LABEL.LESS_THAN, shortLabel: 'Less than', abbrLabel: 'LSS', value: FILTER_VALIDATOR.LESS_THAN, displayed: true, i18nLabelPath: 'filter.validators.less_than_label' },
+    [FILTER_VALIDATOR.LESS_THAN_EQUAL]: { label: FILTER_VALIDATOR_LABEL.LESS_THAN_EQUAL, shortLabel: 'Less equal', abbrLabel: 'LSSEQL', value: FILTER_VALIDATOR.LESS_THAN_EQUAL, displayed: true, i18nLabelPath: 'filter.validators.less_than_equal_label' },
+    [FILTER_VALIDATOR.GREATER_THAN]: { label: FILTER_VALIDATOR_LABEL.GREATER_THAN, shortLabel: 'Greater than', abbrLabel: 'GRT', value: FILTER_VALIDATOR.GREATER_THAN, displayed: true, i18nLabelPath: 'filter.validators.greater_than_label' },
+    [FILTER_VALIDATOR.GREATER_THAN_EQUAL]: { label: FILTER_VALIDATOR_LABEL.GREATER_THAN_EQUAL, shortLabel: 'Greater equal', abbrLabel: 'GRTEQL', value: FILTER_VALIDATOR.GREATER_THAN_EQUAL, displayed: true, i18nLabelPath: 'filter.validators.greater_than_equal_label' },
+    [FILTER_VALIDATOR.STARTS_WITH]: { label: FILTER_VALIDATOR_LABEL.STARTS_WITH, shortLabel: 'Starts with', abbrLabel: 'STR', value: FILTER_VALIDATOR.STARTS_WITH, displayed: true, i18nLabelPath: 'filter.validators.starts_with_label' },
+    [FILTER_VALIDATOR.ENDS_WITH]: { label: FILTER_VALIDATOR_LABEL.ENDS_WITH, shortLabel: 'Ends with', abbrLabel: 'END', value: FILTER_VALIDATOR.ENDS_WITH, displayed: true, i18nLabelPath: 'filter.validators.ends_with_label' },
+    [FILTER_VALIDATOR.CONTAINS]: { label: FILTER_VALIDATOR_LABEL.CONTAINS, shortLabel: 'Contains', abbrLabel: 'CTNS', value: FILTER_VALIDATOR.CONTAINS, displayed: true, i18nLabelPath: 'filter.validators.contains_label' },
+    [FILTER_VALIDATOR.NOT_START_WITH]: { label: FILTER_VALIDATOR_LABEL.NOT_START_WITH, shortLabel: 'Not start', abbrLabel: 'NSTR', value: FILTER_VALIDATOR.NOT_START_WITH, displayed: true, i18nLabelPath: 'filter.validators.not_start_with_label' },
+    [FILTER_VALIDATOR.NOT_END_WITH]: { label: FILTER_VALIDATOR_LABEL.NOT_END_WITH, shortLabel: 'Not end', abbrLabel: 'NEND', value: FILTER_VALIDATOR.NOT_END_WITH, displayed: true, i18nLabelPath: 'filter.validators.not_end_with_label' },
+    [FILTER_VALIDATOR.NOT_CONTAIN]: { label: FILTER_VALIDATOR_LABEL.NOT_CONTAIN, shortLabel: 'Not contain', abbrLabel: 'NCTNS', value: FILTER_VALIDATOR.NOT_CONTAIN, displayed: true, i18nLabelPath: 'filter.validators.not_contain_label' },
+    [FILTER_VALIDATOR.IN] : { label: FILTER_VALIDATOR_LABEL.IN, shortLabel: 'In', abbrLabel: 'IN', value: FILTER_VALIDATOR.IN, displayed: true, i18nLabelPath: 'filter.validators.in' }
 };

package/src/filters/helpers/common/getFilterColumnLabel.ts

@@ -1,6 +1,6 @@
+import { AGGREGATE_ABBREVIATION } from "../../../charts/constants/AGGREGATE_ABBREVIATION";
 import { COMPLEX_COLUMN_PROPERTIES } from "../../../columns/constants/COMPLEX_COLUMN_PROPERTIES";
 import { isComplexColumn } from "../../../columns/helpers/isComplexColumn";
-import { AGGREGATE_ABBREVIATION } from "../../../qrvey/constants/AGGREGATE_ABBREVIATION";
 import { IFUColumn } from "../../interfaces/ui/IFUColumn";
 
 /**