@zeedhi/common 1.113.0 → 1.115.0

package/dist/zd-common.umd.js

@@ -1923,6 +1923,7 @@
           this.internalDisplayValue = '';
           this.internalValue = null;
           this.formParent = this.getFormParent();
+          this.grid = {};
           this.lastInputValue = '';
           this.callInputEvent = debounce__default["default"](({ event, element, component }) => {
               this.callEvent('input', { event, element, component });
@@ -1950,6 +1951,7 @@
           this.value = this.getInitValue('value', props.value, this.value);
           this.validations = this.getInitValue('validations', props.validations, this.validations);
           this.autoRegister = this.getInitValue('autoRegister', props.autoRegister, this.autoRegister);
+          this.grid = this.getInitValue('grid', props.grid, this.grid);
           this.parseValidations(props.validations || {});
           if (this.autoRegister && this.formParent) {
               this.formParent.registerInput(this);
@@ -4439,6 +4441,9 @@
                   userAppendIconClick({ event, element, component });
               }
           };
+          if (this.value && Array.isArray(this.value)) {
+              this.internalDisplayValue = this.formatter(this.value);
+          }
       }
       /**
        * Character that will separate the two dates
@@ -5865,7 +5870,24 @@
               && (!this.searchVisibleOnly || column.isVisible)
               && (this.searchIn === undefined || this.searchIn === column.name);
       }
-  }
+  }
+  core.Messages.add({
+      'pt-BR': {
+          translation: {
+              gridPageText: '{{firstRow}} - {{lastRow}} de {{total}}',
+          },
+      },
+      'en-US': {
+          translation: {
+              gridPageText: '{{firstRow}} - {{lastRow}} of {{total}}',
+          },
+      },
+      'es-CL': {
+          translation: {
+              gridPageText: '{{firstRow}} - {{lastRow}} de {{total}}',
+          },
+      },
+  });
 
   /**
    * Delete rows error
@@ -7064,6 +7086,9 @@
               });
           }
       }
+      /**
+       * Retrieves the visible value of a cell, which is the corresponding cell in edited row or in the default row
+       */
       getVisibleValue(row, column) {
           const key = row[this.datasource.uniqueKey];
           if (this.editedRows[key] && Object.prototype.hasOwnProperty.call(this.editedRows[key], column.valueIn)) {
@@ -7071,6 +7096,18 @@
           }
           return row[column.valueIn];
       }
+      /**
+       * Retrieves the visible values of a row
+       * @param row
+       * @returns
+       */
+      getVisibleRow(row) {
+          const visibleRow = Object.assign({}, row);
+          this.columns.forEach((column) => {
+              visibleRow[column.valueIn] = this.getVisibleValue(row, column);
+          });
+          return visibleRow;
+      }
       /**
        * Returns editable component properties based on the column definition
        * @param column Column definition
@@ -7166,6 +7203,15 @@
               delete this.invalidComponents[component.name];
           }
       }
+      clearInvalidComponentsForRow(rowKey) {
+          const cloneInvalidComponents = Object.assign({}, this.invalidComponents);
+          Object.keys(cloneInvalidComponents).forEach((compName) => {
+              if (compName.includes(`_editable_${rowKey}`)) {
+                  delete cloneInvalidComponents[compName];
+              }
+          });
+          this.invalidComponents = cloneInvalidComponents;
+      }
       /**
        * change event of editable components
        */
@@ -7277,6 +7323,7 @@
               delete cloneAddedRows[key];
               this.editedRows = cloneEditedRows;
               this.addedRows = cloneAddedRows;
+              this.clearInvalidComponentsForRow(key);
               const { data, uniqueKey } = this.datasource;
               const index = data.findIndex((row) => row[uniqueKey] === key);
               data.splice(index, 1);
@@ -7290,6 +7337,8 @@
               for (let index = allData.length - 1; index >= 0; index -= 1) {
                   const row = allData[index];
                   if (this.addedRows[row[this.datasource.uniqueKey]]) {
+                      const key = row[this.datasource.uniqueKey];
+                      this.clearInvalidComponentsForRow(key);
                       allData.splice(index, 1);
                   }
               }
