@qrvey/utils 1.5.0 → 1.6.0-1

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

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLogicByDatasets = void 0;
-const general_1 = require("../../../general");
+const filterNestedTree_1 = require("../../../general/array/filterNestedTree");
 const isEmpty_1 = require("../../../general/mix/isEmpty");
+const hasProperty_1 = require("../../../general/object/hasProperty");
 /**
  * [TODO: Add filterEmptyArrays to the filterNestedTree filter condition. Firstly, that function should accept this argument]
  * Filters the logic by a qrveyids array
@@ -17,10 +18,10 @@ function getLogicByDatasets(logic, datasets = [], settings) {
     if ((0, isEmpty_1.isEmpty)(datasets))
         return logic;
     const defaultSettings = getGetLogicByDatasetsSettings(settings);
-    return logic.map((_l) => (Object.assign(Object.assign({}, _l), { filters: (0, general_1.filterNestedTree)(_l.filters, "expressions", (expression) => {
+    return logic.map((_l) => (Object.assign(Object.assign({}, _l), { filters: (0, filterNestedTree_1.filterNestedTree)(_l.filters, "expressions", (expression) => {
             const dataset = datasets.find((_data) => _data === expression.qrveyid);
             return ((defaultSettings.letPassUndefinedProperties.qrveyid &&
-                !(0, general_1._hasProperty)(expression, "qrveyid")) ||
+                !(0, hasProperty_1._hasProperty)(expression, "qrveyid")) ||
                 !(0, isEmpty_1.isEmpty)(dataset));
         }) })));
 }

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

@@ -1,6 +1,7 @@
 export * from "./backend/index";
 export * from "./builder/index";
 export * from "./common/index";
+export * from "./settings/index";
 export * from "./ui/index";
 export * from "./applyHierarchyForAggFilters";
 export * from "./getAvailableScopes";

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

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./backend/index"), exports);
 __exportStar(require("./builder/index"), exports);
 __exportStar(require("./common/index"), exports);
+__exportStar(require("./settings/index"), exports);
 __exportStar(require("./ui/index"), exports);
 __exportStar(require("./applyHierarchyForAggFilters"), exports);
 __exportStar(require("./getAvailableScopes"), exports);

package/dist/cjs/filters/helpers/settings/areMultipleScopesByProperties.d.ts

@@ -0,0 +1,9 @@
+import { IFSettings } from "../../interfaces/settings/IFSettings";
+/**
+ * Validates if the scope settings is satisfied by properties in multiple scopes
+ * @param {IFSettings} settings the filter setting
+ * @param {string} scopeProperties the property or the string path of the scope settings
+ * @param {string} condition validate with AND or OR condition
+ * @returns true iif there are scopes to be satisfied; false: one or none scopes to be satisfied
+ */
+export declare function areMultipleScopesByProperties(settings: IFSettings, scopeProperties: string[], condition?: "AND" | "OR"): boolean;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.areMultipleScopesByProperties = void 0;
+const isEmpty_1 = require("../../../general/mix/isEmpty");
+const get_1 = require("../../../general/object/get");
+const getScopesSettings_1 = require("./getScopesSettings");
+/**
+ * Validates if the scope settings is satisfied by properties in multiple scopes
+ * @param {IFSettings} settings the filter setting
+ * @param {string} scopeProperties the property or the string path of the scope settings
+ * @param {string} condition validate with AND or OR condition
+ * @returns true iif there are scopes to be satisfied; false: one or none scopes to be satisfied
+ */
+function areMultipleScopesByProperties(settings, scopeProperties, condition = "AND") {
+    if ((0, isEmpty_1.isEmpty)(settings) || (0, isEmpty_1.isEmpty)(settings.scopes))
+        return false;
+    const scopes = Object.keys(settings.scopes);
+    const conditionFunction = (scope) => (property) => (0, get_1._get)(scope, property, false);
+    return (scopes.length > 0 &&
+        (0, getScopesSettings_1.getScopesSettings)(settings.scopes).filter((scope) => condition === "AND"
+            ? scopeProperties.every(conditionFunction(scope))
+            : scopeProperties.some(conditionFunction(scope))).length > 0);
+}
+exports.areMultipleScopesByProperties = areMultipleScopesByProperties;

