@qrvey/utils 1.15.0-1 → 1.15.0-10

package/dist/cjs/filters/adapters/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./transformFilters";
 export * from "./modelAnswerToFilterValue";
 export * from "./adaptDateGroupingProperty";
 export * from "./adaptFilterData";

package/dist/cjs/filters/adapters/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./transformFilters"), exports);
 __exportStar(require("./modelAnswerToFilterValue"), exports);
 __exportStar(require("./adaptDateGroupingProperty"), exports);
 __exportStar(require("./adaptFilterData"), exports);

package/dist/cjs/filters/adapters/transformFilters.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Transform the old filters structure into the new one
+ *
+ * @deprecated Since 2020, Added back in 2024 but not support provided (unmantained)
+ * @param {Object} oldFiltersObj an object with the old filters structure
+ * @param {String} section could be 'ANALYZE', 'PB', 'UM' or any other value. Deafult is 'ANYWHERE'
+ *
+ * @returns {Object} an object with the new filters structure
+ *
+ * @example
+ *
+ * const oldPreferenceFilters = {
+ *   "WWXHAULtR-_-xYOQAdpqT__ENABLED": true,
+ *   "WWXHAULtR-_-xYOQAdpqT__ALL--ENABLED": true,
+ *   "WWXHAULtR-_-xYOQAdpqT__COLLAPSED": false,
+ *   "WWXHAULtR-_-xYOQAdpqT__LABEL": "GLOBAL",
+ *   "WWXHAULtR-_-xYOQAdpqT-_-AK4M8UV2": {
+ *     "formulaId": null,
+ *     "panelId": null,
+ *     "values": [
+ *       {
+ *         "EQUALS": [
+ *           {
+ *             "id": "AK4M8UV2a0",
+ *             "value": "A",
+ *             "enabled": true,
+ *             "imageUrl": null
+ *           },
+ *           {
+ *             "id": "AK4M8UV2a1",
+ *             "value": "B",
+ *             "enabled": true,
+ *             "imageUrl": null
+ *           }
+ *         ]
+ *       }
+ *     ],
+ *     "bucketId": null,
+ *     "text": "MC",
+ *     "title": "MC",
+ *     "type": "SINGLE_CHOICE",
+ *     "qid": "AK4M8UV2",
+ *     "dataset": {
+ *       "sourceid": "xYOQAdpqT",
+ *       "name": "Form All Questions",
+ *       "qrveyid": "xYOQAdpqT",
+ *       "text": "Form All Questions",
+ *       "linkid": 0
+ *     },
+ *     "enabled": true,
+ *     "linked": null
+ *   }
+ * };
+ *
+ * const filterData = transformFilters(oldPreferenceFilters, 'ANALYZE');
+ */
+export declare function transformFilters(oldFiltersObj?: {}, section?: string): {
+    enabled: boolean;
+    logic: any[];
+    section: string;
+};

package/dist/cjs/filters/adapters/transformFilters.js

