@sankhyalabs/sankhyablocks 8.16.0-dev.12 → 8.16.0-dev.120

package/dist/esm/{dataunit-fetcher-3d2ec959.js → dataunit-fetcher-0e025732.js}

@@ -1,5 +1,5 @@
-import { ObjectUtils, DataUnit, DataType, DateUtils, StringUtils, ChangeOperation, ApplicationContext, UserInterface, DataUnitStorage } from '@sankhyalabs/core';
-import { D as DataFetcher, d as dist } from './DataFetcher-773a3e4b.js';
+import { ObjectUtils, DataUnit, DataUnitInMemoryLoader, ApplicationContext, StringUtils, UserInterface, DataUnitStorage, DataType, ChangeOperation } from '@sankhyalabs/core';
+import { D as DataFetcher, d as dist } from './DataFetcher-88e56266.js';
 import { DISTINCT_FILTER_NAME_PREFIX } from '@sankhyalabs/ezui/dist/collection/utils/constants';
 import { DataUnitTransient } from '@sankhyalabs/core/dist/dataunit/metadata/UnitMetadata';
 import { ColumnFilterManager } from '@sankhyalabs/ezui/dist/collection/components/ez-grid/utils';
@@ -9,6 +9,9 @@ import { R as ResourceIDUtils } from './ResourceIDUtils-a114189a.js';
 class ArrayRepository {
   constructor(equalsFunction) {
     this._list = [];
+    this._listCopy = [];
+    this._listLastUpdate = 0;
+    this._listCopyLastUpdate = 0;
     this._equalsFunction = equalsFunction;
   }
   async load(filterFunction, sortingFunction, offset, limit) {
@@ -47,13 +50,13 @@ class ArrayRepository {
     return Promise.resolve(new Map(processedItems.map(item => [item.key, item.value])));
   }
   async push(items) {
-    this._list.push(...items);
+    this.updateList([...this._list, ...items]);
   }
   async clear() {
-    this._list = [];
+    this.updateList([]);
   }
   async delete(items) {
-    this._list = this._list.filter(item => {
+    const list = this._list.filter(item => {
       for (const removed of items) {
         if (this._equalsFunction(item, removed)) {
           return false;
@@ -61,20 +64,23 @@ class ArrayRepository {
       }
       return true;
     });
+    this.updateList(list);
   }
   async update(items) {
-    this._list = this._list.map(existingItem => {
+    const list = this._list.map(existingItem => {
       const newItem = items.find(newItem => this._equalsFunction(existingItem, newItem));
       return newItem == undefined ? existingItem : newItem;
     });
+    this.updateList(list);
   }
   async insert(itemReference, items) {
     const itemPosition = this._list.indexOf(itemReference);
     if (itemPosition == -1) {
-      this._list.push(...items);
+      this.push(items);
       return;
     }
-    this._list = this._list.slice(0, itemPosition).concat(items).concat(this._list.slice(itemPosition));
+    const list = this._list.slice(0, itemPosition).concat(items).concat(this._list.slice(itemPosition));
+    this.updateList(list);
   }
   isOperating() {
     return true;
@@ -86,7 +92,15 @@ class ArrayRepository {
     return Promise.resolve(this._list.length);
   }
   getFromCache() {
-    return ObjectUtils.copy(this._list);
+    if (this._listLastUpdate > this._listCopyLastUpdate) {
+      this._listCopyLastUpdate = this._listLastUpdate;
+      this._listCopy = ObjectUtils.copy(this._list);
+    }
+    return this._listCopy;
+  }
+  updateList(newList) {
+    this._list = newList;
+    this._listLastUpdate = Date.now();
   }
 }
 
@@ -111,7 +125,7 @@ class PreloadManager {
   static getSortingFunction(dataUnit, sorting) {
     return SortingUtils.getSortingFunction(dataUnit, sorting);
   }
-  static async getDistinct(dataUnit, fieldName) {
+  static async getDistinct(dataUnit, fieldName, onlyLabel = false) {
     if (!PreloadManager.isCacheEnabled(dataUnit)) {
       return Promise.resolve(ColumnFilterManager.compileDistinct(fieldName, dataUnit));
     }
@@ -130,7 +144,10 @@ class PreloadManager {
         if (fieldValue == undefined) {
           return { key: null, value: null };
         }
-        const value = fieldValue.value != undefined ? fieldValue.value : fieldValue;
+        let value = fieldValue.value != undefined ? fieldValue.value : fieldValue;
+        if ((fieldValue === null || fieldValue === void 0 ? void 0 : fieldValue.label) && onlyLabel) {
+          return { key: fieldValue === null || fieldValue === void 0 ? void 0 : fieldValue.label, value: dataUnit.getFormattedValue(fieldName, value) };
+        }
         return { key: dataUnit.getFormattedValue(fieldName, fieldValue), value };
       })
         .then(result => {
@@ -224,159 +241,33 @@ class PreloadManager {
 PreloadManager._repositories = new Map();
 PreloadManager._loadingStatus = new Map();
 
-function applyFilter(records, dataUnit, filters) {
-  const columnFilters = ColumnFilterManager.getColumnFilters(filters, "");
-  if (!(columnFilters === null || columnFilters === void 0 ? void 0 : columnFilters.size)) {
-    return records;
-  }
-  const filterFunction = ColumnFilterManager.getFilterFunction(dataUnit, Array.from(columnFilters.values()));
-  if (filterFunction == undefined) {
-    return records;
-  }
-  return records.filter(filterFunction);
-}
-function applySorting(records, dataUnit, sorting) {
-  if (sorting == undefined || sorting.length == 0) {
-    return records;
-  }
-  const sortingFunction = PreloadManager.getSortingFunction(dataUnit, sorting);
-  if (sortingFunction == undefined) {
-    return records;
-  }
-  return records.sort(sortingFunction);
-}
-function buildPaginationInfo(records, offset = 0, limit = 0) {
-  if (records === undefined) {
-    return undefined;
-  }
-  const total = (records === null || records === void 0 ? void 0 : records.length) || 0;
-  const lastRecord = Math.min(offset + limit, total);
-  return {
-    currentPage: limit === 0 ? 0 : Math.ceil(offset / limit),
-    firstRecord: offset,
-    lastRecord: lastRecord,
-    total: total,
-    hasMore: !!(total - lastRecord),
-  };
-}
-
 class InMemoryLoader {
   constructor(metadata, records, config) {
-    this.metadata = metadata;
-    this.records = records;
-    this._dataUnit = new DataUnit(InMemoryLoader.IN_MEMORY_DATA_UNIT_NAME);
-    this._dataUnit.pageSize = 150;
-    this._dataUnit.metadataLoader = () => this.metadaLoader();
-    this._dataUnit.dataLoader = (dataUnit, request) => this.inMemoryLoader(dataUnit, request, this.getRecordsToLoad());
-    this._dataUnit.saveLoader = (_dataUnit, changes) => this.saveLoader(_dataUnit, changes);
-    this._dataUnit.removeLoader = (_dataUnit, recordIds) => this.removeLoader(_dataUnit, recordIds);
-    this.dataUnit.loadMetadata().then(() => {
-      if ((config === null || config === void 0 ? void 0 : config.autoLoad) !== false) {
-        this.dataUnit.loadData();
-      }
-    });
-  }
-  getRecordsToLoad() {
-    if (this._initialRecords == undefined && this.dataUnit.records.length > 0) {
-      this._initialRecords = this.dataUnit.records;
-    }
-    const addedRecords = this.dataUnit.getAddedRecords();
-    if (addedRecords) {
-      return [...this._initialRecords, ...addedRecords];
-    }
-    return this._initialRecords;
+    this._dataUnitInMemoryLoader = new DataUnitInMemoryLoader(metadata, records, config);
   }
   get dataUnit() {
-    return this._dataUnit;
+    return this._dataUnitInMemoryLoader.dataUnit;
   }
   get records() {
-    return this.dataUnit.records;
-  }
-  static getConvertedValue(descriptor, strValue) {
-    if (descriptor.dataType === DataType.BOOLEAN) {
-      return strValue === "S";
-    }
-    if (descriptor.dataType === DataType.NUMBER) {
-      return Number(strValue);
-    }
-    if (descriptor.dataType === DataType.DATE) {
-      return DateUtils.strToDate(strValue, true);
-    }
-    if (descriptor.dataType === DataType.OBJECT) {
-      return JSON.parse(strValue);
-    }
-    return strValue;
+    return this._dataUnitInMemoryLoader.records;
   }
   set records(records) {
-    const columns = this._metadata ? new Map(this._metadata.fields.map(descriptor => [descriptor.name, descriptor])) : undefined;
-    const newRecords = records === null || records === void 0 ? void 0 : records.map(record => {
-      if (!record["__record__id__"]) {
-        record["__record__id__"] = this.generateUniqueId();
-      }
-      if (columns != undefined) {
-        for (const name in record) {
-          const value = record[name];
-          if (typeof value === "string" && columns.has(name)) {
-            record[name] = InMemoryLoader.getConvertedValue(columns.get(name), value);
-          }
-        }
-      }
-      return record;
-    });
-    this._initialRecords = newRecords;
-    if (this._dataUnit) {
-      //Isso força o refresh internamente no datunit
-      this._dataUnit.loadData();
-    }
+    this._dataUnitInMemoryLoader.records = records;
   }
   get metadata() {
-    return this._metadata;
+    return this._dataUnitInMemoryLoader.metadata;
   }
   set metadata(metadata) {
-    this._metadata = metadata;
-    if (this._dataUnit) {
-      this._dataUnit.metadata = this._metadata;
-    }
-  }
-  generateUniqueId() {
-    return StringUtils.generateUUID();
-  }
-  inMemoryLoader(dataUnit, request, recordsIn) {
-    let records = applyFilter(recordsIn, dataUnit, request.filters);
-    records = applySorting(records, dataUnit, request.sort);
-    return Promise.resolve({ records, paginationInfo: buildPaginationInfo(records, request.offset, request.limit) });
-  }
-  metadaLoader() {
-    return Promise.resolve(this._metadata);
-  }
-  saveLoader(_dataUnit, changes) {
-    return new Promise((resolve) => {
-      let dataUnitRecords = [];
-      changes.forEach(change => {
-        let { record, updatingFields, operation } = change;
-        const changedRecord = Object.assign(Object.assign({}, record), updatingFields);
-        if (operation === ChangeOperation.INSERT ||
-          operation === ChangeOperation.COPY) {
-          changedRecord["__old__id__"] = record["__record__id__"];
-          changedRecord["__record__id__"] = this.generateUniqueId();
-          this.records.push(changedRecord);
-        }
-        else {
-          const recordIndex = this.records.findIndex(r => r["__record__id__"] == changedRecord["__record__id__"]);
-          this.records[recordIndex] = changedRecord;
-        }
-        dataUnitRecords.push(changedRecord);
-      });
-      resolve(dataUnitRecords);
-    });
+    this._dataUnitInMemoryLoader.metadata = metadata;
   }
   removeLoader(_dataUnit, recordIds) {
-    return new Promise((resolve) => {
-      resolve(recordIds);
-    });
+    return this._dataUnitInMemoryLoader.removeLoader(_dataUnit, recordIds);
+  }
+  static getConvertedValue(descriptor, strValue, dateFormat) {
+    return DataUnitInMemoryLoader.getConvertedValue(descriptor, strValue, dateFormat);
   }
 }
-InMemoryLoader.IN_MEMORY_DATA_UNIT_NAME = "InMemoryDataUnit";
+InMemoryLoader.IN_MEMORY_DATA_UNIT_NAME = DataUnitInMemoryLoader.IN_MEMORY_DATA_UNIT_NAME;
 
 function getRecordValue(record, fieldName) {
   var _a, _b;
@@ -420,16 +311,25 @@ class DatasetStrategy {
       const serviceName = "DatasetSP.loadRecords";
       const requestBody = this.buildRequestBody(serviceName, fields, dataUnit, request, loadingInfo, serverSorting, serverSideFilters);
       const params = loadingInfo.quiet ? { urlParams: { quietMode: "true" } } : undefined;
-      const { result: responseRecords, pagerID: pagerId } = await DataFetcher.get().callServiceBroker(serviceName, requestBody, params);
+      const { result: responseRecords, pagerID: pagerId, askRowsLimit } = await DataFetcher.get().callServiceBroker(serviceName, requestBody, params);
       const records = this.processRecords(dataUnit, fields, responseRecords);
       const loadingInProgress = pagerId != undefined;
       const count = loadingInfo.count + records.length;
-      const needReload = !loadingInProgress && localSorting.length > 0;
+      const isInsertingNewRecord = dataUnit.hasNewRecord();
+      const hasLocalSorting = localSorting.length > 0;
+      const needReload = !loadingInProgress && hasLocalSorting;
+      /**
+       * Caso precise recarregar dados, porém está no meio de uma inserção, os dados não devem recarregados instantaneamente,
+       * Mas sim, sinalizar que o dataUnit está aguardando para der recarregado.
+       */
+      if (needReload && isInsertingNewRecord) {
+        dataUnit.setWaitingToReload(true);
+      }
       return Promise.resolve({
         records,
         loadingInfo: Object.assign(Object.assign({}, loadingInfo), { pagerId,
-          loadingInProgress, total: loadingInProgress ? undefined : count, count,
-          needReload })
+          loadingInProgress, total: loadingInProgress ? undefined : count, count, needReload: needReload && !isInsertingNewRecord, askRowsLimit,
+          hasLocalSorting })
       });
     }
     catch (error) {
@@ -481,8 +381,7 @@ class DatasetStrategy {
         },
       }
     };
-    const parsedRequestBody = JSON.stringify(requestBody);
-    return parsedRequestBody;
+    return JSON.stringify(requestBody);
   }
   getFieldsList(dataUnit) {
     let fields = ["__record__id__", "__record__label__"];
@@ -599,17 +498,128 @@ class DatasetStrategy {
     return InMemoryLoader.getConvertedValue(descriptor, strValue);
   }
   getSearchDescriptionField(descriptor) {
-    if (descriptor.userInterface === UserInterface.SEARCH) {
-      const { ENTITYNAME, mergedFrom, DESCRIPTIONFIELD } = descriptor.properties;
-      if (!StringUtils.isEmpty(DESCRIPTIONFIELD)) {
-        return mergedFrom != undefined ? `${mergedFrom}.${ENTITYNAME}.${DESCRIPTIONFIELD}` : `${ENTITYNAME}.${DESCRIPTIONFIELD}`;
-      }
+    if (![UserInterface.SEARCH, UserInterface.SEARCHPLUS].includes(descriptor.userInterface)) {
+      return undefined;
+    }
+    const { ENTITYNAME, mergedFrom, DESCRIPTIONFIELD } = descriptor.properties;
+    if (!StringUtils.isEmpty(DESCRIPTIONFIELD)) {
+      return mergedFrom != undefined ? `${mergedFrom}.${ENTITYNAME}.${DESCRIPTIONFIELD}` : `${ENTITYNAME}.${DESCRIPTIONFIELD}`;
     }
     return undefined;
   }
 }
 
+async function showAskCancelPaginationPopup() {
+  return new Promise((resolve) => {
+    const { checkboxContainer, checkbox } = buildCheckboxContainer();
+    const popup = builPopup(resolve, checkbox);
+    const contentContainer = buildContentContainer();
+    contentContainer.appendChild(buildMessage());
+    contentContainer.appendChild(checkboxContainer);
+    const actionsContainer = buildActionsContainer();
+    actionsContainer.appendChild(buildContinuePaginationBtn(popup, checkbox, resolve));
+    actionsContainer.appendChild(buildCancelPaginationBtn(popup, resolve));
+    contentContainer.appendChild(actionsContainer);
+    popup.appendChild(contentContainer);
+    document.body.appendChild(popup);
+  });
+}
+function buildCheckboxContainer() {
+  const checkboxContainer = document.createElement('div');
+  checkboxContainer.style.marginBottom = '14px';
+  checkboxContainer.style.display = 'flex';
+  checkboxContainer.style.alignItems = 'center';
+  const { checkbox, checkboxLabel } = buildCheckbox();
+  checkboxContainer.appendChild(checkbox);
+  checkboxContainer.appendChild(checkboxLabel);
+  return { checkboxContainer, checkbox };
+}
+function buildCheckbox() {
+  const checkbox = document.createElement('input');
+  checkbox.type = 'checkbox';
+  checkbox.id = 'loadAll';
+  const checkboxLabel = document.createElement('label');
+  checkboxLabel.htmlFor = 'loadAll';
+  checkboxLabel.textContent = 'Carregar tudo';
+  checkboxLabel.style.marginLeft = '5px';
+  return { checkbox, checkboxLabel };
+}
+function buildActionsContainer() {
+  const actionsContainer = document.createElement('div');
+  actionsContainer.style.display = 'flex';
+  actionsContainer.style.flexDirection = 'row';
+  actionsContainer.style.justifyContent = 'end';
+  actionsContainer.style.gap = '5px';
+  return actionsContainer;
+}
+function buildContentContainer() {
+  const contentContainer = document.createElement('div');
+  contentContainer.style.display = 'flex';
+  contentContainer.style.flexDirection = 'column';
+  contentContainer.style.fontFamily = 'var(--font-pattern, Roboto)';
+  contentContainer.style.fontSize = 'var(--text--medium)';
+  return contentContainer;
+}
+function buildMessage() {
+  const message = document.createElement('div');
+  const line1 = document.createElement('p');
+  const line2 = document.createElement('p');
+  const line3 = document.createElement('p');
+  line3.style.fontWeight = 'var(--text-weight--large, 600)';
+  line1.textContent = 'Uma quantidade de registros muito grande está sendo carregada.';
+  line2.textContent = 'Recomendamos que a paginação seja cancelada e que seja criado um filtro para os registros.';
+  line3.textContent = 'Deseja cancelar o carregamento?';
+  message.appendChild(line1);
+  message.appendChild(line2);
+  message.appendChild(line3);
+  return message;
+}
+function buildCancelPaginationBtn(popup, resolve) {
+  const cancelPaginationBtn = document.createElement('ez-button');
+  cancelPaginationBtn.label = 'Cancelar paginação';
+  cancelPaginationBtn.size = 'medium';
+  cancelPaginationBtn.classList.add('ez-button--primary');
+  cancelPaginationBtn.onclick = () => {
+    document.body.removeChild(popup);
+    resolve(CancelPaginationResponse.CANCEL);
+  };
+  return cancelPaginationBtn;
+}
+function buildContinuePaginationBtn(popup, checkBox, resolve) {
+  const continuePaginationBtn = document.createElement('ez-button');
+  continuePaginationBtn.label = 'Continuar';
+  continuePaginationBtn.size = 'medium';
+  continuePaginationBtn.onclick = () => {
+    document.body.removeChild(popup);
+    resolve(checkBox.checked ? CancelPaginationResponse.LOAD_ALL : CancelPaginationResponse.CONTINUE);
+  };
+  return continuePaginationBtn;
+}
+function builPopup(resolve, checkBox) {
+  const popup = document.createElement('ez-popup');
+  popup.opened = true;
+  popup.size = 'x-small';
+  popup.ezTitle = 'Aviso';
+  popup.heightMode = "auto";
+  popup.addEventListener('ezClosePopup', () => {
+    document.body.removeChild(popup);
+    resolve(checkBox.checked ? CancelPaginationResponse.LOAD_ALL : CancelPaginationResponse.CONTINUE);
+  }, { once: true });
+  popup.addEventListener('ezPopupAction', () => {
+    document.body.removeChild(popup);
+    resolve(CancelPaginationResponse.CANCEL);
+  }, { once: true });
+  return popup;
+}
+var CancelPaginationResponse;
+(function (CancelPaginationResponse) {
+  CancelPaginationResponse["CANCEL"] = "CANCEL";
+  CancelPaginationResponse["CONTINUE"] = "CONTINUE";
+  CancelPaginationResponse["LOAD_ALL"] = "LOAD_ALL";
+})(CancelPaginationResponse || (CancelPaginationResponse = {}));
+
 class DataUnitDataLoader {
+  constructor() { }
   static async debounce(dataUnit, callBack) {
     const duName = dataUnit.name;
     if (DataUnitDataLoader._debouncingTimeouts[duName]) {
@@ -655,25 +665,67 @@ class DataUnitDataLoader {
   }
   static async callLoader(dataUnit, request, requestLoadingInfo, dataLoader) {
     if (dataLoader == undefined) {
-      //dataLoader = new DataUnitStrategy();
       dataLoader = new DatasetStrategy();
     }
     const result = await dataLoader.load(dataUnit, request, requestLoadingInfo);
-    const { records, loadingInfo: responseLoadingInfo } = result;
-    if (DataUnitDataLoader.isOldRequest(dataUnit, responseLoadingInfo)) {
+    const responseLoadingInfo = result.loadingInfo;
+    if (DataUnitDataLoader.isOldRequest(dataUnit, responseLoadingInfo))
       return Promise.resolve(undefined);
+    this.handleCache(dataLoader, responseLoadingInfo, dataUnit, result.records);
+    if (dataUnit.cancelPagination)
+      return this.handlePaginationCanceled(dataUnit, result);
+    //Não existem mais páginas a serem carregadas
+    if (this.canFinishPagination(dataUnit, responseLoadingInfo))
+      return Promise.resolve(result);
+    const newRequest = Object.assign(Object.assign({}, request), { offset: responseLoadingInfo.count });
+    let newLoadingInfo = this.buildNewLoadingInfo(responseLoadingInfo);
+    if (this.canProceedPagination(responseLoadingInfo))
+      return this.recallLoader(dataUnit, newRequest, newLoadingInfo, dataLoader, result);
+    const confirm = await showAskCancelPaginationPopup();
+    if (confirm === CancelPaginationResponse.CANCEL)
+      return this.handlePaginationCanceled(dataUnit, result);
+    if (confirm === CancelPaginationResponse.LOAD_ALL) {
+      newLoadingInfo = Object.assign(Object.assign({}, newLoadingInfo), { loadAllRecords: true });
     }
+    newLoadingInfo = Object.assign(Object.assign({}, newLoadingInfo), { lastRowLimitAsked: newLoadingInfo.count });
+    return this.recallLoader(dataUnit, newRequest, newLoadingInfo, dataLoader, result);
+  }
+  static buildNewLoadingInfo(responseLoadingInfo) {
+    let newLoadingInfo = Object.assign(Object.assign({}, responseLoadingInfo), { pageNumber: (responseLoadingInfo.pageNumber || 0) + 1, quiet: true });
+    return newLoadingInfo;
+  }
+  static handleCache(dataLoader, responseLoadingInfo, dataUnit, records) {
     const recreateCache = !dataLoader.canSlice() || responseLoadingInfo.count === 0;
     PreloadManager.cacheRecords(dataUnit, records, recreateCache, responseLoadingInfo.loadingInProgress);
-    if (PreloadManager.isCacheEnabled(dataUnit) && responseLoadingInfo.loadingInProgress) {
-      const newRequest = Object.assign(Object.assign({}, request), { offset: responseLoadingInfo.count });
-      const newLoadingInfo = Object.assign(Object.assign({}, responseLoadingInfo), { pageNumber: (responseLoadingInfo.pageNumber || 0) + 1, quiet: true });
-      this.callLoader(dataUnit, newRequest, newLoadingInfo, dataLoader)
-        .then(result => DataUnitDataLoader.afterLoadingPage(dataUnit, result.loadingInfo))
-        .catch(reason => console.error(reason));
-    }
+  }
+  static recallLoader(dataUnit, newRequest, newLoadingInfo, dataLoader, result) {
+    this.callLoader(dataUnit, newRequest, newLoadingInfo, dataLoader)
+      .then(result => DataUnitDataLoader.afterLoadingPage(dataUnit, result.loadingInfo))
+      .catch(reason => console.error(reason));
     return Promise.resolve(result);
   }
+  static canFinishPagination(dataUnit, responseLoadingInfo) {
+    return !PreloadManager.isCacheEnabled(dataUnit) || !responseLoadingInfo.loadingInProgress;
+  }
+  static canProceedPagination(info) {
+    const { count, askRowsLimit, loadAllRecords, lastRowLimitAsked } = info;
+    if (loadAllRecords)
+      return true;
+    if (!count || !askRowsLimit)
+      return true;
+    const askRowLimitNumber = Number(askRowsLimit);
+    if (count < askRowLimitNumber)
+      return true;
+    const nextLimitToAsk = askRowLimitNumber + (lastRowLimitAsked ? lastRowLimitAsked : 0);
+    return count < nextLimitToAsk;
+  }
+  static handlePaginationCanceled(dataUnit, result) {
+    dataUnit.cancelPagination = false;
+    let loadingInfo = result.loadingInfo;
+    loadingInfo = Object.assign(Object.assign({}, loadingInfo), { total: loadingInfo.count, loadingInProgress: false, pagerId: undefined, needReload: loadingInfo.hasLocalSorting });
+    const loadDataResult = { records: result.records, loadingInfo };
+    return Promise.resolve(loadDataResult);
+  }
   static afterLoadingPage(dataUnit, loadingInfo) {
     PreloadManager.setLoadingStatus(dataUnit, loadingInfo.loadingInProgress);
     const dataUnitPagination = dataUnit.getPaginationInfo();
@@ -682,7 +734,7 @@ class DataUnitDataLoader {
     }
     const count = loadingInfo.count;
     if (loadingInfo.loadingInProgress) {
-      dataUnit.updatePagination(Object.assign(Object.assign({}, dataUnitPagination), { count }));
+      dataUnit.updatePagination(Object.assign(Object.assign({}, dataUnitPagination), { count, loadingInProgress: true }));
       return;
     }
     if (loadingInfo.needReload) {
@@ -690,7 +742,7 @@ class DataUnitDataLoader {
       dataUnit.gotoPage(0);
       return;
     }
-    dataUnit.updatePagination(Object.assign(Object.assign({}, dataUnitPagination), { total: count, count }));
+    dataUnit.updatePagination(Object.assign(Object.assign({}, dataUnitPagination), { total: count, count, loadingInProgress: false }));
   }
   static registryLoading(dataUnit, loadingInfo) {
     if (loadingInfo == undefined) {
@@ -713,7 +765,7 @@ class DataUnitDataLoader {
       // controle de paginação voltar pra primeira página.
       offset = 0;
     }
-    const { total, count, loadingInProgress } = loadingInfo;
+    const { total, count, loadingInProgress, askRowsLimit } = loadingInfo;
     const firstRecord = (count === 0 || pageSize === 0) ? 0 : offset + 1;
     const lastRecord = offset + Math.min(pageSize, limit);
     return {
@@ -722,7 +774,8 @@ class DataUnitDataLoader {
       lastRecord,
       firstRecord,
       currentPage: offset / limit,
-      hasMore: lastRecord < count || loadingInProgress
+      hasMore: lastRecord < count || loadingInProgress,
+      askRowsLimit
     };
   }
 }
@@ -1052,4 +1105,4 @@ class DataUnitFetcher {
   }
 }
 
-export { DataUnitFetcher as D, InMemoryLoader as I, PreloadManager as P, DatasetStrategy as a, applyFilter as b, applySorting as c, buildPaginationInfo as d, getRecordValue as g };
+export { DataUnitFetcher as D, InMemoryLoader as I, PreloadManager as P, DatasetStrategy as a, getRecordValue as g };

package/dist/esm/default-filters-50105e43.js

@@ -0,0 +1,8 @@
+var ActionDefaultFilter;
+(function (ActionDefaultFilter) {
+  ActionDefaultFilter["EDIT"] = "edit";
+  ActionDefaultFilter["REMOVE"] = "remove";
+  ActionDefaultFilter["CREATE"] = "create";
+})(ActionDefaultFilter || (ActionDefaultFilter = {}));
+
+export { ActionDefaultFilter as A };