@qrvey/filters 0.0.45 → 0.1.0

package/dist/helpers/filter-adapt.logic.helpers.js

@@ -7,22 +7,12 @@ import { FILTER_LOGIC_VALIDATOR, } from "../resources/filter-logic.resources";
 import { FILTER_OPERATOR, } from "../resources/filter-operators.resources";
 import { FILTER_LOGIC_VALIDATOR_BY_VALIDATOR, FILTER_VALIDATOR, } from "../resources/filter-validators.resources";
 import { FILTER_TYPE } from "../resources/filters.resources";
-/**
- * Generates a Logic structure from the filter collection
- * @param filters the filter collection
- * @returns the logic structure
- */
 export function filterToLogic(filters) {
     if (isEmpty(filters))
         return [];
     const visual = filterToVisual(filters);
     return visualToLogic(visual);
 }
-/**
- * Generates a Logic structure from the visual filter structure
- * @param visual the visual filter structure
- * @returns the logic structure
- */
 export function visualToLogic(visual) {
     return visual.scopes.reduce((logics, scope) => {
         const logic = buildLogic(scope);
@@ -37,11 +27,6 @@ export function visualToLogic(visual) {
         return logics;
     }, []);
 }
-/**
- * Gets the Logic structure for the given scope
- * @param scope the visual filter scope object
- * @returns a logic structure
- */
 function buildLogic(scope) {
     return {
         filters: [],
@@ -49,13 +34,7 @@ function buildLogic(scope) {
         scopeid: scope.id,
     };
 }
-/**
- * Gets the Logic Filters collection based on filters
- * @param filters the filter collection
- * @param groupColumns a flag to know if the
- * @returns the logic filter collection
- */
-function buildLogicFilters(filters, groupColumns = false) {
+function buildLogicFilters(filters, groupColumns) {
     const expression = numericExpression(filters, groupColumns);
     const orOperators = expression.split("+");
     const getFilter = (fi) => {
@@ -97,11 +76,6 @@ function buildLogicFilters(filters, groupColumns = false) {
         },
     ];
 }
-/**
- *
- * @param group
- * @param getFilter
- */
 function getColumnExpressions(group, getFilter) {
     const columnOrOperators = group.split("/");
     if (columnOrOperators.length > 1) {
@@ -114,23 +88,13 @@ function getColumnExpressions(group, getFilter) {
     }
     return getFilter(group);
 }
-/**
- *
- * @param operator
- * @param priority
- */
-function logicToNumeric(operator, priority = false) {
+function logicToNumeric(operator, priority) {
     if (operator === FILTER_OPERATOR.AND) {
         return "*";
     }
     return priority ? "/" : "+";
 }
-/**
- *
- * @param filters
- * @param groupColumns
- */
-function numericExpression(filters, groupColumns = false) {
+function numericExpression(filters, groupColumns) {
     let expression = "";
     filters.forEach((item, index) => {
         const filter = filters[index + 1] || {};
@@ -139,12 +103,6 @@ function numericExpression(filters, groupColumns = false) {
     });
     return expression.substring(0, expression.length - 1);
 }
-/**
- * Builds filter expression by the filter data.
- * - If the resulting value array is empty the enabled property will be false.
- * @param filter The filter to transform
- * @returns a filter expression
- */
 export function buildLogicExpression(filter) {
     const expression = {
         enabled: filter.enabled,
@@ -158,11 +116,6 @@ export function buildLogicExpression(filter) {
         filter.selectAll || expression.value.length > 0 ? filter.enabled : false;
     return expression;
 }
-/**
- * Gets a group value for the backend logic structure
- * @param filter The filter object
- * @returns the group value
- */
 function getLogicExpressionGroupValue(filter) {
     if (filter.aggregateType == null &&
         isDateColumn({
@@ -176,11 +129,6 @@ function getLogicExpressionGroupValue(filter) {
     }
     return undefined;
 }
-/**
- * Gets a property for the logic expression structure
- * @param filter The filter
- * @returns a property
- */
 function getLogicExpressionProperty(filter) {
     if (isEmpty(filter.aggregateType)) {
         if (isNullValidator(filter.validator) ||
@@ -211,11 +159,6 @@ function getLogicExpressionProperty(filter) {
     }
     return filter.grouping;
 }
-/**
- * Gets the filter logic Validator
- * @param filter the filter object
- * @returns the Filter Logic Validator
- */
 function getLogicExpressionValidator(filter) {
     let logicValidator = FILTER_LOGIC_VALIDATOR_BY_VALIDATOR[filter.validator];
     if (filter.selectAll && filter.validator === FILTER_VALIDATOR.EQUALS)
@@ -224,11 +167,6 @@ function getLogicExpressionValidator(filter) {
         logicValidator = FILTER_LOGIC_VALIDATOR.EQUALS;
     return logicValidator;
 }
-/**
- * Gets the expresion values in the logic format
- * @param filter The filter structure
- * @returns A collection of backend expression value
- */
 export function getFilterLogicValues(filter) {
     const values = filter.values || [];
     switch (filter.validator) {
@@ -269,11 +207,6 @@ export function getFilterLogicValues(filter) {
             return [];
     }
 }
-/**
- * Gets the expression values for Exclusive Ranges
- * @param values the collection of values
- * @returns the logic expression values
- */
 function getExclusiveRange(values) {
     return values.reduce((expressionValues, value) => {
         const expressionValue = getValue(value, {
@@ -285,11 +218,6 @@ function getExclusiveRange(values) {
         return expressionValues;
     }, []);
 }
-/**
- * Gets the expression values for Inclusive Ranges
- * @param values the collection of values
- * @returns the logic expression values
- */
 function getInclusiveRange(values) {
     return values.reduce((expressionValues, value) => {
         const expressionValue = getValue(value, {
@@ -301,11 +229,6 @@ function getInclusiveRange(values) {
         return expressionValues;
     }, []);
 }
-/**
- * Gets the expression values for Before Ranges
- * @param values the collection of values
- * @returns the logic expression values
- */
 function getBeforeValues(values) {
     return values.reduce((expressionValues, value) => {
         const expressionValue = getValue(value, {
@@ -316,11 +239,6 @@ function getBeforeValues(values) {
         return expressionValues;
     }, []);
 }
-/**
- * Gets the expression values for BeforeOn Ranges
- * @param values the collection of values
- * @returns the logic expression values
- */
 function getBeforeOnValues(values) {
     return values.reduce((expressionValues, value) => {
         const expressionValue = getValue(value, {
@@ -331,11 +249,6 @@ function getBeforeOnValues(values) {
         return expressionValues;
     }, []);
 }
-/**
- * Gets the expression values for After Ranges
- * @param values the collection of values
- * @returns the logic expression values
- */
 function getAfterValues(values) {
     return values.reduce((expressionValues, value) => {
         const expressionValue = getValue(value, {
@@ -346,11 +259,6 @@ function getAfterValues(values) {
         return expressionValues;
     }, []);
 }
-/**
- * Gets the expression values for AfterOn Ranges
- * @param values the collection of values
- * @returns the logic expression values
- */
 function getAfterOnValues(values) {
     return values.reduce((expressionValues, value) => {
         const expressionValue = getValue(value, {
@@ -361,21 +269,10 @@ function getAfterOnValues(values) {
         return expressionValues;
     }, []);
 }
-/**
- * Gets the expression values for Nulls
- * @param values the collection of values
- * @param filter the filter structure
- * @returns the logic expression values
- */
 function getNullValues(values, filter) {
     const addValue = values.length > 0 && values.every((value) => value.enabled);
     return addValue ? [filter.validator] : [];
 }
-/**
- * Gets the expression values for Relative Dates
- * @param values the collection of values
- * @returns the logic expression values
- */
 function getInValues(values) {
     return values.reduce((expressionValues, value) => {
         const expressionValue = getValue(value, value);
@@ -384,21 +281,9 @@ function getInValues(values) {
         return expressionValues;
     }, []);
 }
-/**
- * Gets the value on the filter values
- * @param objectValue The filter structure
- * @param value The filter structure
- * @returns the value
- */
 function getValue(objectValue, value) {
     return objectValue.enabled ? value : undefined;
 }
-/**
- * Gets the expression values. Depending on the column type
- * @param values a collection of filter values
- * @param filter The filter structure
- * @returns Expression values
- */
 function getResultValues(values, filter) {
     return values.reduce((expressionValues, value) => {
         let expressionValue = "";
@@ -413,11 +298,6 @@ function getResultValues(values, filter) {
         return expressionValues;
     }, []);
 }
-/**
- * Gets the Ranking values.
- * @param values a collection of filter values in the ranking structure
- * @returns Expression values for ranking
- */
 function getRankingValues(values) {
     const flattenValues = flattenDeep(values);
     return flattenValues.reduce((expressionValues, value) => {

package/dist/helpers/filter-builder.helpers.d.ts

@@ -1,11 +1,4 @@
 import { IFilterFilterGroupingSettings } from "../resources/filter-functions.resources";
 import { IFilterGrouping } from "../resources/filter-grouping.resources";
 import { IFilter } from "../resources/filters.resources";
-/**
- * Gets the filter grouping for a given filter.
- * @param filter The filter to get the grouping for.
- * @param settings Settings for the filter grouping.
- * @returns The filter grouping.
- */
 export declare function getFilterGrouping(filter: Partial<IFilter>, settings?: IFilterFilterGroupingSettings): IFilterGrouping | undefined;
-//# sourceMappingURL=filter-builder.helpers.d.ts.map

package/dist/helpers/filter-builder.helpers.js

@@ -1,11 +1,5 @@
 import { FilterResources } from "../classes/FilterResources";
 import { DEFAULT_FILTER } from "../resources/filters.resources";
-/**
- * Gets the filter grouping for a given filter.
- * @param filter The filter to get the grouping for.
- * @param settings Settings for the filter grouping.
- * @returns The filter grouping.
- */
 export function getFilterGrouping(filter, settings) {
     return ((settings?.strictValidation
         ? FilterResources.getGroupingInfoByColumnType({

package/dist/helpers/filter-settings.helpers.d.ts

@@ -1,42 +1,7 @@
 import { IFilterAddSettings, IFilterBuilderEditSettings, IFilterCreateSettings, IFilterGroupingInfoListByColumnSettings, IFilterParamSettings, IFilterReplaceParamSettings } from "../resources/filter-functions.resources";
-/**
- * Gets a complete settings for the edit filters settings
- * - Fills the missing properties with default ones
- * @param settings the settings
- * @returns the complete settings
- */
 export declare function getEditFiltersSettings(settings?: IFilterBuilderEditSettings): IFilterBuilderEditSettings;
-/**
- * Gets a complete settings for the filter-create settings
- * @param settings the filter-create settings
- * @returns the complete filter-create settings
- */
 export declare function getFilterAddSettings(settings?: IFilterAddSettings): IFilterAddSettings;
-/**
- * Gets a complete settings for the filter-create settings
- * @param settings the filter-create settings
- * @returns the complete filter-create settings
- */
 export declare function getFilterCreateSettings(settings?: IFilterCreateSettings): IFilterCreateSettings;
-/**
- * Gets a complete settings for the info grouping by column settings
- * - Fills the missing properties with default ones
- * @param settings the settings
- * @returns the complete settings
- */
 export declare function getInfoGroupingsByColumnTypeSettings(settings?: IFilterGroupingInfoListByColumnSettings): IFilterGroupingInfoListByColumnSettings;
-/**
- * Gets a complete settings for the param settings
- * - Fills the missing properties with default ones
- * @param settings the settings
- * @returns the complete settings
- */
 export declare function getParamFiltersSettings(settings?: IFilterParamSettings): IFilterParamSettings;
-/**
- * Gets a complete settings for the replaceByParams settings
- * - Fills the missing properties with default ones
- * @param settings the settings
- * @returns the complete settings
- */
 export declare function getReplaceByParamsSettings(settings?: IFilterReplaceParamSettings): IFilterReplaceParamSettings;
-//# sourceMappingURL=filter-settings.helpers.d.ts.map

package/dist/helpers/filter-settings.helpers.js

@@ -1,10 +1,4 @@
 import { DEFAULT_FILTER_ADD_SETTINGS, DEFAULT_FILTER_CREATE_SETTINGS, DEFAULT_FILTERS_EDIT_SETTINGS, DEFAULT_FILTERS_GROUPING_INFO_BY_COLUMN_SETTINGS, DEFAULT_FILTERS_PARAM_SETTINGS, } from "../resources/filter-functions.resources";
-/**
- * Gets a complete settings for the edit filters settings
- * - Fills the missing properties with default ones
- * @param settings the settings
- * @returns the complete settings
- */
 export function getEditFiltersSettings(settings) {
     return {
         automaticId: settings?.automaticId ?? DEFAULT_FILTERS_EDIT_SETTINGS.automaticId,
@@ -12,11 +6,6 @@ export function getEditFiltersSettings(settings) {
             DEFAULT_FILTERS_EDIT_SETTINGS.strictValidation,
     };
 }
-/**
- * Gets a complete settings for the filter-create settings
- * @param settings the filter-create settings
- * @returns the complete filter-create settings
- */
 export function getFilterAddSettings(settings) {
     return {
         automaticId: settings?.automaticId ?? DEFAULT_FILTER_ADD_SETTINGS.automaticId,
@@ -24,11 +13,6 @@ export function getFilterAddSettings(settings) {
             DEFAULT_FILTER_ADD_SETTINGS.automaticOperator,
     };
 }
-/**
- * Gets a complete settings for the filter-create settings
- * @param settings the filter-create settings
- * @returns the complete filter-create settings
- */
 export function getFilterCreateSettings(settings) {
     return {
         automaticId: settings?.automaticId ?? DEFAULT_FILTER_CREATE_SETTINGS.automaticId,
@@ -38,12 +22,6 @@ export function getFilterCreateSettings(settings) {
         ...getInfoGroupingsByColumnTypeSettings(settings),
     };
 }
-/**
- * Gets a complete settings for the info grouping by column settings
- * - Fills the missing properties with default ones
- * @param settings the settings
- * @returns the complete settings
- */
 export function getInfoGroupingsByColumnTypeSettings(settings) {
     return {
         hasDateTime: settings?.hasDateTime ??
@@ -58,12 +36,6 @@ export function getInfoGroupingsByColumnTypeSettings(settings) {
             DEFAULT_FILTERS_GROUPING_INFO_BY_COLUMN_SETTINGS.isExpressionCategorizable,
     };
 }
-/**
- * Gets a complete settings for the param settings
- * - Fills the missing properties with default ones
- * @param settings the settings
- * @returns the complete settings
- */
 export function getParamFiltersSettings(settings) {
     return {
         letPassUndefinedParams: settings?.letPassUndefinedParams ??
@@ -74,12 +46,6 @@ export function getParamFiltersSettings(settings) {
             DEFAULT_FILTERS_PARAM_SETTINGS.removeEmptyArrays,
     };
 }
-/**
- * Gets a complete settings for the replaceByParams settings
- * - Fills the missing properties with default ones
- * @param settings the settings
- * @returns the complete settings
- */
 export function getReplaceByParamsSettings(settings) {
     return {
         ...settings,

package/dist/helpers/filter-validators.helpers.d.ts

@@ -1,8 +1,5 @@
 import { IFilterValidator } from "../resources/filter-validators.resources";
-/**
- * Checks if the given validator is a Null type.
- * @param validator The Filter Validator
- * @returns True: It is a Null Validator
- */
 export declare function isNullValidator(validator: IFilterValidator): boolean;
-//# sourceMappingURL=filter-validators.helpers.d.ts.map
+export declare function isRegularValidator(validator: IFilterValidator): boolean;
+export declare function isRangeValidator(validator: IFilterValidator): boolean;
+export declare function isInValidator(validator: IFilterValidator): boolean;

package/dist/helpers/filter-validators.helpers.js

@@ -1,9 +1,13 @@
-import { FILTER_VALIDATOR, } from "../resources/filter-validators.resources";
-/**
- * Checks if the given validator is a Null type.
- * @param validator The Filter Validator
- * @returns True: It is a Null Validator
- */
+import { FILTER_TYPE, FILTER_TYPE_BY_VALIDATOR, } from "../resources/filters.resources";
 export function isNullValidator(validator) {
-    return [FILTER_VALIDATOR.IS_NOT_NULL, FILTER_VALIDATOR.IS_NULL].includes(validator);
+    return FILTER_TYPE_BY_VALIDATOR[validator] === FILTER_TYPE.NULL;
+}
+export function isRegularValidator(validator) {
+    return FILTER_TYPE_BY_VALIDATOR[validator] === FILTER_TYPE.REGULAR;
+}
+export function isRangeValidator(validator) {
+    return FILTER_TYPE_BY_VALIDATOR[validator] === FILTER_TYPE.RANGE;
+}
+export function isInValidator(validator) {
+    return FILTER_TYPE_BY_VALIDATOR[validator] === FILTER_TYPE.RELATIVE;
 }

package/dist/helpers/filter-verbose.helpers.d.ts

@@ -0,0 +1,6 @@
+import { IDataset } from "@qrvey/utils";
+import { IFilterToken, IFilterTokenSettings } from "../resources/filter-verbose.resources";
+import { IFilter } from "../resources/filters.resources";
+export declare function getVerboseFilter(filters: IFilter[], datasets?: IDataset[], settings?: IFilterTokenSettings): string;
+export declare function getTokensFromFilters(filters: IFilter[], datasets?: IDataset[], settings?: IFilterTokenSettings): IFilterToken[];
+export declare function filtersTokensToString(tokens: IFilterToken[]): string;

package/dist/helpers/filter-verbose.helpers.js

@@ -0,0 +1,206 @@
+import { isEmpty, RELATIVE_CURSOR, RELATIVE_CURSOR_INFO, } from "@qrvey/utils";
+import { filterToVisual } from "./filter-adapt.helpers";
+import { isInValidator, isNullValidator, isRangeValidator, } from "./filter-validators.helpers";
+import { isRankingFilter } from "./isRankingFilter";
+import { FILTER_GROUPING_INFO } from "../resources/filter-grouping.resources";
+import { FILTER_OPERATOR_INFO } from "../resources/filter-operators.resources";
+import { FILTER_SCOPE, FILTER_SCOPE_INFO, } from "../resources/filter-scopes.resources";
+import { FILTER_VALIDATOR_INFO, } from "../resources/filter-validators.resources";
+import { FILTER_TOKEN_TYPE, } from "../resources/filter-verbose.resources";
+export function getVerboseFilter(filters, datasets = [], settings) {
+    const tokens = getTokensFromFilters(filters, datasets, settings);
+    return filtersTokensToString(tokens);
+}
+export function getTokensFromFilters(filters, datasets = [], settings = {}) {
+    const visual = filterToVisual(filters, datasets);
+    if (!visual)
+        return [];
+    const t = buildTranslator(settings.translate);
+    const tokens = [];
+    for (const scope of visual.scopes) {
+        if (scope.datasets.length === 0)
+            continue;
+        if (settings.showScope) {
+            const scopeInfo = FILTER_SCOPE_INFO[scope.scope];
+            tokens.push({
+                token: `${t(`filter.scope_title.${scope.scope.toLowerCase()}`, scopeInfo?.label ?? scope.scope)}:`,
+                type: FILTER_TOKEN_TYPE.SCOPE,
+            });
+        }
+        let hasFiltersWithValues = false;
+        for (const dataset of scope.datasets) {
+            if (dataset.filters.length === 0)
+                continue;
+            if (settings.showDataset) {
+                tokens.push({
+                    token: `${dataset.label}:`,
+                    type: FILTER_TOKEN_TYPE.DATABASE_NAME,
+                });
+            }
+            for (let i = 0; i < dataset.filters.length; i++) {
+                const filter = dataset.filters[i];
+                if (!filter.enabled) {
+                    if (tokens[tokens.length - 1]?.type ===
+                        FILTER_TOKEN_TYPE.LOGICAL_OPERATOR) {
+                        tokens.pop();
+                    }
+                    continue;
+                }
+                hasFiltersWithValues = true;
+                if (settings.showChart && filter.scope === FILTER_SCOPE.CHART) {
+                    const chartLabel = filter.customLabel ?? "";
+                    const existing = tokens.find((tok) => tok.token === `${chartLabel}:` && tok.id === filter.scopeId);
+                    if (!existing) {
+                        if (tokens[tokens.length - 1]?.type ===
+                            FILTER_TOKEN_TYPE.LOGICAL_OPERATOR) {
+                            tokens.pop();
+                        }
+                        tokens.push({
+                            token: `${chartLabel}:`,
+                            type: FILTER_TOKEN_TYPE.CHART_NAME,
+                            id: filter.scopeId,
+                        });
+                    }
+                }
+                let columnLabel = filter.columnLabel || filter.columnId;
+                if (!isEmpty(filter.aggregateType)) {
+                    const aggLabel = t(`common.aggregate_labels.${filter.aggregateType.toLowerCase()}`, String(filter.aggregateType));
+                    columnLabel += ` (${aggLabel})`;
+                }
+                tokens.push({
+                    token: `${columnLabel}:`,
+                    type: FILTER_TOKEN_TYPE.COLUMN_NAME,
+                });
+                const validatorInfo = FILTER_VALIDATOR_INFO[filter.validator];
+                const validatorLabel = t(`filter.validators.${filter.validator.toLowerCase()}_label`, validatorInfo?.label ?? filter.validator);
+                const groupingLabel = !isEmpty(filter.grouping)
+                    ? (FILTER_GROUPING_INFO[filter.grouping]?.label ?? "")
+                    : "";
+                tokens.push({
+                    token: validatorLabel + (groupingLabel ? ` (${groupingLabel})` : ""),
+                    type: FILTER_TOKEN_TYPE.VALIDATOR,
+                });
+                tokens.push({
+                    token: buildValueLabel(filter, settings, t),
+                    type: FILTER_TOKEN_TYPE.VALUE,
+                });
+                if (i < dataset.filters.length - 1) {
+                    const opInfo = FILTER_OPERATOR_INFO[filter.operator];
+                    const opLabel = t(`filter.operators.${filter.operator.toLowerCase()}`, opInfo?.label ?? filter.operator);
+                    tokens.push({
+                        token: opLabel,
+                        type: FILTER_TOKEN_TYPE.LOGICAL_OPERATOR,
+                    });
+                }
+            }
+            if (!hasFiltersWithValues && settings.showDataset) {
+                tokens.pop();
+            }
+        }
+        if (!hasFiltersWithValues && settings.showScope) {
+            tokens.pop();
+        }
+    }
+    return tokens;
+}
+export function filtersTokensToString(tokens) {
+    let str = "";
+    for (const token of tokens) {
+        if ([FILTER_TOKEN_TYPE.SCOPE, FILTER_TOKEN_TYPE.CHART_NAME].includes(token.type)) {
+            str += "\n";
+        }
+        str += `${token.token} `;
+    }
+    return str.trim();
+}
+function buildTranslator(translate) {
+    if (translate) {
+        return (key, fallback) => translate(key) || fallback;
+    }
+    return (_key, fallback) => fallback;
+}
+function buildValueLabel(filter, settings, t) {
+    const values = filter.values ?? [];
+    let labels;
+    if (isNullValidator(filter.validator)) {
+        const validatorInfo = FILTER_VALIDATOR_INFO[filter.validator];
+        labels = [
+            t(`filter.validators.${filter.validator.toLowerCase()}_label`, validatorInfo?.label ?? filter.validator),
+        ];
+    }
+    else if (isRangeValidator(filter.validator)) {
+        labels = getRangeLabels(values, filter.validator, settings, t);
+    }
+    else if (isInValidator(filter.validator)) {
+        labels = getRelativeLabels(values, t);
+    }
+    else if (isRankingFilter(filter)) {
+        labels = getRankingLabels(values);
+    }
+    else {
+        labels = getRegularLabels(values);
+    }
+    const filtered = labels.filter((l) => !isEmpty(l));
+    let result = filtered.join(", ");
+    if (filter.selectAll) {
+        result = isEmpty(result)
+            ? t("filter_panel.card_all_selected", "All selected")
+            : `${t("filter_panel.card_all_except", "All except")} ${result}`;
+    }
+    else if (isEmpty(result)) {
+        result = t("filter_panel.card_none_selected", "None selected");
+    }
+    return result;
+}
+function getRegularLabels(values) {
+    return values
+        .filter((v) => (v.displayed ?? true) && (v.enabled ?? true))
+        .map((v) => v.value ?? "");
+}
+function getRangeLabels(values, validator, settings, t) {
+    const sep = settings.rangeSeparator ?? t("filter.range_separator", "-");
+    return values
+        .filter((v) => (v.displayed ?? true) && (v.enabled ?? true))
+        .map((v) => {
+        switch (validator) {
+            case "AFTER":
+            case "AFTER_ON":
+            case "GREATER_THAN":
+            case "GREATER_THAN_EQUAL":
+                return v.min ?? "";
+            case "BEFORE":
+            case "BEFORE_ON":
+            case "LESS_THAN":
+            case "LESS_THAN_EQUAL":
+                return v.max ?? "";
+            default:
+                return `${v.min ?? ""} ${sep} ${v.max ?? ""}`;
+        }
+    });
+}
+function getRelativeLabels(values, t) {
+    return values
+        .filter((v) => (v.displayed ?? true) && (v.enabled ?? true))
+        .map((v) => {
+        const cursorInfo = RELATIVE_CURSOR_INFO[v.cursor];
+        const cursorLabel = t(cursorInfo.i18nLabelPath, cursorInfo.label);
+        const isThis = v.cursor === RELATIVE_CURSOR.THIS;
+        const number = !isThis && v.number != null && v.number > 1 ? `${v.number} ` : "";
+        const unit = t(`common.units.${v.unit}`, String(v.unit));
+        const pluralUnit = !isThis && v.number != null && v.number > 1 ? `${unit}s` : unit;
+        if (isThis) {
+            return `${cursorLabel} ${pluralUnit}`.trim();
+        }
+        const fromLabel = t("filter.relative_container.from_label", "from");
+        const anchorLabel = typeof v.anchor === "string" && !isEmpty(v.anchor)
+            ? v.anchor
+            : t("filter.relative_container.current_date", "Current Date");
+        return `${cursorLabel} ${number}${pluralUnit} ${fromLabel} ${anchorLabel}`.trim();
+    });
+}
+function getRankingLabels(values) {
+    return values
+        .flat()
+        .filter((v) => (v.displayed ?? true) && (v.enabled ?? true))
+        .map((v) => `${v.value ?? ""} - ${v.position}`);
+}

package/dist/helpers/getAggregateFilters.d.ts

@@ -0,0 +1,3 @@
+import { IFilter } from "../resources/filters.resources";
+export declare function getAggregateFilters(filters?: IFilter[]): IFilter[];
+export declare function excludeAggregateFilters(filters?: IFilter[]): IFilter[];

package/dist/helpers/getAggregateFilters.js

@@ -0,0 +1,7 @@
+import { isEmpty } from "@qrvey/utils";
+export function getAggregateFilters(filters = []) {
+    return filters.filter((filter) => !isEmpty(filter.aggregateType));
+}
+export function excludeAggregateFilters(filters = []) {
+    return filters.filter((filter) => isEmpty(filter.aggregateType));
+}