@zeedhi/common 1.37.0 → 1.39.1

package/dist/zd-common.umd.js

@@ -2502,7 +2502,7 @@
            */
           this.text = 'Loading';
           this.isVisible = false;
-          this.zIndex = '100';
+          this.zIndex = 999;
           this.text = this.getInitValue('text', props.text, this.text);
           this.zIndex = this.getInitValue('zIndex', props.zIndex, this.zIndex);
           this.defaultText = this.text;
@@ -4320,11 +4320,11 @@
        * Apply conditions
        * @param row Datasource row
        */
-      applyCondition(row) {
+      applyCondition(row, factoredConditions = this.factoredConditions) {
           const appliedConditions = {};
-          Object.keys(this.factoredConditions).forEach((condition) => {
-              const conditionFunction = this.factoredConditions[condition];
-              set__default["default"](appliedConditions, condition, conditionFunction({ row }));
+          Object.keys(factoredConditions).forEach((condition) => {
+              const conditionFunction = factoredConditions[condition];
+              set__default["default"](appliedConditions, condition, conditionFunction({ row, column: this }));
           });
           return appliedConditions;
       }
@@ -4338,11 +4338,7 @@
           const appliedConditions = {};
           Object.keys(this.actionFactoredConditions).forEach((action) => {
               const factoredConditions = this.actionFactoredConditions[action];
-              appliedConditions[action] = {};
-              Object.keys(factoredConditions).forEach((condition) => {
-                  const conditionFunction = factoredConditions[condition];
-                  set__default["default"](appliedConditions[action], condition, conditionFunction({ row }));
-              });
+              appliedConditions[action] = Object.assign({}, this.applyCondition(row, factoredConditions));
           });
           return appliedConditions;
       }
@@ -5075,7 +5071,6 @@
           if (this.editing)
               return;
           if (column.editable) {
-              this.selectedRows = [];
               this.editing = true;
               this.preventRowClick = true;
               this.datasource.currentRow = row;
@@ -5145,7 +5140,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);
@@ -5855,7 +5850,7 @@
        */
       constructor(props) {
           var _a, _b;
-          super(props);
+          super(Object.assign(Object.assign({}, props), { value: undefined }));
           /**
            * Field used to display values
            */
@@ -5938,6 +5933,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,7 +5955,13 @@
               this.dataText = [this.dataText];
           const defaultDatasource = this.getDefaultDatasource(props);
           this.datasource = core.DatasourceFactory.factory(defaultDatasource);
-          this.setDefaultValue(props.value, (_b = props.datasource) === null || _b === void 0 ? void 0 : _b.lazyLoad);
+          this.overrideGet();
+          let defaultValue = props.value;
+          if (core.Accessor.isAccessorDefinition(props.value)) {
+              defaultValue = this.getAccessorValue(props.value);
+              this.getInitValue('value', props.value, this.value);
+          }
+          this.setDefaultValue(defaultValue, (_b = props.datasource) === null || _b === void 0 ? void 0 : _b.lazyLoad);
           this.preventLoadOnFocus = !defaultDatasource.lazyLoad;
           this.preventLoadOnFocus = this.getInitValue('preventLoadOnFocus', props.preventLoadOnFocus, this.preventLoadOnFocus);
           this.loadMoreQtty = this.datasource.limit;
@@ -5968,6 +5970,11 @@
           this.createAccessors();
           this.initialized = true;
       }
+      getAccessorValue(accessorName) {
+          const [controller, accessor] = core.Accessor.getAccessor(accessorName);
+          const instance = core.Loader.getInstance(controller);
+          return instance[accessor];
+      }
       /**
        * Retrieves datasource structure applying infinity scroll
        * @param field Field structure
@@ -5979,6 +5986,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;
       }
@@ -6005,7 +6022,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;
@@ -6064,10 +6081,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;
       }
       /**
@@ -6126,6 +6147,7 @@
               }
               if (!searchValue) {
                   this.setFieldRowValue(null);
+                  this.selectValue = this.selectedData;
                   return false;
               }
               this.setFieldRowValue(searchValue);
@@ -6236,7 +6258,7 @@
               else {
                   this.removePushedValue();
                   this.datasource.search = this.searchValue;
-                  this.datasource.data = this.cachedData;
+                  this.datasource.data = [...this.cachedData];
                   this.datasource.total = this.cachedTotal;
               }
           });
@@ -6249,6 +6271,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();
               }
           });
       }
@@ -6262,7 +6289,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();
@@ -6275,13 +6302,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() {
@@ -7871,7 +7902,6 @@
        */
       constructor(props) {
           super(props);
-          this.selectedValue = [];
           /**
            * Selected items that were added to datasource
            */
@@ -7885,6 +7915,9 @@
            */
           this.moreChip = 0;
           this.showSelectAll = false;
+          if (!this.selectedValue) {
+              this.selectedValue = [];
+          }
           this.showSelectAll = this.getInitValue('showSelectAll', props.showSelectAll, this.showSelectAll);
           this.createAccessors();
       }
@@ -7924,20 +7957,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 = [];
@@ -7967,7 +8003,9 @@
                       }));
                   }
               });
