@zeedhi/teknisa-components-common 1.79.0 → 1.79.1

package/dist/tek-components-common.esm.js

@@ -1,4 +1,4 @@
-import { KeyMap, I18n, FormatterParserProvider, Messages, Metadata, DatasourceFactory, RestDatasource, URL, MemoryDatasource, Utils, Loader, Config, Http, DateHelper, Singleton, VersionService } from '@zeedhi/core';
+import { KeyMap, I18n, FormatterParserProvider, Messages, Metadata, DatasourceFactory, MemoryDatasource, URL, Utils, RestDatasource, Loader, Config, Http, DateHelper, Singleton, VersionService } from '@zeedhi/core';
 import { Form, Button, Tooltip, GridEditable, Grid, ComponentRender, Iterable, Carousel, IterableComponentRender as IterableComponentRender$1, Loading as Loading$1, ModalService, GridColumnEditable, Report, ColumnNotFoundError, IterableColumnsButtonController, IterableColumnsButton, TreeGridEditable, List } from '@zeedhi/common';
 import debounce from 'lodash.debounce';
 import merge from 'lodash.merge';
@@ -1006,6 +1006,7 @@ class GridBase {
                                     {
                                         name: `${this.grid.name}-filter-title`,
                                         component: 'ZdText',
+                                        cssStyle: `color: ${'var(--v-primary-base);'}`,
                                         text: `${mergeModalFilterProps.title}`,
                                         tag: 'h3',
                                     },
@@ -1646,13 +1647,13 @@ const DynamicFilterRelations = {
     OR: true,
 };
 
-class TekRestDatasource extends RestDatasource {
+class TekMemoryDatasource extends MemoryDatasource {
     /**
      * Create new datasource
      * @param props Datasource properties
      */
     constructor(props) {
-        super(Object.assign(Object.assign({}, props), { lazyLoad: true }));
+        super(props);
         /**
          * Dynamic Filter Operations
          */
@@ -1669,13 +1670,10 @@ class TekRestDatasource extends RestDatasource {
             this.dynamicFilter = this.getInitValue('dynamicFilter', props.dynamicFilter, {});
             this.searchJoin = this.getInitValue('searchJoin', props.searchJoin, {});
         }
-        this.lazyLoad = this.getInitValue('lazyLoad', props.lazyLoad, this.lazyLoad);
         this.createAccessors();
         this.createObjAccessors(this.dynamicFilter, 'dynamicFilter');
         this.createObjAccessors(this.searchJoin, 'searchJoin');
-        if (!this.lazyLoad) {
-            this.get();
-        }
+        this.get();
     }
     updateReservedKeys() {
         this.reservedKeys.dynamic_filter = true;
@@ -1804,37 +1802,124 @@ class TekRestDatasource extends RestDatasource {
                 && this.dynamicFilterRelations[filterValue.relation]
                 && filterValue.value !== '' && filterValue.value !== null);
     }
+    clone() {
+        return Object.assign(Object.assign({}, super.clone()), { dynamicFilter: this.dynamicFilter, searchJoin: this.searchJoin, type: 'tek-memory' });
+    }
     /**
-     * Retrieves request params
+     * Updates filtered data
      */
-    getRequestParams() {
-        const requestParams = super.getRequestParams();
-        const isNotEmptyObj = (obj) => !!(obj && Object.keys(obj).length);
-        const isValid = this.dynamicFilter && Object.keys(this.dynamicFilter).every((column) => {
-            const value = this.dynamicFilter[column];
-            return value && value.length > 0 && this.isValidDynamicFilterValue(column, value);
-        });
-        if (isNotEmptyObj(this.dynamicFilter) && isValid) {
-            requestParams.dynamic_filter = btoa(JSON.stringify(this.dynamicFilter));
+    updateFilteredData() {
+        // first apply filters (simple and dynamic)
+        this.filteredData = Object.keys(this.filter).length
+            ? this.allData.filter((row) => this.getRowByFilter(row))
+            : Array.from(this.allData);
+        if (this.dynamicFilter && Object.keys(this.dynamicFilter).length) {
+            this.filteredData = this.filteredData.filter((row) => this.getRowByDynamicFilter(row));
         }
-        if (isNotEmptyObj(this.searchJoin)) {
-            requestParams.search_join = btoa(JSON.stringify(this.searchJoin));
+        const searchWithoutSearchJoin = (row) => {
+            const searchRow = Object.assign({}, row);
+            if (this.searchJoin) {
+                // do not search on columns with searchJoin
+                Object.keys(this.searchJoin).forEach((key) => delete searchRow[key]);
+            }
+            return this.getRowBySearch(searchRow);
+        };
+        // only after do the search
+        const searchData = this.search
+            ? this.filteredData.filter(searchWithoutSearchJoin)
+            : this.filteredData;
+        let searchIds = searchData.map((row) => row[this.uniqueKey]);
+        if (this.searchJoin && Object.keys(this.searchJoin).length) {
+            const searchJoinData = this.filteredData.filter((row) => this.getRowBySearchJoin(row));
+            // get the ids from search and searchJoin
+            searchIds = searchIds
+                .concat(searchJoinData.map((row) => row[this.uniqueKey]))
+                .sort();
         }
-        return requestParams;
+        // filter filteredData using searchIds
+        this.filteredData = this.allData.filter((row) => searchIds.indexOf(row[this.uniqueKey]) !== -1);
     }
-    clone() {
-        return Object.assign(Object.assign({}, super.clone()), { dynamicFilter: this.dynamicFilter, searchJoin: this.searchJoin, type: 'tek-rest' });
+    getRowByDynamicFilter(row) {
+        let filtered;
+        try {
+            Object.keys(this.dynamicFilter).forEach((key) => {
+                const filterItems = this.dynamicFilter[key];
+                filterItems.forEach((item) => {
+                    if (filtered === false && item.relation === 'AND')
+                        return;
+                    if (filtered === true && item.relation === 'OR')
+                        return;
+                    const columnValue = Utils.normalize(row[key].toString());
+                    let value = '';
+                    if (Array.isArray(item.value)) {
+                        value = item.value.map((val) => Utils.normalize(val.toString()));
+                        switch (item.operation) {
+                            case 'IN':
+                                filtered = value.includes(columnValue);
+                                break;
+                            case 'NOT_IN':
+                                filtered = !value.includes(columnValue);
+                                break;
+                            case 'BETWEEN':
+                                filtered = (Number(columnValue) || columnValue) >= (Number(value[0]) || value[0])
+                                    && (Number(columnValue) || columnValue) <= (Number(value[1]) || value[1]);
+                                break;
+                            default:
+                                break;
+                        }
+                    }
+                    else {
+                        value = Utils.normalize(item.value.toString());
+                        switch (item.operation) {
+                            case 'CONTAINS':
+                                filtered = columnValue.indexOf(value) !== -1;
+                                break;
+                            case 'NOT_CONTAINS':
+                                filtered = columnValue.indexOf(value) === -1;
+                                break;
+                            case 'EQUALS':
+                                filtered = columnValue === value;
+                                break;
+                            case 'NOT_EQUALS':
+                                filtered = columnValue !== value;
+                                break;
+                            case 'GREATER_THAN':
+                                filtered = (Number(columnValue) || columnValue) > (Number(value) || value);
+                                break;
+                            case 'LESS_THAN':
+                                filtered = (Number(columnValue) || columnValue) < (Number(value) || value);
+                                break;
+                            case 'GREATER_THAN_EQUALS':
+                                filtered = (Number(columnValue) || columnValue) >= (Number(value) || value);
+                                break;
+                            case 'LESS_THAN_EQUALS':
+                                filtered = (Number(columnValue) || columnValue) <= (Number(value) || value);
+                                break;
+                            default:
+                                break;
+                        }
+                    }
+                });
+            });
+        }
+        catch (_a) {
+            // do nothing
+        }
+        return filtered;
+    }
+    getRowBySearchJoin(row) {
+        return Object.keys(this.searchJoin).some((key) => this.searchJoin[key].includes(row[key]));
     }
 }
-DatasourceFactory.register('tek-rest', TekRestDatasource);
+DatasourceFactory.register('tek-memory', TekMemoryDatasource);
 
-class TekMemoryDatasource extends MemoryDatasource {
+class TekRestDatasource extends RestDatasource {
     /**
      * Create new datasource
      * @param props Datasource properties
      */
     constructor(props) {
-        super(props);
+        super(Object.assign(Object.assign({}, props), { lazyLoad: true }));
         /**
          * Dynamic Filter Operations
          */
@@ -1851,10 +1936,13 @@ class TekMemoryDatasource extends MemoryDatasource {
             this.dynamicFilter = this.getInitValue('dynamicFilter', props.dynamicFilter, {});
             this.searchJoin = this.getInitValue('searchJoin', props.searchJoin, {});
         }
+        this.lazyLoad = this.getInitValue('lazyLoad', props.lazyLoad, this.lazyLoad);
         this.createAccessors();
         this.createObjAccessors(this.dynamicFilter, 'dynamicFilter');
         this.createObjAccessors(this.searchJoin, 'searchJoin');
-        this.get();
+        if (!this.lazyLoad) {
+            this.get();
+        }
     }
     updateReservedKeys() {
         this.reservedKeys.dynamic_filter = true;
@@ -1983,116 +2071,29 @@ class TekMemoryDatasource extends MemoryDatasource {
                 && this.dynamicFilterRelations[filterValue.relation]
                 && filterValue.value !== '' && filterValue.value !== null);
     }
-    clone() {
-        return Object.assign(Object.assign({}, super.clone()), { dynamicFilter: this.dynamicFilter, searchJoin: this.searchJoin, type: 'tek-memory' });
-    }
     /**
-     * Updates filtered data
+     * Retrieves request params
      */
-    updateFilteredData() {
-        // first apply filters (simple and dynamic)
-        this.filteredData = Object.keys(this.filter).length
-            ? this.allData.filter((row) => this.getRowByFilter(row))
-            : Array.from(this.allData);
-        if (this.dynamicFilter && Object.keys(this.dynamicFilter).length) {
-            this.filteredData = this.filteredData.filter((row) => this.getRowByDynamicFilter(row));
-        }
-        const searchWithoutSearchJoin = (row) => {
-            const searchRow = Object.assign({}, row);
-            if (this.searchJoin) {
-                // do not search on columns with searchJoin
-                Object.keys(this.searchJoin).forEach((key) => delete searchRow[key]);
-            }
-            return this.getRowBySearch(searchRow);
-        };
-        // only after do the search
-        const searchData = this.search
-            ? this.filteredData.filter(searchWithoutSearchJoin)
-            : this.filteredData;
-        let searchIds = searchData.map((row) => row[this.uniqueKey]);
-        if (this.searchJoin && Object.keys(this.searchJoin).length) {
-            const searchJoinData = this.filteredData.filter((row) => this.getRowBySearchJoin(row));
-            // get the ids from search and searchJoin
-            searchIds = searchIds
-                .concat(searchJoinData.map((row) => row[this.uniqueKey]))
-                .sort();
-        }
-        // filter filteredData using searchIds
-        this.filteredData = this.allData.filter((row) => searchIds.indexOf(row[this.uniqueKey]) !== -1);
-    }
-    getRowByDynamicFilter(row) {
-        let filtered;
-        try {
-            Object.keys(this.dynamicFilter).forEach((key) => {
-                const filterItems = this.dynamicFilter[key];
-                filterItems.forEach((item) => {
-                    if (filtered === false && item.relation === 'AND')
-                        return;
-                    if (filtered === true && item.relation === 'OR')
-                        return;
-                    const columnValue = Utils.normalize(row[key].toString());
-                    let value = '';
-                    if (Array.isArray(item.value)) {
-                        value = item.value.map((val) => Utils.normalize(val.toString()));
-                        switch (item.operation) {
-                            case 'IN':
-                                filtered = value.includes(columnValue);
-                                break;
-                            case 'NOT_IN':
-                                filtered = !value.includes(columnValue);
-                                break;
-                            case 'BETWEEN':
-                                filtered = (Number(columnValue) || columnValue) >= (Number(value[0]) || value[0])
-                                    && (Number(columnValue) || columnValue) <= (Number(value[1]) || value[1]);
-                                break;
-                            default:
-                                break;
-                        }
-                    }
-                    else {
-                        value = Utils.normalize(item.value.toString());
-                        switch (item.operation) {
-                            case 'CONTAINS':
-                                filtered = columnValue.indexOf(value) !== -1;
-                                break;
-                            case 'NOT_CONTAINS':
-                                filtered = columnValue.indexOf(value) === -1;
-                                break;
-                            case 'EQUALS':
-                                filtered = columnValue === value;
-                                break;
-                            case 'NOT_EQUALS':
-                                filtered = columnValue !== value;
-                                break;
-                            case 'GREATER_THAN':
-                                filtered = (Number(columnValue) || columnValue) > (Number(value) || value);
-                                break;
-                            case 'LESS_THAN':
-                                filtered = (Number(columnValue) || columnValue) < (Number(value) || value);
-                                break;
-                            case 'GREATER_THAN_EQUALS':
-                                filtered = (Number(columnValue) || columnValue) >= (Number(value) || value);
-                                break;
-                            case 'LESS_THAN_EQUALS':
-                                filtered = (Number(columnValue) || columnValue) <= (Number(value) || value);
-                                break;
-                            default:
-                                break;
-                        }
-                    }
-                });
-            });
+    getRequestParams() {
+        const requestParams = super.getRequestParams();
+        const isNotEmptyObj = (obj) => !!(obj && Object.keys(obj).length);
+        const isValid = this.dynamicFilter && Object.keys(this.dynamicFilter).every((column) => {
+            const value = this.dynamicFilter[column];
+            return value && value.length > 0 && this.isValidDynamicFilterValue(column, value);
+        });
+        if (isNotEmptyObj(this.dynamicFilter) && isValid) {
+            requestParams.dynamic_filter = btoa(JSON.stringify(this.dynamicFilter));
         }
-        catch (_a) {
-            // do nothing
+        if (isNotEmptyObj(this.searchJoin)) {
+            requestParams.search_join = btoa(JSON.stringify(this.searchJoin));
         }
-        return filtered;
+        return requestParams;
     }
-    getRowBySearchJoin(row) {
-        return Object.keys(this.searchJoin).some((key) => this.searchJoin[key].includes(row[key]));
+    clone() {
+        return Object.assign(Object.assign({}, super.clone()), { dynamicFilter: this.dynamicFilter, searchJoin: this.searchJoin, type: 'tek-rest' });
     }
 }
-DatasourceFactory.register('tek-memory', TekMemoryDatasource);
+DatasourceFactory.register('tek-rest', TekRestDatasource);
 
 /**
  * Base class for TekGrid column