@qrvey/utils 1.15.0-9 → 1.16.0-0

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/buildExpression.js

@@ -16,6 +16,7 @@ function buildExpression(filter) {
     const expression = {
         groupValue: (0, getBackendGroupValue_1.getBackendGroupValue)(filter),
         questionid: filter.column.id,
+        qrveyid: filter.column.qrveyid,
         questionType: filter.column.type,
         property: (0, getBackendProperty_1.getBackendProperty)(filter),
         validationType: (0, getBackendValidator_1.getBackendValidator)(filter),

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/backend/getBackendValues.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getBackendValues = void 0;
 const COLUMN_1 = require("../../../columns/constants/COLUMN");
 const flattenDeep_1 = require("../../../general/array/flattenDeep");
+const isEmpty_1 = require("../../../general/mix/isEmpty");
 const FILTER_VALIDATOR_1 = require("../../constants/common/FILTER_VALIDATOR");
 const FILTER_VALIDATOR_INFO_1 = require("../../constants/common/FILTER_VALIDATOR_INFO");
 const isRankingFilter_1 = require("../common/isRankingFilter");
@@ -86,7 +87,9 @@ function getNullValues(values, filter) {
     return addValue ? [FILTER_VALIDATOR_INFO_1.FILTER_VALIDATOR_INFO[filter.validator].label] : [];
 }
 function getInValues(values) {
-    return values.map((value) => getValue(value, value)).filter(Boolean);
+    return values
+        .map((value) => (Object.assign(Object.assign({}, getValue(value, value)), { anchor: (0, isEmpty_1.isEmpty)(value.anchor) ? undefined : value.anchor })))
+        .filter(Boolean);
 }
 function getValue(objectValue, value) {
     return objectValue.enabled ? value : undefined;

package/dist/cjs/filters/helpers/getAvailableScopesIDsByConfig.js

@@ -15,6 +15,7 @@ function getAvailableScopesIDsByConfig(config = {}) {
         tabid: (0, getAttribute_1.getAttribute)(config, "tab_id") || config.tabid,
         pageid: (0, getAttribute_1.getAttribute)(config, "page_id") || config.pageid,
         defaultid: (0, getAttribute_1.getAttribute)(config, "default_id") || config.defaultid,
+        panelid: (0, getAttribute_1.getAttribute)(config, "panel_id") || config.panelid,
     };
 }
 exports.getAvailableScopesIDsByConfig = getAvailableScopesIDsByConfig;

package/dist/cjs/filters/interfaces/backend/IFBExpression.js

@@ -4,4 +4,3 @@ Object.defineProperty(exports, "__esModule", { value: true });
 //
 // formulaType?: string;
 // linkid?: string;
-// qrveyid?: string;

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

@@ -0,0 +1,6 @@
+/**
+ * Get unique vaues from an Array of primitive JS types
+ * @param arr Array of primitive types
+ * @returns the new array with unique items
+ */
+export declare function getUniqueSimpleArray<T = unknown>(arr: T[]): T[];

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUniqueSimpleArray = void 0;
+/**
+ * Get unique vaues from an Array of primitive JS types
+ * @param arr Array of primitive types
+ * @returns the new array with unique items
+ */
+function getUniqueSimpleArray(arr) {
+    if (!Array.isArray(arr))
+        return arr;
+    return Array.from(new Set(arr));
+}
+exports.getUniqueSimpleArray = getUniqueSimpleArray;

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

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

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

@@ -21,6 +21,7 @@ __exportStar(require("./getArrayByProperty"), exports);
 __exportStar(require("./filterNestedTree"), exports);
 __exportStar(require("./getFirstIndexFromArray"), exports);
 __exportStar(require("./getUniqueArray"), exports);
+__exportStar(require("./getUniqueSimpleArray"), 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;
+}

package/dist/cjs/general/string/strategies/XSSEstrictedSanitizer.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XSSEstrictedSanitizer = void 0;
+const xss_1 = require("xss");
+class XSSEstrictedSanitizer {
+    constructor(options, attributesBlackList = []) {
+        this.attributesBlackList = attributesBlackList;
+        this.options = Object.assign({ css: false, onIgnoreTagAttr: (_tag, name, value) => {
+                if (this.attributesBlackList.includes(name)) {
+                    return ""; // Elimina el atributo si está en la lista negra
+                }
+                return `${name}="${value}"`; // Mantiene el atributo si no está en la lista negra
+            }, onIgnoreTag: (tag, _html, _options) => {
+                if (["script", "iframe"].includes(tag)) {
+                    return ""; // Elimina los <script>
+                }
+            }, escapeHtml: (str) => str }, options);
+    }
+    sanitize(html) {
+        return (0, xss_1.filterXSS)(html, this.options);
+    }
+}
+exports.XSSEstrictedSanitizer = XSSEstrictedSanitizer;

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;
+}

package/dist/cjs/general/string/strategies/XSSSanitizer.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XSSSanitizer = void 0;
+const xss_1 = require("xss");
+class XSSSanitizer {
+    constructor(options, attributesBlackList = []) {
+        this.attributesBlackList = attributesBlackList;
+        this.options = Object.assign({ css: false, onIgnoreTagAttr: (tag, name, value) => {
+                if (!this.attributesBlackList.includes(name)) {
+                    return `${name}="${value}"`;
+                }
+                return "";
+            } }, options);
+    }
+    sanitize(html) {
+        return (0, xss_1.filterXSS)(html, this.options);
+    }
+}
+exports.XSSSanitizer = XSSSanitizer;

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

@@ -0,0 +1,10 @@
+export declare class URLValidator {
+    private validDomains;
+    private validProtocols;
+    constructor(domains?: string[], protocols?: string[]);
+    setValidDomains(domains?: string[]): this;
+    setValidProtocols(protocols?: string[]): this;
+    validate(url: string): boolean;
+    private isValidProtocol;
+    private isValidDomain;
+}

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.URLValidator = void 0;
+class URLValidator {
+    constructor(domains = [], protocols = ["http", "https"]) {
+        this.validDomains = domains;
+        this.validProtocols = protocols;
+    }
+    setValidDomains(domains = []) {
+        this.validDomains = domains;
+        return this;
+    }
+    setValidProtocols(protocols = []) {
+        this.validProtocols = protocols;
+        return this;
+    }
+    validate(url) {
+        try {
+            const urlObj = new URL(url);
+            return (this.isValidProtocol(urlObj.protocol) &&
+                (this.validDomains.length === 0 || this.isValidDomain(urlObj.hostname)));
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    isValidProtocol(protocol) {
+        const normalizedProtocol = protocol.replace(":", "").toLowerCase();
+        return this.validProtocols.includes(normalizedProtocol);
+    }
+    isValidDomain(domain) {
+        if (this.validDomains.length === 0) {
+            return true;
+        }
+        return this.validDomains.some((validDomain) => domain.endsWith(validDomain));
+    }
+}
+exports.URLValidator = URLValidator;

package/dist/cjs/globalization/helpers/getI18nDateGroupLabel.d.ts

@@ -1,3 +1,9 @@
 import { IDateColumnPropertyType } from "../../columns/interfaces/IDateColumnPropertyType";
 import { II18nServiceTranslate } from "../interfaces/II18nServiceTranslate";
+/**
+ *
+ * @param label
+ * @param dateGroup
+ * @param translate
+ */
 export declare function getI18nDateGroupLabel(label: string, dateGroup: IDateColumnPropertyType, translate?: II18nServiceTranslate): string;