@sankhyalabs/sankhyablocks 9.1.14 → 9.2.0-dev.1

package/dist/cjs/dataunit-fetcher-c34a8217.js

@@ -1,1121 +0,0 @@
-'use strict';
-
-const core = require('@sankhyalabs/core');
-const DataFetcher = require('./DataFetcher-e23a263b.js');
-const constants = require('@sankhyalabs/ezui/dist/collection/utils/constants');
-const UnitMetadata = require('@sankhyalabs/core/dist/dataunit/metadata/UnitMetadata');
-const utils = require('@sankhyalabs/ezui/dist/collection/components/ez-grid/utils');
-const SortingUtils = require('@sankhyalabs/core/dist/utils/SortingUtils');
-const ResourceIDUtils = require('./ResourceIDUtils-5ff86aa7.js');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-const SortingUtils__default = /*#__PURE__*/_interopDefaultLegacy(SortingUtils);
-
-class ArrayRepository {
-  constructor(equalsFunction) {
-    this._list = [];
-    this._listCopy = [];
-    this._listLastUpdate = 0;
-    this._listCopyLastUpdate = 0;
-    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 = [];
-    let hasEmpty = false;
-    for (const item of this._list) {
-      const processedItem = itemProcessor(item);
-      if (processedItem == undefined) {
-        continue;
-      }
-      if (processedItem.value == undefined) {
-        hasEmpty = true;
-        continue;
-      }
-      processedItems.push(processedItem);
-    }
-    if (hasEmpty) {
-      processedItems.push({ key: "", value: null });
-    }
-    return Promise.resolve(new Map(processedItems.map(item => [item.key, item.value])));
-  }
-  async push(items) {
-    this.updateList([...this._list, ...items]);
-  }
-  async clear() {
-    this.updateList([]);
-  }
-  async delete(items) {
-    const list = this._list.filter(item => {
-      for (const removed of items) {
-        if (this._equalsFunction(item, removed)) {
-          return false;
-        }
-      }
-      return true;
-    });
-    this.updateList(list);
-  }
-  async update(items) {
-    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.push(items);
-      return;
-    }
-    const list = this._list.slice(0, itemPosition).concat(items).concat(this._list.slice(itemPosition));
-    this.updateList(list);
-  }
-  isOperating() {
-    return true;
-  }
-  async isEmpty() {
-    return Promise.resolve(this._list.length === 0);
-  }
-  async count() {
-    return Promise.resolve(this._list.length);
-  }
-  getFromCache() {
-    if (this._listLastUpdate > this._listCopyLastUpdate) {
-      this._listCopyLastUpdate = this._listLastUpdate;
-      this._listCopy = core.ObjectUtils.copy(this._list);
-    }
-    return this._listCopy;
-  }
-  updateList(newList) {
-    this._list = newList;
-    this._listLastUpdate = Date.now();
-  }
-}
-
-class PreloadManager {
-  static setLoadingStatus(dataUnit, loadingInProgress) {
-    this._loadingStatus.set(dataUnit.name, loadingInProgress);
-  }
-  static isCacheEnabled(_dataUnit) {
-    return true;
-  }
-  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) {
-    return SortingUtils__default['default'].getSortingFunction(dataUnit, sorting);
-  }
-  static async getDistinct(dataUnit, fieldName, onlyLabel = false) {
-    if (!PreloadManager.isCacheEnabled(dataUnit)) {
-      return Promise.resolve(utils.ColumnFilterManager.compileDistinct(fieldName, dataUnit));
-    }
-    let filterFunction;
-    const request = dataUnit.getLastLoadRequest();
-    if (request != undefined) {
-      const columnFilters = utils.ColumnFilterManager.getColumnFilters(request.filters, fieldName);
-      filterFunction = utils.ColumnFilterManager.getFilterFunction(dataUnit, Array.from(columnFilters.values()));
-    }
-    return new Promise((accept, reject) => {
-      PreloadManager.getRepository(dataUnit).distict(record => {
-        if (filterFunction != undefined && !filterFunction(record)) {
-          return undefined;
-        }
-        const fieldValue = record[fieldName];
-        if (fieldValue == undefined) {
-          return { key: null, value: null };
-        }
-        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 => {
-        if (result == undefined) {
-          accept(undefined);
-          return;
-        }
-        accept(Array.from(result.entries()).map(([label, value]) => ({ label, value, check: true })));
-      })
-        .catch(reason => reject(reason));
-    });
-  }
-  static async loadData(dataUnit, request, loadFromServer) {
-    try {
-      if (PreloadManager.isCacheEnabled(dataUnit)) {
-        const useCache = [
-          "EZ_GRID_LOADING_SOURCE",
-          core.DataUnit.CHANGING_PAGE_LOADING_SOURCE,
-          core.DataUnit.ALL_RECORDS_SELECTION_SOURCE
-        ].includes(request.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 limpo.
-        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 async loadFromCache(dataUnit, request) {
-    return new Promise((accept, reject) => {
-      const columnFilters = utils.ColumnFilterManager.getColumnFilters(request.filters, "");
-      const { limit, offset, sort } = request;
-      PreloadManager.getRepository(dataUnit)
-        .load(utils.ColumnFilterManager.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 ? 0 : 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 getCachedRecords(dataUnit) {
-    return PreloadManager.getRepository(dataUnit).getFromCache();
-  }
-}
-PreloadManager._repositories = new Map();
-PreloadManager._loadingStatus = new Map();
-
-class InMemoryLoader {
-  constructor(metadata, records, config) {
-    this._dataUnitInMemoryLoader = new core.DataUnitInMemoryLoader(metadata, records, config);
-  }
-  get dataUnit() {
-    return this._dataUnitInMemoryLoader.dataUnit;
-  }
-  get records() {
-    return this._dataUnitInMemoryLoader.records;
-  }
-  set records(records) {
-    this._dataUnitInMemoryLoader.records = records;
-  }
-  get metadata() {
-    return this._dataUnitInMemoryLoader.metadata;
-  }
-  set metadata(metadata) {
-    this._dataUnitInMemoryLoader.metadata = metadata;
-  }
-  removeLoader(_dataUnit, recordIds) {
-    return this._dataUnitInMemoryLoader.removeLoader(_dataUnit, recordIds);
-  }
-  static getConvertedValue(descriptor, strValue, dateFormat) {
-    return core.DataUnitInMemoryLoader.getConvertedValue(descriptor, strValue, dateFormat);
-  }
-}
-InMemoryLoader.IN_MEMORY_DATA_UNIT_NAME = core.DataUnitInMemoryLoader.IN_MEMORY_DATA_UNIT_NAME;
-
-function getRecordValue(record, fieldName) {
-  var _a, _b;
-  return ((_a = record[fieldName]) === null || _a === void 0 ? void 0 : _a.value) !== undefined ? (_b = record[fieldName]) === null || _b === void 0 ? void 0 : _b.value : record[fieldName];
-}
-
-class DatasetStrategy {
-  canSlice() {
-    return false;
-  }
-  processSortingSide(request, dataUnit, serverSideFilters) {
-    var _a;
-    const localSorting = [];
-    const serverSorting = [];
-    if (request.sort != undefined) {
-      if (serverSideFilters.length === 0) {
-        return { localSorting: request.sort, serverSorting: [] };
-      }
-      for (const sort of request.sort) {
-        const descriptor = dataUnit.getField(sort.field);
-        const local = ((_a = descriptor === null || descriptor === void 0 ? void 0 : descriptor.properties) === null || _a === void 0 ? void 0 : _a.calculated) === "true" || (descriptor === null || descriptor === void 0 ? void 0 : descriptor.userInterface) === core.UserInterface.LONGTEXT;
-        if (local) {
-          localSorting.push(sort);
-        }
-        else {
-          serverSorting.push(sort);
-        }
-      }
-    }
-    return { localSorting, serverSorting };
-  }
-  async load(dataUnit, request, loadingInfo) {
-    var _a, _b;
-    if (dataUnit.metadata == undefined) {
-      return Promise.resolve({ records: [], loadingInfo });
-    }
-    try {
-      const serverSideFilters = (_b = (_a = request.filters) === null || _a === void 0 ? void 0 : _a.filter(filter => !filter.name.startsWith("FILTRO_COLUNA_"))) !== null && _b !== void 0 ? _b : [];
-      const { localSorting, serverSorting } = this.processSortingSide(request, dataUnit, serverSideFilters);
-      const fields = this.getFieldsList(dataUnit);
-      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, askRowsLimit } = await DataFetcher.DataFetcher.get().callServiceBroker(serviceName, requestBody, params);
-      const records = this.processRecords(dataUnit, fields, responseRecords);
-      const loadingInProgress = pagerId != undefined;
-      const count = loadingInfo.count + records.length;
-      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: needReload && !isInsertingNewRecord, askRowsLimit,
-          hasLocalSorting })
-      });
-    }
-    catch (error) {
-      console.error(error);
-      return Promise.reject(error);
-    }
-  }
-  async loadRowMetadata(snkDataUnit, fieldName, metadataName, updatedFields = {}) {
-    try {
-      const serviceName = "DatasetSP.loadRowMetadata";
-      const parsedRequestBody = await this.buildRequestBodyLoadRowMetadata({ snkDataUnit, fieldName, metadataName, serviceName, updatedFields });
-      const response = await DataFetcher.DataFetcher.get().callServiceBroker(serviceName, parsedRequestBody);
-      return response;
-    }
-    catch (error) {
-      console.error(error);
-      return Promise.reject(error);
-    }
-  }
-  async buildRequestBodyLoadRowMetadata({ snkDataUnit, serviceName, fieldName, metadataName, updatedFields, }) {
-    const dataUnit = snkDataUnit.dataUnit;
-    const entityName = DataUnitFetcher.parseDataUnitName(dataUnit.name).entityName;
-    const recordIdInfo = await snkDataUnit.getSelectedRecordsIDsInfo();
-    const pk = recordIdInfo.reduce((accumulator, currentValue) => {
-      accumulator[currentValue.name] = currentValue.value;
-      return accumulator;
-    }, {});
-    const record = dataUnit.getSelectedRecord();
-    const fields = dataUnit.metadata.fields.filter(({ standAlone, name }) => !standAlone && !name.includes(".")).map(({ name }) => name);
-    const values = fields.reduce((accumulator, currentValue, currentIndex) => {
-      const recordValue = getRecordValue(record, currentValue);
-      const updatedFieldValue = getRecordValue(updatedFields, currentValue);
-      accumulator[currentIndex] = updatedFieldValue !== undefined ? updatedFieldValue : recordValue;
-      return accumulator;
-    }, {});
-    const requestBody = {
-      serviceName,
-      requestBody: {
-        dataSetID: dataUnit.dataUnitId,
-        entityName,
-        standAlone: false,
-        metadataName,
-        fieldName,
-        fields,
-        record: {
-          pk,
-          oldPk: pk,
-          values,
-        },
-      }
-    };
-    return JSON.stringify(requestBody);
-  }
-  getFieldsList(dataUnit) {
-    let fields = ["__record__id__", "__record__label__"];
-    dataUnit.metadata.fields.forEach((descriptor) => {
-      if (descriptor.standAlone)
-        return;
-      fields = fields.concat(this.getFieldNames(descriptor));
-    });
-    return fields;
-  }
-  getStandAloneFieldsList(dataUnit) {
-    let fields = {};
-    dataUnit.metadata.fields.forEach((currentField) => {
-      if (!currentField.standAlone)
-        return;
-      fields = Object.assign(Object.assign({}, fields), { [currentField.name]: { fieldType: currentField.dataType, userType: currentField.userInterface } });
-    });
-    return fields;
-  }
-  getFieldNames(descriptor) {
-    const descriptionField = this.getSearchDescriptionField(descriptor);
-    if (descriptionField == undefined) {
-      return descriptor.name;
-    }
-    return [descriptor.name, descriptionField];
-  }
-  buildRequestBody(serviceName, fields, dataUnit, request, loadingInfo, sorting, serverSideFilters) {
-    const dataSetID = dataUnit.dataUnitId;
-    const dataUnitName = dataUnit.name;
-    const entityName = DataUnitFetcher.parseDataUnitName(dataUnitName).entityName;
-    const useParallelLoader = !!(request.limit || request.offset);
-    const requestBody = {
-      serviceName,
-      requestBody: {
-        dataSetID,
-        fields,
-        entityName,
-        pageNumber: loadingInfo.pageNumber,
-        totalRecordsCount: loadingInfo.count,
-        pagerID: loadingInfo.pagerId,
-        standAlone: false,
-        standAloneFieldsMD: Object.assign({ __record__id__: { "fieldType": "S", "userType": "P" }, __record__label__: { "fieldType": "S", "userType": "P" } }, this.getStandAloneFieldsList(dataUnit)),
-        tryJoinedFields: true,
-        parallelLoader: useParallelLoader,
-        crudListener: `br.com.sankhya.bff.${this.getModuleName()}.BFFDataUnitDatasetAdapter`,
-        txProperties: this.getTxProperties(dataUnit, request, sorting, serverSideFilters),
-        useDefaultRowsLimit: false
-      }
-    };
-    return JSON.stringify(requestBody);
-  }
-  getModuleName() {
-    const app = core.ApplicationContext.getContextValue("__SNK__APPLICATION__");
-    const moduleName = app.getModuleName();
-    return moduleName.replace("-bff", "");
-  }
-  getTxProperties(dataUnit, request, sorting, serverSideFilters) {
-    const txProperties = {
-      "__DATA_UNIT_ADAPTER__[dataUnitName]": dataUnit.name
-    };
-    if (serverSideFilters.length !== 0) {
-      txProperties["__DATA_UNIT_ADAPTER__[criteria]"] = JSON.stringify(serverSideFilters);
-    }
-    if (sorting != undefined && sorting.length !== 0) {
-      txProperties["__DATA_UNIT_ADAPTER__[sorting]"] = JSON.stringify(sorting);
-    }
-    if (request.parentRecordId != undefined) {
-      txProperties["__DATA_UNIT_ADAPTER__[parentRecordId]"] = request.parentRecordId;
-    }
-    const loaderProps = dataUnit.getGlobalLoaderProps();
-    if (loaderProps == undefined || loaderProps.size === 0) {
-      return txProperties;
-    }
-    Array.from(loaderProps.entries()).forEach(([name, value]) => {
-      txProperties[name] = value;
-    });
-    return txProperties;
-  }
-  processRecords(dataUnit, fields, responseRecords) {
-    return responseRecords.map((dataFrame) => {
-      const lastElement = dataFrame[dataFrame.length - 1];
-      const duRecord = {
-        __record__id__: dataFrame[0],
-        __record__label__: dataFrame[1],
-        __record__metadata__: lastElement['_rmd'],
-      };
-      dataUnit.metadata.fields.forEach(fieldDescriptor => {
-        duRecord[fieldDescriptor.name] = this.buildFieldValue(fieldDescriptor, fields, dataFrame);
-      });
-      return duRecord;
-    });
-  }
-  buildFieldValue(descriptor, allFields, dataFrame) {
-    const fieldIndex = allFields.indexOf(descriptor.name);
-    if (fieldIndex < 0) {
-      return null;
-    }
-    const strValue = dataFrame[fieldIndex];
-    if (core.StringUtils.isEmpty(strValue)) {
-      return null;
-    }
-    const descriptionField = this.getSearchDescriptionField(descriptor);
-    if (descriptionField != undefined) {
-      const descriptionFieldIndex = allFields.indexOf(descriptionField);
-      if (descriptionFieldIndex >= 0) {
-        return { value: strValue, label: dataFrame[descriptionFieldIndex] };
-      }
-    }
-    if (descriptor.userInterface === core.UserInterface.SEARCH) {
-      //Se não tem um campo de descrição (código acima)
-      //Mas é um search, tentamos parsear um numero...
-      return isNaN(Number(strValue)) ? strValue : Number(strValue);
-    }
-    return InMemoryLoader.getConvertedValue(descriptor, strValue);
-  }
-  getSearchDescriptionField(descriptor) {
-    if (![core.UserInterface.SEARCH, core.UserInterface.SEARCHPLUS].includes(descriptor.userInterface)) {
-      return undefined;
-    }
-    if (!descriptor.properties) {
-      return undefined;
-    }
-    const { ENTITYNAME, mergedFrom, DESCRIPTIONFIELD } = descriptor.properties;
-    if (!core.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]) {
-      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 getCachedRecords(dataUnit) {
-    return PreloadManager.getCachedRecords(dataUnit);
-  }
-  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 DatasetStrategy();
-    }
-    const result = await dataLoader.load(dataUnit, request, requestLoadingInfo);
-    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);
-  }
-  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();
-    if (dataUnitPagination == undefined) {
-      return;
-    }
-    const count = loadingInfo.count;
-    if (loadingInfo.loadingInProgress) {
-      dataUnit.updatePagination(Object.assign(Object.assign({}, dataUnitPagination), { count, loadingInProgress: true }));
-      return;
-    }
-    if (loadingInfo.needReload) {
-      //Ir para a primeira página, faz com que o loadData seja chamado novamente
-      dataUnit.gotoPage(0);
-      return;
-    }
-    dataUnit.updatePagination(Object.assign(Object.assign({}, dataUnitPagination), { total: count, count, loadingInProgress: false }));
-  }
-  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, askRowsLimit } = loadingInfo;
-    const firstRecord = (count === 0 || pageSize === 0) ? 0 : offset + 1;
-    const lastRecord = offset + Math.min(pageSize, limit);
-    return {
-      total,
-      count,
-      lastRecord,
-      firstRecord,
-      currentPage: offset / limit,
-      hasMore: lastRecord < count || loadingInProgress,
-      askRowsLimit
-    };
-  }
-}
-DataUnitDataLoader._requestTimeByDataUnit = new Map();
-DataUnitDataLoader._debouncingTimeouts = {};
-
-var __rest = (undefined && undefined.__rest) || function (s, e) {
-  var t = {};
-  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-    t[p] = s[p];
-  if (s != null && typeof Object.getOwnPropertySymbols === "function")
-    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-        t[p[i]] = s[p[i]];
-    }
-  return t;
-};
-const DATA_UNIT_NAME_PARSER = /dd:\/\/([^/]+)\/([^/?]+)/;
-class DataUnitFetcher {
-  constructor() {
-    this.templateByQuery = new Map();
-    this.buldTemplates();
-  }
-  buldTemplates() {
-    this.templateByQuery.set("fetchDataUnit", DataFetcher.dist.gql `query($name: String!) {
-              $queryAlias$: fetchDataUnit(name: $name){
-                name
-                fields{
-                  name
-                  defaultValue
-                  label
-                  visible
-                  standAlone
-                  readOnly
-                  required
-                  dataType
-                  userInterface
-                  calculated
-                  group
-                  order
-                  properties{
-                    name
-                    value
-                  }
-                  dependencies{
-                    masterFields
-                    type
-                    expression
-                  }
-                }
-                children{
-                  name
-                  label
-                  links{
-                    source
-                    target
-                  }
-                }
-              }
-            }`);
-    this.templateByQuery.set("saveData", DataFetcher.dist.gql `mutation($changes: [InputBatchChange!]!) {
-            $queryAlias$: batchOperationDataUnit(changes: $changes){
-              oldId
-              id
-              label
-              ownerDataUnitName
-              fields {
-                name
-                value
-              }
-            }
-          }`);
-    this.templateByQuery.set("fetchDataRecord", DataFetcher.dist.gql `query($dataunit: String! $recordID: [String!]) {
-            $queryAlias$: fetchDataUnit(name: $dataunit){
-              record(id: $recordID){
-                id
-                label
-                fields {
-                  name
-                  value
-                }
-              }
-            }
-          }`);
-    this.templateByQuery.set("fetchDistinctColumn", DataFetcher.dist.gql `query($dataUnit: String!, $fieldName: String!, $argument: String, $filters: [InputFilter], $parentRecordId: String) {
-          $queryAlias$: selectDistinct(dataUnit: $dataUnit, fieldName: $fieldName, argument: $argument, filters: $filters, parentRecordId: $parentRecordId)
-      }`);
-  }
-  static parseDataUnitName(name) {
-    if (name == undefined) {
-      return undefined;
-    }
-    const parts = DATA_UNIT_NAME_PARSER.exec(name);
-    if (!parts) {
-      return undefined;
-    }
-    return { entityName: parts[1], resourceID: parts[2] };
-  }
-  getDataUnit(entityName, resourceID, parentDataUnit, configName) {
-    if (PreloadManager.applicationResourceID == undefined) {
-      //Por falta de um lugar melhor pra iniciar essa variável, fazemos isso aqui.
-      ResourceIDUtils.ResourceIDUtils.getResourceID().then(resourceID => PreloadManager.applicationResourceID = resourceID);
-    }
-    const duName = `dd://${entityName}/${resourceID}${configName ? "/" + configName : ""}`;
-    const dataUnit = parentDataUnit != undefined ? parentDataUnit.getChildDataunit(duName) : new core.DataUnit(duName);
-    dataUnit.metadataLoader = (dataUnit) => this.loadMetadata(dataUnit);
-    dataUnit.dataLoader = (dataUnit, request) => DataUnitDataLoader.loadData(dataUnit, request);
-    dataUnit.saveLoader = (_dataUnit, changes) => this.saveData(dataUnit, changes);
-    dataUnit.removeLoader = (dataUnit, recordIds) => this.removeRecords(dataUnit, recordIds);
-    dataUnit.recordLoader = (dataUnit, recordIds) => this.loadRecord(dataUnit, recordIds);
-    dataUnit.allRecordsLoader = (dataUnit) => DataUnitDataLoader.getCachedRecords(dataUnit);
-    return dataUnit;
-  }
-  loadMetadata(dataUnit) {
-    return new Promise((resolve, reject) => {
-      DataFetcher.DataFetcher.get()
-        .callGraphQL({
-        values: { name: dataUnit.name },
-        query: this.templateByQuery.get("fetchDataUnit"),
-      })
-        .then((resp) => {
-        var _a;
-        const metadata = {
-          name: resp.name,
-          label: resp.name,
-          children: [...resp.children],
-          fields: []
-        };
-        (_a = resp.fields) === null || _a === void 0 ? void 0 : _a.forEach((source) => {
-          let properties = undefined;
-          if (Array.isArray(source.properties)) {
-            properties = {};
-            if (source.calculated) {
-              properties.gridHeaderTooltip = "Campos calculados não podem ser ordenados";
-            }
-            source.properties.forEach((prop) => (properties[prop.name] = prop.value));
-          }
-          metadata.fields.push(Object.assign(Object.assign({}, source), { properties }));
-        });
-        metadata.fields.sort((a, b) => a.order - b.order);
-        resolve(metadata);
-      })
-        .catch((error) => {
-        reject(error);
-      });
-    });
-  }
-  loadSelectDistinct(dataUnit, fieldName, argument) {
-    const { parentRecordId, filters } = dataUnit.getLastLoadRequest() || {};
-    const filteredFilters = filters.filter(f => f.name !== `${constants.DISTINCT_FILTER_NAME_PREFIX}${fieldName}`);
-    const values = {
-      dataUnit: dataUnit.name,
-      argument,
-      fieldName,
-      parentRecordId,
-      filters: filteredFilters
-    };
-    return new Promise((resolve, reject) => {
-      DataFetcher.DataFetcher.get()
-        .callGraphQL({
-        values,
-        query: this.templateByQuery.get("fetchDistinctColumn"),
-      })
-        .then((result) => {
-        resolve(result);
-      })
-        .catch((error) => {
-        reject(error);
-      });
-    });
-  }
-  addTransientProperties(dataUnit, updatingFields) {
-    const loaderProps = dataUnit.getGlobalLoaderProps();
-    if (loaderProps == undefined || loaderProps.size === 0) {
-      return updatingFields;
-    }
-    if (updatingFields == undefined) {
-      updatingFields = {};
-    }
-    Array.from(loaderProps.entries()).forEach(([name, value]) => {
-      updatingFields[`transient.${name}`] = value;
-    });
-    return updatingFields;
-  }
-  getUpdatingFields(dataUnit, originalUpdatingFields) {
-    if (originalUpdatingFields == undefined) {
-      return;
-    }
-    const updatingFields = Object.assign({}, originalUpdatingFields);
-    Object.keys(updatingFields).forEach(key => {
-      const descriptor = dataUnit.getField(key);
-      if (descriptor != undefined && descriptor.standAlone) {
-        delete updatingFields[key];
-      }
-    });
-    return this.addTransientProperties(dataUnit, updatingFields);
-  }
-  saveData(dataUnit, duChanges) {
-    const updatedRecordsIds = [];
-    const addedRecordsIds = [];
-    const changes = duChanges.map((change) => {
-      const { dataUnit: changeDU, record, operation } = change;
-      const dataUnitInstance = core.DataUnitStorage.get(changeDU);
-      const updatingFields = this.getUpdatingFields(dataUnitInstance, change.updatingFields);
-      let parsedUpdatingFields;
-      if (updatingFields != undefined) {
-        parsedUpdatingFields = Object.entries(updatingFields).map(([fieldName, value]) => {
-          const descriptor = dataUnitInstance.getField(fieldName);
-          const dataType = descriptor ? descriptor.dataType : core.DataType.TEXT;
-          return { fieldName, dataType, value: dataUnitInstance.valueToString(fieldName, value) };
-        });
-      }
-      if (changeDU === dataUnit.name) {
-        if (operation === core.ChangeOperation.INSERT || operation === core.ChangeOperation.COPY) {
-          addedRecordsIds.push(record.__record__id__);
-        }
-        else {
-          updatedRecordsIds.push(record.__record__id__);
-        }
-      }
-      const reqChange = { dataUnit: changeDU, fields: parsedUpdatingFields, operation, recordId: record.__record__id__ };
-      if (change.sourceId) {
-        reqChange.sourceId = change.sourceId;
-      }
-      if (record.__parent__record__id__) {
-        reqChange.parentRecordId = record.__parent__record__id__;
-      }
-      return reqChange;
-    });
-    return new Promise((resolve, reject) => {
-      const changesFormatted = changes.map((_a) => {
-        var rest = __rest(_a, []);
-        return rest;
-      });
-      DataFetcher.DataFetcher.get()
-        .callGraphQL({
-        values: { changes: changesFormatted },
-        query: this.templateByQuery.get("saveData"),
-      })
-        .then((resp) => {
-        const dataUnitRecords = [];
-        resp === null || resp === void 0 ? void 0 : resp.forEach((responseRecord) => {
-          const duRecord = {
-            __record__id__: responseRecord.id,
-            __record__label__: responseRecord.label,
-            __owner__dataunit__name__: responseRecord.ownerDataUnitName,
-          };
-          const dataUnitInstance = core.DataUnitStorage.get(duRecord.__owner__dataunit__name__) || dataUnit;
-          if (responseRecord.oldId) {
-            duRecord.__old__id__ = responseRecord.oldId;
-          }
-          responseRecord.fields.forEach(({ name, value }) => {
-            var _a;
-            const valueFromString = (_a = dataUnitInstance === null || dataUnitInstance === void 0 ? void 0 : dataUnitInstance.valueFromString) === null || _a === void 0 ? void 0 : _a.call(dataUnitInstance, name, value);
-            duRecord[name] = (valueFromString !== undefined) ? valueFromString : value;
-          });
-          dataUnitRecords.push(duRecord);
-        });
-        this.updateCache(dataUnit, dataUnitRecords, updatedRecordsIds, addedRecordsIds);
-        resolve(dataUnitRecords);
-      })
-        .catch((error) => {
-        reject(error);
-      });
-    });
-  }
-  updateCache(dataUnit, savedRecords, toUpdate, toInsert) {
-    const recordsById = new Map(savedRecords.map(record => [record.__old__id__ || record.__record__id__, record]));
-    const addedRecords = toInsert.map(recordId => {
-      const copy = Object.assign({}, recordsById.get(recordId));
-      delete copy.__old__id__;
-      return copy;
-    });
-    if (addedRecords.length > 0) {
-      const firstRecord = dataUnit.records[0];
-      PreloadManager.insertRecords(dataUnit, firstRecord, addedRecords);
-    }
-    const updatedRecords = toUpdate.map(recordId => (Object.assign({}, recordsById.get(recordId))));
-    PreloadManager.updateRecords(dataUnit, updatedRecords);
-  }
-  getTransientInfo(dataUnit, recordID) {
-    const { records } = dataUnit.getSelectionInfo();
-    return Object.entries(records.filter(record => record.__record__id__ == recordID)[0]).filter(([key]) => key.startsWith(UnitMetadata.DataUnitTransient.DATA_UNIT_TRANSIENT_PREFIX_NAME)).map(([name, value]) => ({ fieldName: name, value, dataType: core.DataType.TEXT }));
-  }
-  removeRecords(dataUnit, recordIds) {
-    const changes = recordIds.map((recordId) => {
-      return { dataUnit: dataUnit.name, operation: core.ChangeOperation.DELETE, recordId, fields: this.getTransientInfo(dataUnit, recordId) };
-    });
-    return new Promise((resolve, reject) => {
-      DataFetcher.DataFetcher.get()
-        .callGraphQL({
-        values: { changes: changes },
-        query: this.templateByQuery.get("saveData"),
-      })
-        .then((_resp) => {
-        PreloadManager.removeRecords(dataUnit, dataUnit.records.filter(record => recordIds.includes(record.__record__id__)));
-        resolve(recordIds);
-      })
-        .catch((error) => {
-        reject(error);
-      });
-    });
-  }
-  loadRecord(dataUnit, recordIds) {
-    return new Promise((resolve, reject) => {
-      DataFetcher.DataFetcher.get()
-        .callGraphQL({
-        values: { recordID: recordIds, dataunit: dataUnit.name },
-        query: this.templateByQuery.get("fetchDataRecord"),
-      })
-        .then((response) => {
-        const dataUnitRecords = [];
-        response.record.forEach(responseRecord => {
-          const duRecord = { __record__id__: responseRecord.id, __record__label__: responseRecord.label };
-          responseRecord.fields.forEach(({ name, value }) => {
-            duRecord[name] = dataUnit.valueFromString(name, value);
-          });
-          dataUnitRecords.push(duRecord);
-        });
-        //TODO: Chamar o worker para persistir a nova versão do registro
-        resolve(dataUnitRecords);
-      })
-        .catch((error) => {
-        reject(error);
-      });
-    });
-  }
-}
-
-exports.DataUnitFetcher = DataUnitFetcher;
-exports.DatasetStrategy = DatasetStrategy;
-exports.InMemoryLoader = InMemoryLoader;
-exports.PreloadManager = PreloadManager;
-exports.getRecordValue = getRecordValue;