@@ -7310,13 +7359,17 @@
       saveEditedRows(revalidate = false) {
           return __awaiter(this, void 0, void 0, function* () {
               const { page } = this.datasource;
+              // Verificar se o grid é válido antes de tentar salvar
+              if (!this.isGridValid(revalidate)) {
+                  throw new Error('Invalid rows');
+              }
+              // Só cancelar as linhas adicionadas se todas forem válidas
               yield this.cancelAddedRows();
-              const response = yield Promise.all(this.getEditedRows(revalidate).map((row) => this.addDataRow(row)));
+              const response = yield Promise.all(this.getEditedRows(revalidate, true).map((row) => this.addDataRow(row)));
               this.editing = false;
               this.editedRows = {};
               this.addedRows = {};
               this.invalidComponents = {};
-              this.addedRows = {};
               yield this.datasource.setPage(page);
               return response;
           });
@@ -7567,6 +7620,8 @@
           const rows = Object.assign({}, this.editedRows);
           delete rows[foundRow[uniqueKey]];
           this.editedRows = rows;
+          const key = foundRow[uniqueKey];
+          this.clearInvalidComponentsForRow(key);
       }
       /**
        * Makes the cell enter edit mode
@@ -9668,6 +9723,22 @@
           }
           return result;
       }
+      loadChildren(row, rowIndex = -1) {
+          return __awaiter(this, void 0, void 0, function* () {
+              const { uniqueKey } = this.originalDatasource;
+              let index = rowIndex;
+              if (index === -1) {
+                  index = this.findDataIndex(this.treeData, row[uniqueKey]);
+              }
+              const originalData = [...this.originalDatasource.data];
+              const data = yield this.originalDatasource.addFilter(this.parentField, row[uniqueKey]);
+              originalData.splice(index + 1, 0, ...data);
+              this.originalDatasource.data = originalData;
+              this.originalDatasource.currentRow = this.clearRow(row);
+              delete this.originalDatasource.filter[this.parentField];
+              return data;
+          });
+      }
       /**
        * Expands or collapses a row
        * @param row Row object
@@ -9682,17 +9753,7 @@
                   && this.fetchOnDemand
                   && rowData.tree__children.length === 1
                   && !rowData.tree__children[0][uniqueKey]) {
-                  let index = rowIndex;
-                  if (index === -1) {
-                      index = this.findDataIndex(this.treeData, row[uniqueKey]);
-                  }
-                  const originalData = [...this.originalDatasource.data];
-                  const data = yield this.originalDatasource.addFilter(this.parentField, row[uniqueKey]);
-                  originalData.splice(index + 1, 0, ...data);
-                  this.originalDatasource.data = originalData;
-                  this.originalDatasource.currentRow = this.clearRow(row);
-                  delete this.originalDatasource.filter[this.parentField];
-                  return data;
+                  return this.loadChildren(row, rowIndex);
               }
               return undefined;
           });
@@ -9854,6 +9915,77 @@
       }
   }
 
+  class DatasourceSearcher {
+      constructor() {
+          this.dsSearch = {
+              SEARCH: (value, searchIn) => ({
+                  searchIn: [searchIn],
+                  search: String(value || ''),
+              }),
+              FILTER: (value, searchIn) => ({
+                  filter: {
+                      [searchIn]: value,
+                  },
+              }),
+              FIND: (value, searchIn) => ({
+                  find: {
+                      [searchIn]: value,
+                  },
+              }),
+              DYNAMIC_FILTER: (value, search_in) => {
+                  const arrayValue = Array.isArray(value) ? value : Array.of(value);
+                  const filter = arrayValue.map((item) => ({ operation: 'EQUALS', relation: 'OR', value: item }));
+                  const dynamicFilter = { [search_in]: filter };
+                  return { dynamicFilter };
+              },
+          };
+      }
+      search(datasource, searchValue, searchIn, searchParam) {
+          return __awaiter(this, void 0, void 0, function* () {
+              // using filter/find/dynamicFilter should make only 1 request
+              // using normal search should make one request per search value
+              if (!Array.isArray(searchValue)) {
+                  return this.searchRequest(datasource, searchValue, searchIn, searchParam);
+              }
+              if (searchParam !== 'SEARCH') {
+                  const items = yield this.searchRequest(datasource, searchValue, searchIn, searchParam);
+                  return items;
+              }
+              const searchedItems = [];
+              const promises = searchValue.map((value) => __awaiter(this, void 0, void 0, function* () {
+                  const [item] = yield this.searchRequest(datasource, value, searchIn, searchParam);
+                  searchedItems.push(item);
+              }));
+              yield Promise.all(promises);
+              return searchedItems;
+          });
+      }
+      searchRequest(datasource, searchValue, searchIn, searchParam) {
+          return __awaiter(this, void 0, void 0, function* () {
+              const config = Object.assign(Object.assign(Object.assign({}, datasource.clone()), this.dsSearch[searchParam](searchValue, searchIn)), { lazyLoad: true, loadAll: Array.isArray(searchValue) });
+              const cloneDatasource = core.DatasourceFactory.factory(config);
+              const items = yield cloneDatasource.get();
+              cloneDatasource.destroy();
+              if (Array.isArray(searchValue)) {
+                  return items.filter((item) => searchValue.includes(item[searchIn]));
+              }
+              return items.filter((row) => row[searchIn] === searchValue);
+          });
+      }
+  }
+
+  const uniqueBy = (a, key) => {
+      const seen = {};
+      return a.filter((item) => {
+          const k = item[key] || JSON.stringify(item);
+          if (!seen[k]) {
+              seen[k] = true;
+              return true;
+          }
+          return false;
+      });
+  };
+
   /**
    * Base class for Select component.
    */