@@ -0,0 +1,432 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformFilters = void 0;
+/* eslint-disable no-nested-ternary */
+const isTokenLabel_1 = require("../../tokens/isTokenLabel");
+const FILTER_VALIDATOR_1 = require("../constants/common/FILTER_VALIDATOR");
+const FILTER_SCOPE_1 = require("../constants/common/FILTER_SCOPE");
+const FILTER_SECTION_1 = require("../constants/common/FILTER_SECTION");
+const FILTER_BACKEND_VALIDATOR_1 = require("../constants/backend/FILTER_BACKEND_VALIDATOR");
+const get_1 = require("../../general/object/get");
+const capitalize_1 = require("../../general/string/capitalize");
+/**
+ * Transform the old filters structure into the new one
+ *
+ * @deprecated Since 2020, Added back in 2024 but not support provided (unmantained)
+ * @param {Object} oldFiltersObj an object with the old filters structure
+ * @param {String} section could be 'ANALYZE', 'PB', 'UM' or any other value. Deafult is 'ANYWHERE'
+ *
+ * @returns {Object} an object with the new filters structure
+ *
+ * @example
+ *
+ * const oldPreferenceFilters = {
+ *   "WWXHAULtR-_-xYOQAdpqT__ENABLED": true,
+ *   "WWXHAULtR-_-xYOQAdpqT__ALL--ENABLED": true,
+ *   "WWXHAULtR-_-xYOQAdpqT__COLLAPSED": false,
+ *   "WWXHAULtR-_-xYOQAdpqT__LABEL": "GLOBAL",
+ *   "WWXHAULtR-_-xYOQAdpqT-_-AK4M8UV2": {
+ *     "formulaId": null,
+ *     "panelId": null,
+ *     "values": [
+ *       {
+ *         "EQUALS": [
+ *           {
+ *             "id": "AK4M8UV2a0",
+ *             "value": "A",
+ *             "enabled": true,
+ *             "imageUrl": null
+ *           },
+ *           {
+ *             "id": "AK4M8UV2a1",
+ *             "value": "B",
+ *             "enabled": true,
+ *             "imageUrl": null
+ *           }
+ *         ]
+ *       }
+ *     ],
+ *     "bucketId": null,
+ *     "text": "MC",
+ *     "title": "MC",
+ *     "type": "SINGLE_CHOICE",
+ *     "qid": "AK4M8UV2",
+ *     "dataset": {
+ *       "sourceid": "xYOQAdpqT",
+ *       "name": "Form All Questions",
+ *       "qrveyid": "xYOQAdpqT",
+ *       "text": "Form All Questions",
+ *       "linkid": 0
+ *     },
+ *     "enabled": true,
+ *     "linked": null
+ *   }
+ * };
+ *
+ * const filterData = transformFilters(oldPreferenceFilters, 'ANALYZE');
+ */
+function transformFilters(oldFiltersObj = {}, section = FILTER_SECTION_1.FILTER_SECTION.ANYWHERE) {
+    const filterData = { enabled: true, logic: [], section };
+    const tempScopes = {};
+    Object.keys(oldFiltersObj).forEach((key) => {
+        if (key.endsWith("__ALL--ENABLED"))
+            filterData.enabled = oldFiltersObj[key];
+        if (!key.endsWith("ENABLED") &&
+            !key.endsWith("LABEL") &&
+            !key.endsWith("COLLAPSED")) {
+            const filterSeparator = "-_-";
+            const keyArray = key.split(filterSeparator);
+            const tempArray = [...keyArray];
+            tempArray.pop();
+            let enabledKey = "__ENABLED";
+            let collapsedKey = "__COLLAPSED";
+            let labelKey = "__LABEL";
+            if (keyArray.length === 5) {
+                tempArray.pop();
+                enabledKey = "__PANELS--ENABLED";
+                collapsedKey = "__PANELS--COLLAPSED";
+                labelKey = "__PANELS--LABEL";
+            }
+            const keyBase = tempArray.join(filterSeparator);
+            const scopeLabel = getScopeLabel(oldFiltersObj[keyBase + labelKey]);
+            const scopeId = tempArray[tempArray.length - 1] !== "VIEW"
+                ? tempArray[tempArray.length - 1]
+                : undefined;
+            const scopeKey = `${scopeLabel}|${scopeId}`;
+            if (!tempScopes[scopeKey]) {
+                tempScopes[scopeKey] = {
+                    enabled: oldFiltersObj[keyBase + enabledKey],
+                    scope: scopeLabel,
+                    filters: [],
+                    uiExtras: {
+                        scopeid: scopeId,
+                        collapsed: oldFiltersObj[keyBase + collapsedKey],
+                        section,
+                    },
+                };
+            }
+            const filtersObj = validateComplexTypes(oldFiltersObj[key], Object.keys(oldFiltersObj[key].values[0]));
+            const validations = Object.keys(filtersObj.values[0]);
+            tempScopes[scopeKey].filters.push({
+                operator: "AND",
+                expressions: [
+                    {
+                        operator: "OR",
+                        uiExtras: {
+                            expressionid: `${filtersObj.qid}|${scopeId}|${filtersObj.panelid || ""}`,
+                        },
+                        expressions: getExpressions(filtersObj, validations, scopeLabel, scopeId, section),
+                    },
+                ],
+            });
+        }
+    });
+    filterData.logic = Object.values(tempScopes);
+    return filterData;
+}
+exports.transformFilters = transformFilters;
+function validateComplexTypes(oldFiltersItem, validations) {
+    if (![
+        "IMAGEUPLOAD",
+        "TEXTFIELD",
+        "LONGTEXT",
+        "NAME",
+        "ADDRESS",
+        "USADDRESS",
+    ].includes(oldFiltersItem.type))
+        return oldFiltersItem;
+    const complexFiltersItem = Object.assign(Object.assign({}, oldFiltersItem), { values: [{}] });
+    validations.forEach((valKey) => {
+        oldFiltersItem.values[0][valKey].forEach((value) => {
+            const newKey = `${valKey}|${(value.targetFilter || value.property || "")
+                .toLowerCase()
+                .replace("_text", "")
+                .replace("_type", "type")}`;
+            if (!complexFiltersItem.values[0][newKey]) {
+                complexFiltersItem.values[0][newKey] = [value];
+            }
+            else {
+                complexFiltersItem.values[0][newKey].push(value);
+            }
+        });
+    });
+    return complexFiltersItem;
+}
+function getScopeLabel(oldScopeLabel) {
+    switch (oldScopeLabel) {
+        case "GLOBAL":
+            return FILTER_SCOPE_1.FILTER_SCOPE.GLOBAL;
+        case "PAGE":
+            return FILTER_SCOPE_1.FILTER_SCOPE.PAGE;
+        case "TAB":
+            return FILTER_SCOPE_1.FILTER_SCOPE.TAB;
+        case "PANEL":
+            return FILTER_SCOPE_1.FILTER_SCOPE.CHART;
+        default:
+            return oldScopeLabel;
+    }
+}
+function getValidationType(oldValidation, columnType, formulaType) {
+    switch (oldValidation) {
+        case "EQUALS":
+        case "EQUAL":
+            return FILTER_VALIDATOR_1.FILTER_VALIDATOR.EQUALS;
+        case "NOT_EQUALS":
+        case "NOT_EQUAL":
+            return FILTER_VALIDATOR_1.FILTER_VALIDATOR.NOT_EQUAL;
+        case "CONTAINS":
+        case "CONTAIN":
+            return FILTER_VALIDATOR_1.FILTER_VALIDATOR.CONTAINS;
+        case "NOT_CONTAINS":
+        case "NOT_CONTAIN":
+            return FILTER_VALIDATOR_1.FILTER_VALIDATOR.NOT_CONTAIN;
+        case "LESS_THAN":
+        case "LESS_THAN_OR_EQUAL":
+            return FILTER_VALIDATOR_1.FILTER_VALIDATOR.LESS_THAN_EQUAL;
+        case "GREATER_THAN":
+        case "GREATER_THAN_OR_EQUAL":
+            return FILTER_VALIDATOR_1.FILTER_VALIDATOR.GREATER_THAN_EQUAL;
+        case "BETWEEN":
+        case "YEAR":
+        case "MONTH_YEAR":
+        case "QUARTER":
+        case "WEEK":
+        case "SECOND":
+        case "MINUTE":
+        case "HOUR":
+        case "DAY":
+            return ![columnType, formulaType].includes("DATE")
+                ? FILTER_VALIDATOR_1.FILTER_VALIDATOR.BETWEEN_INCLUSIVE
+                : FILTER_BACKEND_VALIDATOR_1.FILTER_BACKEND_VALIDATOR.RANGE;
+        default:
+            return oldValidation;
+    }
+}
+function getValidator(oldValidation) {
+    switch (oldValidation) {
+        case "EQUALS":
+        case "EQUAL":
+        case "YEAR":
+        case "MONTH_YEAR":
+        case "QUARTER":
+        case "WEEK":
+        case "SECOND":
+        case "MINUTE":
+        case "HOUR":
+        case "DAY":
+            return FILTER_VALIDATOR_1.FILTER_VALIDATOR.EQUALS;
+        case "NOT_EQUALS":
+        case "NOT_EQUAL":
+            return FILTER_VALIDATOR_1.FILTER_VALIDATOR.NOT_EQUAL;
+        case "CONTAINS":
+        case "CONTAIN":
+            return FILTER_VALIDATOR_1.FILTER_VALIDATOR.CONTAINS;
+        case "NOT_CONTAINS":
+        case "NOT_CONTAIN":
+            return FILTER_VALIDATOR_1.FILTER_VALIDATOR.NOT_CONTAIN;
+        case "BETWEEN":
+            return FILTER_VALIDATOR_1.FILTER_VALIDATOR.BETWEEN_INCLUSIVE;
+        case "LESS_THAN":
+        case "LESS_THAN_OR_EQUAL":
+            return FILTER_VALIDATOR_1.FILTER_VALIDATOR.LESS_THAN_EQUAL;
+        case "GREATER_THAN":
+        case "GREATER_THAN_OR_EQUAL":
+            return FILTER_VALIDATOR_1.FILTER_VALIDATOR.GREATER_THAN_EQUAL;
+        case "IS_EMPTY":
+            return FILTER_VALIDATOR_1.FILTER_VALIDATOR.IS_NULL;
+        case "IS_NOT_EMPTY":
+            return FILTER_VALIDATOR_1.FILTER_VALIDATOR.IS_NOT_NULL;
+        default:
+            return oldValidation;
+    }
+}
+function getProperty(filterObjItem, validationKey) {
+    if (filterObjItem.type === "IMAGE")
+        return "answer_id";
+    const value = (0, get_1._get)(filterObjItem, `values[0]['${validationKey}'][0]`, {});
+    const property = filterObjItem.property || value.property || value.targetFilter;
+    return property && property.toUpperCase();
+}
+function getDateProperty(validationKey, columnType, formulaType) {
+    if (![columnType, formulaType].includes("DATE"))
+        return;
+    return [
+        "MONTH_YEAR",
+        "YEAR",
+        "QUARTER",
+        "WEEK",
+        "HOUR",
+        "MINUTE",
+        "SECOND",
+    ].includes(validationKey)
+        ? validationKey.split("_")[0].toLowerCase()
+        : "day";
+}
+function getFilterRangeValue(range, minProp = "min", maxProp = "max", extras = {}) {
+    return Object.assign({ [minProp]: range.from || range.gte, [maxProp]: range.to || range.lte }, extras);
+}
+function getUiRangeValue(oldValue) {
+    if (oldValue.label)
+        return (oldValue.label + "").replace("-", " ");
+    const range = oldValue.range || oldValue;
+    return `${range.from || range.gte} - ${range.to || range.lte}`;
+}
+function getRankingFBvalues(values) {
+    const returnValues = [];
+    values
+        .map((vItem) => (Object.assign(Object.assign({}, vItem), { position: +vItem.position + 1 })))
+        .forEach((vItem) => {
+        const groupIndex = returnValues.findIndex((group) => group.every((groupItem) => groupItem.value.value !== vItem.value) &&
+            group.every((groupItem) => groupItem.position !== vItem.position));
+        const returnItem = {
+            position: vItem.position,
+            value: { enabled: vItem.enabled, value: vItem.value },
+        };
+        if (groupIndex === -1)
+            returnValues.push([returnItem]);
+        else
+            returnValues[groupIndex].push(returnItem);
+    });
+    return returnValues;
+}
+function getValues(values, columnType, oldValidation = "EQUAL", destination = "value", formulaType) {
+    switch (oldValidation) {
+        case "BETWEEN":
+        case "YEAR":
+        case "MONTH_YEAR":
+            return destination === "value"
+                ? values.map((val) => getFilterRangeValue(val.value.range || val.value, "gte", "lte"))
+                : destination === "uiValue"
+                    ? values.map((val) => getFilterRangeValue(val.value.range || val.value, "min", "max", {
+                        enabled: val.enabled,
+                        value: getUiRangeValue(val.value),
+                        validationLabel: oldValidation,
+                    }))
+                    : ["YEAR", "MONTH_YEAR", "QUARTER"].includes(oldValidation)
+                        ? values.map((item) => ({ value: getUiRangeValue(item.value) }))
+                        : values.map((val) => getFilterRangeValue(val.value.range || val.value));
+        case "LESS_THAN":
+        case "GREATER_THAN": {
+            const prop = oldValidation === "LESS_THAN" ? "lte" : "gte";
+            return destination === "value"
+                ? values.map((val) => getFilterRangeValue({ [prop]: val.value }, "gte", "lte"))
+                : destination === "uiValue"
+                    ? values.map((val) => getFilterRangeValue({ [prop]: val.value }, "min", "max", {
+                        enabled: val.enabled,
+                        value: val.value,
+                    }))
+                    : values.map((val) => getFilterRangeValue({ [prop]: val.value }));
+        }
+        case "IS_EMPTY":
+        case "IS_NOT_EMPTY": {
+            const valueClean = getValidator(oldValidation)
+                .toLowerCase()
+                .split("_")
+                .map((v) => (0, capitalize_1.capitalize)(v))
+                .join(" ");
+            return destination === "value"
+                ? [valueClean]
+                : destination === "uiValue"
+                    ? values.map((val) => ({ value: valueClean, enabled: val.enabled }))
+                    : [];
+        }
+        default:
+            return getFilterEqualValues(values, columnType, destination, formulaType);
+    }
+}
+function getFilterEqualValues(values, columnType, destination = "value", formulaType) {
+    if (columnType === "RANKING") {
+        return destination === "value"
+            ? values.map((item) => ({ position: +item.position, value: item.value }))
+            : destination === "uiValue"
+                ? values.map((item) => ({
+                    value: getUiRangeValue({
+                        from: item.value,
+                        to: +item.position + 1,
+                    }),
+                    enabled: true,
+                }))
+                : getRankingFBvalues(values);
+    }
+    return destination === "value"
+        ? values.map((item) => {
+            let value = item.value;
+            if ([columnType, formulaType].includes("DATE") &&
+                !(0, isTokenLabel_1.isTokenLabel)(value)) {
+                value = getFilterRangeValue(item.value.range || item.value, "gte", "lte");
+            }
+            else if (columnType === "YES_NO") {
+                value = item.value.toLowerCase();
+            }
+            else if (columnType === "IMAGE") {
+                value = item.id || item.answerid || item.answer_id;
+            }
+            else {
+                value = String(item.value);
+            }
+            return value;
+        })
+        : values.map((item) => ({
+            value: columnType === "YES_NO"
+                ? item.value.toLowerCase()
+                : [columnType, formulaType].includes("DATE")
+                    ? item.value.label || item.value
+                    : String(item.value),
+            valueid: columnType === "EXPRESSION" ? undefined : item.id || item.answerid,
+            enabled: item.enabled || true,
+        }));
+}
+function getFormulaType(oldFiltersItem) {
+    if (oldFiltersItem.formulaType)
+        return oldFiltersItem.formulaType;
+    if (oldFiltersItem.formulaId)
+        return oldFiltersItem.type === "NUMERIC"
+            ? "number"
+            : oldFiltersItem.type === "DATE"
+                ? "date"
+                : "string";
+}
+function getExpressions(oldFiltersItem, validations, scopeLabel, scopeid, section) {
+    const expressions = [];
+    validations.forEach((valKey) => {
+        const valKeyArray = valKey.split("|");
+        const validationKey = valKeyArray[0];
+        const property = valKeyArray[1] || getProperty(oldFiltersItem, validationKey);
+        const formulaType = getFormulaType(oldFiltersItem);
+        const questionType = formulaType ? "FORMULA" : oldFiltersItem.type;
+        const expressionItem = {
+            enabled: oldFiltersItem.enabled,
+            property: property,
+            qrveyid: oldFiltersItem.dataset.qrveyid,
+            questionid: oldFiltersItem.qid,
+            formulaType: formulaType,
+            questionType: questionType,
+            type: questionType,
+            validationType: getValidationType(validationKey, questionType, formulaType && formulaType.toUpperCase()),
+            uiExtras: {
+                column: {
+                    dataset: {
+                        qrveyid: oldFiltersItem.dataset.qrveyid,
+                        name: oldFiltersItem.dataset.name,
+                    },
+                    formulaType: formulaType,
+                    id: oldFiltersItem.qid,
+                    qrveyid: oldFiltersItem.dataset.qrveyid,
+                    text: oldFiltersItem.text,
+                    type: questionType,
+                },
+                operator: "AND",
+                property: getDateProperty(validationKey, questionType, formulaType && formulaType.toUpperCase()) || property,
+                validator: getValidator(validationKey),
+                panelid: oldFiltersItem.panelId,
+                panelName: oldFiltersItem.panelId ? oldFiltersItem.title : undefined,
+                uiHidden: false,
+                scope: scopeLabel,
+                scopeid,
+                section,
+            },
+        };
+        expressions.push(Object.assign(Object.assign({}, expressionItem), { value: getValues(oldFiltersItem.values[0][valKey], questionType, validationKey, "value", formulaType && formulaType.toUpperCase()), uiExtras: Object.assign(Object.assign({}, expressionItem.uiExtras), { values: getValues(oldFiltersItem.values[0][valKey], questionType, validationKey, "values", formulaType && formulaType.toUpperCase()), uiValue: getValues(oldFiltersItem.values[0][valKey], questionType, validationKey, "uiValue", formulaType && formulaType.toUpperCase()) }) }));
+    });
+    return expressions;
+}

