@sankhyalabs/sankhyablocks 0.0.0-bugfix-dev-KB-11997.0 → 0.0.0-bugfix-dev-KB-99999.0

package/dist/esm/PreloadManager-c1c2f2b4.js

@@ -0,0 +1,222 @@
+import { FieldComparator, SortMode, DataUnit } from '@sankhyalabs/core';
+import { ColumnFilterManager } from '@sankhyalabs/ezui/dist/collection/components/ez-grid/utils';
+
+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 = [];
+    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._list.push(...items);
+  }
+  async clear() {
+    this._list = [];
+  }
+  async delete(items) {
+    this._list = this._list.filter(item => {
+      for (const removed of items) {
+        if (this._equalsFunction(item, removed)) {
+          return false;
+        }
+      }
+      return true;
+    });
+  }
+  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);
+  }
+}
+
+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) {
+    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(ColumnFilterManager.compileDistinct(fieldName, dataUnit));
+    }
+    let filterFunction;
+    const request = dataUnit.getLastLoadRequest();
+    if (request != undefined) {
+      const columnFilters = ColumnFilterManager.getColumnFilters(request.filters, fieldName);
+      filterFunction = 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 };
+        }
+        const value = fieldValue.value != undefined ? fieldValue.value : fieldValue;
+        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)) {
+        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 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 = ColumnFilterManager.getColumnFilters(request.filters, "");
+      const { limit, offset, sort } = request;
+      PreloadManager.getRepository(dataUnit)
+        .load(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));
+    });
+  }
+}
+PreloadManager._repositories = new Map();
+PreloadManager._loadingStatus = new Map();
+
+export { PreloadManager as P };

package/dist/esm/{SnkFormConfigManager-35876bad.js → SnkFormConfigManager-9be0e7d4.js}

