nuxeo-development-framework 5.3.6 → 5.3.7

package/esm2015/lib/components/ndf-filters/services/dynamic-component-loader.service.js

@@ -0,0 +1,59 @@
+import { Injectable } from '@angular/core';
+import { AggregationAutocompleteComponent, AggregationCheckboxComponent, AggregationCustomComponent, AggregationDateListComponent, AggregationRadioComponent, AggregationSelectComponent, AggregationSwitchComponent, PredicateDateInputComponent, PredicateTextInputComponent } from '../components';
+import { AGGREGATION_FIELD_TYPES, CUSTOM_FIELD_TYPES, PREDICATE_FIELD_TYPES } from '../constants';
+import { ActiveUserSwitchComponent } from '../custom-components';
+import * as i0 from "@angular/core";
+export class DynamicComponentLoaderService {
+    constructor(_factoryResolver) {
+        this._factoryResolver = _factoryResolver;
+        this._components = new Map();
+        this._registerCustomComponent();
+        this._registerAggregationsComponents();
+        this._registerPredicateComponents();
+    }
+    registerComponent(key, component) {
+        this._components.set(key, component);
+    }
+    renderComponent(key, vcr) {
+        if (!this._components.has(key)) {
+            throw 'unknown component ';
+        }
+        const component = this._components.get(key);
+        return this.loadComponent(component, vcr);
+    }
+    loadComponent(componentAngularType, vcr) {
+        const component = this._factoryResolver.resolveComponentFactory(componentAngularType);
+        return vcr.createComponent(component);
+    }
+    //------
+    // CUSTOM
+    //------
+    _registerCustomComponent() {
+        this.registerComponent(CUSTOM_FIELD_TYPES.activeUser, ActiveUserSwitchComponent);
+    }
+    //------
+    // AGGREGATION
+    //------
+    _registerAggregationsComponents() {
+        this.registerComponent(AGGREGATION_FIELD_TYPES.autocomplete, AggregationAutocompleteComponent);
+        this.registerComponent(AGGREGATION_FIELD_TYPES.dropdown, AggregationSelectComponent);
+        this.registerComponent(AGGREGATION_FIELD_TYPES.switch, AggregationSwitchComponent);
+        this.registerComponent(AGGREGATION_FIELD_TYPES.radio, AggregationRadioComponent);
+        this.registerComponent(AGGREGATION_FIELD_TYPES.dateList, AggregationDateListComponent);
+        this.registerComponent(AGGREGATION_FIELD_TYPES.custom, AggregationCustomComponent);
+        this.registerComponent(AGGREGATION_FIELD_TYPES.checkbox, AggregationCheckboxComponent);
+    }
+    //------
+    // PREDICATE
+    //------
+    _registerPredicateComponents() {
+        this.registerComponent(PREDICATE_FIELD_TYPES.input, PredicateTextInputComponent);
+        this.registerComponent(PREDICATE_FIELD_TYPES.date, PredicateDateInputComponent);
+    }
+}
+DynamicComponentLoaderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DynamicComponentLoaderService, deps: [{ token: i0.ComponentFactoryResolver }], target: i0.ɵɵFactoryTarget.Injectable });
+DynamicComponentLoaderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DynamicComponentLoaderService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DynamicComponentLoaderService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.ComponentFactoryResolver }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/ndf-filters/services/filters-mapper.service.js