package/dist/cjs/filters/helpers/settings/areMultipleScopesByProperty.d.ts

@@ -0,0 +1,8 @@
+import { IFSettings } from "../../interfaces/settings/IFSettings";
+/**
+ * Validates if the scope settings is satisfied the property in multiple scopes
+ * @param {IFSettings} settings the filter setting
+ * @param {string} property the property or the string path of the scope settings
+ * @returns true if there are scopes to be satisfied; false: one or none scopes to be satisfied
+ */
+export declare function areMultipleScopesByProperty(settings: IFSettings, property: string): boolean;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.areMultipleScopesByProperty = void 0;
+const isEmpty_1 = require("../../../general/mix/isEmpty");
+const get_1 = require("../../../general/object/get");
+const getScopesSettings_1 = require("./getScopesSettings");
+/**
+ * Validates if the scope settings is satisfied the property in multiple scopes
+ * @param {IFSettings} settings the filter setting
+ * @param {string} property the property or the string path of the scope settings
+ * @returns true if there are scopes to be satisfied; false: one or none scopes to be satisfied
+ */
+function areMultipleScopesByProperty(settings, property) {
+    if ((0, isEmpty_1.isEmpty)(settings) || (0, isEmpty_1.isEmpty)(settings.scopes))
+        return false;
+    const scopes = Object.keys(settings.scopes);
+    return (scopes.length > 1 &&
+        (0, getScopesSettings_1.getScopesSettings)(settings.scopes).filter((scope) => (0, get_1._get)(scope, property, false)).length > 1);
+}
+exports.areMultipleScopesByProperty = areMultipleScopesByProperty;

package/dist/cjs/filters/helpers/settings/getFilterSettings.d.ts

@@ -0,0 +1,13 @@
+import { IFScope } from "../../interfaces/IFScope";
+import { IFSettings } from "../../interfaces/settings/IFSettings";
+/**
+ * Gets a new filter settings object according to various conditions
+ * - By allowed scopes. Different implementation could accept some scopes, so the forbidden scopes into the filter settings will be skipped
+ * - If there is not filter settings provived, a default one is returned
+ * - The returned filter settings depend on the coexisting scopes
+ * @param {IFSettings} filterSettings the given filter settings
+ * @param {IFScope[]} allowedScopes a collection of scope types that are permitted
+ * @param {IFSettings} otherSettings another filter settings object to be merged with the filterSettings param
+ * @returns a new filter settings object
+ */
+export declare function getFilterSettings(filterSettings: IFSettings, allowedScopes?: IFScope[], otherSettings?: IFSettings): IFSettings;

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

