@zeedhi/teknisa-components-common 1.79.0 → 1.79.1

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

@@ -1011,6 +1011,7 @@
                                       {
                                           name: `${this.grid.name}-filter-title`,
                                           component: 'ZdText',
+                                          cssStyle: `color: ${'var(--v-primary-base);'}`,
                                           text: `${mergeModalFilterProps.title}`,
                                           tag: 'h3',
                                       },
@@ -1651,13 +1652,13 @@
       OR: true,
   };
 
-  class TekRestDatasource extends core.RestDatasource {
+  class TekMemoryDatasource extends core.MemoryDatasource {
       /**
        * Create new datasource
        * @param props Datasource properties
        */
       constructor(props) {
-          super(Object.assign(Object.assign({}, props), { lazyLoad: true }));
+          super(props);
           /**
            * Dynamic Filter Operations
            */
@@ -1674,13 +1675,10 @@
               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;
@@ -1809,37 +1807,124 @@
                   && 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 = core.Utils.normalize(row[key].toString());
+                      let value = '';
+                      if (Array.isArray(item.value)) {
+                          value = item.value.map((val) => core.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 = core.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]));
       }
   }
-  core.DatasourceFactory.register('tek-rest', TekRestDatasource);
+  core.DatasourceFactory.register('tek-memory', TekMemoryDatasource);
 
-  class TekMemoryDatasource extends core.MemoryDatasource {
+  class TekRestDatasource extends core.RestDatasource {
       /**
        * Create new datasource
        * @param props Datasource properties
        */
       constructor(props) {
-          super(props);
+          super(Object.assign(Object.assign({}, props), { lazyLoad: true }));
           /**
            * Dynamic Filter Operations
            */
@@ -1856,10 +1941,13 @@
               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;
@@ -1988,116 +2076,29 @@
                   && 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 = core.Utils.normalize(row[key].toString());
-                      let value = '';
-                      if (Array.isArray(item.value)) {
-                          value = item.value.map((val) => core.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 = core.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' });
       }
   }
-  core.DatasourceFactory.register('tek-memory', TekMemoryDatasource);
+  core.DatasourceFactory.register('tek-rest', TekRestDatasource);
 
   /**
    * Base class for TekGrid column

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeedhi/teknisa-components-common",
-  "version": "1.79.0",
+  "version": "1.79.1",
   "description": "Teknisa Components Common",
   "author": "Zeedhi <zeedhi@teknisa.com>",
   "license": "ISC",
@@ -31,5 +31,5 @@
   "peerDependencies": {
     "@zeedhi/core": "*"
   },
-  "gitHead": "21ab64d9a9f50082961702e29e6df8114d5f62cd"
+  "gitHead": "3dbfc60f316134f249bb4c65429623dfb93b0696"
 }

package/types/components/tek-grid/grid.d.ts

@@ -2,7 +2,7 @@ import { GridEditable, IComponentRender } from '@zeedhi/common';
 import { Datasource, IDictionary } from '@zeedhi/core';
 import { ITekGridAtoms } from '../../utils';
 import { TekGridColumn } from './grid-column';
-import { ITekGrid, ITekGridColumn, ITekGridEvents, ITekGridExportConfig, IModalFilterProps } from './interfaces';
+import { IModalFilterProps, ITekGrid, ITekGridColumn, ITekGridEvents, ITekGridExportConfig } from './interfaces';
 import { TekGridLayoutOptions } from './layout-options';
 export declare class TekGrid extends GridEditable implements ITekGrid {
     title: string;