@@ -0,0 +1,60 @@
+import { Injectable } from '@angular/core';
+import { FIELD_SEND_MODE } from '../constants';
+import { isFieldValueObject, NxQlQuery } from '../utility';
+import * as i0 from "@angular/core";
+export class FiltersMapperService {
+    preparePayload(fields, criteria) {
+        return this._preparePayload(fields, criteria);
+    }
+    _preparePayload(fields, criteria) {
+        const params = {};
+        const predicateList = [];
+        const payload = {};
+        for (const field of fields) {
+            const fieldValue = criteria[field.config.fieldKey];
+            const paramKey = field.type == 'aggregation' ? field.config.aggregation : field.config.fieldKey;
+            if (!fieldValue) {
+                continue;
+            }
+            if ((this._sendInPayload(field) || this._sendCustom(field)) && isFieldValueObject(fieldValue)) {
+                const _data = NxQlQuery.preparePayloadItem(fieldValue, field);
+                predicateList.push(_data);
+                continue;
+            }
+            if (this._sendInPayload(field)) {
+                payload[paramKey] = this._stringifyValue(fieldValue);
+            }
+            if (this._sendCustom(field) || this._sendInQueryParams(field)) {
+                params[paramKey] = this._stringifyValue(fieldValue);
+            }
+        }
+        return {
+            params,
+            payload: Object.assign(Object.assign({}, payload), { predicateList })
+        };
+    }
+    _stringifyValue(value) {
+        return Array.isArray(value) ? JSON.stringify(value) : value;
+    }
+    _sendInQueryParams(field) {
+        var _a;
+        return ((_a = field.config) === null || _a === void 0 ? void 0 : _a.sendMode) === FIELD_SEND_MODE.queryParam;
+    }
+    _sendInPayload(field) {
+        var _a;
+        return ((_a = field.config) === null || _a === void 0 ? void 0 : _a.sendMode) === FIELD_SEND_MODE.payload;
+    }
+    _sendCustom(field) {
+        var _a;
+        return ((_a = field.config) === null || _a === void 0 ? void 0 : _a.sendMode) === FIELD_SEND_MODE.custom;
+    }
+}
+FiltersMapperService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FiltersMapperService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FiltersMapperService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FiltersMapperService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FiltersMapperService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/ndf-filters/services/filters-query.service.js