@@ -0,0 +1,331 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFilterSettings = void 0;
+const isEmpty_1 = require("../../../general/mix/isEmpty");
+const cloneDeep_1 = require("../../../general/object/cloneDeep");
+const mergeDeep_1 = require("../../../general/object/mergeDeep");
+const FILTER_SCOPE_1 = require("../../constants/common/FILTER_SCOPE");
+const FILTER_SETTINGS_DEFAULT_1 = require("../../constants/settings/FILTER_SETTINGS_DEFAULT");
+const getScopesToDisplay_1 = require("./getScopesToDisplay");
+/**
+ * Gets a new filter settings object according to various conditions
+ * - By allowed scopes. Different implementation could accept some scopes, so the forbidden scopes into the filter settings will be skipped
+ * - If there is not filter settings provived, a default one is returned
+ * - The returned filter settings depend on the coexisting scopes
+ * @param {IFSettings} filterSettings the given filter settings
+ * @param {IFScope[]} allowedScopes a collection of scope types that are permitted
+ * @param {IFSettings} otherSettings another filter settings object to be merged with the filterSettings param
+ * @returns a new filter settings object
+ */
+function getFilterSettings(filterSettings, allowedScopes = [], otherSettings) {
+    let settings = (0, mergeDeep_1.mergeDeep)(FILTER_SETTINGS_DEFAULT_1.FILTER_SETTINGS_DEFAULT, (0, cloneDeep_1.cloneDeep)(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);
+    }
+    else if (scopesSettings.length > 0) {
+        settings = getFilterSettingsByOnlyScope(settings, allowedScopes);
+    }
+    else {
+        settings = getFilterSettingsByNoScopes(settings);
+    }
+    return settings;
+}
+exports.getFilterSettings = getFilterSettings;
+/**
+ * Gets the filter settings by multiple scopes conditions
+ * @param {IFSettings} settings the given filter settings
+ * @param {IFScope[]} allowedScopes a collection of scope types that are permitted
+ * @returns a new filter settings object
+ */
+function getFilterSettingsByMultipleScopes(settings, allowedScopes) {
+    const scopesSettings = (0, getScopesToDisplay_1.getScopesToDisplay)(settings).filter((scope) => allowedScopes.includes(scope.id));
+    let newSettings = settings;
+    if ((0, isEmpty_1.isEmpty)(scopesSettings.find((scope) => scope.id === FILTER_SCOPE_1.FILTER_SCOPE.DEFAULT))) {
+        newSettings = getFilterSettingsByNoDefaultScope(newSettings);
+    }
+    else if (scopesSettings.length <= 2) {
+        newSettings = getFilterSettingsByDefaultWithOneAdditionalScope(newSettings);
+    }
+    if ((0, isEmpty_1.isEmpty)(scopesSettings.find((scope) => scope.id === FILTER_SCOPE_1.FILTER_SCOPE.CHART))) {
+        newSettings = getFilterSettingsByMultipleNoPanelScopes(newSettings);
+    }
+    if ((0, isEmpty_1.isEmpty)(scopesSettings.find((scope) => scope.id === FILTER_SCOPE_1.FILTER_SCOPE.CHART)) &&
+        (0, isEmpty_1.isEmpty)(scopesSettings.find((scope) => scope.id === FILTER_SCOPE_1.FILTER_SCOPE.GLOBAL)) &&
+        (0, isEmpty_1.isEmpty)(scopesSettings.find((scope) => scope.id === FILTER_SCOPE_1.FILTER_SCOPE.PAGE)) &&
+        (0, isEmpty_1.isEmpty)(scopesSettings.find((scope) => scope.id === FILTER_SCOPE_1.FILTER_SCOPE.TAB))) {
+        newSettings = getFilterSettingsBySkippingGeneralScopes(newSettings);
+    }
+    return newSettings;
+}
+/**
+ * Gets the filter settings when a single scope is permitted
+ * @param {IFSettings} settings the given filter settings
+ * @param {IFScope[]} allowedScopes a collection of scope types that are permitted
+ * @returns a new filter settings object
+ */
+function getFilterSettingsByOnlyScope(settings, allowedScopes) {
+    const scopesSettings = (0, getScopesToDisplay_1.getScopesToDisplay)(settings).filter((scope) => allowedScopes.includes(scope.id));
+    let newSettings = getFilterSettingsByGeneralOnlyScope(settings);
+    if ((0, isEmpty_1.isEmpty)(scopesSettings.find((scope) => scope.id === FILTER_SCOPE_1.FILTER_SCOPE.DEFAULT))) {
+        newSettings = getFilterSettingsByNoDefaultScope(newSettings);
+    }
+    else {
+        newSettings = getFilterSettingsByOnlyDefaultScope(newSettings);
+    }
+    if (!(0, isEmpty_1.isEmpty)(scopesSettings.find((scope) => scope.id === FILTER_SCOPE_1.FILTER_SCOPE.CHART))) {
+        newSettings = getFilterSettingsByOnlyPanelScope(newSettings);
+    }
+    if (!(0, isEmpty_1.isEmpty)(scopesSettings.find((scope) => scope.id === FILTER_SCOPE_1.FILTER_SCOPE.DATA))) {
+        newSettings = getFilterSettingsByOnlyDataScope(newSettings);
+    }
+    return newSettings;
+}
+/**
+ * Gets the filter settings when there is not scope to accept
+ * @param {IFSettings} settings the given filter settings
+ * @returns a new filter settings object
+ */
+function getFilterSettingsByNoScopes(settings) {
+    const newSettings = {
+        chartBuilder: {
+            addFilterDisplayed: false,
+            filterSectionDisplayed: false,
+        },
+        filterBuilder: {
+            scopeSelectorDisplayed: false,
+        },
+        filterDisplayer: {
+            addFilterDisplayed: false,
+            displayed: false,
+        },
+        filterPanel: {
+            body: {
+                dataset: {
+                    headerDisplayed: false,
+                },
+                filter: {
+                    menu: {
+                        deleteDisplayed: false,
+                        displayed: false,
+                        editDisplayed: false,
+                        enableDisplayed: false,
+                    },
+                },
+                scope: {
+                    headerDisplayed: false,
+                },
+            },
+            colorized: false,
+            displayed: false,
+            header: {
+                filterButtonDisplayed: false,
+                menu: {
+                    deleteDisplayed: false,
+                    displayed: false,
+                    enableDisplayed: false,
+                },
+            },
+        },
+        filterPanelSettings: {
+            displayColorModeDisplayed: false,
+            displayIconsDisplayed: false,
+            panelDefaultViewDisplayed: false,
+            showPanelInPageViewDisplayed: false,
+        },
+        panel: {
+            filterAccessDisplayed: false,
+            filterByDisplayed: false,
+            seeDataDisplayed: false,
+        },
+    };
+    return (0, mergeDeep_1.mergeDeep)(settings, newSettings);
+}
+/**
+ * Gets the filter settings when a general scope are only permitted
+ * The general scopes could be the GLOBAL, PAGE, TAB and PANEL types.
+ * @param {IFSettings} settings the given filter settings
+ * @returns a new filter settings object
+ */
+function getFilterSettingsByGeneralOnlyScope(settings) {
+    const newSettings = {
+        filterBuilder: {
+            scopeSelectorDisplayed: false,
+        },
+        filterPanel: {
+            body: {
+                dataset: {
+                    headerDisplayed: false,
+                },
+                scope: {
+                    headerDisplayed: false,
+                },
+            },
+            colorized: false,
+        },
+        filterPanelSettings: {
+            displayColorModeDisplayed: false,
+        },
+    };
+    return (0, mergeDeep_1.mergeDeep)(settings, newSettings);
+}
+/**
+ * Gets the filter settings when there is not a default scope type
+ * @param {IFSettings} settings the given filter settings
+ * @returns a new filter settings object
+ */
+function getFilterSettingsByNoDefaultScope(settings) {
+    const newSettings = {
+        chartBuilder: {
+            addFilterDisplayed: false,
+            filterSectionDisplayed: false,
+        },
+    };
+    return (0, mergeDeep_1.mergeDeep)(settings, newSettings);
+}
+/**
+ * Gets the filter settings when there is only a default scope type
+ * @param {IFSettings} settings the given filter settings
+ * @returns a new filter settings object
+ */
+function getFilterSettingsByOnlyDefaultScope(settings) {
+    const newSettings = {
+        filterDisplayer: {
+            addFilterDisplayed: false,
+            addFilterEnabled: false,
+            displayed: false,
+        },
+        filterPanel: {
+            body: {
+                filter: {
+                    menu: {
+                        deleteDisplayed: false,
+                        displayed: false,
+                        editDisplayed: false,
+                        enableDisplayed: false,
+                    },
+                    readonly: true,
+                },
+                operator: {
+                    displayed: false,
+                    readonly: true,
+                },
+            },
+            displayed: false,
+            header: {
+                displayed: false,
+                filterButtonDisplayed: false,
+                menu: {
+                    deleteDisplayed: false,
+                    displayed: false,
+                    enableDisplayed: false,
+                },
+                readonly: true,
+                settingsButtonDisplayed: false,
+            },
+            readonly: true,
+        },
+        panel: {
+            filterAccessDisplayed: false,
+            filterByDisplayed: false,
+            seeDataDisplayed: false,
+        },
+    };
+    return (0, mergeDeep_1.mergeDeep)(settings, newSettings);
+}
+/**
+ * Gets the filter settings when there are a default scope and other single scope
+ * @param {IFSettings} settings the given filter settings
+ * @returns a new filter settings object
+ */
+function getFilterSettingsByDefaultWithOneAdditionalScope(settings) {
+    const newSettings = {
+        filterPanel: {
+            body: {
+                dataset: {
+                    headerDisplayed: false,
+                },
+                scope: {
+                    headerDisplayed: false,
+                },
+            },
+            colorized: false,
+        },
+    };
+    return (0, mergeDeep_1.mergeDeep)(settings, newSettings);
+}
+/**
+ * Gets the filter settings when there is only the panel scope
+ * @param {IFSettings} settings the given filter settings
+ * @returns a new filter settings object
+ */
+function getFilterSettingsByOnlyPanelScope(settings) {
+    const newSettings = {
+        chartBuilder: {
+            addFilterDisplayed: false,
+            filterSectionDisplayed: false,
+        },
+    };
+    return (0, mergeDeep_1.mergeDeep)(settings, newSettings);
+}
+/**
+ * Gets the filter settings when there is only the data scope
+ * @param {IFSettings} settings the given filter settings
+ * @returns a new filter settings object
+ */
+function getFilterSettingsByOnlyDataScope(settings) {
+    const newSettings = {
+        filterDisplayer: {
+            addFilterDisplayed: false,
+            displayed: false,
+        },
+        panel: {
+            filterAccessDisplayed: false,
+            filterByDisplayed: false,
+            seeDataDisplayed: false,
+        },
+    };
+    return (0, mergeDeep_1.mergeDeep)(settings, newSettings);
+}
+/**
+ * Gets the filter settings when there are not general scopes allowed
+ * The general scopes could be the GLOBAL, PAGE, TAB and PANEL types.
+ * @param {IFSettings} settings the given filter settings
+ * @returns a new filter settings object
+ */
+function getFilterSettingsBySkippingGeneralScopes(settings) {
+    const newSettings = {
+        panel: {
+            filterAccessDisplayed: false,
+            filterByDisplayed: false,
+            seeDataDisplayed: false,
+        },
+        filterPanel: {
+            header: {
+                filterButtonDisplayed: false,
+                menu: {
+                    displayed: false,
+                },
+                settingsButtonDisplayed: false,
+            },
+        },
+    };
+    return (0, mergeDeep_1.mergeDeep)(settings, newSettings);
+}
+/**
+ * Gets the filter settings when there are no panel scopes and multiple scopes allowed.
+ * @param {IFSettings} settings the given filter settings
+ * @returns a new filter settings object
+ */
+function getFilterSettingsByMultipleNoPanelScopes(settings) {
+    const newSettings = {
+        filterDisplayer: {
+            addFilterDisplayed: false,
+        },
+        panel: {
+            filterAccessEnabled: false,
+        },
+    };
+    return (0, mergeDeep_1.mergeDeep)(settings, newSettings);
+}