@@ -1,6 +1,6 @@
-import { C as ConfigStorage } from './ConfigStorage-f359573c.js';
-import { ObjectUtils } from '@sankhyalabs/core';
-import { F as FormConfigFetcher } from './form-config-fetcher-8ef7be16.js';
+import { C as ConfigStorage } from './ConfigStorage-1244b8b0.js';
+import { ObjectUtils, StringUtils } from '@sankhyalabs/core';
+import { F as FormConfigFetcher } from './form-config-fetcher-36219cd3.js';
 
 class SnkFormConfigManager {
   constructor(configName, resourceID, onConfigChange) {
@@ -63,19 +63,36 @@ class SnkFormConfigManager {
     }
     return updatingCardConfig;
   }
-  getFieldsList(dataUnit) {
+  getFieldsList(dataUnit, descriptionFilter) {
     var _a;
     const fields = (_a = this._config) === null || _a === void 0 ? void 0 : _a.fields;
     if (fields != undefined && fields.length > 0) {
-      return [...fields];
+      return fields.map(({ label, name, readOnly }) => {
+        if (label == undefined) {
+          return dataUnit.getField(name);
+        }
+        return { name, label, readOnly };
+      })
+        .filter(field => this.isFieldVisible(field, descriptionFilter));
     }
     if (dataUnit != undefined) {
       return dataUnit.metadata.fields
-        .filter(field => field.visible !== false)
-        .map(({ name }) => { return { name }; });
+        .filter(field => this.isFieldVisible(field, descriptionFilter))
+        .map(({ label, name, readOnly }) => { return { label, name, readOnly }; });
     }
     return [];
   }
+  isFieldVisible(field, descriptionFilter) {
+    if (field.visible === false) {
+      return false;
+    }
+    if (descriptionFilter == undefined) {
+      return true;
+    }
+    const normalizedText = StringUtils.replaceAccentuatedCharsLower((field.label || field.name).toLocaleLowerCase());
+    const normalizedFilter = StringUtils.replaceAccentuatedCharsLower(descriptionFilter.toLocaleLowerCase());
+    return normalizedText.includes(normalizedFilter);
+  }
   getInsertionConfig(dataUnit) {
     const fields = this.getFieldsList(dataUnit).filter(field => {
       if (dataUnit) {

package/dist/esm/{SnkMessageBuilder-68c1c25a.js → SnkMessageBuilder-ca843d1b.js}

@@ -63,11 +63,12 @@ const snkFilterBarMessages = {
   "modalCancelButtonLabel": "Limpar",
   "binarySelectTooltip": "Exibindo registros",
   "multiListToltip": "selecionado(a)s",
-  "onlyStartPeriodToltip": "A partir de",
-  "onlyEndPeriodToltip": "Até",
+  "onlyStartToltip": "A partir de",
+  "onlyEndToltip": "Até",
   "fullPeriodTooltip": "Data de {{LABEL}}: {{START_LABEL}} até {{END_LABEL}}",
-  "labelStartDatePeriod": "Inicial",
-  "labelEndDatePeriod": "Final",
+  "labelStart": "Inicial",
+  "labelEnd": "Final",
+  "fullIntervalTooltip": "{{LABEL}}: {{START_LABEL}} até {{END_LABEL}}",
   "filters": "Filtros",
   "personalizedCount": "{{activeCount}} selecionado(s)",
   "filterModal": {
@@ -139,9 +140,14 @@ const snkCrudMessages = {
     update: "Alterar registro",
     clean: "{{ENTITY_NAME}}"
   },
+  findColumn: "Buscar campos",
   goBackTitle: "Voltar"
 };
 
+const snkSimpleCrudMessages = {
+  findColumn: "Busca de colunas",
+};
+
 const fileViewerMessages = {
   error: {
     title: "Erro na Exportação",
@@ -152,6 +158,15 @@ const fileViewerMessages = {
   }
 };
 
+const snkAttachMessages$1 = {
+  newVersionPopup: {
+    title: "Boas vindas à nova interface da tela {{screenName}}",
+    info: "Com uma jornada mais moderna, simples e intuitiva, a performance aprimorada da nova interface impulsionará a sua produtividade.",
+    okButton: "Quero experimentar!",
+    cancelButton: "Voltar à interface anterior",
+  }
+};
+
 const snkConfigOptionsMessages = {
   label: {
     nameField: "Nome do Campo *",
@@ -224,7 +239,9 @@ const snkConfiguratorMessages = {
   labelForm: "Formulário"
 };
 
-const snkGridMessages = {};
+const snkGridMessages = {
+  findColumn: "Busca de colunas"
+};
 const snkGridConfigMessages = {
   gridConfiguration: "Configuração da Grade",
   columnVisibilityOrder: "Defina visibilidade e ordem das colunas.",
@@ -485,6 +502,7 @@ const snkPrintSelectorMessages = {
 class SnkMessageBuilder {
   constructor(domainName) {
     this._defaults = {
+      snkApplication: snkAttachMessages$1,
       snkDataUnit: snkDataUnitMessages,
       snkFormConfig: snkFormConfigMessages,
       snkConfigOptions: snkConfigOptionsMessages,
@@ -499,6 +517,7 @@ class SnkMessageBuilder {
       snkExporter: snkExporterMessages,
       snkDataExporter: snkDataExporterMessages,
       snkCrud: snkCrudMessages,
+      snkSimpleCrud: snkSimpleCrudMessages,
       fileViewer: fileViewerMessages,
       snkFilterParamConfig: snkFilterParamConfigMessages,
       snkFilterFieldSearch: snkFilterFieldSearchMessages,
@@ -507,7 +526,7 @@ class SnkMessageBuilder {
       snkPersonalizedFilter: snkPersonalizedFilterMessages,
       snkEntityList: snkEntityListMessages,
       snkActionsButton: snkActionsButtonMessages,
-      snkPrintSelector: snkPrintSelectorMessages
+      snkPrintSelector: snkPrintSelectorMessages,
     };
     this._currentOperation = OperationMap.CLEAN;
     this._domainName = domainName;
@@ -554,10 +573,12 @@ class SnkMessageBuilder {
     return this.postProcess(msg, params);
   }
   getDomainMessages() {
-    if (this._domainName == undefined) {
+    if (!this._appMessages)
+      return undefined;
+    if (!this._domainName) {
       return this._appMessages['Global'] || this._appMessages;
     }
-    return (this._appMessages == undefined ? undefined : this._appMessages[this._domainName]);
+    return this._appMessages[this._domainName];
   }
   resolveMessage(keys, object) {
     if (object == undefined) {

package/dist/esm/{SnkMultiSelectionListDataSource-892f37f9.js → SnkMultiSelectionListDataSource-44494b0e.js}

@@ -1,4 +1,6 @@
 import { UserInterface, DateUtils } from '@sankhyalabs/core';
+import InMemoryFilterColumnDataSource from '@sankhyalabs/ezui/dist/collection/components/ez-grid/utils/InMemoryFilterColumnDataSource';
+import { P as PreloadManager } from './PreloadManager-c1c2f2b4.js';
 
 class SnkMultiSelectionListDataSource {
   setDataUnit(dataUnit) {
@@ -14,6 +16,12 @@ class SnkMultiSelectionListDataSource {
     }
     return String(this._dataUnit.getFormattedValue(fieldName, value));
   }
+  async getStaticOptions(fieldName) {
+    if (fieldName == undefined) {
+      return Promise.resolve(undefined);
+    }
+    return Promise.resolve(await PreloadManager.getDistinct(this._dataUnit, fieldName));
+  }
   fetchData(filterTerm, fieldName) {
     return new Promise(resolve => {
       this._application.executeSelectDistinct(this._dataUnit, fieldName, filterTerm).then(result => {
@@ -27,6 +35,9 @@ class SnkMultiSelectionListDataSource {
       });
     });
   }
+  sortItems(fieldName, items) {
+    return InMemoryFilterColumnDataSource.defaultSorterMultSelectionOption(this._dataUnit, fieldName, items);
+  }
 }
 
 export { SnkMultiSelectionListDataSource as S };