@sankhyalabs/sankhyablocks 8.6.0-dev.2 → 8.6.0-dev.4

package/dist/collection/components/snk-attach/snk-attach.js

@@ -2,7 +2,7 @@ import { h } from "@stencil/core";
 import { ApplicationContext } from "@sankhyalabs/core";
 import { AttachFetcher } from "../../lib/http/data-fetcher/fetchers/attach-fetcher";
 import { VIEW_MODE } from "../../lib/utils/constants";
-import DataUnitFetcher from "../../lib/http/data-fetcher/fetchers/dataunit-fetcher";
+import DataUnitFetcher from "../../lib/http/data-fetcher/fetchers/data-unit/dataunit-fetcher";
 import { AttachmentDataUnitBuilder, buildTaskBarManager, crudConfig } from "./structure";
 const RESOURCE_ID = 'AnexoSistema';
 const DATA_UNIT_NAME = 'br.com.sankhya.core.v3.anexoSistema';
@@ -83,13 +83,25 @@ export class SnkAttach {
       dataUnit.addFilterProvider({ getFilter: () => this._dataUnitBuilder.getFilters(this.registerKey) });
       dataUnit.addInterceptor({ interceptAction: (action) => this._dataUnitBuilder.getInterceptions(dataUnit, action, this._crudElement) });
       this.dataUnit = dataUnit;
-      this.dataUnit.loadData();
+      this.dataUnit.loadData().then(() => {
+        this.disableEditFieldsNotInForm();
+      });
       return this.dataUnit;
     }
     catch (error) {
       throw new Error('There was an error while creating the data unit');
     }
   }
