@qrvey/utils 1.15.0-2 → 1.15.0-20

package/dist/cjs/elements/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./helpers/index";
+export * from "./interfaces/index";

package/dist/cjs/elements/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./helpers/index"), exports);
+__exportStar(require("./interfaces/index"), exports);

package/dist/cjs/elements/interfaces/ICanvasGrid.d.ts

@@ -0,0 +1,5 @@
+export declare enum CanvasDevice {
+    DESKTOP = "desktop",
+    TABLET = "tablet",
+    MOBILE = "mobile"
+}

package/dist/cjs/elements/interfaces/ICanvasGrid.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanvasDevice = void 0;
+var CanvasDevice;
+(function (CanvasDevice) {
+    CanvasDevice["DESKTOP"] = "desktop";
+    CanvasDevice["TABLET"] = "tablet";
+    CanvasDevice["MOBILE"] = "mobile";
+})(CanvasDevice || (exports.CanvasDevice = CanvasDevice = {}));

package/dist/cjs/elements/interfaces/IFixedPosition.d.ts

@@ -0,0 +1,5 @@
+export interface FindAvailablePositionOptions {
+    initialY?: number;
+    findRightToLeft?: boolean;
+    canvasHeight?: number;
+}

package/dist/cjs/elements/interfaces/IFixedPosition.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/elements/interfaces/IVemCore.d.ts

@@ -0,0 +1,29 @@
+import { VemPositionConfigFixed, VemPositionConfigMap, VemPositionConfigResponsive, VemPositionType } from "./IVemPosition";
+interface VemBase {
+    elementId: string;
+    type: string;
+    contentId?: string;
+}
+export interface VemCorePosition {
+    fixed?: VemPositionConfigFixed;
+    responsive?: VemPositionConfigResponsive;
+}
+interface VemCore<TPosition extends VemPositionType | unknown, TItemData = unknown> extends VemBase {
+    itemData: TItemData;
+    /** Indicates if its a personalized Vem */
+    isEup?: boolean;
+    /** Data to be saved in the client chart when it's saved by EUP (Only applies for VemAnalytics) */
+    chartBody?: unknown;
+    /** Dashboard Actions in the element */
+    actions?: unknown[];
+    position: TPosition extends VemPositionType ? VemCorePosition & Record<TPosition, VemPositionConfigMap[TPosition]> : VemCorePosition;
+}
+export type Vem<T = unknown, TPosition extends VemPositionType = VemPositionType> = VemCore<TPosition, T>;
+export type VemPos<TPosition extends VemPositionType> = VemCore<TPosition>;
+export type VemResponsive<T = unknown> = VemCore<VemPositionType.RESPONSIVE, T>;
+export type VemFixed<T = unknown> = VemCore<VemPositionType.FIXED, T>;
+export interface VemElementMap<T = unknown> {
+    [VemPositionType.FIXED]: VemFixed<T>;
+    [VemPositionType.RESPONSIVE]: VemResponsive<T>;
+}
+export {};

package/dist/cjs/elements/interfaces/IVemCore.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const IVemPosition_1 = require("./IVemPosition");

package/dist/cjs/elements/interfaces/IVemPosition.d.ts