package/dist/cjs/filters/helpers/settings/getScopeColorSetting.d.ts

@@ -0,0 +1,9 @@
+import { IFScope } from "../../interfaces/IFScope";
+import { IFSettings } from "../../interfaces/settings/IFSettings";
+/**
+ * Gets the color of the scope in the settings object
+ * @param {IFSettings} settings the filter settings
+ * @param {IFScope} scope the scope type
+ * @returns an string with the color.
+ */
+export declare function getScopeColorSetting(settings: IFSettings, scope: IFScope): string;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScopeColorSetting = void 0;
+const isEmpty_1 = require("../../../general/mix/isEmpty");
+const getScopeSettings_1 = require("./getScopeSettings");
+/**
+ * Gets the color of the scope in the settings object
+ * @param {IFSettings} settings the filter settings
+ * @param {IFScope} scope the scope type
+ * @returns an string with the color.
+ */
+function getScopeColorSetting(settings, scope) {
+    const defaultColor = "#C0C0C0";
+    const scopeSetting = (0, getScopeSettings_1.getScopeSettings)(settings, scope);
+    return !(0, isEmpty_1.isEmpty)(scopeSetting) && scopeSetting.colorized
+        ? scopeSetting.color
+        : defaultColor;
+}
+exports.getScopeColorSetting = getScopeColorSetting;