+  disableEditFieldsNotInForm() {
+    var _a;
+    (_a = this.crudConfig) === null || _a === void 0 ? void 0 : _a.grid.columns.forEach(column => {
+      var _a;
+      const fieldName = column.name;
+      if (!((_a = this.crudConfig) === null || _a === void 0 ? void 0 : _a.form.fields.some(field => field.name === fieldName))) {
+        this.dataUnit.disableField(fieldName);
+      }
+    });
+  }
   componentWillLoad() {
     this._application = ApplicationContext.getContextValue("__SNK__APPLICATION__");
     this.loadAttachmentDataUnit();

package/dist/collection/components/snk-grid/filtercolumn/SnkMultiSelectionListDataSource.js

@@ -1,4 +1,5 @@
 import { DateUtils, UserInterface } from '@sankhyalabs/core';
+import PreloadManager from '../../../lib/http/data-fetcher/fetchers/data-unit/cache/PreloadManager';
 export default class SnkMultiSelectionListDataSource {
   setDataUnit(dataUnit) {
     this._dataUnit = dataUnit;
@@ -13,6 +14,16 @@ export default class SnkMultiSelectionListDataSource {
     }
     return String(this._dataUnit.getFormattedValue(fieldName, value));
   }
+  async getStaticOptions(fieldName) {
+    if (fieldName == undefined) {
+      return Promise.resolve(undefined);
+    }
+    const result = await PreloadManager.getDistinct(this._dataUnit, fieldName);
+    if (result == undefined) {
+      return Promise.resolve(undefined);
+    }
+    return Promise.resolve(Array.from(result.entries()).map(([label, value]) => ({ label: String(label), value, check: true })));
+  }
   fetchData(filterTerm, fieldName) {
     return new Promise(resolve => {
       this._application.executeSelectDistinct(this._dataUnit, fieldName, filterTerm).then(result => {

package/dist/collection/components/snk-grid/snk-grid.js

@@ -8,6 +8,7 @@ import TaskbarProcessor from '../snk-taskbar/processor/taskbar-processor';
 import store from "../../lib/store";
 import SnkMultiSelectionListDataSource from './filtercolumn/SnkMultiSelectionListDataSource';
 import { SelectionMode } from '@sankhyalabs/core/dist/dataunit/DataUnit';
+import { SortMode } from '@sankhyalabs/core';
 export class SnkGrid {
   constructor() {
     this._topTaskbarProcessor = new TaskbarProcessor({
@@ -88,6 +89,18 @@ export class SnkGrid {
   }
   setGridConfig(config) {
     this._gridConfig = config;
+    this.assertDefaultSorting();
+  }
+  assertDefaultSorting() {
+    if (this._gridConfig && this._dataUnit) {
+      this._dataUnit.defaultSorting = this._gridConfig
+        .columns
+        .sort((colA, colB) => colA.orderIndex - colB.orderIndex)
+        .map(({ name: field, ascending }) => {
+        const { dataType } = this._dataUnit.getField(field);
+        return { field, dataType, mode: ascending ? SortMode.ASC : SortMode.DESC };
+      });
+    }
   }
   loadConfig() {
     ConfigStorage.loadGridConfig(this.configName, this.resourceID)
@@ -213,11 +226,12 @@ export class SnkGrid {
     ElementIDUtils.addIDInfo(this._element, null, dataInfo);
   }
   finshLoading() {
-    var _a, _b;
-    this._dataUnitLoadLockerResolver = this._dataUnit.addLoadingLocker();
+    this.assertDefaultSorting();
     this.addElementID();
-    (_a = this.columnFilterDataSource) === null || _a === void 0 ? void 0 : _a.setApplication(this._application);
-    (_b = this.columnFilterDataSource) === null || _b === void 0 ? void 0 : _b.setDataUnit(this._dataUnit);
+    if (this.columnFilterDataSource != undefined) {
+      this.columnFilterDataSource.setApplication(this._application);
+      this.columnFilterDataSource.setDataUnit(this._dataUnit);
+    }
   }
   componentWillLoad() {
     this._application = ApplicationContext.getContextValue("__SNK__APPLICATION__");
@@ -298,18 +312,13 @@ export class SnkGrid {
   getPrimaryButton() {
     return this.presentationMode === PresentationMode.PRIMARY ? "INSERT" : "";
   }
-  onEzGridReady() {
-    var _a;
-    (_a = this._dataUnitLoadLockerResolver) === null || _a === void 0 ? void 0 : _a.call(this);
-    this._dataUnitLoadLockerResolver = undefined;
-  }
   render() {
     var _a, _b;
     if (!this._dataUnit) {
       return undefined;
     }
     return (h("div", { class: "snk-grid__container ez-flex ez-flex--column ez-flex-item--auto ez-padding--large" }, h("div", { class: "snk-grid__header ez-margin-bottom--medium" }, h("snk-filter-bar", { ref: (ref) => this._snkFilterBar = ref, dataUnit: this._dataUnit, "data-element-id": "gridFilter", class: "snk-grid__filter-bar ez-align--top", configName: this.configName, messagesBuilder: this.messagesBuilder, resourceID: this.resourceID }), ((_b = (_a = this._snkFilterBar) === null || _a === void 0 ? void 0 : _a.filterConfig) === null || _b === void 0 ? void 0 : _b.length) > 0 &&
-      h("hr", { class: "ez-divider-vertical ez-divider--dark ez-margin-left--medium snk-grid__header-divider" }), h("snk-taskbar", { class: "ez-padding-left--medium", "data-element-id": "grid_top", key: "topTaskbar", configName: this.configName, dataUnit: this._dataUnit, messagesBuilder: this.messagesBuilder, buttons: this._topTaskbarProcessor.buttons, disabledButtons: this._topTaskbarProcessor.disabledButtons, customButtons: this._topTaskbarProcessor.customButtons, primaryButton: this.getPrimaryButton(), resourceID: this.resourceID, customContainerId: this.taskbarCustomContainerId, customSlotId: this.topTaskbarCustomSlotId }, h("slot", { name: this.topTaskbarCustomSlotId }))), h("ez-grid", { ref: ref => this._grid = ref, class: (this.presentationMode === PresentationMode.SECONDARY ? "snk-grid-container__without-shadow " : "") + "snk-grid__table", "data-element-id": "embedded", dataUnit: this._dataUnit, key: "grid-" + this._snkDataUnit.entityName, config: this._gridConfig, onConfigChange: (evt) => { this.gridConfigChangeHandler(evt); }, onEzDoubleClick: () => this.gridDoubleClick.emit(), statusResolver: this.statusResolver, multipleSelection: this.multipleSelection, onComponentReady: () => this.onEzGridReady(), columnfilterDataSource: this.columnFilterDataSource, selectionToastConfig: this.selectionToastConfig, useEnterLikeTab: this.useEnterLikeTab, recordsValidator: this.recordsValidator, canEdit: this.canEdit }, h("snk-taskbar", { dataUnit: this._dataUnit, configName: this.configName, messagesBuilder: this.messagesBuilder, "data-element-id": "grid_left", buttons: this._headerTaskbarProcessor.buttons, disabledButtons: this._headerTaskbarProcessor.disabledButtons, customButtons: this._headerTaskbarProcessor.customButtons, slot: "leftButtons", actionsList: this.actionsList, resourceID: this.resourceID, customContainerId: this.taskbarCustomContainerId, customSlotId: this.gridHeaderCustomSlotId }, h("slot", { name: this.gridHeaderCustomSlotId }))), h("div", { class: "ez-col ez-col--sd-12" }, h("slot", { name: "SnkGridFooter" })), h("ez-modal", { modalSize: "small", closeEsc: false, closeOutsideClick: false, opened: this._popUpGridConfig, onEzCloseModal: () => this.closeGridConfig() }, h("snk-grid-config", { ref: ref => this._snkGridConfig = ref, config: this._gridConfig, "data-element-id": this._element.getAttribute(ElementIDUtils.DATA_ELEMENT_ID_ATTRIBUTE_NAME), application: this._application, selectedIndex: 0, configName: this.configName, onConfigChange: (evt) => this.modalConfigChangeHandler(evt), onConfigCancel: () => this.closeGridConfig(), resourceID: this.resourceID }))));
+      h("hr", { class: "ez-divider-vertical ez-divider--dark ez-margin-left--medium snk-grid__header-divider" }), h("snk-taskbar", { class: "ez-padding-left--medium", "data-element-id": "grid_top", key: "topTaskbar", configName: this.configName, dataUnit: this._dataUnit, messagesBuilder: this.messagesBuilder, buttons: this._topTaskbarProcessor.buttons, disabledButtons: this._topTaskbarProcessor.disabledButtons, customButtons: this._topTaskbarProcessor.customButtons, primaryButton: this.getPrimaryButton(), resourceID: this.resourceID, customContainerId: this.taskbarCustomContainerId, customSlotId: this.topTaskbarCustomSlotId }, h("slot", { name: this.topTaskbarCustomSlotId }))), h("ez-grid", { ref: ref => this._grid = ref, class: (this.presentationMode === PresentationMode.SECONDARY ? "snk-grid-container__without-shadow " : "") + "snk-grid__table", "data-element-id": "embedded", dataUnit: this._dataUnit, key: "grid-" + this._snkDataUnit.entityName, config: this._gridConfig, onConfigChange: (evt) => { this.gridConfigChangeHandler(evt); }, onEzDoubleClick: () => this.gridDoubleClick.emit(), statusResolver: this.statusResolver, multipleSelection: this.multipleSelection, columnfilterDataSource: this.columnFilterDataSource, selectionToastConfig: this.selectionToastConfig, useEnterLikeTab: this.useEnterLikeTab, recordsValidator: this.recordsValidator, canEdit: this.canEdit }, h("snk-taskbar", { dataUnit: this._dataUnit, configName: this.configName, messagesBuilder: this.messagesBuilder, "data-element-id": "grid_left", buttons: this._headerTaskbarProcessor.buttons, disabledButtons: this._headerTaskbarProcessor.disabledButtons, customButtons: this._headerTaskbarProcessor.customButtons, slot: "leftButtons", actionsList: this.actionsList, resourceID: this.resourceID, customContainerId: this.taskbarCustomContainerId, customSlotId: this.gridHeaderCustomSlotId }, h("slot", { name: this.gridHeaderCustomSlotId }))), h("div", { class: "ez-col ez-col--sd-12" }, h("slot", { name: "SnkGridFooter" })), h("ez-modal", { modalSize: "small", closeEsc: false, closeOutsideClick: false, opened: this._popUpGridConfig, onEzCloseModal: () => this.closeGridConfig() }, h("snk-grid-config", { ref: ref => this._snkGridConfig = ref, config: this._gridConfig, "data-element-id": this._element.getAttribute(ElementIDUtils.DATA_ELEMENT_ID_ATTRIBUTE_NAME), application: this._application, selectedIndex: 0, configName: this.configName, onConfigChange: (evt) => this.modalConfigChangeHandler(evt), onConfigCancel: () => this.closeGridConfig(), resourceID: this.resourceID }))));
   }
   static get is() { return "snk-grid"; }
   static get encapsulation() { return "scoped"; }
@@ -329,11 +338,12 @@ export class SnkGrid {
         "type": "unknown",
         "mutable": true,
         "complexType": {
-          "original": "SnkMultiSelectionListDataSource",
-          "resolved": "SnkMultiSelectionListDataSource",
+          "original": "IMultiSelectionListDataSource",
+          "resolved": "IMultiSelectionListDataSource",
           "references": {
-            "SnkMultiSelectionListDataSource": {
-              "location": "global"
+            "IMultiSelectionListDataSource": {
+              "location": "import",
+              "path": "@sankhyalabs/ezui/dist/types/components/ez-multi-selection-list/interfaces/IMultiSelectionListDataSource"
             }
           }
         },

package/dist/collection/lib/dataUnit/InMemoryLoader.js

@@ -1,8 +1,8 @@
-import { ChangeOperation, DataUnit, defaultDataLoader, StringUtils, } from '@sankhyalabs/core';
+import { ChangeOperation, DataType, DataUnit, DateUtils, defaultDataLoader, StringUtils, } from '@sankhyalabs/core';
 export default class InMemoryLoader {
   constructor(metadata, records) {
-    this.records = records;
     this.metadata = metadata;
+    this.records = records;
     this._dataUnit = new DataUnit(InMemoryLoader.IN_MEMORY_DATA_UNIT_NAME);
     this._dataUnit.metadataLoader = () => this.metadaLoader();
     this._dataUnit.dataLoader = (dataUnit, request) => defaultDataLoader(dataUnit, request, this.getRecordsToLoad());
@@ -27,11 +27,32 @@ export default class InMemoryLoader {
   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);
+    }
+    return strValue;
+  }
   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;
     });
     if (this._dataUnit) {

package/dist/collection/lib/http/data-fetcher/DataFetcher.js

@@ -34,9 +34,14 @@ export class DataFetcher {
       }
     }
     this.instance.application = ApplicationContext.getContextValue("__SNK__APPLICATION__");
-    this.instance.graphqlPath = `/${this.instance.application.getModuleName()}/graphql`;
     return this.instance;
   }
+  static getGraphQLPath() {
+    if (StringUtils.isEmpty(this.instance.graphqlPath) && this.instance.application != undefined) {
+      this.instance.graphqlPath = `/${this.instance.application.getModuleName()}/graphql`;
+    }
+    return this.instance.graphqlPath;
+  }
   static addRequestListener(listener) {
     const index = DataFetcher.requestListener.indexOf(listener);
     if (index < 0) {
@@ -86,7 +91,7 @@ export class DataFetcher {
     }
     return new ErrorException(title, statusMessage, tsErrorCode);
   }
-  async callGraphQL(req) {
+  async callGraphQL(req, quietMode = false) {
     var _a;
     if (this.ready) {
       this.pause();
@@ -104,7 +109,7 @@ export class DataFetcher {
     if (this.ready) {
       return new Promise(async (resolve, reject) => {
         let query = this.getQueryTemplate(req);
-        const res = await this.fecthGrapql([{ document: query, variables: req.values }]);
+        const res = await this.fecthGrapql([{ document: query, variables: req.values }], quietMode);
         if (res.errors.length > 0) {
           if (!this.proccesGraphQLClientEvents(res === null || res === void 0 ? void 0 : res.extensions, req, resolve, reject)) {
             const error = this.processGraphQlErrorInfo(res.errors);
@@ -119,7 +124,7 @@ export class DataFetcher {
     }
     else {
       if (!this.watingRequestsById.has(reqKey)) {
-        this.watingRequestsById.set(reqKey, new WaitingRequest(req));
+        this.watingRequestsById.set(reqKey, new WaitingRequest(req, quietMode));
       }
       return (_a = this.watingRequestsById.get(reqKey)) === null || _a === void 0 ? void 0 : _a.promise;
     }
@@ -347,14 +352,16 @@ export class DataFetcher {
   }
   async executePendingRequest(watingRequestsById) {
     const requestsBatch = [];
+    let quietMode = true;
     watingRequestsById.forEach(async (waitingReq) => {
       let query = this.getQueryTemplate(waitingReq.request);
       requestsBatch.push({ document: query, variables: Object.assign({}, waitingReq.request.values) });
+      quietMode = quietMode && waitingReq.quietMode;
     });
     let res = undefined;
     let dataResponse = [];
     let errorsResponse = [];
-    res = await this.fecthGrapql(requestsBatch);
+    res = await this.fecthGrapql(requestsBatch, quietMode);
     dataResponse = res.data;
     errorsResponse = res.errors;
     //Reject promises with errors from query
@@ -372,14 +379,18 @@ export class DataFetcher {
       });
     });
   }
-  async fecthGrapql(request) {
+  async fecthGrapql(request, quietMode) {
     let res = undefined;
     let dataResponse = [];
     let errorsResponse = [];
-    let url = `${this.resolveURL() + this.graphqlPath}`;
+    let url = `${this.resolveURL() + DataFetcher.getGraphQLPath()}`;
     const responseExtensions = [];
-    if (window['mgeSession']) {
-      url += `?mgeSession=${window['mgeSession']}`;
+    const mgeSession = window["mgeSession"];
+    if (mgeSession != undefined) {
+      url += `?mgeSession=${mgeSession}`;
+    }
+    if (quietMode) {
+      url += `${url.indexOf("?") > -1 ? "&" : "?"}quietMode=true`;
     }
     DataFetcher.requestListener.forEach(listener => listener.onRequestStart({ url: url, requestBody: request }));
     try {
@@ -465,7 +476,7 @@ DataFetcher.SERVICE_BROKER_STATUS = {
 };
 DataFetcher.clientEventsByID = new Map();
 class WaitingRequest {
-  constructor(req) {
+  constructor(req, quietMode) {
     this._resolve = () => { };
     this._reject = () => { };
     this._request = undefined;
@@ -474,6 +485,7 @@ class WaitingRequest {
       this._resolve = resolve;
       this._reject = reject;
     });
+    this._quietMode = quietMode;
   }
   get resolve() {
     return this._resolve;
@@ -487,4 +499,7 @@ class WaitingRequest {
   get request() {
     return this._request;
   }
+  get quietMode() {
+    return this._quietMode;
+  }
 }

package/dist/collection/lib/http/data-fetcher/fetchers/data-unit/DataUnitDataLoader.js

@@ -0,0 +1,112 @@
+import PreloadManager from "./cache/PreloadManager";
+import { DatasetStrategy } from "./loadstrategy/DatasetStrategy";
+export default class DataUnitDataLoader {
+  static async debounce(dataUnit, callBack) {
+    const duName = dataUnit.name;
+    if (DataUnitDataLoader._debouncingTimeouts[duName]) {
+      clearTimeout(DataUnitDataLoader._debouncingTimeouts[duName]);
+      delete DataUnitDataLoader._debouncingTimeouts[duName];
+    }
+    DataUnitDataLoader._debouncingTimeouts[duName] = setTimeout(() => {
+      delete DataUnitDataLoader._debouncingTimeouts[duName];
+      callBack();
+    }, 100);
+  }
+  static async loadData(dataUnit, request) {
+    return new Promise((resolve, reject) => {
+      DataUnitDataLoader.debounce(dataUnit, () => {
+        PreloadManager.loadData(dataUnit, request, this.loadFromServer)
+          .then(resp => resolve(resp))
+          .catch(reason => reject(reason));
+      });
+    });
+  }
+  static async loadFromServer(dataUnit, request, loadingInfo) {
+    try {
+      //Registramos a request com as informações de carga para determinarmos a última.
+      //Caso o usuário inicie outro refresh antes de terminar, devemos ignorar o resultado.
+      loadingInfo = DataUnitDataLoader.registryLoading(dataUnit, loadingInfo);
+      const loadResult = await DataUnitDataLoader.callLoader(dataUnit, request, loadingInfo);
+      if (loadResult == undefined) {
+        //Essa request foi originada de refresh antigo. Será ignorada;
+        return;
+      }
+      const loadedRecords = loadResult.records;
+      const paginationInfo = DataUnitDataLoader.buildPaginationInfo(loadedRecords.length, request, loadResult.loadingInfo);
+      const records = paginationInfo == undefined ? loadedRecords : loadedRecords.slice(0, paginationInfo.lastRecord);
+      return Promise.resolve({ records, paginationInfo });
+    }
+    catch (error) {
+      console.error(error);
+      return Promise.reject(error);
+    }
+  }
+  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)) {
+      return Promise.resolve(undefined);
+    }
+    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 });
+      this.callLoader(dataUnit, newRequest, newLoadingInfo, dataLoader)
+        .then(result => DataUnitDataLoader.afterLoadingPage(dataUnit, result.loadingInfo))
+        .catch(reason => console.error(reason));
+    }
+    return Promise.resolve(result);
+  }
+  static afterLoadingPage(dataUnit, loadingInfo) {
+    PreloadManager.setLoadingStatus(dataUnit, loadingInfo.loadingInProgress);
+    const dataUnitPagination = dataUnit.getPaginationInfo();
+    if (dataUnitPagination == undefined) {
+      return;
+    }
+    const count = loadingInfo.count;
+    if (loadingInfo.loadingInProgress) {
+      dataUnit.updatePagination(Object.assign(Object.assign({}, dataUnitPagination), { count }));
+      return;
+    }
+    dataUnit.updatePagination(Object.assign(Object.assign({}, dataUnitPagination), { total: count, count }));
+  }
+  static registryLoading(dataUnit, loadingInfo) {
+    if (loadingInfo == undefined) {
+      loadingInfo = { requestTime: new Date().getTime(), count: 0 };
+    }
+    DataUnitDataLoader._requestTimeByDataUnit.set(dataUnit.name, loadingInfo.requestTime);
+    return loadingInfo;
+  }
+  static isOldRequest(dataUnit, loadingInfo) {
+    return DataUnitDataLoader._requestTimeByDataUnit.get(dataUnit.name) > loadingInfo.requestTime;
+  }
+  static buildPaginationInfo(pageSize, request, loadingInfo) {
+    let { limit, offset } = request;
+    if (!limit) {
+      return undefined;
+    }
+    if (loadingInfo.pageNumber === 1) {
+      // Quando o loader não é capaz de fatiar os registros
+      // ele pode decidir por uma carga completa, o que faz o
+      // controle de paginação voltar pra primeira página.
+      offset = 0;
+    }
+    const { total, count, loadingInProgress } = loadingInfo;
+    const lastRecord = offset + Math.min(pageSize, limit);
+    return {
+      total,
+      count,
+      lastRecord,
+      firstRecord: offset + 1,
+      currentPage: offset / limit,
+      hasMore: lastRecord < count || loadingInProgress
+    };
+  }
+}
+DataUnitDataLoader._requestTimeByDataUnit = new Map();
+DataUnitDataLoader._debouncingTimeouts = {};

package/dist/collection/lib/http/data-fetcher/fetchers/data-unit/cache/ArrayRepository.js

@@ -0,0 +1,59 @@
+export class ArrayRepository {
+  constructor(equalsFunction) {
+    this._list = [];
+    this._equalsFunction = equalsFunction;
+  }
+  async load(filterFunction, sortingFunction, offset, limit) {
+    let result = [].concat(this._list);
+    if (filterFunction != undefined) {
+      result = this._list.filter(item => filterFunction(item));
+    }
+    if (sortingFunction != undefined) {
+      result = result.sort(sortingFunction);
+    }
+    const count = result.length;
+    if (limit != undefined) {
+      const start = offset || 0;
+      const end = limit ? start + limit : result.length;
+      result = result.slice(start, end);
+    }
+    return Promise.resolve({ result, count });
+  }
+  async distict(itemProcessor) {
+    const processedItems = this._list.map(item => itemProcessor(item));
+    return Promise.resolve(new Map(processedItems.filter(item => item != undefined)
+      .map(item => [item.key, item.value])));
+  }
+  async push(items) {
+    this._list.push(...items);
+  }
+  async clear() {
+    this._list = [];
+  }
+  async delete(items) {
+    this._list = this._list.filter(item => !items.includes(item));
+  }
+  async update(items) {
+    this._list = this._list.map(existingItem => {
+      const newItem = items.find(newItem => this._equalsFunction(existingItem, newItem));
+      return newItem == undefined ? existingItem : newItem;
+    });
+  }
+  async insert(itemReference, items) {
+    const itemPosition = this._list.indexOf(itemReference);
+    if (itemPosition == -1) {
+      this._list.push(...items);
+      return;
+    }
+    this._list = this._list.slice(0, itemPosition).concat(items).concat(this._list.slice(itemPosition));
+  }
+  isOperating() {
+    return true;
+  }
+  async isEmpty() {
+    return Promise.resolve(this._list.length === 0);
+  }
+  async count() {
+    return Promise.resolve(this._list.length);
+  }
+}

package/dist/collection/lib/http/data-fetcher/fetchers/data-unit/cache/PreloadManager.js

@@ -0,0 +1,169 @@
+import { DataUnit, FieldComparator, SortMode } from "@sankhyalabs/core";
+import DataUnitFetcher from "../dataunit-fetcher";
+import { ArrayRepository } from "./ArrayRepository";
+const COLUMN_FILTER_PATTERN = /FILTRO_COLUNA_(.+)/;
+export default class PreloadManager {
+  static setLoadingStatus(dataUnit, loadingInProgress) {
+    this._loadingStatus.set(dataUnit.name, loadingInProgress);
+  }
+  static isCacheEnabled(dataUnit) {
+    const dataUnitResourceId = PreloadManager.getResourceId(dataUnit.name);
+    if (dataUnitResourceId !== this.applicationResourceID) {
+      return false;
+    }
+    return this.getRepository(dataUnit).isOperating();
+  }
+  static getResourceId(dataUnitName) {
+    const dataUnitNameInfo = DataUnitFetcher.parseDataUnitName(dataUnitName);
+    return dataUnitNameInfo == undefined ? undefined : dataUnitNameInfo.resourceID;
+  }
+  static cacheRecords(dataUnit, records, resetDatabase, loadingInProgress) {
+    PreloadManager.setLoadingStatus(dataUnit, loadingInProgress);
+    if (PreloadManager.isCacheEnabled(dataUnit)) {
+      this.getRepository(dataUnit).push(records);
+    }
+    else {
+      if (resetDatabase) {
+        this._repositories.delete(dataUnit.name);
+      }
+    }
+  }
+  static getSortingFunction(dataUnit, sorting) {
+    if (sorting == undefined || sorting.length == 0) {
+      return undefined;
+    }
+    return (recordA, recordB) => {
+      for (const sort of sorting) {
+        const result = FieldComparator.compare(dataUnit.getField(sort.field), recordA, recordB, sort.mode === SortMode.ASC);
+        if (result != 0) {
+          return result;
+        }
+      }
+    };
+  }
+  static async getDistinct(dataUnit, fieldName) {
+    if (!PreloadManager.isCacheEnabled(dataUnit)) {
+      return Promise.resolve(undefined);
+    }
+    return new Promise((accept, reject) => {
+      PreloadManager.getRepository(dataUnit).distict(record => {
+        const fieldValue = record[fieldName];
+        if (fieldValue == undefined) {
+          return undefined;
+        }
+        const value = fieldValue.value != undefined ? fieldValue.value : fieldValue;
+        return { key: dataUnit.getFormattedValue(fieldName, fieldValue), value };
+      })
+        .then(values => accept(values))
+        .catch(reason => reject(reason));
+    });
+  }
+  static async loadData(dataUnit, request, loadFromServer) {
+    try {
+      if (PreloadManager.isCacheEnabled(dataUnit)) {
+        let useCache = request.source === "EZ_GRID_LOADING_SOURCE" || request.source === DataUnit.CHANGING_PAGE_LOADING_SOURCE;
+        if (useCache) {
+          const isCacheEmpty = await PreloadManager.getRepository(dataUnit).isEmpty();
+          if (!isCacheEmpty) {
+            return PreloadManager.loadFromCache(dataUnit, request);
+          }
+        }
+        //Como não vamos aproveitar o cache, ele precisa ser limpado.
+        PreloadManager.getRepository(dataUnit).clear().catch(() => { });
+      }
+      return loadFromServer(dataUnit, request);
+    }
+    catch (error) {
+      console.error(error);
+      return Promise.reject(error);
+    }
+  }
+  static insertRecords(dataUnit, reference, records) {
+    if (PreloadManager.isCacheEnabled(dataUnit)) {
+      PreloadManager.getRepository(dataUnit).insert(reference, records);
+    }
+  }
+  static updateRecords(dataUnit, records) {
+    if (PreloadManager.isCacheEnabled(dataUnit)) {
+      PreloadManager.getRepository(dataUnit).update(records);
+    }
+  }
+  static removeRecords(dataUnit, records) {
+    if (PreloadManager.isCacheEnabled(dataUnit)) {
+      PreloadManager.getRepository(dataUnit).delete(records);
+    }
+  }
+  static async countRecords(dataUnit) {
+    if (PreloadManager.isCacheEnabled(dataUnit)) {
+      return PreloadManager.getRepository(dataUnit).count();
+    }
+    return Promise.resolve(0);
+  }
+  static getRepository(dataUnit) {
+    const name = dataUnit.name;
+    if (!PreloadManager._repositories.has(name)) {
+      PreloadManager._repositories.set(name, new ArrayRepository((recordA, recordB) => recordA.__record__id__ === recordB.__record__id__));
+    }
+    return PreloadManager._repositories.get(name);
+  }
+  static getFilterFunction(dataUnit, filters) {
+    if (filters != undefined && filters.length > 0) {
+      return record => {
+        for (const filter of filters) {
+          if (!PreloadManager.recordMatchesFilter(dataUnit, record, filter)) {
+            return false;
+          }
+        }
+        return true;
+      };
+    }
+    return undefined;
+  }
+  static recordMatchesFilter(dataUnit, record, columnFilter) {
+    const fieldValue = record[columnFilter.columnName];
+    for (let param of columnFilter.params) {
+      const paramValue = dataUnit.valueFromString(columnFilter.columnName, param.value);
+      if (FieldComparator.compareValues(dataUnit.getField(columnFilter.columnName), fieldValue, paramValue) === 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+  static async loadFromCache(dataUnit, request) {
+    return new Promise((accept, reject) => {
+      const columnFilters = PreloadManager.getColumnFilters(request.filters);
+      const { limit, offset, sort } = request;
+      PreloadManager.getRepository(dataUnit)
+        .load(PreloadManager.getFilterFunction(dataUnit, Array.from(columnFilters.values())), PreloadManager.getSortingFunction(dataUnit, sort), offset, limit)
+        .then(loadResult => {
+        const stillLoading = PreloadManager._loadingStatus.get(dataUnit.name);
+        const { count, result: records } = loadResult;
+        const firstRecord = count == 0 ? 1 : offset + 1;
+        const lastRecord = offset + Math.min(records.length, limit);
+        const currentPage = offset / limit;
+        const paginationInfo = {
+          count, currentPage, firstRecord, lastRecord,
+          hasMore: stillLoading || (lastRecord < count),
+          total: stillLoading ? undefined : count
+        };
+        accept({ records, paginationInfo });
+      })
+        .catch(reason => reject(reason));
+    });
+  }
+  static getColumnFilters(filters) {
+    const columnFilters = new Map();
+    if (filters == undefined || filters.length == 0) {
+      return columnFilters;
+    }
+    filters.forEach(filter => {
+      const match = COLUMN_FILTER_PATTERN.exec(filter.name);
+      if (match) {
+        columnFilters.set(filter.name, Object.assign({ columnName: match[1] }, filter));
+      }
+    });
+    return columnFilters;
+  }
+}
+PreloadManager._repositories = new Map();
+PreloadManager._loadingStatus = new Map();