@@ -0,0 +1,44 @@
+export interface VemSizeFixed {
+    width: number;
+    height: number;
+}
+export interface VemSizeResponsive {
+    colSpan: number;
+    rowSpan: number;
+}
+export interface VemPositionFixed extends VemSizeFixed {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface VemPositionResponsive extends VemSizeResponsive {
+    colStart: number;
+    rowStart: number;
+}
+export type VemPosition = VemPositionFixed | VemPositionResponsive;
+export interface VemPositionMap {
+    [VemPositionType.FIXED]: VemPositionFixed;
+    [VemPositionType.RESPONSIVE]: VemPositionResponsive;
+}
+export declare enum VemPositionType {
+    FIXED = "fixed",
+    RESPONSIVE = "responsive"
+}
+interface VemPositionBase<TPosition extends VemPosition> {
+    desktop: TPosition;
+    tablet?: TPosition;
+    mobile?: TPosition;
+}
+export type VemPositionConfigFixed = VemPositionBase<VemPositionFixed>;
+export type VemPositionConfigResponsive = VemPositionBase<VemPositionResponsive>;
+export type VemPositionConfig = VemPositionConfigFixed | VemPositionConfigResponsive;
+export interface VemPositionConfigMap {
+    [VemPositionType.FIXED]: VemPositionConfigFixed;
+    [VemPositionType.RESPONSIVE]: VemPositionConfigResponsive;
+}
+export type VemSize = VemSizeFixed | VemSizeResponsive;
+export interface VemSizeConfig {
+    [VemPositionType.FIXED]: VemSizeFixed;
+    [VemPositionType.RESPONSIVE]: VemSizeResponsive;
+}
+export {};

package/dist/cjs/elements/interfaces/IVemPosition.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VemPositionType = void 0;
+var VemPositionType;
+(function (VemPositionType) {
+    VemPositionType["FIXED"] = "fixed";
+    VemPositionType["RESPONSIVE"] = "responsive";
+})(VemPositionType || (exports.VemPositionType = VemPositionType = {}));

package/dist/cjs/elements/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./ICanvasGrid";
+export * from "./IFixedPosition";
+export * from "./IVemCore";
+export * from "./IVemPosition";

package/dist/cjs/elements/interfaces/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./ICanvasGrid"), exports);
+__exportStar(require("./IFixedPosition"), exports);
+__exportStar(require("./IVemCore"), exports);
+__exportStar(require("./IVemPosition"), exports);

package/dist/cjs/elements/utils/element.d.ts

@@ -0,0 +1,4 @@
+import { CanvasDevice } from "../interfaces/ICanvasGrid";
+import { Vem } from "../interfaces/IVemCore";
+import { VemPositionType } from "../interfaces/IVemPosition";
+export declare const copyDesktopPositionToDevice: (elements: Vem[], newCanvasDevice: CanvasDevice, canvasType: VemPositionType) => Vem[];

package/dist/cjs/elements/utils/element.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyDesktopPositionToDevice = void 0;
+const position_1 = require("./position");
+const ICanvasGrid_1 = require("../interfaces/ICanvasGrid");
+const IVemPosition_1 = require("../interfaces/IVemPosition");
+const copyDesktopPositionToDevice = (elements, newCanvasDevice, canvasType) => {
+    const defaultPositionMap = {
+        [IVemPosition_1.VemPositionType.FIXED]: {
+            x: 0,
+            y: 0,
+        },
+        [IVemPosition_1.VemPositionType.RESPONSIVE]: {
+            colStart: 1,
+            rowStart: 1,
+        },
+    };
+    return elements.map((element) => {
+        var _a;
+        if (!((_a = element.position[canvasType]) === null || _a === void 0 ? void 0 : _a[newCanvasDevice])) {
+            const desktopViewPosition = element.position[canvasType][ICanvasGrid_1.CanvasDevice.DESKTOP];
+            const newDevicePosition = Object.assign(Object.assign({}, desktopViewPosition), defaultPositionMap[canvasType]);
+            return (0, position_1.setElementPosition)(element, canvasType, newCanvasDevice, newDevicePosition);
+        }
+        return element;
+    });
+};
+exports.copyDesktopPositionToDevice = copyDesktopPositionToDevice;

package/dist/cjs/elements/utils/general.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Compares two objects based on their `distance` property and determines their relative order.
+ * @param a - An object with a `distance` property (number).
+ * @param b - Another object with a `distance` property (number).
+ * @param a.distance
+ * @param b.distance
+ * @returns - A negative number if `a` has a smaller distance than `b`,
+ *            a positive number if `a` has a larger distance than `b`,
+ *            or 0 if both have equal distances.
+ */
+export declare const sortByDistanceFunction: (a: {
+    distance: number;
+}, b: {
+    distance: number;
+}) => 0 | 1 | -1;

package/dist/cjs/elements/utils/general.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortByDistanceFunction = void 0;
+/**
+ * Compares two objects based on their `distance` property and determines their relative order.
+ * @param a - An object with a `distance` property (number).
+ * @param b - Another object with a `distance` property (number).
+ * @param a.distance
+ * @param b.distance
+ * @returns - A negative number if `a` has a smaller distance than `b`,
+ *            a positive number if `a` has a larger distance than `b`,
+ *            or 0 if both have equal distances.
+ */
+const sortByDistanceFunction = (a, b) => {
+    if (a.distance === b.distance) {
+        return 0;
+    }
+    return a.distance < b.distance ? -1 : 1;
+};
+exports.sortByDistanceFunction = sortByDistanceFunction;

package/dist/cjs/elements/utils/overlap.d.ts

@@ -0,0 +1,63 @@
+interface OverlapNode {
+    startX: number;
+    endX: number;
+    startY: number;
+    endY: number;
+    maxEndX: number;
+    maxEndY: number;
+    left?: OverlapNode;
+    right?: OverlapNode;
+}
+/**
+ *
+ */
+export declare class OverlapIntervalTree {
+    root?: OverlapNode;
+    /**
+     *
+     */
+    constructor();
+    /**
+     *
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    insert(startX: number, endX: number, startY: number, endY: number): void;
+    /**
+     *
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    private _initNode;
+    /**
+     *
+     * @param node
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    private _insert;
+    /**
+     *
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    overlaps(startX: number, endX: number, startY: number, endY: number): boolean;
+    /**
+     *
+     * @param node
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    private _overlaps;
+}
+export {};

package/dist/cjs/elements/utils/overlap.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverlapIntervalTree = void 0;
+/**
+ *
+ */
+class OverlapIntervalTree {
+    /**
+     *
+     */
+    constructor() {
+        this.root = undefined;
+    }
+    /**
+     *
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    insert(startX, endX, startY, endY) {
+        this.root = this._insert(this.root, startX, endX, startY, endY);
+    }
+    /**
+     *
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    _initNode(startX, endX, startY, endY) {
+        return {
+            startX,
+            endX,
+            startY,
+            endY,
+            maxEndX: endX,
+            maxEndY: endY,
+            left: undefined,
+            right: undefined,
+        };
+    }
+    /**
+     *
+     * @param node
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    _insert(node, startX, endX, startY, endY) {
+        if (node === undefined) {
+            return this._initNode(startX, endX, startY, endY);
+        }
+        if (startY < node.startY) {
+            node.left = this._insert(node.left, startX, endX, startY, endY);
+        }
+        else {
+            node.right = this._insert(node.right, startX, endX, startY, endY);
+        }
+        node.maxEndX = Math.max(node.maxEndX, endX);
+        node.maxEndY = Math.max(node.maxEndY, endY);
+        return node;
+    }
+    /**
+     *
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    overlaps(startX, endX, startY, endY) {
+        return this._overlaps(this.root, startX, endX, startY, endY);
+    }
+    /**
+     *
+     * @param node
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    _overlaps(node, startX, endX, startY, endY) {
+        if (node === undefined) {
+            return false;
+        }
+        if (startX <= node.endX &&
+            endX >= node.startX &&
+            startY <= node.endY &&
+            endY >= node.startY) {
+            return true;
+        }
+        if (node.left !== undefined && node.left.maxEndY >= startY) {
+            return this._overlaps(node.left, startX, endX, startY, endY);
+        }
+        return this._overlaps(node.right, startX, endX, startY, endY);
+    }
+}
+exports.OverlapIntervalTree = OverlapIntervalTree;

package/dist/cjs/elements/utils/position.d.ts

@@ -0,0 +1,4 @@
+import { CanvasDevice } from "../interfaces/ICanvasGrid";
+import { Vem } from "../interfaces/IVemCore";
+import { VemPosition, VemPositionType } from "../interfaces/IVemPosition";
+export declare const setElementPosition: <T extends VemPositionType = VemPositionType>(baseElement: Vem<unknown, T>, type: T, device: CanvasDevice, position: VemPosition) => Vem<unknown, T>;

package/dist/cjs/elements/utils/position.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setElementPosition = void 0;
+const setElementPosition = (baseElement, type, device, position) => (Object.assign(Object.assign({}, baseElement), { position: Object.assign(Object.assign({}, baseElement.position), { [type]: Object.assign(Object.assign({}, baseElement.position[type]), { [device]: position }) }) }));
+exports.setElementPosition = setElementPosition;

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

@@ -38,7 +38,8 @@ function getLogicBodyFromFD21(filterData) {
                 filters = filters.concat(expressions);
             });
         }
-        logics.push(Object.assign(Object.assign({}, logic), { filters }));
+        if (!(0, isEmpty_1.isEmpty)(filters))
+            logics.push(Object.assign(Object.assign({}, logic), { filters }));
         return logics;
     }, []);
 }

package/dist/cjs/filters/helpers/backend/buildFilters.d.ts

@@ -1,3 +1,8 @@
 import { IFBFilter } from "../../interfaces/backend/IFBFilter";
 import { IFSFilter } from "../../interfaces/common/IFSFilter";
+/**
+ *
+ * @param filters
+ * @param groupColumns
+ */
 export declare function buildFilters(filters: IFSFilter[], groupColumns?: boolean): IFBFilter[];

package/dist/cjs/filters/helpers/backend/buildFilters.js

@@ -1,10 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildFilters = void 0;
+const buildExpression_1 = require("./buildExpression");
 const isEmpty_1 = require("../../../general/mix/isEmpty");
 const hasProperty_1 = require("../../../general/object/hasProperty");
 const FILTER_OPERATOR_1 = require("../../constants/common/FILTER_OPERATOR");
-const buildExpression_1 = require("./buildExpression");
+/**
+ *
+ * @param filters
+ * @param groupColumns
+ */
 function buildFilters(filters, groupColumns = false) {
     const expression = numericExpression(filters, groupColumns);
     const orOperators = expression.split("+");
@@ -28,6 +33,8 @@ function buildFilters(filters, groupColumns = false) {
         return getColumnExpressions(group, getFilter);
     })
         .filter(Boolean);
+    if ((0, isEmpty_1.isEmpty)(expressions))
+        return [];
     if (orOperators.length > 1) {
         return [
             {
@@ -42,6 +49,11 @@ function buildFilters(filters, groupColumns = false) {
     return [{ operator: FILTER_OPERATOR_1.FILTER_OPERATOR.AND, expressions }];
 }
 exports.buildFilters = buildFilters;
+/**
+ *
+ * @param group
+ * @param getFilter
+ */
 function getColumnExpressions(group, getFilter) {
     const columnOrOperators = group.split("/");
     if (columnOrOperators.length > 1) {
@@ -54,12 +66,22 @@ function getColumnExpressions(group, getFilter) {
     }
     return getFilter(group);
 }
+/**
+ *
+ * @param operator
+ * @param priority
+ */
 function logicToNumeric(operator, priority = false) {
     if (operator === FILTER_OPERATOR_1.FILTER_OPERATOR.AND) {
         return "*";
     }
     return priority ? "/" : "+";
 }
+/**
+ *
+ * @param filters
+ * @param groupColumns
+ */
 function numericExpression(filters, groupColumns = false) {
     let expression = "";
     filters.forEach((item, index) => {

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,7 @@ export * from "./capitalize";
 export * from "./padLeadingZeros";
 export * from "./parseUrl";
 export * from "./camelize";
+export * from "./secureHTML";
+export * from "./strategies/XSSSanitizer";
+export * from "./strategies/XSSEstrictedSanitizer";
+export * from "./urlValidator";

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

@@ -18,3 +18,7 @@ __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);
+__exportStar(require("./strategies/XSSEstrictedSanitizer"), exports);
+__exportStar(require("./urlValidator"), 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/XSSEstrictedSanitizer.d.ts

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