package/dist/cjs/filters/helpers/settings/getScopeSettings.d.ts

@@ -0,0 +1,10 @@
+import { IFScope } from "../../interfaces/IFScope";
+import { IFSettings } from "../../interfaces/settings/IFSettings";
+import { IFSettingsScope } from "../../interfaces/settings/IFSettingsScope";
+/**
+ * Gets the scope settings by the scope type
+ * @param {IFSettings} settings the filter settings
+ * @param {IFScope} scope the scope type
+ * @returns the scope settings
+ */
+export declare function getScopeSettings(settings: IFSettings, scope: IFScope): IFSettingsScope;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScopeSettings = void 0;
+const isEmpty_1 = require("../../../general/mix/isEmpty");
+const getScopesSettings_1 = require("./getScopesSettings");
+/**
+ * Gets the scope settings by the scope type
+ * @param {IFSettings} settings the filter settings
+ * @param {IFScope} scope the scope type
+ * @returns the scope settings
+ */
+function getScopeSettings(settings, scope) {
+    if ((0, isEmpty_1.isEmpty)(settings) || (0, isEmpty_1.isEmpty)(settings.scopes))
+        return;
+    return (0, getScopesSettings_1.getScopesSettings)(settings.scopes).find((_scope) => _scope.id === scope);
+}
+exports.getScopeSettings = getScopeSettings;

