@qrvey/utils 1.10.1 → 1.11.0-1

package/dist/dates/helpers/isValidDateObject.d.ts

@@ -1,6 +1,6 @@
 /**
  * If the date is a valid Date object, return true, otherwise return false.
  * @param {Date} date - The date object to check.
- * @returns A boolean value.
+ * @returns {boolean} True: The Date object is valid
  */
 export declare function isValidDateObject(date: Date): boolean;

package/dist/dates/helpers/isValidDateObject.js

@@ -1,7 +1,7 @@
 /**
  * If the date is a valid Date object, return true, otherwise return false.
  * @param {Date} date - The date object to check.
- * @returns A boolean value.
+ * @returns {boolean} True: The Date object is valid
  */
 export function isValidDateObject(date) {
     return date instanceof Date && !isNaN(date.getTime());

package/dist/dates/helpers/isValidISOOffset.d.ts

@@ -1,7 +1,8 @@
+import { IDTimezoneOffset } from "../interfaces/IDTimezoneOffset";
 /**
  * Validate if offset uses a valid ISO 8601 offset specification
  * - If the given offset is a numeric, returns an invalid flag.
- * @param {string} offset the timezone offset
+ * @param {IDTimezoneOffset} offset the timezone offset
  * @returns {boolean} true if the given offset is valid
  */
-export declare function isValidISOOffset(offset: number | string): boolean;
+export declare function isValidISOOffset(offset: IDTimezoneOffset): boolean;

package/dist/dates/helpers/isValidISOOffset.js

@@ -1,12 +1,13 @@
+import { isEmpty } from "../../general/mix/isEmpty";
 import { ISO_8601_REGEX } from "../constants/ISO_8601_REGEX";
 /**
  * Validate if offset uses a valid ISO 8601 offset specification
  * - If the given offset is a numeric, returns an invalid flag.
- * @param {string} offset the timezone offset
+ * @param {IDTimezoneOffset} offset the timezone offset
  * @returns {boolean} true if the given offset is valid
  */
 export function isValidISOOffset(offset) {
-    if (typeof offset !== "string")
+    if (isEmpty(offset) || typeof offset !== "string")
         return false;
     const newOffset = (offset || "").trim();
     return ISO_8601_REGEX.test(newOffset);

package/dist/dates/helpers/isValidPotentialDate.d.ts

@@ -1,7 +1,8 @@
+import { IDate } from "../interfaces/IDate";
 /**
  * Checks if the given date is allowed to continue the process for adapting dates
  * - If the string is a token or a combination of tokens is not valid
- * @param {string | Date | number} date String, object or millisencond number of the date
+ * @param {IDate} date String, object or millisencond number of the date
  * @returns true: the date is valid.
  */
-export declare function isValidPotentialDate(date: string | Date | number): boolean;
+export declare function isValidPotentialDate(date: IDate): boolean;

package/dist/dates/helpers/isValidPotentialDate.js

@@ -4,7 +4,7 @@ import { areIncludedDateTokens } from "./areIncludedDateTokens";
 /**
  * Checks if the given date is allowed to continue the process for adapting dates
  * - If the string is a token or a combination of tokens is not valid
- * @param {string | Date | number} date String, object or millisencond number of the date
+ * @param {IDate} date String, object or millisencond number of the date
  * @returns true: the date is valid.
  */
 export function isValidPotentialDate(date) {
@@ -12,12 +12,27 @@ export function isValidPotentialDate(date) {
         !includingDateTokens(date) &&
         (isDateInstance(date) || isStringDate(date) || typeof date === "number"));
 }
+/**
+ * Validates if the given date has tokens
+ * @param {IDate} date String, object or millisencond number of the date
+ * @returns {boolean} true: the date has tokens
+ */
 function includingDateTokens(date) {
     return DATE_FORMATS.some((dateFormat) => areIncludedDateTokens(date, dateFormat));
 }
+/**
+ * Validates if the given date is a date instance
+ * @param {IDate} date String, object or millisencond number of the date
+ * @returns {boolean} true: the date is a date instance
+ */
 function isDateInstance(date) {
     return date instanceof Date && !isNaN(date);
 }
+/**
+ * Validates if the given date is a string date
+ * @param {IDate} date String, object or millisencond number of the date
+ * @returns {boolean} true: the date is a string date
+ */
 function isStringDate(date) {
     return (typeof date === "string" && new Date(date).toString() !== "Invalid Date");
 }

package/dist/dates/helpers/isValidTimezoneOffset.d.ts

@@ -0,0 +1,7 @@
+import { IDTimezoneOffset } from "../interfaces/IDTimezoneOffset";
+/**
+ * Validates if the given param is a valid timezone offset
+ * @param {IDTimezoneOffset} offset the timezone offset
+ * @returns {boolean} true: is valid timezone offset.
+ */
+export declare function isValidTimezoneOffset(offset: IDTimezoneOffset): boolean;

package/dist/dates/helpers/isValidTimezoneOffset.js

@@ -0,0 +1,27 @@
+import { isNaNV2 } from "../../general/mix/isNaNV2";
+import { ISOToNumericOffset } from "../adapters/ISOToNumericOffset";
+import { isValidISOOffset } from "./isValidISOOffset";
+/**
+ * Validates if the given param is a valid timezone offset
+ * @param {IDTimezoneOffset} offset the timezone offset
+ * @returns {boolean} true: is valid timezone offset.
+ */
+export function isValidTimezoneOffset(offset) {
+    if (typeof offset === "string") {
+        return (offset === "browser" ||
+            (isValidISOOffset(offset) && isValidOffsetRange(offset)));
+    }
+    if (typeof offset === "number") {
+        return !isNaNV2(offset) && isValidOffsetRange(offset);
+    }
+    return false;
+}
+/**
+ * Validates if the given offset is in the timezone range
+ * @param {IDTimezoneOffset} offset the timezone offset
+ * @returns {boolean} true: the offset is in the timezone range
+ */
+function isValidOffsetRange(offset) {
+    const numericOffset = ISOToNumericOffset(offset);
+    return -720 <= numericOffset && numericOffset <= 840;
+}

package/dist/dates/helpers/validateDate.d.ts

@@ -4,8 +4,8 @@ import { IDateFormat } from "../interfaces/IDateFormat";
  * - 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
+ * @param {string} date String of date
+ * @param {IDateFormat} format String of the format to validate
+ * @returns {boolean} True if it is valid or not. Undefined if date is undefined
  */
 export declare function validateDate(date: string, format?: IDateFormat): boolean;

package/dist/dates/helpers/validateDate.js

@@ -8,9 +8,9 @@ import { getSeparatorByDateFormat } from "./getSeparatorByDateFormat";
  * - 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
+ * @param {string} date String of date
+ * @param {IDateFormat} format String of the format to validate
+ * @returns {boolean} True if it is valid or not. Undefined if date is undefined
  */
 export function validateDate(date, format = DATE_FORMAT.DAY) {
     if (isEmpty(date) || typeof date !== "string")

package/dist/dates/interfaces/IDate.d.ts

@@ -0,0 +1 @@
+export type IDate = Date | string | number;

package/dist/dates/interfaces/IDate.js

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

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

@@ -0,0 +1,9 @@
+import { IFFGetVerboseFilters } from "../../interfaces/functions/IFFGetVerboseFilters";
+import { IFUDataset } from "../../interfaces/ui/IFUDataset";
+/**
+ * Gets an string that describes the filter datasets content
+ * @param {IFUDataset[]} filters The filter datasets to verbose
+ * @param {IFFGetVerboseFilters} settings the settings to the function
+ * @returns the description of the datasets array
+ */
+export declare function getVerboseFilterDatasets(datasets: IFUDataset[], settings?: IFFGetVerboseFilters): string;

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

@@ -0,0 +1,90 @@
+import { isEmpty } from "../../../general/mix/isEmpty";
+import { isObject } from "../../../general/object/isObject";
+import { I18N_FILTER_OPERATOR } from "../../../globalization/labels/filters/I18N_FILTER_OPERATOR";
+import { FILTER_OPERATOR } from "../../constants/common/FILTER_OPERATOR";
+import { getVerboseFilterFilters } from "./getVerboseFilterFilters";
+import { getVerboseFiltersSettings } from "./getVerboseFilters";
+/**
+ * Gets an string that describes the filter datasets content
+ * @param {IFUDataset[]} filters The filter datasets to verbose
+ * @param {IFFGetVerboseFilters} settings the settings to the function
+ * @returns the description of the datasets array
+ */
+export function getVerboseFilterDatasets(datasets, settings) {
+    if (isEmpty(datasets) || !Array.isArray(datasets))
+        return "";
+    const defaultSettings = getVerboseFiltersSettings(settings);
+    const filteredDatasets = getDatasets(datasets, defaultSettings);
+    return filteredDatasets.reduce((verbose, dataset, currentIndex, array) => {
+        let newVerbose = "";
+        const title = getTitle(dataset, defaultSettings);
+        const titleSeparator = getTitleSeparator(defaultSettings);
+        const filterVerbose = getVerboseFilterFilters(dataset.filters, defaultSettings);
+        const newSeparator = getSeparator(defaultSettings, currentIndex >= array.length - 1);
+        newVerbose += `${isEmpty(title) ? "" : `${title}${titleSeparator}`}${filterVerbose}${newSeparator}`;
+        return `${verbose}${newVerbose}`;
+    }, "");
+}
+/**
+ * Gets the datasets by some conditions
+ * @param {IFUDataset[]} filters The filtered datasets to verbose
+ * @param {IFFGetVerboseFilters} settings the settings to the function
+ * @returns {IFUDataset[]} the collection of the datasets
+ */
+function getDatasets(datasets, settings) {
+    return datasets.filter((dataset) => isObject(dataset) &&
+        (settings.datasetDisplayDisplayed || dataset.displayed) &&
+        (settings.datasetEnableDisplayed || dataset.enabled));
+}
+/**
+ * Gets the title of the filter dataset
+ * @param {IFUDataset} dataset the filter dataset object
+ * @param {IFFGetVerboseFilters} settings the settings to the function
+ * @returns {string} the title of the filter dataset
+ */
+function getTitle(dataset, settings) {
+    return settings.datasetTitleDisplayed ? dataset.label || "" : "";
+}
+/**
+ * Gets the separators for the title. It would be
+ * - New Line
+ * - An string from argument
+ * @param {IFFGetVerboseFilters} settings the settings of the module
+ * @returns {string} the string of the separator
+ */
+function getTitleSeparator(settings) {
+    let newLine = "";
+    if (settings.datasetTitleNewLine) {
+        newLine = "\n";
+    }
+    else if (!isEmpty(settings.datasetTitleSeparator)) {
+        newLine = settings.datasetTitleSeparator;
+    }
+    return newLine;
+}
+/**
+ * Gets the separators of each filter. It would be
+ * - New Line
+ * - The operator
+ * - An string from argument
+ * @param {IFFGetVerboseFilters} settings the settings of the module
+ * @returns {string} the string of the separator
+ */
+function getSeparator(settings, lastValue = false) {
+    let newLine = "";
+    if (lastValue)
+        return newLine;
+    if (settings.datasetNewLine) {
+        newLine = "\n";
+    }
+    else if (settings.datasetOperatorDisplayed) {
+        newLine = isEmpty(settings.translate)
+            ? I18N_FILTER_OPERATOR.and
+            : settings.translate(`filter.operators.${FILTER_OPERATOR.AND.toLowerCase()}`);
+        newLine = ` ${newLine} `;
+    }
+    else {
+        newLine = settings.datasetSeparator;
+    }
+    return newLine;
+}

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

@@ -0,0 +1,9 @@
+import { IFFGetVerboseFilters } from "../../interfaces/functions/IFFGetVerboseFilters";
+import { IFUFilter } from "../../interfaces/ui/IFUFilter";
+/**
+ * Gets an string that describes the filter filters content
+ * @param {IFUFilter[]} filters The filter filters to verbose
+ * @param {IFFGetVerboseFilters} settings the settings to the function
+ * @returns the description of the filters array
+ */
+export declare function getVerboseFilterFilters(filters: IFUFilter[], settings?: IFFGetVerboseFilters): string;

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

@@ -0,0 +1,93 @@
+import { isEmpty } from "../../../general/mix/isEmpty";
+import { isObject } from "../../../general/object/isObject";
+import { I18N_FILTER_OPERATOR } from "../../../globalization/labels/filters/I18N_FILTER_OPERATOR";
+import { getVerboseFilterValues } from "./getVerboseFilterValues";
+import { getVerboseFiltersSettings } from "./getVerboseFilters";
+/**
+ * Gets an string that describes the filter filters content
+ * @param {IFUFilter[]} filters The filter filters to verbose
+ * @param {IFFGetVerboseFilters} settings the settings to the function
+ * @returns the description of the filters array
+ */
+export function getVerboseFilterFilters(filters, settings) {
+    if (isEmpty(filters) || !Array.isArray(filters))
+        return "";
+    const defaultSettings = getVerboseFiltersSettings(settings);
+    const filteredFilters = getFilters(filters, defaultSettings);
+    return filteredFilters.reduce((verbose, filter, currentIndex, array) => {
+        let newVerbose = "";
+        const title = getTitle(filter, defaultSettings);
+        const titleSeparator = getTitleSeparator(defaultSettings);
+        const valuesVerbose = getVerboseFilterValues(filter, defaultSettings);
+        const newSeparator = getSeparator(filter, defaultSettings, currentIndex >= array.length - 1);
+        newVerbose += `${isEmpty(title) ? "" : `${title}${titleSeparator}`}${valuesVerbose}${newSeparator}`;
+        return `${verbose}${newVerbose}`;
+    }, "");
+}
+/**
+ * Gets the filters by some conditions
+ * @param {IFUFilter[]} filters The filtered filters to verbose
+ * @param {IFFGetVerboseFilters} settings the settings to the function
+ * @returns {IFUFilter[]} the collection of the filters
+ */
+function getFilters(filters, settings) {
+    return filters.filter((filter) => isObject(filter) &&
+        (settings.filterDisplayDisplayed || filter.displayed) &&
+        (settings.filterEnableDisplayed || filter.enabled));
+}
+/**
+ * Gets the title of the filter
+ * @param {IFUFilter} filter the filter object
+ * @param {IFFGetVerboseFilters} settings the settings to the function
+ * @returns {string} the title of the filter
+ */
+function getTitle(filter, settings) {
+    return settings.filterTitleDisplayed
+        ? filter.extras.filterLabel || filter.column.label || ""
+        : "";
+}
+/**
+ * Gets the separators of each filter. It would be
+ * - New Line
+ * - The operator
+ * - An string from argument
+ * @param {number} currentIndex the iteration index of the value
+ * @param {IFUFilter} filter the filter object
+ * @param {IFFGetVerboseFilters} settings the settings of the module
+ * @returns {string} the string of the separator
+ */
+function getSeparator(filter, settings, lastValue = false) {
+    let newLine = "";
+    if (lastValue)
+        return newLine;
+    if (settings.filterNewLine) {
+        newLine = "\n";
+    }
+    else if (settings.filterOperatorDisplayed) {
+        newLine = isEmpty(settings.translate)
+            ? I18N_FILTER_OPERATOR[filter.operator.toLowerCase()]
+            : settings.translate(`filter.operators.${filter.operator.toLowerCase()}`);
+        newLine = ` ${newLine} `;
+    }
+    else {
+        newLine = settings.filterSeparator;
+    }
+    return newLine;
+}
+/**
+ * Gets the separators for the title. It would be
+ * - New Line
+ * - An string from argument
+ * @param {IFFGetVerboseFilters} settings the settings of the module
+ * @returns {string} the string of the separator
+ */
+function getTitleSeparator(settings) {
+    let newLine = "";
+    if (settings.filterTitleNewLine) {
+        newLine = "\n";
+    }
+    else if (!isEmpty(settings.filterTitleSeparator)) {
+        newLine = settings.filterTitleSeparator;
+    }
+    return newLine;
+}

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

@@ -0,0 +1,9 @@
+import { IFFGetVerboseFilters } from "../../interfaces/functions/IFFGetVerboseFilters";
+import { IFUScope } from "../../interfaces/ui/IFUScope";
+/**
+ * Gets an string that describes the filter scopes content
+ * @param {IFUScope[]} filters The filters scopes to verbose
+ * @param {IFFGetVerboseFilters} settings the settings to the function
+ * @returns A string
+ */
+export declare function getVerboseFilterScopes(scopes: IFUScope[], settings?: IFFGetVerboseFilters): string;

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

@@ -0,0 +1,96 @@
+import { isEmpty } from "../../../general/mix/isEmpty";
+import { isObject } from "../../../general/object/isObject";
+import { I18N_FILTER_OPERATOR } from "../../../globalization/labels/filters/I18N_FILTER_OPERATOR";
+import { I18N_FILTER_SCOPE } from "../../../globalization/labels/filters/I18N_FILTER_SCOPE";
+import { FILTER_OPERATOR } from "../../constants/common/FILTER_OPERATOR";
+import { getVerboseFilterDatasets } from "./getVerboseFilterDatasets";
+import { getVerboseFiltersSettings } from "./getVerboseFilters";
+/**
+ * Gets an string that describes the filter scopes content
+ * @param {IFUScope[]} filters The filters scopes to verbose
+ * @param {IFFGetVerboseFilters} settings the settings to the function
+ * @returns A string
+ */
+export function getVerboseFilterScopes(scopes, settings) {
+    if (isEmpty(scopes) || !Array.isArray(scopes))
+        return "";
+    const defaultSettings = getVerboseFiltersSettings(settings);
+    const filteredScopes = getScopes(scopes, defaultSettings);
+    return filteredScopes.reduce((verbose, scope, currentIndex, array) => {
+        let newVerbose = "";
+        const title = getTitle(scope, defaultSettings);
+        const titleSeparator = getTitleSeparator(defaultSettings);
+        const datasetsVerbose = getVerboseFilterDatasets(scope.datasets, defaultSettings);
+        const newSeparator = getSeparator(defaultSettings, currentIndex >= array.length - 1);
+        newVerbose += `${isEmpty(title) ? "" : `${title}${titleSeparator}`}${datasetsVerbose}${newSeparator}`;
+        return `${verbose}${newVerbose}`;
+    }, "");
+}
+/**
+ * Gets the scopes by some conditions
+ * @param {IFUScope[]} filters The filtered scopes to verbose
+ * @param {IFFGetVerboseFilters} settings the settings to the function
+ * @returns {IFUScope[]} the collection of the scopes
+ */
+function getScopes(scopes, settings) {
+    return scopes.filter((scope) => isObject(scope) &&
+        (settings.scopeDisplayDisplayed || scope.displayed) &&
+        (settings.scopeEnableDisplayed || scope.enabled));
+}
+/**
+ * Gets the title of the filter scope
+ * @param {IFUScope} scope the filter scope info
+ * @param {IFFGetVerboseFilters} settings the settings of the function
+ * @returns {string} the title of the filter scope
+ */
+function getTitle(scope, settings) {
+    if (settings.scopeTitleDisplayed) {
+        return isEmpty(settings.translate)
+            ? scope.label || I18N_FILTER_SCOPE[scope.scope.toLowerCase()] || ""
+            : settings.translate(`filter.scope_title.${scope.scope.toLowerCase()}`);
+    }
+    return "";
+}
+/**
+ * Gets the separators for the title. It would be
+ * - New Line
+ * - An string from argument
+ * @param {IFFGetVerboseFilters} settings the settings of the module
+ * @returns {string} the string of the title separator
+ */
+function getTitleSeparator(settings) {
+    let newLine = "";
+    if (settings.scopeTitleNewLine) {
+        newLine = "\n";
+    }
+    else if (!isEmpty(settings.scopeTitleSeparator)) {
+        newLine = settings.scopeTitleSeparator;
+    }
+    return newLine;
+}
+/**
+ * Gets the separators of each filter. It would be
+ * - New Line
+ * - The operator
+ * - An string from argument
+ * @param {IFFGetVerboseFilters} settings the settings of the module
+ * @returns {string} the string of the separator
+ */
+function getSeparator(settings, lastValue = false) {
+    let newLine = "";
+    if (lastValue)
+        return newLine;
+    if (settings.scopeNewLine) {
+        newLine = "\n";
+    }
+    else if (settings.scopeOperatorDisplayed) {
+        newLine = isEmpty(settings.translate)
+            ? I18N_FILTER_OPERATOR.and
+            : settings.translate(`filter.operators.${FILTER_OPERATOR.AND.toLowerCase()}`);
+        newLine = ` ${newLine} `;
+    }
+    else {
+        newLine = settings.scopeSeparator;
+    }
+    return newLine;
+}

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

@@ -0,0 +1,9 @@
+import { IFFGetVerboseFilters } from "../../interfaces/functions/IFFGetVerboseFilters";
+import { IFUFilter } from "../../interfaces/ui/IFUFilter";
+/**
+ * Gets an string that describes the filter values content
+ * @param {IFValue[]} filters The filter values to verbose
+ * @param {IFFGetVerboseFilters} settings the settings to the function
+ * @returns the description of the filter values
+ */
+export declare function getVerboseFilterValues(filter: IFUFilter, settings?: IFFGetVerboseFilters): string;

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

@@ -0,0 +1,96 @@
+import { COLUMN } from "../../../columns/constants/COLUMN";
+import { isEmpty } from "../../../general/mix/isEmpty";
+import { isObject } from "../../../general/object/isObject";
+import { I18N_FILTER_OPERATOR } from "../../../globalization/labels/filters/I18N_FILTER_OPERATOR";
+import { I18N_FILTER_PANEL } from "../../../globalization/labels/filters/I18N_FILTER_PANEL";
+import { FILTER_OPERATOR } from "../../constants/common/FILTER_OPERATOR";
+import { getUIValues } from "../ui/getUIValues";
+import { getVerboseFiltersSettings } from "./getVerboseFilters";
+/**
+ * Gets an string that describes the filter values content
+ * @param {IFValue[]} filters The filter values to verbose
+ * @param {IFFGetVerboseFilters} settings the settings to the function
+ * @returns the description of the filter values
+ */
+export function getVerboseFilterValues(filter, settings) {
+    if (isEmpty(filter) ||
+        !isObject(filter) ||
+        (!filter.selectAll && isEmpty(filter.values)))
+        return "";
+    const defaultSettings = getVerboseFiltersSettings(settings);
+    const values = getValues(filter, defaultSettings);
+    const newSeparator = getSeparator(defaultSettings);
+    const stringValues = values.join(newSeparator);
+    if (filter.selectAll) {
+        if (isEmpty(values)) {
+            return isEmpty(defaultSettings.translate)
+                ? I18N_FILTER_PANEL.card_all_selected
+                : defaultSettings.translate("filter_panel.card_all_selected");
+        }
+        return `${isEmpty(defaultSettings.translate)
+            ? I18N_FILTER_PANEL.card_all_except
+            : defaultSettings.translate("filter_panel.card_all_except")} ${stringValues}`;
+    }
+    else if (isEmpty(values)) {
+        return isEmpty(defaultSettings.translate)
+            ? I18N_FILTER_PANEL.card_none_selected
+            : defaultSettings.translate("filter_panel.card_none_selected");
+    }
+    return stringValues;
+}
+/**
+ * Gets the value collection of the filter by some conditions
+ * @param {IFValue} filter The filter to get the values
+ * @param {IFFGetVerboseFilters} settings the settings to the function
+ * @returns {string[]} the collection of the filter values
+ */
+function getValues(filter, settings) {
+    const uiValues = getUIValues(filter, Object.assign(Object.assign({}, settings), { addEnableds: true }));
+    return uiValues
+        .map((uiValue) => {
+        if ((settings.valueDisplayDisplayed || uiValue.displayed) &&
+            (settings.valueEnableDisplayed || uiValue.enabled))
+            return getValue(filter, uiValue);
+    })
+        .filter(Boolean);
+}
+/**
+ * Gets the separators of each values. It would be
+ * - New Line
+ * - The operator
+ * - An string from argument
+ * @param {number} currentIndex the iteration index of the value
+ * @param {IFUValue[]} values the collection of values
+ * @param {IFFGetVerboseFilters} settings the settings of the module
+ * @returns {string} the string of the separator
+ */
+function getSeparator(settings) {
+    let newLine = "";
+    if (settings.valueNewLine) {
+        newLine = "\n";
+    }
+    else if (settings.valueOperatorDisplayed) {
+        newLine = isEmpty(settings.translate)
+            ? I18N_FILTER_OPERATOR.or
+            : settings.translate(`filter.operators.${FILTER_OPERATOR.OR.toLowerCase()}`);
+        newLine = ` ${newLine} `;
+    }
+    else {
+        newLine = settings.valueSeparator;
+    }
+    return newLine;
+}
+/**
+ * Gets the value according to the filter info
+ * - When the filter column type is image the URL should be returned in case value is undefined.
+ * @param {IFUFilter} filter the filter object
+ * @param {IFUValue} value the value item
+ * @returns {string} the resulting value
+ */
+function getValue(filter, value) {
+    let newValue = value.value || "";
+    if (filter.column.type === COLUMN.IMAGE) {
+        newValue = value.value || value.imageUrl || "";
+    }
+    return newValue;
+}

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

@@ -0,0 +1,10 @@
+import { IFFGetVerboseFilters } from "../../interfaces/functions/IFFGetVerboseFilters";
+import { IFUData } from "../../interfaces/ui/IFUData";
+/**
+ * Gets an string that describes the filter data content
+ * @param {IFUData} filters The filters object to verbose
+ * @param {IFFGetVerboseFilters} settings the settings for the function
+ * @returns A string
+ */
+export declare function getVerboseFilters(filterData: IFUData, settings?: IFFGetVerboseFilters): string;
+export declare function getVerboseFiltersSettings(settings?: IFFGetVerboseFilters): IFFGetVerboseFilters;