@@ -0,0 +1,117 @@
+import { Injectable } from '@angular/core';
+import { VALUE_OBJECT } from '../constants';
+import * as i0 from "@angular/core";
+export class FilterQueryService {
+    constructor() {
+        this.keyToShortMap = new Map();
+        this.shortToKeyMap = new Map();
+        this.defaultShortKeys = {
+            value: 'v',
+            operator: 'o',
+            min: 'n',
+            max: 'x',
+            prefix: 'p'
+        };
+        this.initializeDefaultKeys();
+    }
+    registerKeys(keys) {
+        Object.entries(keys).forEach(([key, value]) => this.registerKey(key, value));
+    }
+    registerKey(longKey, shortKey) {
+        this.keyToShortMap.set(longKey, shortKey);
+        this.shortToKeyMap.set(shortKey, longKey);
+    }
+    /**
+     * Encodes a query object into a URL-safe string by transforming its keys
+     * and converting it to a JSON string.
+     *
+     * @param {Record<string, any>} query - The query object to encode.
+     *
+     * @example
+     * // Example query object
+     * const query = {
+     *   // Predicate field (payload sent)
+     *   'locRef:boxCode': {
+     *     value: '1',
+     *     operator: 'LIKE',
+     *   },
+     *
+     *   // Aggregation field (query parameter)
+     *   'locRef:boxCode': [1]
+     * };
+     *
+     * const encodedQuery = encodeQuery(query);
+     * console.log(encodedQuery); // Encoded string representation
+     *
+     * @returns {string} - The URL-encoded JSON string representation of the query object.
+     */
+    encodeQuery(query) {
+        const transformed = this.transformObject(query, this.keyToShortMap, false);
+        return encodeURIComponent(JSON.stringify(transformed));
+    }
+    /**
+     * Decodes a URL-encoded query string back into its original object form.
+     *
+     * @param {string} encodedQuery - The URL-encoded JSON string representation of a query.
+     *
+     * @example
+     * const encodedQuery = "%7B%22locRef%3AboxCode%22%3A%7B%22value%22%3A%221%22%2C%22operator%22%3A%22LIKE%22%7D%7D";
+     * const decodedQuery = decodeQuery(encodedQuery);
+     * console.log(decodedQuery);
+     * Output:
+     * {
+     *   'locRef:boxCode': {
+     *     value: '1',
+     *     operator: 'LIKE'
+     *   }
+     * }
+     *
+     * @returns {Record<string, any> | null} - The decoded query object, or `null` if decoding fails.
+     */
+    decodeQuery(encodedQuery) {
+        try {
+            const parsedQuery = JSON.parse(decodeURIComponent(encodedQuery));
+            return this.transformObject(parsedQuery, this.shortToKeyMap, true);
+        }
+        catch (error) {
+            console.error('Failed to decode query:', error);
+            return null;
+        }
+    }
+    initializeDefaultKeys() {
+        Object.entries(this.defaultShortKeys).forEach(([longKey, shortKey]) => {
+            this.registerKey(longKey, shortKey);
+        });
+    }
+    transformObject(entry, keyMap, isDecode) {
+        if (Array.isArray(entry)) {
+            return entry.map((item) => this.transformObject(item, keyMap, isDecode));
+        }
+        if (entry && typeof entry === 'object') {
+            if (!isDecode) {
+                delete entry[VALUE_OBJECT];
+            }
+            return Object.keys(entry).reduce((acc, key) => {
+                const newKey = keyMap.get(key);
+                if (!newKey) {
+                    throw new Error(`Query key mapping not found for: ${key}`);
+                }
+                if (isDecode && newKey === 'operator') {
+                    acc[VALUE_OBJECT] = `${VALUE_OBJECT}`;
+                }
+                acc[newKey] = this.transformObject(entry[key], keyMap, isDecode);
+                return acc;
+            }, {});
+        }
+        return entry;
+    }
+}
+FilterQueryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FilterQueryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FilterQueryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FilterQueryService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FilterQueryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filters-query.service.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/components/ndf-filters/services/filters-query.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { VALUE_OBJECT } from '../constants';\r\n\r\n@Injectable({\r\n\tprovidedIn: 'root'\r\n})\r\nexport class FilterQueryService {\r\n\tprivate readonly keyToShortMap = new Map<string, string>();\r\n\tprivate readonly shortToKeyMap = new Map<string, string>();\r\n\r\n\tprivate readonly defaultShortKeys: Record<string, string> = {\r\n\t\tvalue: 'v',\r\n\t\toperator: 'o',\r\n\t\tmin: 'n',\r\n\t\tmax: 'x',\r\n\t\tprefix: 'p'\r\n\t};\r\n\r\n\tconstructor() {\r\n\t\tthis.initializeDefaultKeys();\r\n\t}\r\n\r\n\tregisterKeys(keys: Record<string, string>): void {\r\n\t\tObject.entries(keys).forEach(([key, value]) => this.registerKey(key, value));\r\n\t}\r\n\r\n\tregisterKey(longKey: string, shortKey: string): void {\r\n\t\tthis.keyToShortMap.set(longKey, shortKey);\r\n\t\tthis.shortToKeyMap.set(shortKey, longKey);\r\n\t}\r\n\r\n\t/**\r\n\t * Encodes a query object into a URL-safe string by transforming its keys\r\n\t * and converting it to a JSON string.\r\n\t *\r\n\t * @param {Record<string, any>} query - The query object to encode.\r\n\t *\r\n\t * @example\r\n\t * // Example query object\r\n\t * const query = {\r\n\t *   // Predicate field (payload sent)\r\n\t *   'locRef:boxCode': {\r\n\t *     value: '1',\r\n\t *     operator: 'LIKE',\r\n\t *   },\r\n\t *\r\n\t *   // Aggregation field (query parameter)\r\n\t *   'locRef:boxCode': [1]\r\n\t * };\r\n\t *\r\n\t * const encodedQuery = encodeQuery(query);\r\n\t * console.log(encodedQuery); // Encoded string representation\r\n\t *\r\n\t * @returns {string} - The URL-encoded JSON string representation of the query object.\r\n\t */\r\n\tencodeQuery(query: Record<string, any>): string {\r\n\t\tconst transformed = this.transformObject(query, this.keyToShortMap, false);\r\n\t\treturn encodeURIComponent(JSON.stringify(transformed));\r\n\t}\r\n\r\n\t/**\r\n\t * Decodes a URL-encoded query string back into its original object form.\r\n\t *\r\n\t * @param {string} encodedQuery - The URL-encoded JSON string representation of a query.\r\n\t *\r\n\t * @example\r\n\t * const encodedQuery = \"%7B%22locRef%3AboxCode%22%3A%7B%22value%22%3A%221%22%2C%22operator%22%3A%22LIKE%22%7D%7D\";\r\n\t * const decodedQuery = decodeQuery(encodedQuery);\r\n\t * console.log(decodedQuery);\r\n\t * Output:\r\n\t * {\r\n\t *   'locRef:boxCode': {\r\n\t *     value: '1',\r\n\t *     operator: 'LIKE'\r\n\t *   }\r\n\t * }\r\n\t *\r\n\t * @returns {Record<string, any> | null} - The decoded query object, or `null` if decoding fails.\r\n\t */\r\n\r\n\tdecodeQuery(encodedQuery: string): Record<string, any> | null {\r\n\t\ttry {\r\n\t\t\tconst parsedQuery = JSON.parse(decodeURIComponent(encodedQuery));\r\n\t\t\treturn this.transformObject(parsedQuery, this.shortToKeyMap, true);\r\n\t\t} catch (error) {\r\n\t\t\tconsole.error('Failed to decode query:', error);\r\n\t\t\treturn null;\r\n\t\t}\r\n\t}\r\n\r\n\tprivate initializeDefaultKeys(): void {\r\n\t\tObject.entries(this.defaultShortKeys).forEach(([longKey, shortKey]) => {\r\n\t\t\tthis.registerKey(longKey, shortKey);\r\n\t\t});\r\n\t}\r\n\r\n\tprivate transformObject(entry: any, keyMap: Map<string, string>, isDecode: boolean): any {\r\n\t\tif (Array.isArray(entry)) {\r\n\t\t\treturn entry.map((item) => this.transformObject(item, keyMap, isDecode));\r\n\t\t}\r\n\r\n\t\tif (entry && typeof entry === 'object') {\r\n\t\t\tif (!isDecode) {\r\n\t\t\t\tdelete entry[VALUE_OBJECT];\r\n\t\t\t}\r\n\t\t\treturn Object.keys(entry).reduce(\r\n\t\t\t\t(acc, key) => {\r\n\t\t\t\t\tconst newKey = keyMap.get(key);\r\n\t\t\t\t\tif (!newKey) {\r\n\t\t\t\t\t\tthrow new Error(`Query key mapping not found for: ${key}`);\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif (isDecode && newKey === 'operator') {\r\n\t\t\t\t\t\tacc[VALUE_OBJECT] = `${VALUE_OBJECT}`;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tacc[newKey] = this.transformObject(entry[key], keyMap, isDecode);\r\n\t\t\t\t\treturn acc;\r\n\t\t\t\t},\r\n\t\t\t\t{} as Record<string, any>\r\n\t\t\t);\r\n\t\t}\r\n\r\n\t\treturn entry;\r\n\t}\r\n}\r\n"]}

package/esm2015/lib/components/ndf-filters/services/index.js

@@ -0,0 +1,5 @@
+export * from './aggregation-field.service';
+export * from './dynamic-component-loader.service';
+export * from './filters-query.service';
+export * from './filters-mapper.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9udXhlby1kZXZlbG9wbWVudC1mcmFtZXdvcmsvc3JjL2xpYi9jb21wb25lbnRzL25kZi1maWx0ZXJzL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxvQ0FBb0MsQ0FBQztBQUNuRCxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsMEJBQTBCLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2FnZ3JlZ2F0aW9uLWZpZWxkLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2R5bmFtaWMtY29tcG9uZW50LWxvYWRlci5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9maWx0ZXJzLXF1ZXJ5LnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2ZpbHRlcnMtbWFwcGVyLnNlcnZpY2UnXHJcbiJdfQ==

package/esm2015/lib/components/ndf-filters/utility/index.js

@@ -0,0 +1,4 @@
+export * from './nxql';
+export * from './object';
+export * from './nxql-query';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9udXhlby1kZXZlbG9wbWVudC1mcmFtZXdvcmsvc3JjL2xpYi9jb21wb25lbnRzL25kZi1maWx0ZXJzL3V0aWxpdHkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxRQUFRLENBQUM7QUFDdkIsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxjQUFjLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL254cWwnO1xyXG5leHBvcnQgKiBmcm9tICcuL29iamVjdCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbnhxbC1xdWVyeSdcclxuIl19

package/esm2015/lib/components/ndf-filters/utility/nxql-query.js

@@ -0,0 +1,53 @@
+import { COMPARISON_OPERATOR } from "../constants";
+import { NxQL } from './nxql';
+export class NxQlQuery extends NxQL {
+    static preparePayloadItem(value, field) {
+        var _a;
+        const _defaultOperator = field.type == 'aggregation' ? COMPARISON_OPERATOR.in : COMPARISON_OPERATOR.like;
+        const _fieldName = field.config.fieldKey;
+        const _operator = (value === null || value === void 0 ? void 0 : value.operator) || ((_a = field.config) === null || _a === void 0 ? void 0 : _a.operator) || _defaultOperator;
+        return {
+            name: _fieldName,
+            operator: _operator,
+            value: NxQlQuery.prepareValueByOperator(_operator, value)
+        };
+    }
+    static prepareValueByOperator(operator, fieldValue) {
+        const _opr = COMPARISON_OPERATOR;
+        const { value, prefix } = fieldValue;
+        if (operator === _opr.between) {
+            return NxQlQuery._getMinMaxRange(fieldValue, prefix);
+        }
+        const operatorHandlers = {
+            [_opr.equals]: NxQlQuery.equals,
+            [_opr.notEquals]: NxQlQuery.equals,
+            [_opr.lessThan]: NxQlQuery.equals,
+            [_opr.greaterThan]: NxQlQuery.equals,
+            [_opr.in]: NxQlQuery.in,
+            [_opr.notIn]: NxQlQuery.in,
+            [_opr.lessThanOrEqual]: NxQlQuery.equals,
+            [_opr.greaterThanOrEqual]: NxQlQuery.equals,
+            [_opr.like]: NxQlQuery.like,
+            [_opr.iLike]: NxQlQuery.like,
+            [_opr.notLike]: NxQlQuery.like,
+            [_opr.notILike]: NxQlQuery.like,
+            [_opr.startsWith]: NxQlQuery.equals,
+            [_opr.fullText]: NxQlQuery.equals
+        };
+        const _val = Array.isArray(value) ? value.join(',') : value;
+        return operatorHandlers[operator](_val, prefix);
+    }
+    static equals(value, prefix = '') {
+        return `${prefix ? `${prefix} ` : ''}'${value.trim()}'`;
+    }
+    static like(value, prefix = '') {
+        return `${prefix ? `${prefix} ` : ''}'%${value.trim()}%'`;
+    }
+    static in(value, prefix = '') {
+        return `${prefix ? `${prefix} ` : ''}(${value.trim()})`;
+    }
+    static between(value1, value2) {
+        return `${value1} AND ${value2}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/ndf-filters/utility/nxql.js

@@ -0,0 +1,47 @@
+import { COMPARISON_OPERATOR } from '../constants';
+import { FieldValueObject } from '../models';
+export class NxQL {
+    static _getDateRange(value) {
+        return NxQL._getMinMaxRange(value, 'DATE');
+    }
+    static _getMinMaxRange(value, prefix = '') {
+        const { min, max } = value;
+        if (min && max) {
+            return `${prefix} '${min}' AND ${prefix} '${max}'`;
+        }
+        if (max) {
+            return `${prefix} '${max}'`;
+        }
+        if (min) {
+            return `${prefix} '${min}'`;
+        }
+        return '';
+    }
+    static _getRangeOperator(value) {
+        const { min, max } = value;
+        if (min && max) {
+            return COMPARISON_OPERATOR.between;
+        }
+        if (max) {
+            return COMPARISON_OPERATOR.lessThan;
+        }
+        if (min) {
+            return COMPARISON_OPERATOR.greaterThan;
+        }
+        return null;
+    }
+    static _getValueRange(value, prefix = '', operator) {
+        const { min, max } = value;
+        const baseObject = { value: '', prefix, operator };
+        if (min && max) {
+            return new FieldValueObject(Object.assign(Object.assign({}, baseObject), { value: `${prefix} '${min}' AND ${prefix} '${max}'`, min: `${min}`, max: `${max}` }));
+        }
+        if (max) {
+            return new FieldValueObject(Object.assign(Object.assign({}, baseObject), { value: `${max}`, max: `${max}` }));
+        }
+        if (min) {
+            return new FieldValueObject(Object.assign(Object.assign({}, baseObject), { value: `${min}`, min: `${min}` }));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/ndf-filters/utility/object.js

@@ -0,0 +1,42 @@
+import { isBoolean, isDate, isNumber, isObject } from 'lodash';
+import { VALUE_OBJECT } from '../constants';
+export function isFieldValueObject(value) {
+    return typeof value === 'object' && (value[VALUE_OBJECT] || ('value' in value && 'operator' in value));
+}
+export function isDateObject(obj) {
+    return (obj &&
+        typeof obj === 'object' &&
+        'min' in obj &&
+        'max' in obj &&
+        typeof obj.min === 'string' &&
+        typeof obj.max === 'string');
+}
+export function removeEmptyKeys(data) {
+    return Object.entries(data || {}).reduce((obj, [key, value]) => {
+        if (Array.isArray(value)) {
+            const cleanedArray = value
+                .map((item) => (isObject(value) ? removeEmptyKeys(item) : item))
+                .filter(shouldIncludeValue);
+            if (cleanedArray.length > 0) {
+                obj[key] = cleanedArray;
+            }
+        }
+        if (isObject(value) && !isDate(value) && !Array.isArray(value)) {
+            const cleanedValue = removeEmptyKeys(value);
+            if (Object.keys(cleanedValue).length > 0) {
+                obj[key] = cleanedValue;
+            }
+        }
+        else if (shouldIncludeValue(value)) {
+            obj[key] = value;
+        }
+        return obj;
+    }, {});
+}
+function shouldIncludeValue(value) {
+    if (Array.isArray(value) && value.length > 0) {
+        return value.some((item) => shouldIncludeValue(item));
+    }
+    return !Array.isArray(value) && (!!value || isBoolean(value) || isNumber(value) || isDate(value));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/ndf-tabs/tab.type.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFiLnR5cGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9udXhlby1kZXZlbG9wbWVudC1mcmFtZXdvcmsvc3JjL2xpYi9jb21wb25lbnRzL25kZi10YWJzL3RhYi50eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQcmV0dGlmeSB9IGZyb20gJy4uL3RhYmxlcyc7XHJcblxyXG50eXBlIEJhc2VUYWJUeXBlPFQ+ID0ge1xyXG5cdGlkOiBUO1xyXG5cdGxhYmVsOiBzdHJpbmc7XHJcblx0cGVybWlzc2lvbj86IHN0cmluZztcclxufTtcclxuXHJcbnR5cGUgU2Vjb25kYXJ5VGFic1R5cGU8VD4gPSBCYXNlVGFiVHlwZTxUPjtcclxuXHJcbmV4cG9ydCB0eXBlIFRhYlR5cGU8VD4gPSBQcmV0dGlmeTxcclxuXHRCYXNlVGFiVHlwZTxUPiAmIHtcclxuXHRcdHF1aWNrRmlsdGVycz86IHN0cmluZztcclxuXHRcdGlzRW5hYmxlPzogYm9vbGVhbjtcclxuXHRcdGFsbG93ZWRXaXRob3V0UGVybWlzc2lvbnM/OiBib29sZWFuO1xyXG5cdFx0c2Vjb25kYXJ5X3RhYnM/OiBTZWNvbmRhcnlUYWJzVHlwZTxUPltdO1xyXG5cdH1cclxuPjtcclxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFiLnR5cGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9udXhlby1kZXZlbG9wbWVudC1mcmFtZXdvcmsvc3JjL2xpYi9jb21wb25lbnRzL25kZi10YWJzL3RhYi50eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQcmV0dGlmeSB9IGZyb20gJy4uLy4uL3NoYXJlZC9tb2RlbHMnO1xyXG5cclxuXHJcbnR5cGUgQmFzZVRhYlR5cGU8VD4gPSB7XHJcblx0aWQ6IFQ7XHJcblx0bGFiZWw6IHN0cmluZztcclxuXHRwZXJtaXNzaW9uPzogc3RyaW5nO1xyXG59O1xyXG5cclxudHlwZSBTZWNvbmRhcnlUYWJzVHlwZTxUPiA9IEJhc2VUYWJUeXBlPFQ+O1xyXG5cclxuZXhwb3J0IHR5cGUgVGFiVHlwZTxUPiA9IFByZXR0aWZ5PFxyXG5cdEJhc2VUYWJUeXBlPFQ+ICYge1xyXG5cdFx0cXVpY2tGaWx0ZXJzPzogc3RyaW5nO1xyXG5cdFx0aXNFbmFibGU/OiBib29sZWFuO1xyXG5cdFx0YWxsb3dlZFdpdGhvdXRQZXJtaXNzaW9ucz86IGJvb2xlYW47XHJcblx0XHRzZWNvbmRhcnlfdGFicz86IFNlY29uZGFyeVRhYnNUeXBlPFQ+W107XHJcblx0fVxyXG4+O1xyXG4iXX0=