package/dist/cjs/filters/helpers/settings/getScopesSettings.d.ts

@@ -0,0 +1,8 @@
+import { IFSettingsScope } from "../../interfaces/settings/IFSettingsScope";
+import { IFSettingsScopes } from "../../interfaces/settings/IFSettingsScopes";
+/**
+ * Gets the scopes settings as array
+ * @param {IFSettingsScopes} scopes the scopes settings
+ * @returns an array of the scopes settings
+ */
+export declare function getScopesSettings(scopes: IFSettingsScopes): IFSettingsScope[];

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScopesSettings = void 0;
+const isEmpty_1 = require("../../../general/mix/isEmpty");
+/**
+ * Gets the scopes settings as array
+ * @param {IFSettingsScopes} scopes the scopes settings
+ * @returns an array of the scopes settings
+ */
+function getScopesSettings(scopes) {
+    if ((0, isEmpty_1.isEmpty)(scopes))
+        return [];
+    return Object.keys(scopes).map((scope) => (Object.assign(Object.assign({}, scopes[scope.toUpperCase()]), { id: scope.toUpperCase() })));
+}
+exports.getScopesSettings = getScopesSettings;

package/dist/cjs/filters/helpers/settings/getScopesToDisplay.d.ts

@@ -0,0 +1,8 @@
+import { IFSettings } from "../../interfaces/settings/IFSettings";
+import { IFSettingsScope } from "../../interfaces/settings/IFSettingsScope";
+/**
+ * Gets the scope allowed to display
+ * @param {IFSettings} settings the filter settings
+ * @returns an array of the scopes settings
+ */
+export declare function getScopesToDisplay(settings: IFSettings): IFSettingsScope[];

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScopesToDisplay = void 0;
+const isEmpty_1 = require("../../../general/mix/isEmpty");
+const getScopesSettings_1 = require("./getScopesSettings");
+/**
+ * Gets the scope allowed to display
+ * @param {IFSettings} settings the filter settings
+ * @returns an array of the scopes settings
+ */
+function getScopesToDisplay(settings) {
+    if ((0, isEmpty_1.isEmpty)(settings) || (0, isEmpty_1.isEmpty)(settings.scopes))
+        return [];
+    return (0, getScopesSettings_1.getScopesSettings)(settings.scopes).filter((scope) => scope.displayed);
+}
+exports.getScopesToDisplay = getScopesToDisplay;