package/dist/cjs/filters/helpers/common/getDateProperties.d.ts

@@ -8,3 +8,9 @@ import { IFValidator } from "../../interfaces/IFValidator";
  * @returns properties of the Date column
  */
 export declare function getDateProperties(column: IColumn, validator: IFValidator): IColumnPropertyInfo[];
+/**
+ * Returns True or false when the output format in the date column exists and is a time type
+ * @param column Column prop
+ * @returns True if The Date Column has a time format, otherwise is false.
+ */
+export declare function isDateColumnTimeFormat(column: IColumn): boolean;

package/dist/cjs/filters/helpers/common/getDateProperties.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDateProperties = void 0;
+exports.isDateColumnTimeFormat = exports.getDateProperties = void 0;
 const isValidatorMatchedToWindow_1 = require("./isValidatorMatchedToWindow");
 const DATE_DISTINCT_PROPERTY_INFO_LIST_1 = require("../../../dates/constants/DATE_DISTINCT_PROPERTY_INFO_LIST");
 const DATE_DISTINCT_TIME_PROPERTY_INFO_LIST_1 = require("../../../dates/constants/DATE_DISTINCT_TIME_PROPERTY_INFO_LIST");
@@ -44,3 +44,4 @@ function isDateColumnTimeFormat(column) {
     const formatDate = (0, get_1._get)(column.outputFormat, "format");
     return !(0, isEmpty_1.isEmpty)(formatDate) && formatDate.split(" ").length > 1;
 }
