@zeedhi/common 1.38.1 → 1.39.0

package/dist/zd-common.esm.js

@@ -4317,7 +4317,7 @@ class Column extends Component {
         const appliedConditions = {};
         Object.keys(this.factoredConditions).forEach((condition) => {
             const conditionFunction = this.factoredConditions[condition];
-            set(appliedConditions, condition, conditionFunction({ row }));
+            set(appliedConditions, condition, conditionFunction({ row, column: this }));
         });
         return appliedConditions;
     }
@@ -5068,7 +5068,6 @@ class GridEditable extends Grid {
         if (this.editing)
             return;
         if (column.editable) {
-            this.selectedRows = [];
             this.editing = true;
             this.preventRowClick = true;
             this.datasource.currentRow = row;
@@ -5138,7 +5137,7 @@ class GridEditable extends Grid {
         else {
             colValue = row[column.name];
         }
-        const componentProps = merge({}, column.componentProps, cellProps.componentProps);
+        const componentProps = merge({}, column.componentProps, cellProps === null || cellProps === void 0 ? void 0 : cellProps.componentProps);
         let compEvents = {};
         if (componentProps && componentProps.events) {
             compEvents = Event.factory(componentProps.events);
@@ -5931,6 +5930,7 @@ class Select extends TextInput {
         this.cachedData = [];
         this.cachedTotal = 0;
         this.formatterFn = FormatterParserProvider.getFormatter('ZdSelect');
+        this.pushedValue = null;
         this.loadMoreQtty = 0;
         this.debounceSearch = debounce(this.doSearch, 500);
         this.appendIcon = this.getInitValue('appendIcon', props.appendIcon, 'expand');
@@ -5952,6 +5952,7 @@ class Select extends TextInput {
             this.dataText = [this.dataText];
         const defaultDatasource = this.getDefaultDatasource(props);
         this.datasource = DatasourceFactory.factory(defaultDatasource);
+        this.overrideGet();
         let defaultValue = props.value;
         if (Accessor.isAccessorDefinition(props.value)) {
             defaultValue = this.getAccessorValue(props.value);
@@ -5982,6 +5983,16 @@ class Select extends TextInput {
         const searchIn = (((_a = field.datasource) === null || _a === void 0 ? void 0 : _a.searchIn) || []).concat(searchInDefault);
         return Object.assign(Object.assign({}, field.datasource), { searchIn, lazyLoad: (field.value !== '' && field.value !== undefined) || (field.datasource && field.datasource.lazyLoad) });
     }
+    overrideGet() {
+        const oldGet = this.datasource.get;
+        this.datasource.get = () => __awaiter(this, void 0, void 0, function* () {
+            yield oldGet.call(this.datasource);
+            if (this.indexOf(this.value) !== -1 || this.datasource.search || this.isFocused)
+                return;
+            yield this.setValue(this.value, false);
+            this.removePushedValue();
+        });
+    }
     get search() {
         return this.searchValue;
     }
@@ -6008,7 +6019,7 @@ class Select extends TextInput {
             }
             if (this.manualMode)
                 return;
-            this.cachedData = this.datasource.data;
+            this.cachedData = [...this.datasource.data];
             this.cachedTotal = this.datasource.total;
             if (pushed) {
                 this.pushedValue = this.selectedData;
@@ -6067,10 +6078,14 @@ class Select extends TextInput {
         if (!this.pushedValue && this.isFilledObj(this.selectValue) && this.indexOf(this.selectValue) === -1) {
             this.pushedValue = this.selectValue;
         }
-        if (this.isFilledObj(this.pushedValue) && this.indexOf(this.pushedValue) === -1) {
+        const index = this.indexOf(this.pushedValue);
+        if (this.isFilledObj(this.pushedValue) && index === -1) {
             this.datasource.data.unshift(this.pushedValue);
         }
-        this.cachedData = this.datasource.data;
+        else if (index !== 0) {
+            this.pushedValue = null;
+        }
+        this.cachedData = [...this.datasource.data];
         this.cachedTotal = this.datasource.total;
     }
     /**
@@ -6129,6 +6144,7 @@ class Select extends TextInput {
             }
             if (!searchValue) {
                 this.setFieldRowValue(null);
+                this.selectValue = this.selectedData;
                 return false;
             }
             this.setFieldRowValue(searchValue);
@@ -6239,7 +6255,7 @@ class Select extends TextInput {
             else {
                 this.removePushedValue();
                 this.datasource.search = this.searchValue;
-                this.datasource.data = this.cachedData;
+                this.datasource.data = [...this.cachedData];
                 this.datasource.total = this.cachedTotal;
             }
         });
@@ -6252,6 +6268,11 @@ class Select extends TextInput {
             yield this.datasource.setLimit(this.datasource.limit + this.loadMoreQtty);
             if (!this.datasource.search) {
                 this.afterLoad();
+                const { dataValue } = this;
+                const isSelected = this.selectValue && this.pushedValue && this.selectValue[dataValue] === this.pushedValue[dataValue];
+                if (isSelected)
+                    return;
+                this.removePushedValue();
             }
         });
     }
@@ -6265,7 +6286,7 @@ class Select extends TextInput {
             this.datasource.search = '';
             this.dirtySearchValue = '';
             if (!this.manualMode) {
-                this.datasource.data = this.cachedData;
+                this.datasource.data = [...this.cachedData];
                 this.datasource.total = this.cachedTotal;
             }
             this.checkValueOnBlur();
@@ -6278,13 +6299,17 @@ class Select extends TextInput {
         }
         if (this.manualMode)
             return;
-        if (this.isFilledObj(this.selectValue)) {
-            if (this.indexOf(this.selectValue) === -1) {
-                this.datasource.data.unshift(this.selectValue);
-                this.pushedValue = this.selectValue;
+        if (this.isFilledObj(this.selectValue) && this.indexOf(this.selectValue) === -1) {
+            if (this.pushedValue) {
+                this.removePushedValue();
             }
+            this.datasource.data.unshift(this.selectValue);
+            this.pushedValue = this.selectValue;
             return;
         }
+        const { dataValue } = this;
+        if (this.pushedValue && this.selectValue && this.selectValue[dataValue] === this.pushedValue[dataValue])
+            return;
         this.removePushedValue();
     }
     showLoadMore() {
@@ -7929,20 +7954,23 @@ class SelectMultiple extends Select {
     set selectValue(rows) {
         if (!Array.isArray(rows))
             return;
-        if (!this.manualMode && this.insertedValues.length > 0) {
-            this.insertsRemoved = [];
+        if (!this.manualMode) {
             const values = rows.map((row) => row[this.dataValue]);
-            this.insertedValues = this.insertedValues.filter((inserted) => {
-                const removed = !values.includes(inserted[this.dataValue]);
-                if (removed) {
-                    this.insertsRemoved.push(inserted);
-                }
-                return !removed;
-            });
+            this.cutFromAToB(this.insertedValues, this.insertsRemoved, (value) => !values.includes(value[this.dataValue]));
+            this.cutFromAToB(this.insertsRemoved, this.insertedValues, (value) => values.includes(value[this.dataValue]));
         }
         this.selectedValue = rows;
         this.setFieldValue(this.getValues(rows));
     }
+    /**
+     * Removes item from array a and add it to array b if condition is satisfied
+     */
+    cutFromAToB(a, b, condition) {
+        const indices = a.reduce((result, value, index) => (condition(value) ? [...result, index] : result), []);
+        indices.forEach((index) => {
+            b.push(a.splice(index)[0]);
+        });
+    }
     setFieldValue(value) {
         return __awaiter(this, void 0, void 0, function* () {
             const promises = [];
@@ -8119,7 +8147,7 @@ class SelectMultiple extends Select {
     showLoadMore() {
         return !!this.datasource.data.length
             && !this.datasource.loadAll
-            && (this.datasource.data.length - this.insertedValues.length) < this.datasource.total;
+            && (this.datasource.data.length - this.insertedValues.length - this.insertsRemoved.length) < this.datasource.total;
     }
     /**
      * Load more data
@@ -8127,10 +8155,16 @@ class SelectMultiple extends Select {
     loadMore() {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.datasource.setLimit(this.datasource.limit + this.loadMoreQtty);
+            this.insertsRemoved = this.insertsRemoved.filter((insert) => {
+                const value = insert[this.dataValue];
+                const foundInData = this.datasource.data.find(this.getCondition(value));
+                return !foundInData;
+            });
+            this.insertSelected();
             if (!this.datasource.search) {
                 this.setCache();
             }
-            this.insertSelected();
+            this.removePushedValue();
         });
     }
     /**
@@ -8324,6 +8358,9 @@ class TreeDataStructure {
             }
             return item;
         });
+        if (parent) { // remove all existing children to add new ones
+            this.treeData = this.treeData.filter((item) => item.tree__parent !== parent);
+        }
         if (!parent) {
             this.treeData = childData;
         }
@@ -8507,7 +8544,7 @@ class TreeDataStructure {
         this.treeStructure = {};
         const childData = this.originalDatasource.data.map((row) => (Object.assign(Object.assign({}, row), { tree__children: [], tree__opened: false, tree__searched: true, tree__level: 1, tree__parent: undefined })));
         this.treeData = childData;
-        this.treeStructure['no-parent'] = this.originalDatasource.data;
+        this.treeStructure['no-parent'] = childData;
     }
     /**
      * Search value against a memory datasource
@@ -10184,7 +10221,6 @@ class TreeGridEditable extends TreeGrid {
         if (this.editing)
             return;
         if (column.editable) {
-            this.selectedRows = [];
             this.editing = true;
             this.preventRowClick = true;
             this.datasource.currentRow = row;
@@ -11133,17 +11169,37 @@ class PDFReport extends BaseReport {
 }
 
 class XLSReport extends BaseReport {
-    constructor() {
-        super(...arguments);
+    constructor(type) {
+        super();
         this.route = '/generateXLS';
+        this.expressionZeedhiToXls = {
+            AVG: 'AVERAGE',
+            COUNT: 'COUNTA',
+            MAX: 'MAX',
+            MIN: 'MIN',
+            SUM: 'SUM',
+        };
+        this.colunmXLS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+        this.type = type || 'xls';
     }
-    buildDataset(data, columns) {
+    buildDataset(data, columns, metadata) {
+        let result;
+        if (this.type === 'xls') {
+            result = this.formatRawDataSet(data, columns);
+        }
+        else if (metadata) {
+            result = this.formatDataSet(metadata, data);
+        }
+        return JSON.stringify(result);
+    }
+    // formata o dataset para o formato "cru" xls
+    formatRawDataSet(data, columns) {
         const columnNames = columns.map((col) => col.name);
         const result = data.reduce((reduced, row) => {
             const values = columnNames.map((col) => row[col] || '');
             return [...reduced, values];
         }, [columnNames]);
-        return JSON.stringify(result);
+        return result;
     }
     buildMetadata(name, title, columns, filter) {
         const builtCols = this.buildColumns(columns);
@@ -11172,9 +11228,215 @@ class XLSReport extends BaseReport {
             orientation: 'PORTRAIT',
             columns: builtCols,
             filter: builtFilters,
+            reportXLS: true,
+            xlsMergedCell: [],
         };
         return Promise.resolve(JSON.stringify(metadataObj));
     }
+    isFormat3(format) {
+        return format === 'xls3';
+    }
+    // Ordenar o nome das colunas de acordo com seu index, excluindo o nome das colunas agrupadas
+    getColumnsNameFormat3(columns, metaData) {
+        const columnsNameGroup = metaData.groups.map((row) => row.field);
+        let columnsName = [];
+        Object.entries(columns).forEach((row) => {
+            const columnName = row[0];
+            if (columnsNameGroup.indexOf(columnName) === -1) {
+                const index = row[1].sequence;
+                columnsName[index] = columnName;
+            }
+        });
+        columnsName = columnsName.filter((columnName) => typeof columnName === 'string');
+        return columnsName;
+    }
+    // Ordenar o nome das colunas de acordo com seu index, e sempre deixando as colunas agrupadas nas primeiras posições
+    getColumnsName(columns, metaData, lengthGroup) {
+        const columnsNameGroup = metaData.groups.map((row) => row.field);
+        let columnsName = [];
+        Object.entries(columns).forEach((row) => {
+            const columnName = row[0];
+            const index = row[1].sequence;
+            if (columnsNameGroup.indexOf(columnName) === -1) {
+                columnsName[index + lengthGroup] = columnName;
+            }
+            else {
+                columnsName[index] = columnName;
+            }
+        });
+        columnsName = columnsName.filter((columnName) => typeof columnName === 'string');
+        return columnsName;
+    }
+    // Inicializa alguns valores auxiliares
+    initVars(metaData, type) {
+        metaData.xlsMergedCell = [];
+        const { columns } = metaData;
+        const lengthGroup = metaData.groups.length;
+        const indexLastGroup = lengthGroup - 1;
+        let columnsName = [];
+        if (this.isFormat3(type)) {
+            columnsName = this.getColumnsNameFormat3(columns, metaData);
+        }
+        else {
+            columnsName = this.getColumnsName(columns, metaData, lengthGroup);
+        }
+        const rowValues = [];
+        const formatedDataSet = [];
+        const groups = [];
+        groups.groupEnd = {};
+        groups.groupEnd.cellsfunc = {};
+        return {
+            columns, indexLastGroup, columnsName, rowValues, formatedDataSet, groups,
+        };
+    }
+    // formata a linha do grupo de acordo com o formato xls3
+    setRowGroupFormat3(row, rowValuesParam, groups, formatedDataSet, columnsName, columns, indexLastGroup) {
+        let rowValues = rowValuesParam;
+        const label = `${row.groupLabel}:${row.groupValue}`;
+        const index = row.groupIndex;
+        if (row.groupHeader) {
+            rowValues[index] = label;
+            groups[index] = { init: null, end: null };
+            formatedDataSet.push(rowValues);
+            rowValues = [];
+        }
+        else if (row.groupFooter) {
+            if (!row.groupLabel) {
+                rowValues.push('Total');
+            }
+            else {
+                rowValues.push(`Total (${label})`);
+            }
+            formatedDataSet.push(rowValues);
+            rowValues = [];
+            const funcXls = null;
+            columnsName.forEach((column) => {
+                this.formatRowFunc(column, columns, row, index, rowValues, funcXls, groups, indexLastGroup);
+            });
+        }
+        return rowValues;
+    }
+    // formata as expressões da linha
+    formatRowFunc(column, columns, row, index, rowValues, funcXlsParam, groups, indexLastGroup) {
+        let funcXls = funcXlsParam;
+        if ((row[column] === 0 || row[column]) && index !== undefined) {
+            const letter = this.colunmXLS[rowValues.length];
+            funcXls = this.expressionZeedhiToXls[columns[column].expression];
+            const cellsfunc = `${letter + groups[index].init}:${letter}${groups[index].end}`;
+            let expression = '';
+            if (indexLastGroup === index) {
+                expression = `=${funcXls}(${cellsfunc})`;
+            }
+            else {
+                expression = `=${funcXls}(${groups[index].cellsfunc[column]})`;
+                if (index === 0) {
+                    if (groups.groupEnd.cellsfunc[column]) {
+                        groups.groupEnd.cellsfunc[column] += `,${groups[index].cellsfunc[column]}`;
+                    }
+                    else {
+                        groups.groupEnd.cellsfunc[column] = groups[index].cellsfunc[column];
+                    }
+                }
+                groups[index].cellsfunc[column] = null;
+            }
+            rowValues.push(expression);
+            groups.forEach((group, indexGroup) => {
+                if (indexGroup !== indexLastGroup) {
+                    if (!group.cellsfunc) {
+                        group.cellsfunc = {};
+                    }
+                    if (group.cellsfunc[column]) {
+                        group.cellsfunc[column] += `,${cellsfunc}`;
+                    }
+                    else {
+                        group.cellsfunc[column] = cellsfunc;
+                    }
+                }
+            });
+        }
+        else {
+            let cell = row[column];
+            if (row.groupSummary) {
+                const groupEndFunc = groups.groupEnd.cellsfunc;
+                if (groupEndFunc[column]) {
+                    funcXls = this.expressionZeedhiToXls[columns[column].expression];
+                    cell = `=${funcXls}(${groupEndFunc[column]})`;
+                }
+            }
+            rowValues.push(cell);
+        }
+    }
+    // formata a linha de grupo de acordo com o formato xls2
+    setRowGroup(row, rowValues, groups, metaData, formatedDataSet, columnsName, columns, indexLastGroup) {
+        const label = `${row.groupLabel}:${row.groupValue}`;
+        const index = row.groupIndex;
+        if (row.groupHeader) {
+            rowValues[index] = label;
+            groups[index] = { init: null, end: null };
+        }
+        else if (row.groupFooter) {
+            if (!row.groupLabel) {
+                rowValues.push('Total');
+            }
+            else {
+                rowValues.push(`Total (${label})`);
+            }
+            const funcXls = null;
+            if (groups[index]) {
+                metaData.xlsMergedCell.push({
+                    start_row: groups[index].init,
+                    start_col: this.colunmXLS[index],
+                    end_row: formatedDataSet.length + 2,
+                    end_col: this.colunmXLS[index],
+                });
+            }
+            columnsName.forEach((column, columnIndex) => {
+                if (!(row.groupFooter && columnIndex === 0)) {
+                    this.formatRowFunc(column, columns, row, index, rowValues, funcXls, groups, indexLastGroup);
+                }
+            });
+        }
+        return rowValues;
+    }
+    // Defina o index dos grupos
+    setIndexGroups(groups, formatedDataSet) {
+        groups.forEach((group) => {
+            if (!group.init) {
+                group.init = formatedDataSet.length + 2;
+            }
+            group.end = formatedDataSet.length + 2;
+        });
+    }
+    // Preenche uma linha "normal"
+    setRowNormal(columnsName, rowValues, row) {
+        columnsName.forEach((column) => {
+            rowValues.push(row[column]);
+        });
+    }
+    formatDataSet(metaData, dataSet) {
+        const initVars = this.initVars(metaData, this.type);
+        const { columns, indexLastGroup, columnsName, formatedDataSet, groups, } = initVars;
+        let { rowValues } = initVars;
+        dataSet.forEach((row) => {
+            if (row.group || row.groupFooter) {
+                if (this.isFormat3(this.type)) {
+                    rowValues = this.setRowGroupFormat3(row, rowValues, groups, formatedDataSet, columnsName, columns, indexLastGroup);
+                }
+                else {
+                    rowValues = this.setRowGroup(row, rowValues, groups, metaData, formatedDataSet, columnsName, columns, indexLastGroup);
+                }
+            }
+            else {
+                this.setIndexGroups(groups, formatedDataSet);
+                this.setRowNormal(columnsName, rowValues, row);
+            }
+            if (!row.groupHeader) {
+                formatedDataSet.push(rowValues);
+            }
+            rowValues = [];
+        });
+        return [columnsName].concat(formatedDataSet);
+    }
 }
 
 class Report {
@@ -11210,8 +11472,8 @@ class Report {
         if (type === 'pdf') {
             return new PDFReport();
         }
-        if (type === 'xls') {
-            return new XLSReport();
+        if (type === 'xls' || type === 'xls2' || type === 'xls3') {
+            return new XLSReport(type);
         }
         throw new Error(`Invalid report type: ${type}`);
     }
@@ -11226,9 +11488,18 @@ class Report {
             const reportType = this.getReportType(type);
             const { route } = reportType;
             const { name, columns, datasource } = this.iterable;
+            const { groupedData } = Object.assign({}, this.iterable);
             const formattedColumns = this.removeActionColumns(columns);
-            const dataset = reportType.buildDataset(data, formattedColumns);
             const metadataObj = yield reportType.buildMetadata(name, this.title, formattedColumns, datasource.filter, portrait);
+            let dataset;
+            if ((reportType.type === 'xls2' || reportType.type === 'xls3') && groupedData) {
+                const rowMetadata = rowObj.metaData;
+                const metadataObjClone = merge(rowMetadata, JSON.parse(metadataObj));
+                dataset = reportType.buildDataset(groupedData, formattedColumns, metadataObjClone);
+            }
+            else {
+                dataset = reportType.buildDataset(data, formattedColumns);
+            }
             const filter = '[]';
             let row = {};
             if (rowObj) {

package/dist/zd-common.umd.js

@@ -4324,7 +4324,7 @@
           const appliedConditions = {};
           Object.keys(this.factoredConditions).forEach((condition) => {
               const conditionFunction = this.factoredConditions[condition];
-              set__default["default"](appliedConditions, condition, conditionFunction({ row }));
+              set__default["default"](appliedConditions, condition, conditionFunction({ row, column: this }));
           });
           return appliedConditions;
       }
@@ -5075,7 +5075,6 @@
           if (this.editing)
               return;
           if (column.editable) {
-              this.selectedRows = [];
               this.editing = true;
               this.preventRowClick = true;
               this.datasource.currentRow = row;
@@ -5145,7 +5144,7 @@
           else {
               colValue = row[column.name];
           }
-          const componentProps = merge__default["default"]({}, column.componentProps, cellProps.componentProps);
+          const componentProps = merge__default["default"]({}, column.componentProps, cellProps === null || cellProps === void 0 ? void 0 : cellProps.componentProps);
           let compEvents = {};
           if (componentProps && componentProps.events) {
               compEvents = core.Event.factory(componentProps.events);
@@ -5938,6 +5937,7 @@
           this.cachedData = [];
           this.cachedTotal = 0;
           this.formatterFn = core.FormatterParserProvider.getFormatter('ZdSelect');
+          this.pushedValue = null;
           this.loadMoreQtty = 0;
           this.debounceSearch = debounce__default["default"](this.doSearch, 500);
           this.appendIcon = this.getInitValue('appendIcon', props.appendIcon, 'expand');
@@ -5959,6 +5959,7 @@
               this.dataText = [this.dataText];
           const defaultDatasource = this.getDefaultDatasource(props);
           this.datasource = core.DatasourceFactory.factory(defaultDatasource);
+          this.overrideGet();
           let defaultValue = props.value;
           if (core.Accessor.isAccessorDefinition(props.value)) {
               defaultValue = this.getAccessorValue(props.value);
@@ -5989,6 +5990,16 @@
           const searchIn = (((_a = field.datasource) === null || _a === void 0 ? void 0 : _a.searchIn) || []).concat(searchInDefault);
           return Object.assign(Object.assign({}, field.datasource), { searchIn, lazyLoad: (field.value !== '' && field.value !== undefined) || (field.datasource && field.datasource.lazyLoad) });
       }
+      overrideGet() {
+          const oldGet = this.datasource.get;
+          this.datasource.get = () => __awaiter(this, void 0, void 0, function* () {
+              yield oldGet.call(this.datasource);
+              if (this.indexOf(this.value) !== -1 || this.datasource.search || this.isFocused)
+                  return;
+              yield this.setValue(this.value, false);
+              this.removePushedValue();
+          });
+      }
       get search() {
           return this.searchValue;
       }
@@ -6015,7 +6026,7 @@
               }
               if (this.manualMode)
                   return;
-              this.cachedData = this.datasource.data;
+              this.cachedData = [...this.datasource.data];
               this.cachedTotal = this.datasource.total;
               if (pushed) {
                   this.pushedValue = this.selectedData;
@@ -6074,10 +6085,14 @@
           if (!this.pushedValue && this.isFilledObj(this.selectValue) && this.indexOf(this.selectValue) === -1) {
               this.pushedValue = this.selectValue;
           }
-          if (this.isFilledObj(this.pushedValue) && this.indexOf(this.pushedValue) === -1) {
+          const index = this.indexOf(this.pushedValue);
+          if (this.isFilledObj(this.pushedValue) && index === -1) {
               this.datasource.data.unshift(this.pushedValue);
           }
-          this.cachedData = this.datasource.data;
+          else if (index !== 0) {
+              this.pushedValue = null;
+          }
+          this.cachedData = [...this.datasource.data];
           this.cachedTotal = this.datasource.total;
       }
       /**
@@ -6136,6 +6151,7 @@
               }
               if (!searchValue) {
                   this.setFieldRowValue(null);
+                  this.selectValue = this.selectedData;
                   return false;
               }
               this.setFieldRowValue(searchValue);
@@ -6246,7 +6262,7 @@
               else {
                   this.removePushedValue();
                   this.datasource.search = this.searchValue;
-                  this.datasource.data = this.cachedData;
+                  this.datasource.data = [...this.cachedData];
                   this.datasource.total = this.cachedTotal;
               }
           });
@@ -6259,6 +6275,11 @@
               yield this.datasource.setLimit(this.datasource.limit + this.loadMoreQtty);
               if (!this.datasource.search) {
                   this.afterLoad();
+                  const { dataValue } = this;
+                  const isSelected = this.selectValue && this.pushedValue && this.selectValue[dataValue] === this.pushedValue[dataValue];
+                  if (isSelected)
+                      return;
+                  this.removePushedValue();
               }
           });
       }
@@ -6272,7 +6293,7 @@
               this.datasource.search = '';
               this.dirtySearchValue = '';
               if (!this.manualMode) {
-                  this.datasource.data = this.cachedData;
+                  this.datasource.data = [...this.cachedData];
                   this.datasource.total = this.cachedTotal;
               }
               this.checkValueOnBlur();
@@ -6285,13 +6306,17 @@
           }
           if (this.manualMode)
               return;
-          if (this.isFilledObj(this.selectValue)) {
-              if (this.indexOf(this.selectValue) === -1) {
-                  this.datasource.data.unshift(this.selectValue);
-                  this.pushedValue = this.selectValue;
+          if (this.isFilledObj(this.selectValue) && this.indexOf(this.selectValue) === -1) {
+              if (this.pushedValue) {
+                  this.removePushedValue();
               }
+              this.datasource.data.unshift(this.selectValue);
+              this.pushedValue = this.selectValue;
               return;
           }
+          const { dataValue } = this;
+          if (this.pushedValue && this.selectValue && this.selectValue[dataValue] === this.pushedValue[dataValue])
+              return;
           this.removePushedValue();
       }
       showLoadMore() {
@@ -7936,20 +7961,23 @@
       set selectValue(rows) {
           if (!Array.isArray(rows))
               return;
-          if (!this.manualMode && this.insertedValues.length > 0) {
-              this.insertsRemoved = [];
+          if (!this.manualMode) {
               const values = rows.map((row) => row[this.dataValue]);
-              this.insertedValues = this.insertedValues.filter((inserted) => {
-                  const removed = !values.includes(inserted[this.dataValue]);
-                  if (removed) {
-                      this.insertsRemoved.push(inserted);
-                  }
-                  return !removed;
-              });
+              this.cutFromAToB(this.insertedValues, this.insertsRemoved, (value) => !values.includes(value[this.dataValue]));
+              this.cutFromAToB(this.insertsRemoved, this.insertedValues, (value) => values.includes(value[this.dataValue]));
           }
           this.selectedValue = rows;
           this.setFieldValue(this.getValues(rows));
       }
+      /**
+       * Removes item from array a and add it to array b if condition is satisfied
+       */
+      cutFromAToB(a, b, condition) {
+          const indices = a.reduce((result, value, index) => (condition(value) ? [...result, index] : result), []);
+          indices.forEach((index) => {
+              b.push(a.splice(index)[0]);
+          });
+      }
       setFieldValue(value) {
           return __awaiter(this, void 0, void 0, function* () {
               const promises = [];
@@ -8126,7 +8154,7 @@
       showLoadMore() {
           return !!this.datasource.data.length
               && !this.datasource.loadAll
-              && (this.datasource.data.length - this.insertedValues.length) < this.datasource.total;
+              && (this.datasource.data.length - this.insertedValues.length - this.insertsRemoved.length) < this.datasource.total;
       }
       /**
        * Load more data
@@ -8134,10 +8162,16 @@
       loadMore() {
           return __awaiter(this, void 0, void 0, function* () {
               yield this.datasource.setLimit(this.datasource.limit + this.loadMoreQtty);
+              this.insertsRemoved = this.insertsRemoved.filter((insert) => {
+                  const value = insert[this.dataValue];
+                  const foundInData = this.datasource.data.find(this.getCondition(value));
+                  return !foundInData;
+              });
+              this.insertSelected();
               if (!this.datasource.search) {
                   this.setCache();
               }
-              this.insertSelected();
+              this.removePushedValue();
           });
       }
       /**
@@ -8331,6 +8365,9 @@
               }
               return item;
           });
+          if (parent) { // remove all existing children to add new ones
+              this.treeData = this.treeData.filter((item) => item.tree__parent !== parent);
+          }
           if (!parent) {
               this.treeData = childData;
           }
@@ -8514,7 +8551,7 @@
           this.treeStructure = {};
           const childData = this.originalDatasource.data.map((row) => (Object.assign(Object.assign({}, row), { tree__children: [], tree__opened: false, tree__searched: true, tree__level: 1, tree__parent: undefined })));
           this.treeData = childData;
-          this.treeStructure['no-parent'] = this.originalDatasource.data;
+          this.treeStructure['no-parent'] = childData;
       }
       /**
        * Search value against a memory datasource
@@ -10191,7 +10228,6 @@
           if (this.editing)
               return;
           if (column.editable) {
-              this.selectedRows = [];
               this.editing = true;
               this.preventRowClick = true;
               this.datasource.currentRow = row;
@@ -11140,17 +11176,37 @@
   }
 
   class XLSReport extends BaseReport {
-      constructor() {
-          super(...arguments);
+      constructor(type) {
+          super();
           this.route = '/generateXLS';
+          this.expressionZeedhiToXls = {
+              AVG: 'AVERAGE',
+              COUNT: 'COUNTA',
+              MAX: 'MAX',
+              MIN: 'MIN',
+              SUM: 'SUM',
+          };
+          this.colunmXLS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+          this.type = type || 'xls';
       }
-      buildDataset(data, columns) {
+      buildDataset(data, columns, metadata) {
+          let result;
+          if (this.type === 'xls') {
+              result = this.formatRawDataSet(data, columns);
+          }
+          else if (metadata) {
+              result = this.formatDataSet(metadata, data);
+          }
+          return JSON.stringify(result);
+      }
+      // formata o dataset para o formato "cru" xls
+      formatRawDataSet(data, columns) {
           const columnNames = columns.map((col) => col.name);
           const result = data.reduce((reduced, row) => {
               const values = columnNames.map((col) => row[col] || '');
               return [...reduced, values];
           }, [columnNames]);
-          return JSON.stringify(result);
+          return result;
       }
       buildMetadata(name, title, columns, filter) {
           const builtCols = this.buildColumns(columns);
@@ -11179,9 +11235,215 @@
               orientation: 'PORTRAIT',
               columns: builtCols,
               filter: builtFilters,
+              reportXLS: true,
+              xlsMergedCell: [],
           };
           return Promise.resolve(JSON.stringify(metadataObj));
       }
+      isFormat3(format) {
+          return format === 'xls3';
+      }
+      // Ordenar o nome das colunas de acordo com seu index, excluindo o nome das colunas agrupadas
+      getColumnsNameFormat3(columns, metaData) {
+          const columnsNameGroup = metaData.groups.map((row) => row.field);
+          let columnsName = [];
+          Object.entries(columns).forEach((row) => {
+              const columnName = row[0];
+              if (columnsNameGroup.indexOf(columnName) === -1) {
+                  const index = row[1].sequence;
+                  columnsName[index] = columnName;
+              }
+          });
+          columnsName = columnsName.filter((columnName) => typeof columnName === 'string');
+          return columnsName;
+      }
+      // Ordenar o nome das colunas de acordo com seu index, e sempre deixando as colunas agrupadas nas primeiras posições
+      getColumnsName(columns, metaData, lengthGroup) {
+          const columnsNameGroup = metaData.groups.map((row) => row.field);
+          let columnsName = [];
+          Object.entries(columns).forEach((row) => {
+              const columnName = row[0];
+              const index = row[1].sequence;
+              if (columnsNameGroup.indexOf(columnName) === -1) {
+                  columnsName[index + lengthGroup] = columnName;
+              }
+              else {
+                  columnsName[index] = columnName;
+              }
+          });
+          columnsName = columnsName.filter((columnName) => typeof columnName === 'string');
+          return columnsName;
+      }
+      // Inicializa alguns valores auxiliares
+      initVars(metaData, type) {
+          metaData.xlsMergedCell = [];
+          const { columns } = metaData;
+          const lengthGroup = metaData.groups.length;
+          const indexLastGroup = lengthGroup - 1;
+          let columnsName = [];
+          if (this.isFormat3(type)) {
+              columnsName = this.getColumnsNameFormat3(columns, metaData);
+          }
+          else {
+              columnsName = this.getColumnsName(columns, metaData, lengthGroup);
+          }
+          const rowValues = [];
+          const formatedDataSet = [];
+          const groups = [];
+          groups.groupEnd = {};
+          groups.groupEnd.cellsfunc = {};
+          return {
+              columns, indexLastGroup, columnsName, rowValues, formatedDataSet, groups,
+          };
+      }
+      // formata a linha do grupo de acordo com o formato xls3
+      setRowGroupFormat3(row, rowValuesParam, groups, formatedDataSet, columnsName, columns, indexLastGroup) {
+          let rowValues = rowValuesParam;
+          const label = `${row.groupLabel}:${row.groupValue}`;
+          const index = row.groupIndex;
+          if (row.groupHeader) {
+              rowValues[index] = label;
+              groups[index] = { init: null, end: null };
+              formatedDataSet.push(rowValues);
+              rowValues = [];
+          }
+          else if (row.groupFooter) {
+              if (!row.groupLabel) {
+                  rowValues.push('Total');
+              }
+              else {
+                  rowValues.push(`Total (${label})`);
+              }
+              formatedDataSet.push(rowValues);
+              rowValues = [];
+              const funcXls = null;
+              columnsName.forEach((column) => {
+                  this.formatRowFunc(column, columns, row, index, rowValues, funcXls, groups, indexLastGroup);
+              });
+          }
+          return rowValues;
+      }
+      // formata as expressões da linha
+      formatRowFunc(column, columns, row, index, rowValues, funcXlsParam, groups, indexLastGroup) {
+          let funcXls = funcXlsParam;
+          if ((row[column] === 0 || row[column]) && index !== undefined) {
+              const letter = this.colunmXLS[rowValues.length];
+              funcXls = this.expressionZeedhiToXls[columns[column].expression];
+              const cellsfunc = `${letter + groups[index].init}:${letter}${groups[index].end}`;
+              let expression = '';
+              if (indexLastGroup === index) {
+                  expression = `=${funcXls}(${cellsfunc})`;
+              }
+              else {
+                  expression = `=${funcXls}(${groups[index].cellsfunc[column]})`;
+                  if (index === 0) {
+                      if (groups.groupEnd.cellsfunc[column]) {
+                          groups.groupEnd.cellsfunc[column] += `,${groups[index].cellsfunc[column]}`;
+                      }
+                      else {
+                          groups.groupEnd.cellsfunc[column] = groups[index].cellsfunc[column];
+                      }
+                  }
+                  groups[index].cellsfunc[column] = null;
+              }
+              rowValues.push(expression);
+              groups.forEach((group, indexGroup) => {
+                  if (indexGroup !== indexLastGroup) {
+                      if (!group.cellsfunc) {
+                          group.cellsfunc = {};
+                      }
+                      if (group.cellsfunc[column]) {
+                          group.cellsfunc[column] += `,${cellsfunc}`;
+                      }
+                      else {
+                          group.cellsfunc[column] = cellsfunc;
+                      }
+                  }
+              });
+          }
+          else {
+              let cell = row[column];
+              if (row.groupSummary) {
+                  const groupEndFunc = groups.groupEnd.cellsfunc;
+                  if (groupEndFunc[column]) {
+                      funcXls = this.expressionZeedhiToXls[columns[column].expression];
+                      cell = `=${funcXls}(${groupEndFunc[column]})`;
+                  }
+              }
+              rowValues.push(cell);
+          }
+      }
+      // formata a linha de grupo de acordo com o formato xls2
+      setRowGroup(row, rowValues, groups, metaData, formatedDataSet, columnsName, columns, indexLastGroup) {
+          const label = `${row.groupLabel}:${row.groupValue}`;
+          const index = row.groupIndex;
+          if (row.groupHeader) {
+              rowValues[index] = label;
+              groups[index] = { init: null, end: null };
+          }
+          else if (row.groupFooter) {
+              if (!row.groupLabel) {
+                  rowValues.push('Total');
+              }
+              else {
+                  rowValues.push(`Total (${label})`);
+              }
+              const funcXls = null;
+              if (groups[index]) {
+                  metaData.xlsMergedCell.push({
+                      start_row: groups[index].init,
+                      start_col: this.colunmXLS[index],
+                      end_row: formatedDataSet.length + 2,
+                      end_col: this.colunmXLS[index],
+                  });
+              }
+              columnsName.forEach((column, columnIndex) => {
+                  if (!(row.groupFooter && columnIndex === 0)) {
+                      this.formatRowFunc(column, columns, row, index, rowValues, funcXls, groups, indexLastGroup);
+                  }
+              });
+          }
+          return rowValues;
+      }
+      // Defina o index dos grupos
+      setIndexGroups(groups, formatedDataSet) {
+          groups.forEach((group) => {
+              if (!group.init) {
+                  group.init = formatedDataSet.length + 2;
+              }
+              group.end = formatedDataSet.length + 2;
+          });
+      }
+      // Preenche uma linha "normal"
+      setRowNormal(columnsName, rowValues, row) {
+          columnsName.forEach((column) => {
+              rowValues.push(row[column]);
+          });
+      }
+      formatDataSet(metaData, dataSet) {
+          const initVars = this.initVars(metaData, this.type);
+          const { columns, indexLastGroup, columnsName, formatedDataSet, groups, } = initVars;
+          let { rowValues } = initVars;
+          dataSet.forEach((row) => {
+              if (row.group || row.groupFooter) {
+                  if (this.isFormat3(this.type)) {
+                      rowValues = this.setRowGroupFormat3(row, rowValues, groups, formatedDataSet, columnsName, columns, indexLastGroup);
+                  }
+                  else {
+                      rowValues = this.setRowGroup(row, rowValues, groups, metaData, formatedDataSet, columnsName, columns, indexLastGroup);
+                  }
+              }
+              else {
+                  this.setIndexGroups(groups, formatedDataSet);
+                  this.setRowNormal(columnsName, rowValues, row);
+              }
+              if (!row.groupHeader) {
+                  formatedDataSet.push(rowValues);
+              }
+              rowValues = [];
+          });
+          return [columnsName].concat(formatedDataSet);
+      }
   }
 
   class Report {
@@ -11217,8 +11479,8 @@
           if (type === 'pdf') {
               return new PDFReport();
           }
-          if (type === 'xls') {
-              return new XLSReport();
+          if (type === 'xls' || type === 'xls2' || type === 'xls3') {
+              return new XLSReport(type);
           }
           throw new Error(`Invalid report type: ${type}`);
       }
@@ -11233,9 +11495,18 @@
               const reportType = this.getReportType(type);
               const { route } = reportType;
               const { name, columns, datasource } = this.iterable;
+              const { groupedData } = Object.assign({}, this.iterable);
               const formattedColumns = this.removeActionColumns(columns);
-              const dataset = reportType.buildDataset(data, formattedColumns);
               const metadataObj = yield reportType.buildMetadata(name, this.title, formattedColumns, datasource.filter, portrait);
+              let dataset;
+              if ((reportType.type === 'xls2' || reportType.type === 'xls3') && groupedData) {
+                  const rowMetadata = rowObj.metaData;
+                  const metadataObjClone = merge__default["default"](rowMetadata, JSON.parse(metadataObj));
+                  dataset = reportType.buildDataset(groupedData, formattedColumns, metadataObjClone);
+              }
+              else {
+                  dataset = reportType.buildDataset(data, formattedColumns);
+              }
               const filter = '[]';
               let row = {};
               if (rowObj) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeedhi/common",
-  "version": "1.38.1",
+  "version": "1.39.0",
   "description": "Zeedhi Common",
   "author": "Zeedhi <zeedhi@teknisa.com>",
   "license": "ISC",
@@ -37,5 +37,5 @@
     "lodash.times": "^4.3.2",
     "mockdate": "^3.0.2"
   },
-  "gitHead": "42488b369e2e54bf20d39a3bb5bd66462bfec5e4"
+  "gitHead": "71a699db31a055a0ea5102b6903c97f80bc34edd"
 }

package/types/components/zd-grid/grid-editable.d.ts

@@ -78,7 +78,7 @@ export declare class GridEditable extends Grid implements IGridEditable {
      * @param cellProps Column conditional props
      * @param events Component events
      */
-    getEditableComponent(column: IGridColumnEditable, row: IDictionary<any>, cellProps: IDictionary<any>, events: any): {
+    getEditableComponent(column: IGridColumnEditable, row: IDictionary<any>, cellProps: IDictionary<any> | null, events: any): {
         name: string;
         parent: GridEditable;
         align: "left" | "center" | "right" | undefined;

package/types/components/zd-select/select.d.ts

@@ -105,6 +105,7 @@ export declare class Select extends TextInput implements ISelect {
      * @param field Field structure
      */
     private getDefaultDatasource;
+    overrideGet(): void;
     get search(): string;
     set search(value: string);
     /**

package/types/components/zd-select-multiple/select-multiple.d.ts

@@ -28,6 +28,10 @@ export declare class SelectMultiple extends Select implements ISelectMultiple {
      */
     get selectValue(): IDictionary<any>[];
     set selectValue(rows: IDictionary<any>[]);
+    /**
+     * Removes item from array a and add it to array b if condition is satisfied
+     */
+    private cutFromAToB;
     protected setFieldValue(value: any[]): Promise<boolean>;
     /**
      * Set value accessors

package/types/components/zd-tree-grid/interfaces.d.ts

@@ -1,6 +1,8 @@
-import { IGrid } from '../zd-grid/interfaces';
+import { IGrid, IGridEditable } from '../zd-grid/interfaces';
 export interface ITreeGrid extends IGrid {
     parentField?: string;
     openLevelOnLoad?: number | boolean;
     fetchOnDemand?: boolean;
 }
+export interface ITreeGridEditable extends IGridEditable {
+}

package/types/components/zd-tree-grid/tree-grid-editable.d.ts

@@ -1,8 +1,9 @@
 import { IDictionary } from '@zeedhi/core';
 import { TreeGrid } from './tree-grid';
 import { GridColumnEditable } from '../zd-grid/grid-column-editable';
-import { IGridColumnEditable, IGridEditable } from '../zd-grid/interfaces';
-export declare class TreeGridEditable extends TreeGrid implements IGridEditable {
+import { IGridColumnEditable } from '../zd-grid/interfaces';
+import { ITreeGridEditable } from './interfaces';
+export declare class TreeGridEditable extends TreeGrid implements ITreeGridEditable {
     /**
      * Editable columns
      */
@@ -25,7 +26,7 @@ export declare class TreeGridEditable extends TreeGrid implements IGridEditable
      * Enter edit mode on double click
      */
     doubleClickEdit: boolean;
-    constructor(props: IGridEditable);
+    constructor(props: ITreeGridEditable);
     /**
      * Get Grid columns objects
      * @param columns Grid columns parameter

package/types/utils/report/report-type/interfaces.d.ts

@@ -2,7 +2,8 @@ import { IDictionary } from '@zeedhi/core';
 import { IColumn } from '../../../components';
 export interface IReportType {
     readonly route: string;
-    buildDataset(data: IDictionary[], columns?: IColumn[]): any;
+    type?: string;
+    buildDataset(data: IDictionary[], columns?: IColumn[], metadata?: any): any;
     buildMetadata(name: string, title: string, columns: IColumn[], filter?: IDictionary, portrait?: boolean): Promise<any>;
 }
 export declare type MetadataColumn = IDictionary<{
@@ -10,6 +11,7 @@ export declare type MetadataColumn = IDictionary<{
     description: string;
     sequence: number;
     size: string;
+    expression?: string;
 }>;
 export declare type MetadataFilter = {
     label: string;
@@ -34,5 +36,8 @@ export interface IMetadataObj {
         Version: string;
     };
     staticData: {};
-    groups: [];
+    groups: Array<any>;
+    reportXLS?: boolean;
+    type?: string;
+    xlsMergedCell?: any[];
 }

package/types/utils/report/report-type/xls-report.d.ts

@@ -1,8 +1,24 @@
 import { IDictionary } from '@zeedhi/core';
 import { IColumn } from '../../../components';
 import { BaseReport } from './base-report';
+import { IMetadataObj } from './interfaces';
 export declare class XLSReport extends BaseReport {
     readonly route: string;
-    buildDataset(data: IDictionary<any>[], columns: IColumn[]): string;
+    type: string;
+    constructor(type?: string);
+    buildDataset(data: IDictionary<any>[], columns: IColumn[], metadata?: IMetadataObj): string;
+    private formatRawDataSet;
     buildMetadata(name: string, title: string, columns: IColumn[], filter?: IDictionary<any>): Promise<string>;
+    private expressionZeedhiToXls;
+    private isFormat3;
+    private colunmXLS;
+    private getColumnsNameFormat3;
+    private getColumnsName;
+    private initVars;
+    private setRowGroupFormat3;
+    private formatRowFunc;
+    private setRowGroup;
+    private setIndexGroups;
+    private setRowNormal;
+    formatDataSet(metaData: IMetadataObj, dataSet: IDictionary[]): any[];
 }