package/dist/cjs/filters/helpers/settings/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./areMultipleScopesByProperties";
+export * from "./areMultipleScopesByProperty";
+export * from "./getFilterSettings";
+export * from "./getScopeColorSetting";
+export * from "./getScopeSettings";
+export * from "./getScopesSettings";
+export * from "./getScopesToDisplay";
+export * from "./isLeastSingleScopeByProperties";
+export * from "./isLeastSingleScopeByProperty";

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

@@ -0,0 +1,25 @@
+"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("./areMultipleScopesByProperties"), exports);
+__exportStar(require("./areMultipleScopesByProperty"), exports);
+__exportStar(require("./getFilterSettings"), exports);
+__exportStar(require("./getScopeColorSetting"), exports);
+__exportStar(require("./getScopeSettings"), exports);
+__exportStar(require("./getScopesSettings"), exports);
+__exportStar(require("./getScopesToDisplay"), exports);
+__exportStar(require("./isLeastSingleScopeByProperties"), exports);
+__exportStar(require("./isLeastSingleScopeByProperty"), exports);

package/dist/cjs/filters/helpers/settings/isLeastSingleScopeByProperties.d.ts

@@ -0,0 +1,9 @@
+import { IFSettings } from "../../interfaces/settings/IFSettings";
+/**
+ * Validates if the scope settings is satisfied by properties at least in one scope
+ * @param {IFSettings} settings the filter setting
+ * @param {string} scopeProperties the property or the string path of the scope settings
+ * @param {string} condition validate with AND or OR condition
+ * @returns true if there is one scope to be satisfied; false: none scopes to be satisfied
+ */
+export declare function isLeastSingleScopeByProperties(settings: IFSettings, scopeProperties: string[], condition?: "AND" | "OR"): boolean;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLeastSingleScopeByProperties = void 0;
+const isEmpty_1 = require("../../../general/mix/isEmpty");
+const get_1 = require("../../../general/object/get");
+const getScopesSettings_1 = require("./getScopesSettings");
+/**
+ * Validates if the scope settings is satisfied by properties at least in one scope
+ * @param {IFSettings} settings the filter setting
+ * @param {string} scopeProperties the property or the string path of the scope settings
+ * @param {string} condition validate with AND or OR condition
+ * @returns true if there is one scope to be satisfied; false: none scopes to be satisfied
+ */
+function isLeastSingleScopeByProperties(settings, scopeProperties, condition = "AND") {
+    if ((0, isEmpty_1.isEmpty)(settings) || (0, isEmpty_1.isEmpty)(settings.scopes))
+        return false;
+    const scopes = Object.keys(settings.scopes);
+    const conditionFunction = (scope) => (property) => (0, get_1._get)(scope, property, false);
+    return (scopes.length > 0 &&
+        (0, getScopesSettings_1.getScopesSettings)(settings.scopes).filter((scope) => condition === "AND"
+            ? scopeProperties.every(conditionFunction(scope))
+            : scopeProperties.some(conditionFunction(scope))).length > 0);
+}
+exports.isLeastSingleScopeByProperties = isLeastSingleScopeByProperties;

package/dist/cjs/filters/helpers/settings/isLeastSingleScopeByProperty.d.ts

@@ -0,0 +1,8 @@
+import { IFSettings } from "../../interfaces/settings/IFSettings";
+/**
+ * Validates if the scope settings is satisfied by a property at least in one scope
+ * @param {IFSettings} settings the filter setting
+ * @param {string} property the property or the string path of the scope settings
+ * @returns true if there is one scope to be satisfied; false: none scopes to be satisfied
+ */
+export declare function isLeastSingleScopeByProperty(settings: IFSettings, property: string): boolean;