@qrvey/utils 1.11.0-8 → 1.11.0

package/dist/filters/helpers/common/mergeFilters.js

@@ -1,6 +1,6 @@
 import { isEmpty } from "../../../general/mix/isEmpty";
-import { cloneDeep } from "../../../general/object/cloneDeep";
-import { FILTER_GROUPED_COLUMN_OPERATOR } from "../../constants/common/FILTER_GROUPED_COLUMN_OPERATOR";
+import { mergeDeep } from "../../../general/object/mergeDeep";
+import { objectCopy } from "../../../general/object/objectCopy";
 import { getFilterid } from "./getFilterid";
 import { getMergeFiltersSettings } from "./getMergeFiltersSettings";
 import { mergeValues } from "./mergeValues";
@@ -8,13 +8,17 @@ import { resolveDatasetConditions } from "./resolveDatasetConditions";
 import { resolveFilterConditions } from "./resolveFilterConditions";
 import { resolveScopeConditions } from "./resolveScopeConditions";
 /**
- * Merge filter data structures in a new one. The first Filter Data passed in the argument has the priority
- * @param filterData1 The target filter data
- * @param filterData2 the filter data to be merged
- * @param settings configuration of the mergeFilter
- * @returns a new filter data structure
+ * Merges the second filter data into the first one; the first Filter Data passed in the argument has the priority.
+ * Conditions:
+ * - If the info in the second filter data does not exist in the first one, the info will be added
+ * - If the info in the second filter data exists in the first one, the info will be merged
+ * @param {IFUData} filterData1 The target filter data
+ * @param {IFUData} filterData2 the filter data to be merged
+ * @param {IFFiltersMergeFilters} settings configuration of the mergeFilters
+ * @returns {IFUData} a new filter data structure
  */
 export function mergeFilters(filterData1, filterData2, settings) {
+    var _a;
     if (isEmpty(filterData1) || isEmpty(filterData1.scopes)) {
         if (isEmpty(filterData2) || isEmpty(filterData2.scopes))
             return;
@@ -22,22 +26,28 @@ export function mergeFilters(filterData1, filterData2, settings) {
     }
     if (isEmpty(filterData2) || isEmpty(filterData2.scopes))
         return filterData1;
-    const _filterData1 = cloneDeep(filterData1);
-    const _filterData2 = cloneDeep(filterData2);
+    const newFilterData1 = objectCopy(filterData1);
+    const newFilterData2 = objectCopy(filterData2);
     const defaultSettings = getMergeFiltersSettings(settings);
-    return {
-        enabled: _filterData1.enabled,
-        scopes: mergeScopes(_filterData1.scopes, _filterData2.scopes, defaultSettings),
-        section: _filterData1.section,
-        version: _filterData1.version,
-    };
+    const scopes = mergeScopes(newFilterData1.scopes, newFilterData2.scopes, defaultSettings);
+    if (defaultSettings.mergeFilterDataProps) {
+        return {
+            enabled: (_a = newFilterData2.enabled) !== null && _a !== void 0 ? _a : newFilterData1.enabled,
+            section: newFilterData2.section || newFilterData1.section,
+            scopes,
+            version: newFilterData2.version || newFilterData1.version,
+        };
+    }
+    return Object.assign(Object.assign({}, newFilterData1), { scopes });
 }
 /**
- * Gets a new scope structure array by merging two scope structures
- * @param scopes1 the target scope structure
- * @param scopes2 the scope to be merged
- * @param settings configuration of the mergeFilter
- * @returns a new scope structure array
+ * Gets a new scope array structure by merging both scope structures
+ * - If the info in the second scope does not exist in the first one, the scope will be added
+ * - If the info in the second scope exists in the first one, the scope will be merged
+ * @param {IFUScope[]} scopes1 the target scope structure
+ * @param {IFUScope[]} scopes2 the scope to be merged
+ * @param {IFFiltersMergeFilters} settings configuration of the mergeFilters
+ * @returns {IFUScope[]} a new scope array structure
  */
 function mergeScopes(scopes1 = [], scopes2 = [], settings) {
     let newScopes = scopes1.reduce((scopes, scope1) => {
@@ -47,7 +57,7 @@ function mergeScopes(scopes1 = [], scopes2 = [], settings) {
         }));
         let _scope1 = scope1;
         if (scope2Index > -1) {
-            _scope1 = Object.assign(Object.assign({}, scopes2[scope2Index]), { datasets: mergeDatasets(scope1.datasets, scopes2[scope2Index].datasets, settings) });
+            _scope1 = Object.assign(Object.assign({}, mergeScopeProps(scope1, scopes2[scope2Index], settings)), { datasets: mergeDatasets(scope1.datasets, scopes2[scope2Index].datasets, settings) });
             scopes2.splice(scope2Index, 1);
         }
         scopes.push(_scope1);
@@ -58,11 +68,13 @@ function mergeScopes(scopes1 = [], scopes2 = [], settings) {
     return newScopes;
 }
 /**
- * Gets a new dataset structure array by merging two dataset structures
- * @param datasets1 the target dataset structure
- * @param datasets2 the dataset to be merged
- * @param settings configuration of the mergeFilter
- * @returns a new dataset structure array
+ * Gets a new dataset structure array by merging both dataset structures
+ * - If the info in the second dataset does not exist in the first one, the dataset will be added
+ * - If the info in the second dataset exists in the first one, the dataset will be merged
+ * @param {IFUDataset[]} datasets1 the target dataset structure
+ * @param {IFUDataset[]} datasets2 the dataset to be merged
+ * @param {IFFiltersMergeFilters} settings configuration of the mergeFilter
+ * @returns {IFUDataset[]} a new dataset structure array
  */
 function mergeDatasets(datasets1 = [], datasets2 = [], settings) {
     let newDatasets = datasets1.reduce((datasets, dataset1) => {
@@ -71,7 +83,7 @@ function mergeDatasets(datasets1 = [], datasets2 = [], settings) {
         }));
         let _dataset1 = dataset1;
         if (dataset2Index > -1) {
-            _dataset1 = Object.assign(Object.assign({}, datasets2[dataset2Index]), { filters: mergeFilterss(dataset1.filters, datasets2[dataset2Index].filters, settings) });
+            _dataset1 = Object.assign(Object.assign({}, mergeDatasetProps(dataset1, datasets2[dataset2Index], settings)), { filters: mergeFilterss(dataset1.filters, datasets2[dataset2Index].filters, settings) });
             datasets2.splice(dataset2Index, 1);
         }
         datasets.push(_dataset1);
@@ -83,10 +95,10 @@ function mergeDatasets(datasets1 = [], datasets2 = [], settings) {
 }
 /**
  * Gets a new filter structure array by merging two filter structures
- * @param filters1 the target filter structure
- * @param filters2 the filter to be merged
- * @param settings configuration of the mergeFilter
- * @returns a new filter structure array
+ * @param {IFUFilter[]} filters1 the target filter structure
+ * @param {IFUFilter[]} filters2 the filter to be merged
+ * @param {IFFiltersMergeFilters} settings configuration of the mergeFilters
+ * @returns {IFUFilter[]} a new filter structure array
  */
 function mergeFilterss(filters1 = [], filters2 = [], settings) {
     let newFilters = filters1.reduce((filters, filter1) => {
@@ -99,14 +111,11 @@ function mergeFilterss(filters1 = [], filters2 = [], settings) {
         }));
         let _filter1 = filter1;
         if (filter2Index > -1) {
-            _filter1 = Object.assign(Object.assign({}, _filter1), { values: mergeValues(_filter1, filters2[filter2Index], settings) });
-            _filter1 = mergeFilterProps(_filter1, filters2[filter2Index], settings);
+            _filter1 = Object.assign(Object.assign(Object.assign({}, _filter1), mergeFilterProps(_filter1, filters2[filter2Index], settings)), { values: mergeValues(_filter1, filters2[filter2Index], settings) });
             filters2.splice(filter2Index, 1);
         }
-        else {
-            _filter1 = Object.assign(Object.assign({}, _filter1), { operator: settings.setGroupedColumnOperator
-                    ? FILTER_GROUPED_COLUMN_OPERATOR
-                    : _filter1.operator });
+        else if (!isEmpty(settings.setGroupedColumnOperator)) {
+            _filter1.operator = settings.setGroupedColumnOperator;
         }
         _filter1.filterid = getFilterid(_filter1);
         filters.push(_filter1);
@@ -117,17 +126,47 @@ function mergeFilterss(filters1 = [], filters2 = [], settings) {
     return newFilters;
 }
 /**
- * Gets a new filter structure when the setting is configured
- * @param filter1 the target filter structure
- * @param filter2 the filter to be used to merge the values
- * @param settings configuration of the mergeFilter
+ * Gets a new scope structure for the configured settings
+ * @param {IFUScope} scope1 the target scope structure
+ * @param {IFUScope} scope2 the scope to be used to merge the values
+ * @param {IFFiltersMergeFilters} settings configuration of the mergeFilters
+ * @returns {IFUScope} a new filter structure with overwritted props
+ */
+function mergeScopeProps(scope1, scope2, settings) {
+    var _a, _b, _c;
+    let _scope1 = scope1;
+    if (settings.mergeScopeProps) {
+        _scope1 = Object.assign(Object.assign({}, scope1), { collapsed: (_a = scope2.collapsed) !== null && _a !== void 0 ? _a : scope1.collapsed, displayed: (_b = scope2.displayed) !== null && _b !== void 0 ? _b : scope1.displayed, enabled: (_c = scope2.enabled) !== null && _c !== void 0 ? _c : scope1.enabled, label: scope2.label || scope1.label, scope: scope2.scope || scope1.scope, scopeid: scope2.scopeid || scope1.scopeid });
+    }
+    return _scope1;
+}
+/**
+ * Gets a new dataset structure for the configured settings
+ * @param {IFUDataset} dataset1 the target dataset structure
+ * @param {IFUDataset} dataset2 the dataset to be used to merge the values
+ * @param {IFFiltersMergeFilters} settings configuration of the mergeFilters
+ * @returns {IFUDataset} a new filter structure with overwritted props
+ */
+function mergeDatasetProps(dataset1, dataset2, settings) {
+    var _a, _b, _c;
+    let _dataset1 = dataset1;
+    if (settings.mergeDatasetProps) {
+        _dataset1 = Object.assign(Object.assign({}, dataset1), { collapsed: (_a = dataset2.collapsed) !== null && _a !== void 0 ? _a : dataset1.collapsed, displayed: (_b = dataset2.displayed) !== null && _b !== void 0 ? _b : dataset1.displayed, enabled: (_c = dataset2.enabled) !== null && _c !== void 0 ? _c : dataset1.enabled, label: dataset2.label || dataset1.label, qrveyid: dataset2.qrveyid || dataset1.qrveyid });
+    }
+    return _dataset1;
+}
+/**
+ * Gets a new filter structure for the configured settings
+ * @param {IFUFilter} filter1 the target filter structure
+ * @param {IFUFilter} filter2 the filter to be used to merge the values
+ * @param {IFFiltersMergeFilters} settings configuration of the mergeFilters
  * @returns a new filter structure with overwritted props
  */
 function mergeFilterProps(filter1, filter2, settings) {
     var _a, _b, _c;
     let _filter1 = filter1;
-    if (settings.overwriteFilterProps) {
-        _filter1 = Object.assign(Object.assign({}, filter1), { collapsed: (_a = filter2.collapsed) !== null && _a !== void 0 ? _a : filter1.collapsed, displayed: (_b = filter2.displayed) !== null && _b !== void 0 ? _b : filter1.displayed, dateSection: filter2.dateSection, extras: filter2.extras, enabled: (_c = filter2.enabled) !== null && _c !== void 0 ? _c : filter1.enabled, operator: filter2.operator || filter1.operator, filterid: filter2.filterid, lookupDisplayIndex: filter2.lookupDisplayIndex, nullValues: filter2.nullValues, selectAll: filter2.selectAll });
+    if (settings.mergeFilterProps) {
+        _filter1 = Object.assign(Object.assign({}, filter1), { collapsed: (_a = filter2.collapsed) !== null && _a !== void 0 ? _a : filter1.collapsed, column: mergeDeep(filter2.column, filter1.column), displayed: (_b = filter2.displayed) !== null && _b !== void 0 ? _b : filter1.displayed, dateSection: filter2.dateSection, extras: filter2.extras, enabled: (_c = filter2.enabled) !== null && _c !== void 0 ? _c : filter1.enabled, lookupDisplayIndex: filter2.lookupDisplayIndex, nullValues: filter2.nullValues, property: filter2.property || filter1.property, operator: filter2.operator || filter1.operator, selectAll: filter2.selectAll, validator: filter2.validator || filter1.validator });
     }
     return _filter1;
 }

package/dist/filters/helpers/common/resolveScopeConditions.d.ts

@@ -4,8 +4,8 @@ import { IFSScope } from "../../interfaces/common/IFSScope";
  * Resolves the conditions by given params
  * @param filter The filter scope structure
  * @param params given parameters to validate the filter
- * @param letPassUndefinedProperties Flag to avoid applying the condition when the filter properties are undefined
- * @param letPassUndefinedParams Flag to avoid applying the condition when the param properties are explicit undefined.
+ * @param letPassUndefinedProperties Flag to avoid applying the condition when the properties of the properties are undefined
+ * @param letPassUndefinedParams Flag to avoid applying the condition when the properties of the params are explicit undefined.
  * @returns true: the condition is satisfied
  */
 export declare function resolveScopeConditions(scope: IFSScope, params: IFSParamsToGetFilter, letPassUndefinedProperties?: boolean, letPassUndefinedParams?: boolean): boolean;

package/dist/filters/helpers/common/resolveScopeConditions.js

@@ -4,8 +4,8 @@ import { _hasProperty } from "../../../general/object/hasProperty";
  * Resolves the conditions by given params
  * @param filter The filter scope structure
  * @param params given parameters to validate the filter
- * @param letPassUndefinedProperties Flag to avoid applying the condition when the filter properties are undefined
- * @param letPassUndefinedParams Flag to avoid applying the condition when the param properties are explicit undefined.
+ * @param letPassUndefinedProperties Flag to avoid applying the condition when the properties of the properties are undefined
+ * @param letPassUndefinedParams Flag to avoid applying the condition when the properties of the params are explicit undefined.
  * @returns true: the condition is satisfied
  */
 export function resolveScopeConditions(scope, params, letPassUndefinedProperties = false, letPassUndefinedParams = true) {

package/dist/filters/helpers/getTokensFromFilters.js

@@ -3,6 +3,7 @@ import { getFilterPropertyLabel } from "./ui/getFilterPropertyLabel";
 import { FILTER_TOKENS_STRUCTURE_TYPE } from "../constants/common/FILTER_TOKENS_STRUCTURE_TYPE";
 import { isEmpty } from "../../general/mix/isEmpty";
 import { FILTER_SCOPE } from "../constants";
+import { transformFilterValues } from "./ui/transformFilterValues";
 /**
  * It takes a filter object and returns an array of tokens that represent the filter
  * @param {IFUData} filters - The filters object.
@@ -17,6 +18,10 @@ export function getTokensFromFilters(filters, options) {
         translate: i18nService.translate.bind(i18nService),
         addEnableds: true,
     };
+    const settingsTransform = {
+        i18n: options === null || options === void 0 ? void 0 : options.i18n,
+        translate: i18nService.translate.bind(i18nService),
+    };
     const getValue = (valueItem) => {
         var _a, _b;
         if (valueItem.value) {
@@ -56,6 +61,7 @@ export function getTokensFromFilters(filters, options) {
                     }
                     continue;
                 }
+                filter.values = transformFilterValues(filter, settingsTransform);
                 const values = getUIValues(filter, settings);
                 if (!thereIsFiltersWithValues)
                     thereIsFiltersWithValues = true;

package/dist/filters/interfaces/IFTokensFromFiltersSettings.d.ts

@@ -1,7 +1,9 @@
+import { II18nConfig } from "../../globalization";
 import { I18nService } from "../../globalization/service/i18nextBuilder";
 export interface IFTokensFromFiltersSettings {
     showScope?: boolean;
     showDatabaseName?: boolean;
     showChartName?: boolean;
     i18nService: I18nService;
+    i18n?: II18nConfig;
 }

package/dist/filters/interfaces/functions/IFFiltersMergeFilters.d.ts

@@ -1,8 +1,27 @@
+import { IFOperator } from "../IFOperator";
 import { IFFiltersMergeValues } from "./IFFiltersMergeValues";
 /**
  * Structure for MergeFilters property settings
  */
 export interface IFFiltersMergeFilters extends IFFiltersMergeValues {
-    overwriteFilterProps?: boolean;
-    setGroupedColumnOperator?: boolean;
+    /**
+     * Flag to merge second filter data props to first one
+     */
+    mergeFilterDataProps?: boolean;
+    /**
+     * Flag to merge second scope props to first one
+     */
+    mergeScopeProps?: boolean;
+    /**
+     * Flag to merge second dataset props to first one
+     */
+    mergeDatasetProps?: boolean;
+    /**
+     * Flag to merge second filter props to first one
+     */
+    mergeFilterProps?: boolean;
+    /**
+     * Whet setting, the operator is overwritten on new added filters
+     */
+    setGroupedColumnOperator?: IFOperator;
 }

package/dist/globalization/interfaces/formula_builder/II18nFormulaBuilderCreateModal.d.ts

@@ -54,6 +54,7 @@ export interface II18nFormulaBuilderCreateModal {
         output: string;
         output_result: string;
         output_case: string;
+        output_invalid_column: string;
         randomize_data: string;
         randomize_data_tooltip: string;
         console_output_title: string;

package/dist/globalization/interfaces/formula_builder/II18nFormulaBuilderErrorMessage.d.ts

@@ -13,6 +13,7 @@ export interface II18nFormulaBuilderErrorMessage {
     UNKNOWN: string;
     TOO_MANY_ARGUMENTS: string;
     DATE_DIF_UNIT_PARAM: string;
+    INVALID_ALLOW_VALUE: string;
     UNKNOWN_EXPRESSION: string;
     NOT_ALLOWED_EXPRESSION: string;
     OUT_OF_RANGE: string;
@@ -23,4 +24,9 @@ export interface II18nFormulaBuilderErrorMessage {
     MISSING_COLUMN_EXPRESSION: string;
     NO_COLUMN_EXPRESSION: string;
     ARGUMENTS_DATATYPE_ERROR: string;
+    FUNCTION_ARGUMENTS_MISMATCH: string;
+    NOT_ALLOWED_OPERATION: string;
+    NOT_ALLOWED_OPERATION_DIFFERENT_TYPES: string;
+    NOT_ALLOWED_OPERATION_MISSING_OPERATOR: string;
+    GREATER_THAN: string;
 }

package/dist/globalization/interfaces/formula_builder/II18nFormulaBuilderFunctionAnd.d.ts

@@ -0,0 +1,9 @@
+import { II18nFormulaBuilderFunction } from "./II18nFormulaBuilderFunction";
+export interface II18nFormulaBuilderFunctionAnd extends II18nFormulaBuilderFunction {
+    param_logicalTest1_name: string;
+    param_logicalTest1_description: string;
+    param_logicalTest2_name: string;
+    param_logicalTest2_description: string;
+    param_logicalTestn_name: string;
+    param_logicalTestn_description: string;
+}

package/dist/globalization/interfaces/formula_builder/II18nFormulaBuilderFunctionAnd.js

@@ -0,0 +1 @@
+export {};

package/dist/globalization/interfaces/formula_builder/index.d.ts

@@ -57,3 +57,4 @@ export * from "./II18nFormulaBuilderFunctionAggMax";
 export * from "./II18nFormulaBuilderFunctionAggDistinctcount";
 export * from "./II18nFormulaBuilderFunctionAggCount";
 export * from "./II18nFormulaBuilderErrorMessage";
+export * from "./II18nFormulaBuilderFunctionAnd";

package/dist/globalization/interfaces/formula_builder/index.js

@@ -57,3 +57,4 @@ export * from "./II18nFormulaBuilderFunctionAggMax";
 export * from "./II18nFormulaBuilderFunctionAggDistinctcount";
 export * from "./II18nFormulaBuilderFunctionAggCount";
 export * from "./II18nFormulaBuilderErrorMessage";
+export * from "./II18nFormulaBuilderFunctionAnd";

package/dist/globalization/interfaces/panel/II18nPanelErrors.d.ts

@@ -5,6 +5,7 @@ export interface II18nPanelErrors {
     continuous_time_limit: string;
     drilldown_unavailable: string;
     invalid_data_for_chart: string;
+    invalid_data_log_scale: string;
     longer_available_panel: string;
     long_text: string;
     missing_column: string;

package/dist/globalization/labels/chart_builder/I18N_CHART_BUILDER_GENERAL_OPTIONS.js

@@ -32,7 +32,7 @@ export const I18N_CHART_BUILDER_GENERAL_OPTIONS = {
         select_column_placeholder: "Select column",
         display_values: "Display Values As",
         display_values_placeholder: "Select aggregate",
-        display_values_multiples: "When multiples values display",
+        display_values_multiples: "When multiple values display",
         display_values_multiples_placeholder: "Select display Type",
         values_format: "Values Format",
         remove: "Remove",

package/dist/globalization/labels/formula_builder/I18N_FORMULA_BUILDER.js

@@ -1,3 +1,4 @@
+import { I18N_FORMULA_BUILDER_FUNCTION_AND } from "./I18N_FORMULA_BUILDER_FUNCTION_AND";
 export const I18N_FORMULA_BUILDER = {
     list_modal: {
         create_button: "Create Formula",
@@ -79,6 +80,7 @@ export const I18N_FORMULA_BUILDER = {
             output: "Output",
             output_case: "Test Case",
             output_result: "Result",
+            output_invalid_column: "Invalid column name.",
             randomize_data: "Randomize data",
             randomize_data_tooltip: "Refresh the testing data with random data from the dataset.",
             console_output_title: "Console Output",
@@ -177,6 +179,76 @@ export const I18N_FORMULA_BUILDER = {
                     param_replacement_name: "replacement",
                     param_replacement_description: "The value that will replace the null value. It must have the same data type as the column.",
                 },
+                dateadd: {
+                    description: "Adds a specific date part value to a given date.",
+                    function_placeholder: 'DATEADD(date_value1, "date_part", interval_value)',
+                    param_date_value1_name: "date_value1",
+                    param_date_value1_description: 'Date value for which you will get the weekday. It can be a column or a datetime value entered with a format of either "MM/DD/YYYY" or "MM/DD/YYYY HH:MM:SS".',
+                    param_date_part_name: "date_part",
+                    param_date_part_description: 'Date part allows: "Y" for years, "M" for months, "D" for days, "H" for hours, "MI" for minutes and "S" for seconds.',
+                    param_interval_value_name: "interval_value",
+                    param_interval_value_description: "Number of units of the selected date part that you want to add to the given date.",
+                },
+                dayofweek: {
+                    description: "Returns a number or string representative of the weekday for a given date.",
+                    function_placeholder: "DAYOFWEEK(date_value1, day_name)",
+                    param_date_value1_name: "date_value1",
+                    param_date_value1_description: 'Date value to which you will add the date part value. It can be a column or a datetime value entered with a format of either "MM/DD/YYYY" or "MM/DD/YYYY HH:MM:SS".',
+                    param_day_name_name: "day_name",
+                    param_day_name_description: 'If set equal to "Day" it will return the name of the day of the week, if set to "D" it will return a number from 1 to 7; if not set, it will also return a number from 1 to 7. 1=Sunday, 2=Monday, 3=Tuesday, 4=Wednesday, 5=Thursday, 6=Friday, 7=Saturday.',
+                },
+                trim: {
+                    description: "Removes all leading and trailing spaces from text.",
+                    function_placeholder: "TRIM(string1)",
+                    param_string1_name: "string1",
+                    param_string1_description: "Text to trim.",
+                },
+                concatenate: {
+                    description: "Joins two or more strings into one string.",
+                    function_placeholder: "CONCATENATE(string1,string2,...stringn)",
+                    param_string1_name: "string1 (required)",
+                    param_string1_description: "The first text to join.",
+                    param_string2_name: "string2 (required)",
+                    param_string2_description: "The second text to join.",
+                    param_stringn_name: "stringn (optional)",
+                    param_stringn_description: "Additional text items to join.",
+                },
+                left: {
+                    description: "Returns the first character or characters in a text string, based on the number of characters you specify.",
+                    function_placeholder: "LEFT(string1, num_chars)",
+                    param_string1_name: "string1 (required)",
+                    param_string1_description: "The text with characters to extract.",
+                    param_num_chars_name: "num_chars (optional)",
+                    param_num_chars_description: "Number of characters you want to extract. It has to be an integer greater than or equal to zero. If not defined, LEFT will return one character.",
+                },
+                right: {
+                    description: "Returns the last character or characters in a text string, based on the number of characters you specify.",
+                    function_placeholder: "RIGHT(string1, num_chars)",
+                    param_string1_name: "string1 (required)",
+                    param_string1_description: "The text with characters to extract.",
+                    param_num_chars_name: "num_chars (optional)",
+                    param_num_chars_description: "Number of characters you want to extract. It has to be an integer greater than or equal to zero. If not defined, RIGHT will return one character.",
+                },
+                upper: {
+                    description: "Converts all the characters in a string to uppercase.",
+                    function_placeholder: "UPPER(string1)",
+                    param_string1_name: "string1",
+                    param_string1_description: "The text you want converted to uppercase.",
+                },
+                lower: {
+                    description: "Converts all the characters in a string to lowercase.",
+                    function_placeholder: "LOWER(string1)",
+                    param_string1_name: "string1",
+                    param_string1_description: "The text you want converted to lowercase.",
+                },
+                proper: {
+                    description: "Capitalizes the first letter in a string and any other letters in the text placed next to any character other than a letter or number. Converts the rest of the letters to lowercase.",
+                    function_placeholder: "PROPER(string1)",
+                    param_string1_name: "string1",
+                    param_string1_description: "The text you want converted.",
+                },
+                and: Object.assign({}, I18N_FORMULA_BUILDER_FUNCTION_AND),
+                or: Object.assign(Object.assign({}, I18N_FORMULA_BUILDER_FUNCTION_AND), { description: "Evaluates different logical tests and returns false if all logical tests are false and true if at least one of the logical tests returns true.", function_placeholder: "OR(logicalTest1,logicalTest2,...logicalTestn)" }),
             },
             editor: {
                 error_messages: {
@@ -193,7 +265,7 @@ export const I18N_FORMULA_BUILDER = {
                     UNKNOWN_FUNCTION: "Unknown function",
                     UNKNOWN: "Unknown error",
                     TOO_MANY_ARGUMENTS: "Too many arguments",
-                    DATE_DIF_UNIT_PARAM: 'Unit param have to be equal to: "Y", "M", "D"',
+                    DATE_DIF_UNIT_PARAM: "Argument {{i18n.function.argument.position}} has to be {{i18n.function.argument.datedif_unit}}",
                     UNKNOWN_EXPRESSION: "Unknown expression",
                     NOT_ALLOWED_EXPRESSION: "Expression not allowed",
                     OUT_OF_RANGE: "Expression out of range",
@@ -204,6 +276,12 @@ export const I18N_FORMULA_BUILDER = {
                     MISSING_COLUMN_EXPRESSION: "Argument should be a column.",
                     NO_COLUMN_EXPRESSION: "Argument cannot be a column.",
                     ARGUMENTS_DATATYPE_ERROR: "Arguments should have the same data type.",
+                    FUNCTION_ARGUMENTS_MISMATCH: "{{i18n.function.name}} function is expecting {{i18n.function.input}} and is receiving {{i18n.function.received}}",
+                    NOT_ALLOWED_OPERATION: "Expression not allowed. Allowed operators between {{i18n.function.expression.types}}: {{i18n.function.expression.operators}}",
+                    NOT_ALLOWED_OPERATION_DIFFERENT_TYPES: "Expression not allowed {{i18n.function.expression.value}}",
+                    NOT_ALLOWED_OPERATION_MISSING_OPERATOR: "Expression not allowed. Missing operator",
+                    GREATER_THAN: "Argument {{i18n.function.argument.position}} has to be greater or equal than {{i18n.function.argument.greater_than}}",
+                    INVALID_ALLOW_VALUE: "Argument {{i18n.function.argument.position}} has to be {{i18n.function.argument.allow_value}}",
                 },
             },
         },

package/dist/globalization/labels/formula_builder/I18N_FORMULA_BUILDER_FUNCTION_AND.d.ts

@@ -0,0 +1,2 @@
+import { II18nFormulaBuilderFunctionAnd } from "../../interfaces";
+export declare const I18N_FORMULA_BUILDER_FUNCTION_AND: II18nFormulaBuilderFunctionAnd;

package/dist/globalization/labels/formula_builder/I18N_FORMULA_BUILDER_FUNCTION_AND.js

@@ -0,0 +1,10 @@
+export const I18N_FORMULA_BUILDER_FUNCTION_AND = {
+    description: "Evaluates different logical tests and returns true if all logical tests are true and false if at least one of the logical tests returns false. ",
+    function_placeholder: "AND(logicalTest1,logicalTest2,...logicalTestn)",
+    param_logicalTest1_name: "logicalTest1 (required)",
+    param_logicalTest1_description: "Logical test between two values, it should include logical operators such as =, >, <, >=, <= or <>. This argument can also be anything that returns a boolean value.",
+    param_logicalTest2_name: "logicalTest2 (required)",
+    param_logicalTest2_description: "Logical test between two values, it should include logical operators such as =, >, <, >=, <= or <>. This argument can also be anything that returns a boolean value.",
+    param_logicalTestn_name: "logicalTestn (optional)",
+    param_logicalTestn_description: "Logical test between two values, it should include logical operators such as =, >, <, >=, <= or <>. This argument can also be anything that returns a boolean value.",
+};

package/dist/globalization/labels/formula_builder/index.d.ts

@@ -1 +1,2 @@
 export * from "./I18N_FORMULA_BUILDER";
+export * from "./I18N_FORMULA_BUILDER_FUNCTION_AND";

package/dist/globalization/labels/formula_builder/index.js

@@ -1 +1,2 @@
 export * from "./I18N_FORMULA_BUILDER";
+export * from "./I18N_FORMULA_BUILDER_FUNCTION_AND";

package/dist/globalization/labels/panel/I18N_PANEL.js

@@ -13,6 +13,7 @@ export const I18N_PANEL = {
         continuous_time_limit: "The combination of data used in this chart exceeds the maximum number of data points that the system can return.<br><br>We recommend you try:<br>• Using a <i>Time Grouping</i> that returns less data<br>• Using another chart visualization<br>• Switching to Discrete Values",
         drilldown_unavailable: "No data found with drilldown.",
         invalid_data_for_chart: "No valid data for this chart.",
+        invalid_data_log_scale: "The data contains 0 or negative values and cannot be plotted in logarithmic scale.",
         longer_available_panel: "This panel is no longer available.",
         long_text: "long-text",
         max_buckets_limit: "The combination of data used in this chart exceeds the maximum number of aggregation buckets allowed in a single response.<br><br>To fix this issue, try the following:<br>• <i>Filter</i> your data<br>• Apply a <i>Date Grouping</i> that returns less data<br>• Use another chart visualization",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qrvey/utils",
-  "version": "1.11.0-8",
+  "version": "1.11.0",
   "description": "Helper, Utils for all Qrvey Projects",
   "homepage": "https://bitbucket.org/qrvey/qrvey_utils/wiki/Home",
   "main": "dist/index.js",