@@ -10144,18 +10276,13 @@
        * Finds and retrieves items searching by value
        * @param value Default value
        */
-      getItemsBySearchValue(value, searchIn) {
+      getItemsBySearchValue(value) {
           return __awaiter(this, void 0, void 0, function* () {
-              const config = Object.assign(Object.assign(Object.assign({}, this.datasource.clone()), this.dsSearch[this.searchParam](value, searchIn)), { lazyLoad: true, loadAll: Array.isArray(value) });
               this.datasource.loading = true;
-              const datasource = core.DatasourceFactory.factory(config);
-              const items = yield datasource.get();
+              const datasourceSearcher = new DatasourceSearcher();
+              const result = yield datasourceSearcher.search(this.datasource, value, this.dataValue, this.searchParam);
               this.datasource.loading = false;
-              datasource.destroy();
-              if (Array.isArray(value)) {
-                  return items.filter((item) => value.includes(item[this.dataValue]));
-              }
-              return items.filter(this.getCondition(value));
+              return result;
           });
       }
       getCondition(filterValue) {
@@ -10180,17 +10307,6 @@
               this.updateSearch(this.dirtySearchValue);
           });
       }
-      uniqueBy(a, key) {
-          const seen = {};
-          return a.filter((item) => {
-              const k = item[key] || JSON.stringify(item);
-              if (!seen[k]) {
-                  seen[k] = true;
-                  return true;
-              }
-              return false;
-          });
-      }
       afterLoad() {
           if (this.manualMode)
               return;
@@ -10256,11 +10372,10 @@
               else {
                   filterValue = value;
               }
-              const searchIn = this.dataValue;
               const foundInData = this.datasource.data.find(this.getCondition(filterValue));
               let searchValue = foundInData;
               if (!foundInData && !this.manualMode) {
-                  [searchValue] = yield this.getItemsBySearchValue(filterValue, searchIn);
+                  [searchValue] = yield this.getItemsBySearchValue(filterValue);
               }
               if (!searchValue) {
                   this.setFieldRowValue(null);
@@ -10893,15 +11008,12 @@
           this.createAccessors();
       }
       addSlashes(value) {
-          if (typeof value === 'string') {
-              return value.replace(/\\/g, '\\\\')
-                  .replace(/\t/g, '\\t')
-                  .replace(/\n/g, '\\n')
-                  .replace(/\f/g, '\\f')
-                  .replace(/\r/g, '\\r')
-                  .replace(/"/g, '\\"');
-          }
-          return value;
+          return value.replace(/\\/g, '\\\\')
+              .replace(/\t/g, '\\t')
+              .replace(/\n/g, '\\n')
+              .replace(/\f/g, '\\f')
+              .replace(/\r/g, '\\r')
+              .replace(/"/g, '\\"');
       }
       /**
        * Returns the iterable component metadata based on row data
@@ -10914,14 +11026,13 @@
               .replace(rowExp, JSON.stringify(row))
               .replace(exp, (match) => {
               const propPath = match.replace(/<<|>>|"/g, '').split('.').splice(1).join('.');
-              const value = this.addSlashes(get__default["default"](row, propPath));
+              let value = get__default["default"](row, propPath);
+              if (value === undefined || value === null)
+                  value = '';
               if (typeof value === 'string') {
-                  if (match.startsWith('"') && match.endsWith('"'))
-                      return `"${value}"`;
-                  return value;
+                  const escaped = this.addSlashes(value);
+                  return match.startsWith('"') && match.endsWith('"') ? `"${escaped}"` : escaped;
               }
-              if (value === undefined)
-                  return '""';
               return value;
           });
           return JSON.parse(metadata);
@@ -12599,19 +12710,10 @@
                   this.insertedValues.push(item);
                   pushed = true;
               });
-              // using filter/find/dynamicFilter should make only 1 request
-              // using normal search should make one request per search value
-              if (this.searchParam !== 'SEARCH') {
-                  const items = yield this.getItemsBySearchValue(searchedValues, this.dataValue);
+              if (searchedValues.length) {
+                  const items = yield this.getItemsBySearchValue(searchedValues);
                   items.forEach(insertItem);
               }
-              else {
-                  const promises = searchedValues.map((searchedValue) => __awaiter(this, void 0, void 0, function* () {
-                      const [item] = yield this.getItemsBySearchValue(searchedValue, this.dataValue);
-                      insertItem(item);
-                  }));
-                  yield Promise.all(promises);
-              }
               if (foundValues.length > 0) {
                   this.setFieldRowValue(foundValues);
               }
@@ -12849,7 +12951,7 @@
           if (this.manualMode)
               return;
           if (this.insertedValues.length) {
-              this.datasource.data = this.uniqueBy(this.insertedValues.concat(this.datasource.data), this.datasource.uniqueKey);
+              this.datasource.data = uniqueBy(this.insertedValues.concat(this.datasource.data), this.datasource.uniqueKey);
               const values = this.insertedValues.map((inserted) => inserted[this.dataValue]);
               // prevent caching insertedValues
               this.cachedData = this.datasource.data.filter((row) => !values.includes(row[this.dataValue]));
@@ -13084,6 +13186,7 @@
            * Defines if should wait and not execute GET method when Datasource is created
            */
           this.lazyLoad = true;
+          this.selectValue = null;
           /**
            * Uses delayed loading to load tree branches
            */
@@ -13105,6 +13208,10 @@
            */
           this.dataValueOutFormName = '';
           this.formatterFn = core.FormatterParserProvider.getFormatter('ZdSelectTree');
+          /**
+           * Defines if data handling should be manual or automatic
+           */
+          this.searchParam = 'SEARCH';
           this.savedNodes = undefined;
           this.search = '';
           this.debounceSearch = debounce__default["default"](this.searchChange, 500);
@@ -13132,6 +13239,7 @@
           this.autoSelection = this.getInitValue('autoSelection', props.autoSelection, this.autoSelection);
           this.dataValueOut = this.getInitValue('dataValueOut', props.dataValueOut, this.dataValueOut);
           this.dataValueOutFormName = this.getInitValue('dataValueOutFormName', props.dataValueOutFormName, this.dataValueOutFormName);
+          this.searchParam = this.getInitValue('searchParam', props.searchParam, this.searchParam);
           if (props.datasource && Object.keys(props.datasource).length) {
               this.lazyLoad = props.datasource.lazyLoad !== false;
               const searchFields = Array.isArray(this.dataText) ? this.dataText : [this.dataText];
@@ -13201,6 +13309,9 @@
               this.nodes = this.createChildrenNodes(firstLevelNodes);
           }
       }
+      /**
+       * Creates a Tree Node from a datasource row
+       */
       createNodeFromRow(row) {
           let children;
           if (this.fetchOnDemand && !this.datasource.search) {
@@ -13340,31 +13451,71 @@
           });
           return result;
       }
+      clearNodeRow(row) {
+          return this.clearRow(row.row || row);
+      }
+      /**
+       * Finds and retrieves items searching by value
+       * @param value Default value
+       */
+      getItemsBySearchValue(value) {
+          return __awaiter(this, void 0, void 0, function* () {
+              this.datasource.loading = true;
+              const datasourceSearcher = new DatasourceSearcher();
+              const result = yield datasourceSearcher.search(this.datasource, value, this.dataValue, this.searchParam);
+              this.datasource.loading = false;
+              return result;
+          });
+      }
       get value() {
           if (!this.selectValue)
               return this.selectValue;
           if (this.returnObject) {
-              return this.clearRow(this.selectValue.row || this.selectValue);
+              return this.clearNodeRow(this.selectValue);
           }
-          return this.selectValue;
+          const key = this.datasource ? this.dataValue : 'id';
+          return this.selectValue[key];
       }
       set value(value) {
           this.setValue(value);
       }
       setValue(value) {
-          let val = value;
-          const key = this.datasource ? this.dataValue : 'id';
-          if (typeof value === 'object' && !Array.isArray(value) && value !== null) {
-              val = value[key];
-          }
-          else if (!value && value !== 0) {
-              val = null;
-          }
-          if (this.returnObject) {
-              this.selectValue = val ? { id: val } : null;
-              return;
-          }
-          this.selectValue = val;
+          return __awaiter(this, void 0, void 0, function* () {
+              let val = null;
+              const key = this.datasource ? this.dataValue : 'id';
+              if (!value && value !== 0) {
+                  val = null;
+              }
+              else if (typeof value === 'object') {
+                  val = value[key];
+              }
+              else {
+                  val = value;
+              }
+              if (!val) {
+                  this.selectValue = null;
+                  return;
+              }
+              if (!this.datasource) {
+                  this.selectValue = { id: val };
+                  return;
+              }
+              const searchIn = this.dataValue;
+              const foundInData = this.datasource.data.find((row) => row[searchIn] === val);
+              let foundValue = foundInData;
+              if (!foundInData) {
+                  [foundValue] = yield this.getItemsBySearchValue(val);
+              }
+              if (!foundValue) {
+                  if (typeof value === 'object') {
+                      this.selectValue = Object.assign({ id: val }, value);
+                      return;
+                  }
+                  this.selectValue = { id: val };
+                  return;
+              }
+              this.selectValue = foundValue;
+          });
       }
       loadChildren(parentNode) {
           return __awaiter(this, void 0, void 0, function* () {
@@ -13417,6 +13568,7 @@
            * Selected Nodes
            */
           this.selectedNodes = [];
+          this.selectValue = [];
           /**
            * Changes the behavior of checked nodes that will be displayed in the array of values
            */
@@ -13435,7 +13587,9 @@
        * Triggered after selected nodes change
        */
       changeSelectedNodes(selectedNodes, element) {
-          this.callEvent('onChangeSelectedNodes', { element, component: this, selectedNodes });
+          const selection = this.returnObject
+              ? selectedNodes.map((value) => this.clearNodeRow(value)) : selectedNodes.map((node) => node.id);
+          this.callEvent('onChangeSelectedNodes', { element, component: this, selectedNodes: selection });
       }
       /**
        * Triggered deselecting an node
@@ -13447,34 +13601,58 @@
           if (!this.selectValue)
               return [];
           if (this.returnObject) {
-              return this.selectValue.map((value) => this.clearRow(value.row || value));
+              return this.selectValue.map((value) => this.clearNodeRow(value));
           }
-          return this.selectValue;
+          const key = this.datasource ? this.dataValue : 'id';
+          return this.selectValue.map((item) => item[key]);
       }
       set value(value) {
           this.setValue(value);
       }
       setValue(value) {
-          if (!value) {
-              this.selectValue = [];
-              return;
-          }
-          const arrValue = Array.isArray(value) ? value : [value];
-          const key = this.datasource ? this.dataValue : 'id';
-          if (!this.returnObject) {
-              this.selectValue = arrValue.map((item) => {
+          return __awaiter(this, void 0, void 0, function* () {
+              if (!value) {
+                  this.selectValue = [];
+                  return;
+              }
+              const arrValue = Array.isArray(value) ? value : [value];
+              const key = this.datasource ? this.dataValue : 'id';
+              if (!this.datasource) {
+                  this.selectValue = arrValue.map((item) => {
+                      if (item && typeof item === 'object') {
+                          return item;
+                      }
+                      return { [key]: item };
+                  });
+                  return;
+              }
+              const valuesToSearch = [];
+              const foundValues = [];
+              const insertItem = (item) => __awaiter(this, void 0, void 0, function* () {
+                  if (!item)
+                      return;
+                  foundValues.push(item);
+              });
+              arrValue.forEach((item) => __awaiter(this, void 0, void 0, function* () {
+                  const searchIn = this.dataValue;
+                  if (!item)
+                      return;
                   if (typeof item === 'object') {
-                      return item[key];
+                      insertItem(item);
+                      return;
                   }
-                  return item;
-              });
-              return;
-          }
-          this.selectValue = arrValue.map((item) => {
-              if (typeof item !== 'object') {
-                  return { id: item };
+                  const foundInData = this.datasource.data.find((row) => row[searchIn] === item);
+                  if (!foundInData) {
+                      valuesToSearch.push(item);
+                      return;
+                  }
+                  insertItem(foundInData);
+              }));
+              if (valuesToSearch.length) {
+                  const items = yield this.getItemsBySearchValue(valuesToSearch);
+                  items.forEach(insertItem);
               }
-              return { id: item[key] };
+              this.selectValue = foundValues;
           });
       }
       /**
@@ -13522,16 +13700,18 @@
        */
       selectAllItems(nodes = this.nodes) {
           var _a;
-          if (((_a = this.datasource) === null || _a === void 0 ? void 0 : _a.data) && this.fetchOnDemand) {
-              this.setValue(this.datasource.data);
-              return;
-          }
-          const allNodes = this.getAllNodes(nodes, !this.search);
-          // merge all nodes with the current value before setting it
-          const currentValue = this.getValueAsObject();
-          const nodeMap = this.createMergeMap(currentValue, allNodes);
-          const uniqueArray = Array.from(nodeMap.values());
-          this.setValue(uniqueArray);
+          return __awaiter(this, void 0, void 0, function* () {
+              if (((_a = this.datasource) === null || _a === void 0 ? void 0 : _a.data) && this.fetchOnDemand) {
+                  yield this.setValue(this.datasource.data);
+                  return;
+              }
+              const allNodes = this.getAllNodes(nodes, !this.search);
+              // merge all nodes with the current value before setting it
+              const currentValue = this.getValueAsObject();
+              const nodeMap = this.createMergeMap(currentValue, allNodes);
+              const uniqueArray = Array.from(nodeMap.values());
+              yield this.setValue(uniqueArray);
+          });
       }
       /**
        * Unelects all items in the tree \
@@ -13543,21 +13723,23 @@
        */
       unSelectAllItems(nodes = this.nodes) {
           var _a;
-          if (((_a = this.datasource) === null || _a === void 0 ? void 0 : _a.data) && this.fetchOnDemand) {
-              this.setValue([]);
-              return;
-          }
-          const allNodes = this.getAllNodes(nodes, !this.search);
-          // merge all nodes with the current value before setting it
-          const currentValue = this.getValueAsObject();
-          const nodeMap = this.createMergeMap(currentValue);
-          // remove the current visible nodes from the array
-          const valuesToRemove = allNodes.map((node) => node.id);
-          valuesToRemove.forEach((value) => {
-              nodeMap.delete(value);
+          return __awaiter(this, void 0, void 0, function* () {
+              if (((_a = this.datasource) === null || _a === void 0 ? void 0 : _a.data) && this.fetchOnDemand) {
+                  yield this.setValue([]);
+                  return;
+              }
+              const allNodes = this.getAllNodes(nodes, !this.search);
+              // merge all nodes with the current value before setting it
+              const currentValue = this.getValueAsObject();
+              const nodeMap = this.createMergeMap(currentValue);
+              // remove the current visible nodes from the array
+              const valuesToRemove = allNodes.map((node) => node.id);
+              valuesToRemove.forEach((value) => {
+                  nodeMap.delete(value);
+              });
+              const uniqueArray = Array.from(nodeMap.values());
+              yield this.setValue(uniqueArray);
           });
-          const uniqueArray = Array.from(nodeMap.values());
-          this.setValue(uniqueArray);
       }
       /**
        * Takes two arrays and creates a map of the unique values
@@ -13579,10 +13761,9 @@
           return this.value;
       }
       getValueAsObject() {
-          return this.value.map((row) => {
-              if (this.returnObject)
-                  return row;
-              return { id: row };
+          return this.selectValue.map((row) => {
+              const key = this.datasource ? this.dataValue : 'id';
+              return Object.assign({ id: row[key] }, row);
           });
       }
   }
@@ -15296,6 +15477,11 @@
               return response;
           });
       }
+      loadChildren(row, rowIndex = -1) {
+          return __awaiter(this, void 0, void 0, function* () {
+              yield this.treeDataStructure.loadChildren(row, rowIndex);
+          });
+      }
       /**
        * Expands or collapses a row
        * @param row Row object
@@ -16124,6 +16310,7 @@
   exports.Currency = Currency;
   exports.Dashboard = Dashboard;
   exports.DataValueOutHelper = DataValueOutHelper;
+  exports.DatasourceSearcher = DatasourceSearcher;
   exports.Date = Date$1;
   exports.DateRange = DateRange;
   exports.Dialog = Dialog;
@@ -16210,6 +16397,7 @@
   exports.XLS3Report = XLS3Report;
   exports.XLSReport = XLSReport;
   exports.initTheme = initTheme;
+  exports.uniqueBy = uniqueBy;
 
   Object.defineProperty(exports, '__esModule', { value: true });