-              yield Promise.all(promises);
+              if (promises.length) {
+                  yield Promise.all(promises);
+              }
               if (searchValues.length > 0) {
                   this.setFieldRowValue(searchValues);
               }
@@ -8112,7 +8150,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
@@ -8120,10 +8158,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();
           });
       }
       /**
@@ -8317,6 +8361,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;
           }
@@ -8500,7 +8547,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
@@ -8635,6 +8682,7 @@
            * Defines if should wait and not execute GET method when Datasource is created
            */
           this.lazyLoad = true;
+          this.selectValue = null;
           this.nodes = this.getInitValue('nodes', props.nodes, this.nodes);
           this.alwaysOpen = this.getInitValue('alwaysOpen', props.alwaysOpen, this.alwaysOpen);
           this.flattenSearchResults = this.getInitValue('flattenSearchResults', props.flattenSearchResults, this.flattenSearchResults);
@@ -8802,8 +8850,41 @@
       get searchValue() {
           return this.lastInputValue;
       }
+      clearRow(row) {
+          const result = Object.assign({}, row);
+          Object.keys(result).forEach((key) => {
+              if (key.indexOf('tree__') === 0) {
+                  delete result[key];
+              }
+          });
+          return result;
+      }
+      get value() {
+          if (!this.selectValue)
+              return this.selectValue;
+          if (this.returnObject) {
+              return this.clearRow(this.selectValue.row);
+          }
+          return this.selectValue;
+      }
+      set value(value) {
+          this.selectValue = value;
+      }
       setValue(value) {
-          this.value = value;
+          if (this.returnObject) {
+              if (typeof value !== 'object') {
+                  this.value = { id: value };
+              }
+              else {
+                  this.value = { id: value[this.dataValue] };
+              }
+          }
+          else if (typeof value === 'object') {
+              this.value = value[this.dataValue];
+          }
+          else {
+              this.value = value;
+          }
       }
   }
 
@@ -8829,6 +8910,7 @@
            * Selected Nodes
            */
           this.selectedNodes = [];
+          this.selectValue = [];
           this.flat = this.getInitValue('flat', props.flat, this.flat);
           this.limit = this.getInitValue('limit', props.limit, this.limit);
           this.createAccessors();
@@ -8845,6 +8927,34 @@
       deselect(node, element) {
           this.callEvent('onDeselect', { element, component: this, node });
       }
+      get value() {
+          if (this.returnObject) {
+              return this.selectValue.map((value) => this.clearRow(value.row));
+          }
+          return this.selectValue;
+      }
+      set value(value) {
+          this.selectValue = value;
+      }
+      setValue(value) {
+          const arrValue = Array.isArray(value) ? value : [value];
+          if (this.returnObject) {
+              this.value = arrValue.map((item) => {
+                  if (typeof item !== 'object') {
+                      return { id: item };
+                  }
+                  return { id: item[this.dataValue] };
+              });
+          }
+          else {
+              this.value = arrValue.map((item) => {
+                  if (typeof item === 'object') {
+                      return item[this.dataValue];
+                  }
+                  return item;
+              });
+          }
+      }
   }
 
   /**
@@ -10114,7 +10224,6 @@
           if (this.editing)
               return;
           if (column.editable) {
-              this.selectedRows = [];
               this.editing = true;
               this.preventRowClick = true;
               this.datasource.currentRow = row;
@@ -11063,17 +11172,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);
@@ -11102,9 +11231,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 {
@@ -11140,8 +11475,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}`);
       }
@@ -11156,9 +11491,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) {