+exports.isDateColumnTimeFormat = isDateColumnTimeFormat;

package/dist/cjs/filters/helpers/settings/getFilterSettings.js

@@ -19,7 +19,6 @@ const getScopesToDisplay_1 = require("./getScopesToDisplay");
  */
 function getFilterSettings(filterSettings, allowedScopes = [], otherSettings) {
     let settings = (0, mergeDeep_1.mergeDeep)(FILTER_SETTINGS_DEFAULT_1.FILTER_SETTINGS_DEFAULT, (0, objectCopy_1.objectCopy)(filterSettings));
-    settings = (0, mergeDeep_1.mergeDeep)(settings, otherSettings);
     const scopesSettings = (0, getScopesToDisplay_1.getScopesToDisplay)(settings).filter((scope) => allowedScopes.includes(scope.id));
     if (scopesSettings.length > 1) {
         settings = getFilterSettingsByMultipleScopes(settings, allowedScopes);
@@ -30,6 +29,7 @@ function getFilterSettings(filterSettings, allowedScopes = [], otherSettings) {
     else {
         settings = getFilterSettingsByNoScopes(settings);
     }
+    settings = (0, mergeDeep_1.mergeDeep)(settings, otherSettings);
     return settings;
 }
 exports.getFilterSettings = getFilterSettings;

package/dist/cjs/filters/interfaces/common/IFSScopeID.d.ts

@@ -2,4 +2,8 @@ import { IFScope } from "../IFScope";
 export interface IFSScopeID {
     label: IFScope;
     id?: string;
+    /**
+     * The ID of the dataset related to the filter
+     */
+    datasetId?: string;
 }

package/dist/cjs/general/array/howManyByParam.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Gets the number of times that the param value exists into the object array
+ * @param array the given array
+ * @param param the param of the array object to compare
+ * @param value the value of the array object to compare
+ * @returns the number of times the parameter value exists
+ */
+export declare function howManyByParam<T = Record<string, unknown>>(array: T[], param: keyof T, value: unknown): number;

package/dist/cjs/general/array/howManyByParam.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.howManyByParam = void 0;
+/**
+ * Gets the number of times that the param value exists into the object array
+ * @param array the given array
+ * @param param the param of the array object to compare
+ * @param value the value of the array object to compare
+ * @returns the number of times the parameter value exists
+ */
+function howManyByParam(array, param, value) {
+    let count = 0;
+    if (!Array.isArray(array))
+        return count;
+    for (const i of array) {
+        if (i[param] === value)
+            count = count + 1;
+    }
+    return count;
+}
+exports.howManyByParam = howManyByParam;

package/dist/cjs/general/array/index.d.ts

@@ -4,5 +4,7 @@ export * from "./flattenDeep";
 export * from "./getArrayByProperty";
 export * from "./filterNestedTree";
 export * from "./getFirstIndexFromArray";
+export * from "./getUniqueArray";
+export * from "./howManyByParam";
 export * from "./getLastIndexFromArray";
 export * from "./intersectObjectArrays";

package/dist/cjs/general/array/index.js

@@ -20,5 +20,7 @@ __exportStar(require("./flattenDeep"), exports);
 __exportStar(require("./getArrayByProperty"), exports);
 __exportStar(require("./filterNestedTree"), exports);
 __exportStar(require("./getFirstIndexFromArray"), exports);
+__exportStar(require("./getUniqueArray"), exports);
+__exportStar(require("./howManyByParam"), exports);
 __exportStar(require("./getLastIndexFromArray"), exports);
 __exportStar(require("./intersectObjectArrays"), exports);

package/dist/cjs/general/string/index.d.ts

@@ -2,3 +2,5 @@ export * from "./capitalize";
 export * from "./padLeadingZeros";
 export * from "./parseUrl";
 export * from "./camelize";
+export * from "./secureHTML";
+export * from "./strategies/XSSSanitizer";

package/dist/cjs/general/string/index.js

@@ -18,3 +18,5 @@ __exportStar(require("./capitalize"), exports);
 __exportStar(require("./padLeadingZeros"), exports);
 __exportStar(require("./parseUrl"), exports);
 __exportStar(require("./camelize"), exports);
+__exportStar(require("./secureHTML"), exports);
+__exportStar(require("./strategies/XSSSanitizer"), exports);

package/dist/cjs/general/string/secureHTML.d.ts

@@ -0,0 +1,8 @@
+import { SanitizerStrategy } from "../../interfaces/SatinizerStrategy";
+/**
+ * Sanitizes HTML using the provided strategy.
+ * @param {string} html - HTML to sanitize.
+ * @param {SanitizerStrategy} sanitizer - Sanitization strategy.
+ * @returns {string} - Sanitized HTML.
+ */
+export declare const secureHTML: (html: string, sanitizer: SanitizerStrategy) => string;

package/dist/cjs/general/string/secureHTML.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secureHTML = void 0;
+/**
+ * Sanitizes HTML using the provided strategy.
+ * @param {string} html - HTML to sanitize.
+ * @param {SanitizerStrategy} sanitizer - Sanitization strategy.
+ * @returns {string} - Sanitized HTML.
+ */
+const secureHTML = (html, sanitizer) => {
+    return sanitizer.sanitize(html);
+};
+exports.secureHTML = secureHTML;

package/dist/cjs/general/string/strategies/XSSSanitizer.d.ts

@@ -0,0 +1,8 @@
+import { IFilterXSSOptions } from "xss";
+import { SanitizerStrategy } from "../../../interfaces/SatinizerStrategy";
+export declare class XSSSanitizer implements SanitizerStrategy {
+    private attributesBlackList;
+    private options;
+    constructor(options?: IFilterXSSOptions, attributesBlackList?: string[]);
+    sanitize(html: string): string;
+}