@sankhyalabs/sankhyablocks 8.15.0-dev.5 → 8.15.0-dev.51

package/dist/collection/components/snk-taskbar/elements/taskbar-elements.js

@@ -86,29 +86,29 @@ export const buildElem = (element, className, dataElementId, getTitle, action, i
     case TaskbarElement.CONFIGURATOR:
       return iconButton("settings-inverted", element, className, dataElementId, title, action, isEnabled);
     case TaskbarElement.MORE_OPTIONS:
-      return actionButton(element, dataElementId, title, isEnabled, actions, action);
+      return actionButton(element, className, dataElementId, title, isEnabled, actions, action);
     case TaskbarElement.DIVIDER:
-      return h("hr", { class: "ez-divider-vertical ez-divider--dark ez-margin-horizontal--medium", "data-taskbar-divider": true });
+      return h("hr", { class: "ez-divider-vertical ez-divider--dark ez-margin--none ez-margin-left--medium", "data-taskbar-divider": true });
     case TaskbarElement.DATA_EXPORTER:
       const provider = (_a = store.get("exporterProviders")) === null || _a === void 0 ? void 0 : _a[configName];
-      return h("snk-data-exporter", { class: className, provider: provider, "data-element-id": dataElementId });
+      return h("snk-data-exporter", { class: className, provider: provider, "data-element-id": dataElementId, "data-taskbar-element": element });
     case TaskbarElement.ATTACH:
       return iconButton("anexo", element, className, dataElementId, title, action, isEnabled);
     case TaskbarElement.ACTIONS_BUTTON:
-      return h("snk-actions-button", { "data-element-id": dataElementId });
+      return h("snk-actions-button", { "data-element-id": dataElementId, "data-taskbar-element": element });
   }
 };
 function textButton(name, className, dataElementId, text, title, action, isEnabled) {
-  return h("ez-button", { key: dataElementId, title: title, label: text, size: "small", class: className, "data-element-id": dataElementId, enabled: isEnabled(name), onClick: () => action(name) });
+  return h("ez-button", { key: dataElementId, title: title, label: text, size: "small", class: className, "data-taskbar-label": text, "data-taskbar-element": name, "data-element-id": dataElementId, enabled: isEnabled(name), onClick: () => action(name) });
 }
 function iconButton(iconName, name, className, dataElementId, title, action, isEnabled) {
-  return h("ez-button", { key: dataElementId, title: title, mode: "icon", size: "small", class: className, "data-element-id": dataElementId, iconName: iconName, enabled: isEnabled(name), onClick: () => action(name) });
+  return h("ez-button", { key: dataElementId, title: title, mode: "icon", size: "small", class: className, "data-taskbar-label": title, "data-taskbar-element": name, "data-taskbar-icon": iconName, "data-element-id": dataElementId, iconName: iconName, enabled: isEnabled(name), onClick: () => action(name) });
 }
 function iconTextButton(iconName, name, className, dataElementId, text, title, action, isEnabled) {
-  return h("ez-button", { key: dataElementId, title: title, label: text, size: "small", class: className, "data-element-id": dataElementId, enabled: isEnabled(name), onClick: () => action(name) }, h("ez-icon", { class: "ez-padding-right--small", slot: "leftIcon", iconName: iconName }));
+  return h("ez-button", { key: dataElementId, title: title, label: text, size: "small", class: className, "data-taskbar-label": text, "data-taskbar-icon": iconName, "data-taskbar-element": name, "data-element-id": dataElementId, enabled: isEnabled(name), onClick: () => action(name) }, h("ez-icon", { class: "ez-padding-right--small", slot: "leftIcon", iconName: iconName }));
 }
-function actionButton(element, dataElementId, title, isEnabled, actions, action) {
+function actionButton(element, className, dataElementId, title, isEnabled, actions, action) {
   return actions && actions.length > 0
-    ? h("taskbar-actions-button", { key: dataElementId, title: title, "data-element-id": dataElementId, enabled: isEnabled(element), actions: actions, onTaskbarActionSelected: (evt) => action(evt.detail.value) })
+    ? h("taskbar-actions-button", { class: className, key: dataElementId, title: title, "data-taskbar-element": element, "data-element-id": dataElementId, enabled: isEnabled(element), actions: actions, onTaskbarActionSelected: (evt) => action(evt.detail.value) })
     : undefined;
 }

package/dist/collection/components/snk-taskbar/snk-taskbar.css

@@ -1,3 +1,20 @@
 :host {
   display: flex;
+  flex-wrap: wrap;
+}
+
+:host.no-wrap {
+  flex-wrap: nowrap;
+}
+
+:host.full-width{
+  width: 100%;
+}
+
+:host.align-right{
+  justify-content: flex-end;
+}
+
+.overflowed {
+  display: none;
 }

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

@@ -1,4 +1,4 @@
-import { ApplicationContext, ElementIDUtils, StringUtils } from '@sankhyalabs/core';
+import { ApplicationContext, ElementIDUtils, OverflowDirection, OverflowWatcher, StringUtils, OVERFLOWED_CLASS_NAME } from '@sankhyalabs/core';
 import { h, Host } from '@stencil/core';
 import { AuthorizationConfig } from '../snk-configurator/AuthorizationConfig';
 import { AuthorizationElements, buildCustomButton, buildElem, TaskbarElement, VisibleWhenForbidden, } from './elements/taskbar-elements';
@@ -6,6 +6,9 @@ import { PresentationMode } from '../../lib/@types';
 export class SnkTaskbar {
   constructor() {
     this.TASKBAR_ITEM_ID_PREFIX = 'TASKBAR_ITEM_';
+    this.TASKBAR_CUSTOM_ELEMENTS_CONTAINER_CLASS_NAME = 'taskbar-custom-elements-container';
+    this.ACTIONS_BUTTON_TAG = 'TASKBAR-ACTIONS-BUTTON';
+    this.NOT_OVERFLOW_ELEMENTS = ["moreOptions", "dataExporter_snkDataExporter", "actionsButton_snkActionsButton"];
     this._titleKeyByElement = {
       [TaskbarElement.UPDATE]: "snkTaskbar.titleUpdate",
       [TaskbarElement.PREVIOUS]: "snkTaskbar.titlePrevious",
@@ -23,11 +26,17 @@ export class SnkTaskbar {
       [TaskbarElement.ATTACH]: "snkTaskbar.titleAttach",
     };
     this._permissions = undefined;
+    this._overFlowedElements = [];
     this._customElements = undefined;
     this._customElementsId = undefined;
     this._slotContainer = undefined;
+    this._hiddenActionsList = [];
+    this._lastWidth = undefined;
+    this._hasToUpdateOverFlow = false;
+    this.alignRigth = false;
     this.customSlotId = "TASKBAR_CUSTOM_ELEMENTS";
     this.customContainerId = undefined;
+    this.overflowStrategy = 'hiddenItems';
     this.configName = undefined;
     this.resourceID = undefined;
     this.buttons = undefined;
@@ -41,6 +50,18 @@ export class SnkTaskbar {
   }
   observeButtons() {
     this._definitions = undefined;
+    requestAnimationFrame(() => {
+      requestAnimationFrame(() => { var _a; return (_a = this._overFlowWatcher) === null || _a === void 0 ? void 0 : _a.forceUpdate(); });
+    });
+  }
+  observeDisabledButtons() {
+    var _a;
+    (_a = this._overFlowWatcher) === null || _a === void 0 ? void 0 : _a.forceUpdate();
+  }
+  observeLastWidth(newValue, oldValue) {
+    if (oldValue === 0 && newValue !== 0) {
+      this._hasToUpdateOverFlow = true;
+    }
   }
   // Internal methods
   elementsFromString(strButtons) {
@@ -136,12 +157,19 @@ export class SnkTaskbar {
     }
     const taskbarElement = TaskbarElement[def.toString()];
     if (taskbarElement) {
-      return buildElem(def, className, this.getIdElemBtnNative(def), elem => this.getTitle(elem), elem => this.elementClick(elem), elem => this.isEnabled(elem), this.actionsList, this.configName, this.presentationMode);
+      return buildElem(def, className, this.getIdElemBtnNative(def), elem => this.getTitle(elem), elem => this.elementClick(elem), elem => this.isEnabled(elem), this.buildDynamicActionsList(), this.configName, this.presentationMode);
     }
     else {
       return buildCustomButton(def, className, this.getIdElemBtnCustom(def), elem => this.elementClick(elem), elem => this.isEnabled(elem));
     }
   }
+  buildDynamicActionsList() {
+    var _a;
+    if (this._hiddenActionsList.length) {
+      return [...((_a = this.actionsList) !== null && _a !== void 0 ? _a : []), { type: 'divider', label: "", value: "" }, ...this._hiddenActionsList];
+    }
+    return this.actionsList;
+  }
   getIdElemBtnNative(taskbarElem) {
     return StringUtils.toCamelCase(taskbarElem);
   }
@@ -182,11 +210,13 @@ export class SnkTaskbar {
     });
   }
   addCustomElementContainer(elem) {
+    var _a;
     const elementId = `${this.TASKBAR_ITEM_ID_PREFIX}${elem}`;
     if (!this._customElementsId.includes(elementId)) {
       this._customElementsId.push(elementId);
+      (_a = this._overFlowWatcher) === null || _a === void 0 ? void 0 : _a.addNotOverFlowElement(elementId);
     }
-    return h("span", { key: elementId, id: elementId });
+    return h("span", { class: "ez-padding-left--medium", key: elementId, id: elementId });
   }
   getCustomElements() {
     var _a, _b;
@@ -216,20 +246,95 @@ export class SnkTaskbar {
     this.getCustomElements();
   }
   componentWillRender() {
+    this.handleDefinitions();
+    this.validatePresentationMode();
+    this.updateOverFlowIfNeeded();
+  }
+  handleDefinitions() {
     if (this._definitions == undefined && this._permissions) {
       this._definitions = this.elementsFromString(this.buttons);
     }
-    this.validatePresentationMode();
+  }
+  updateOverFlowIfNeeded() {
+    if (this._hasToUpdateOverFlow) {
+      requestAnimationFrame(() => { var _a; return (_a = this._overFlowWatcher) === null || _a === void 0 ? void 0 : _a.forceUpdate(); });
+      this._hasToUpdateOverFlow = false;
+    }
+  }
+  handleOverFlow(overFlowingElements) {
+    const elementsToHandle = overFlowingElements.filter(element => !this.hasToIgnoreOverFlow(element));
+    this.resetOverFlowedElements();
+    this.doOverFlowElements(elementsToHandle);
+  }
+  resetOverFlowedElements() {
+    this._overFlowedElements.forEach(element => {
+      element.classList.remove(OVERFLOWED_CLASS_NAME);
+    });
+    this._hiddenActionsList = [];
+    this._overFlowedElements = [];
+  }
+  doOverFlowElements(overFlowedElements) {
+    overFlowedElements.forEach(element => {
+      element.classList.add(OVERFLOWED_CLASS_NAME);
+      this._overFlowedElements.push(element);
+      this.addItemToActionList(element);
+    });
+  }
+  addItemToActionList(element) {
+    const taskbarElement = this.getTaskbarElementName(element);
+    if (taskbarElement && this.isEnabled(taskbarElement) && this.isAllowed(taskbarElement)) {
+      const optionItem = {
+        value: taskbarElement,
+        label: this.getTaskbarElementLabel(element),
+        iconName: this.getTaskbarElementIcon(element)
+      };
+      this._hiddenActionsList.push(optionItem);
+    }
+  }
+  getTaskbarElementName(element) {
+    var _a;
+    return (_a = element.getAttribute('data-taskbar-element')) !== null && _a !== void 0 ? _a : "";
+  }
+  getTaskbarElementIcon(element) {
+    var _a;
+    return (_a = element.getAttribute('data-taskbar-icon')) !== null && _a !== void 0 ? _a : "";
+  }
+  getTaskbarElementLabel(element) {
+    var _a;
+    return (_a = element.getAttribute('data-taskbar-label')) !== null && _a !== void 0 ? _a : "";
+  }
+  hasToIgnoreOverFlow(element) {
+    return element.classList.contains(this.TASKBAR_CUSTOM_ELEMENTS_CONTAINER_CLASS_NAME);
+  }
+  handleOverFlowStrategy() {
+    if (this.overflowStrategy === 'hiddenItems') {
+      this._overFlowWatcher = new OverflowWatcher(this.buildOverFlowWatcherParams());
+    }
+  }
+  buildOverFlowWatcherParams() {
+    return {
+      element: this._element,
+      callback: this.handleOverFlow.bind(this),
+      overFlowDirection: OverflowDirection.HORIZONTAL,
+      notOverFlow: this.NOT_OVERFLOW_ELEMENTS
+    };
   }
   componentDidLoad() {
     const dataInfo = { dataUnit: this.dataUnit };
     ElementIDUtils.addIDInfo(this._element, null, dataInfo);
+    this.handleOverFlowStrategy();
   }
   componentDidRender() {
     this.appendCustomElementsInTaskbar();
+    this.updateLastWidth();
+  }
+  updateLastWidth() {
+    this._lastWidth = this._element.getBoundingClientRect().width;
   }
   disconnectedCallback() {
+    var _a;
     this.unlinkAllCustomElements();
+    (_a = this._overFlowWatcher) === null || _a === void 0 ? void 0 : _a.destroy();
   }
   unlinkAllCustomElements() {
     var _a;
@@ -247,14 +352,9 @@ export class SnkTaskbar {
       return undefined;
     }
     let index = 0;
-    return (h(Host, null, this.removeEmpty(this._definitions.map((elem) => {
-      var _a;
-      if (elem === TaskbarElement.DIVIDER) {
-        index = 0;
-      }
-      else {
-        index++;
-      }
+    return (h(Host, { class: this.getHostClasses() }, this.removeEmpty(this._definitions.map((elem) => {
+      var _a, _b;
+      index++;
       if (TaskbarElement[elem]) {
         return this.getElement(index, TaskbarElement[elem]);
       }
@@ -264,8 +364,14 @@ export class SnkTaskbar {
       if (this._customElements.has(elem)) {
         return this.addCustomElementContainer(elem);
       }
+      (_b = this._overFlowWatcher) === null || _b === void 0 ? void 0 : _b.addNotOverFlowElement(elem);
       return h("slot", { name: elem });
-    })), h("div", { class: "taskbar-custom-elements-container" }, h("slot", { name: this.customSlotId }))));
+    })), h("div", { class: this.TASKBAR_CUSTOM_ELEMENTS_CONTAINER_CLASS_NAME }, h("slot", { name: this.customSlotId }))));
+  }
+  getHostClasses() {
+    if (this.overflowStrategy !== 'hiddenItems')
+      return 'no-wrap';
+    return `full-width ${this.alignRigth ? 'align-right' : ""}`;
   }
   static get is() { return "snk-taskbar"; }
   static get encapsulation() { return "scoped"; }
@@ -281,6 +387,24 @@ export class SnkTaskbar {
   }
   static get properties() {
     return {
+      "alignRigth": {
+        "type": "boolean",
+        "mutable": false,
+        "complexType": {
+          "original": "boolean",
+          "resolved": "boolean",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Usado para determinar O alinhamento dos items na taskbar."
+        },
+        "attribute": "align-rigth",
+        "reflect": false,
+        "defaultValue": "false"
+      },
       "customSlotId": {
         "type": "string",
         "mutable": false,
@@ -316,6 +440,24 @@ export class SnkTaskbar {
         "attribute": "custom-container-id",
         "reflect": false
       },
+      "overflowStrategy": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "'hiddenItems' | 'none'",
+          "resolved": "\"hiddenItems\" | \"none\"",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Define como ser\u00E1 o comportamento da taskbar quando ocorrer overflow"
+        },
+        "attribute": "overflow-strategy",
+        "reflect": false,
+        "defaultValue": "'hiddenItems'"
+      },
       "configName": {
         "type": "string",
         "mutable": false,
@@ -515,9 +657,13 @@ export class SnkTaskbar {
   static get states() {
     return {
       "_permissions": {},
+      "_overFlowedElements": {},
       "_customElements": {},
       "_customElementsId": {},
-      "_slotContainer": {}
+      "_slotContainer": {},
+      "_hiddenActionsList": {},
+      "_lastWidth": {},
+      "_hasToUpdateOverFlow": {}
     };
   }
   static get events() {
@@ -543,6 +689,12 @@ export class SnkTaskbar {
     return [{
         "propName": "buttons",
         "methodName": "observeButtons"
+      }, {
+        "propName": "disabledButtons",
+        "methodName": "observeDisabledButtons"
+      }, {
+        "propName": "_lastWidth",
+        "methodName": "observeLastWidth"
       }];
   }
 }

package/dist/collection/lib/configs/ConfigStorage.js

@@ -2,17 +2,37 @@ import { FormConfigFetcher } from "../http/data-fetcher/fetchers/form-config-fet
 import GridConfigFetcher from "../http/data-fetcher/fetchers/grid-config-fetcher";
 import FilterBarConfigFetcher from "../http/data-fetcher/fetchers/filter-bar-config-fetcher";
 import PersonalizedFilterFetcher from "../http/data-fetcher/fetchers/personalized-filter-fetcher";
-const CONFIG_SOURCE = {
-  form: "form",
-  grid: "grid",
-  filterBar: "filterBar"
-};
+export var CONFIG_SOURCE;
+(function (CONFIG_SOURCE) {
+  CONFIG_SOURCE["form"] = "form";
+  CONFIG_SOURCE["grid"] = "grid";
+  CONFIG_SOURCE["filterBar"] = "filterBar";
+})(CONFIG_SOURCE || (CONFIG_SOURCE = {}));
 export class ConfigStorage {
-  static preload(resourceID, configName) {
+  static addFilterBarLegacyConfig(configName, legacyConfigName) {
+    this.validateConfigName(configName, legacyConfigName);
+    this.filterBarLegacyConfig.set(configName, legacyConfigName);
+  }
+  static addFormLegacyConfig(configName, legacyConfigName) {
+    this.validateConfigName(configName, legacyConfigName);
+    this.formLegacyConfig.set(configName, legacyConfigName);
+  }
+  static addGridLegacyConfig(configName, legacyConfigName) {
+    this.validateConfigName(configName, legacyConfigName);
+    this.gridLegacyConfig.set(configName, legacyConfigName);
+  }
+  static preload(resourceID, configName, legacyConfigs) {
+    if (configName && (legacyConfigs === null || legacyConfigs === void 0 ? void 0 : legacyConfigs.gridLegacyConfig)) {
+      ConfigStorage.addGridLegacyConfig(configName, legacyConfigs.gridLegacyConfig);
+    }
+    if (configName && (legacyConfigs === null || legacyConfigs === void 0 ? void 0 : legacyConfigs.formLegacyConfig)) {
+      ConfigStorage.addFormLegacyConfig(configName, legacyConfigs.formLegacyConfig);
+    }
     ConfigStorage.loadFormConfig(configName, resourceID);
     ConfigStorage.loadGridConfig(configName, resourceID);
   }
   static async loadFilterBarConfig(name, resourceID, urlParams) {
+    urlParams = this.handleLegacyConfig(name, CONFIG_SOURCE.filterBar, urlParams);
     const cacheID = ConfigStorage.buildCacheID(name, CONFIG_SOURCE.filterBar, resourceID);
     if (!ConfigStorage.configById.has(cacheID)) {
       ConfigStorage.configById.set(cacheID, ConfigStorage.filterBarConfigFetcher.getConfig(resourceID, name, urlParams));
@@ -20,6 +40,7 @@ export class ConfigStorage {
     return ConfigStorage.configById.get(cacheID);
   }
   static async loadFormConfig(name, resourceID) {
+    name = this.handleLegacyConfigAsString(name, CONFIG_SOURCE.form);
     const cacheID = ConfigStorage.buildCacheID(name, CONFIG_SOURCE.form, resourceID);
     if (!ConfigStorage.configById.has(cacheID)) {
       ConfigStorage.configById.set(cacheID, ConfigStorage.formConfigFetcher.loadFormConfig(name, resourceID));
@@ -27,6 +48,7 @@ export class ConfigStorage {
     return ConfigStorage.configById.get(cacheID);
   }
   static async loadGridConfig(name, resourceID) {
+    name = this.handleLegacyConfigAsString(name, CONFIG_SOURCE.grid);
     const cacheID = ConfigStorage.buildCacheID(name, CONFIG_SOURCE.grid, resourceID);
     if (!ConfigStorage.configById.has(cacheID)) {
       ConfigStorage.configById.set(cacheID, ConfigStorage.gridConfigFetcher.getConfig(name, resourceID));
@@ -34,13 +56,12 @@ export class ConfigStorage {
     return ConfigStorage.configById.get(cacheID);
   }
   static async saveFilterBarConfig(config, name, resourceID) {
-    const cacheID = this.buildCacheID(name, CONFIG_SOURCE.filterBar, resourceID);
-    this.configById.delete(cacheID);
+    await this.deleteFilterBarConfigCache(name, resourceID);
     return this.filterBarConfigFetcher.saveConfig(config, resourceID, name);
   }
   static async saveFormConfig(config, name, resourceID) {
-    const cacheID = this.buildCacheID(name, CONFIG_SOURCE.form, resourceID);
-    this.configById.delete(cacheID);
+    name = this.handleLegacyConfigAsString(name, CONFIG_SOURCE.form);
+    await this.deleteFormConfigCache(name, resourceID);
     return this.formConfigFetcher.saveConfig(config, name, resourceID);
   }
   static async saveCardState(config, name, resourceID) {
@@ -50,18 +71,17 @@ export class ConfigStorage {
     if (config == undefined) {
       return;
     }
-    const cacheID = this.buildCacheID(name, CONFIG_SOURCE.grid, resourceID);
-    this.configById.delete(cacheID);
+    await this.deleteGridConfigCache(name, resourceID);
     return this.gridConfigFetcher.saveConfig(config, name, resourceID);
   }
   static async loadPersonalizedFilter(filterId, resourceID, configName) {
-    return this.personalizedFilterFetcher.loadPersonalizedFilter(resourceID, filterId, configName);
+    const legacyConfigName = this.filterBarLegacyConfig.get(configName);
+    return this.personalizedFilterFetcher.loadPersonalizedFilter(resourceID, filterId, configName, legacyConfigName);
   }
   static async savePersonalizedFilter(personalizedFilter, resourceID, configName) {
-    //Ao criar ou alterar um filtro personalizado, 
+    //Ao criar ou alterar um filtro personalizado,
     //precisamos remover o cache do status da filterbar.
-    const cacheID = this.buildCacheID(configName, CONFIG_SOURCE.filterBar, resourceID);
-    this.configById.delete(cacheID);
+    await this.deleteFilterBarConfigCache(configName, resourceID);
     return this.personalizedFilterFetcher.savePersonalizedFilter(personalizedFilter, resourceID, configName);
   }
   static async removePersonalizedFilter(personalizedFilter, resourceID, configName) {
@@ -70,6 +90,51 @@ export class ConfigStorage {
   static async validatePersonalizedFilter(dataUnitName, expression) {
     return this.personalizedFilterFetcher.validatePersonalizedFilter(dataUnitName, expression);
   }
+  static async deleteGridConfigCache(name, resourceID) {
+    await this.deleteConfigCache(name, resourceID, CONFIG_SOURCE.grid);
+  }
+  static async deleteFormConfigCache(name, resourceID) {
+    await this.deleteConfigCache(name, resourceID, CONFIG_SOURCE.form);
+  }
+  static async deleteFilterBarConfigCache(name, resourceID) {
+    await this.deleteConfigCache(name, resourceID, CONFIG_SOURCE.filterBar);
+  }
+  static validateConfigName(configName, legacyConfigName) {
+    if (!configName)
+      throw Error(this.CONFIG_NAME_ERROR_MESSAGE);
+    if (!legacyConfigName)
+      throw Error(this.LEGACY_CONFIG_NAME_ERROR_MESSAGE);
+  }
+  static handleLegacyConfig(configName, configSource, urlParams) {
+    let legacyConfigName;
+    switch (configSource) {
+      case CONFIG_SOURCE.filterBar:
+        legacyConfigName = this.filterBarLegacyConfig.get(configName);
+        break;
+      case CONFIG_SOURCE.grid:
+        legacyConfigName = this.gridLegacyConfig.get(configName);
+        break;
+      case CONFIG_SOURCE.form:
+        legacyConfigName = this.formLegacyConfig.get(configName);
+    }
+    const params = urlParams ? Object.assign({}, urlParams) : {};
+    if (legacyConfigName) {
+      params['legacyResourceID'] = legacyConfigName;
+    }
+    return params;
+  }
+  static handleLegacyConfigAsString(name, source) {
+    const params = this.handleLegacyConfig(name, source);
+    const legacyResourceID = params['legacyResourceID'];
+    if (legacyResourceID) {
+      name = name + `?legacyResourceID=${legacyResourceID}`;
+    }
+    return name;
+  }
+  static async deleteConfigCache(name, resourceID, source) {
+    const cacheID = ConfigStorage.buildCacheID(name, source, resourceID);
+    this.configById.delete(cacheID);
+  }
   static buildCacheID(name, source, resourceID) {
     if (name == undefined) {
       return `req_${source}_${resourceID}`;
@@ -77,6 +142,11 @@ export class ConfigStorage {
     return `req_${source}_${name}_${resourceID}`;
   }
 }
+ConfigStorage.CONFIG_NAME_ERROR_MESSAGE = "ConfigName precisa ser informado.";
+ConfigStorage.LEGACY_CONFIG_NAME_ERROR_MESSAGE = "LegacyConfigName precisa ser informado.";
+ConfigStorage.filterBarLegacyConfig = new Map();
+ConfigStorage.formLegacyConfig = new Map();
+ConfigStorage.gridLegacyConfig = new Map();
 ConfigStorage.configById = new Map();
 ConfigStorage.filterBarConfigFetcher = new FilterBarConfigFetcher();
 ConfigStorage.formConfigFetcher = new FormConfigFetcher();

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

@@ -1,6 +1,5 @@
 import { ChangeOperation, DataType, DataUnit, DateUtils, StringUtils, } from '@sankhyalabs/core';
-import { ColumnFilterManager } from "@sankhyalabs/ezui/dist/collection/components/ez-grid/utils";
-import PreloadManager from '../http/data-fetcher/fetchers/data-unit/cache/PreloadManager';
+import { applyFilter, applySorting, buildPaginationInfo } from './dataUnitInMemoryUtils';
 export default class InMemoryLoader {
   constructor(metadata, records) {
     this.metadata = metadata;
@@ -16,7 +15,7 @@ export default class InMemoryLoader {
     if (this._initialRecords == undefined && this.dataUnit.records.length > 0) {
       this._initialRecords = this.dataUnit.records;
     }
-    return this._initialRecords;
+    return [...this._initialRecords, ...this.dataUnit.getAddedRecords()];
   }
   get dataUnit() {
     return this._dataUnit;
@@ -74,30 +73,9 @@ export default class InMemoryLoader {
     return StringUtils.generateUUID();
   }
   inMemoryLoader(dataUnit, request, recordsIn) {
-    let records = this.applyFilter(recordsIn, dataUnit, request.filters);
-    records = this.applySorting(records, dataUnit, request.sort);
-    return Promise.resolve({ records, paginationInfo: buildPaginationInfo(request, records) });
-  }
-  applyFilter(records, dataUnit, filters) {
-    const columnFilters = ColumnFilterManager.getColumnFilters(filters, "");
-    if (columnFilters == undefined || columnFilters.size == 0) {
-      return records;
-    }
-    const filterFunciton = ColumnFilterManager.getFilterFunction(dataUnit, Array.from(columnFilters.values()));
-    if (filterFunciton == undefined) {
-      return records;
-    }
-    return records.filter(filterFunciton);
-  }
-  applySorting(records, dataUnit, sorting) {
-    if (sorting == undefined || sorting.length == 0) {
-      return records;
-    }
-    const sortingFunction = PreloadManager.getSortingFunction(dataUnit, sorting);
-    if (sortingFunction == undefined) {
-      return records;
-    }
-    return records.sort(sortingFunction);
+    let records = applyFilter(recordsIn, dataUnit, request.filters);
+    records = applySorting(records, dataUnit, request.sort);
+    return Promise.resolve({ records, paginationInfo: buildPaginationInfo(records, request.offset, request.limit) });
   }
   metadaLoader() {
     return Promise.resolve(this._metadata);
@@ -130,16 +108,3 @@ export default class InMemoryLoader {
   }
 }
 InMemoryLoader.IN_MEMORY_DATA_UNIT_NAME = "InMemoryDataUnit";
-function buildPaginationInfo({ offset, limit }, records) {
-  if (offset === undefined || limit === undefined) {
-    return undefined;
-  }
-  const lastRecord = Math.min(offset + limit, records.length);
-  return {
-    currentPage: Math.ceil(offset / limit),
-    firstRecord: offset,
-    lastRecord: lastRecord,
-    total: records.length,
-    hasMore: !!(records.length - lastRecord),
-  };
-}

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

@@ -0,0 +1,33 @@
+import { ColumnFilterManager } from '@sankhyalabs/ezui/dist/collection/components/ez-grid/utils';
+import PreloadManager from '../http/data-fetcher/fetchers/data-unit/cache/PreloadManager';
+export function applyFilter(records, dataUnit, filters) {
+  const columnFilters = ColumnFilterManager.getColumnFilters(filters, "");
+  if (!(columnFilters === null || columnFilters === void 0 ? void 0 : columnFilters.size)) {
+    return records;
+  }
+  const filterFunction = ColumnFilterManager.getFilterFunction(dataUnit, Array.from(columnFilters.values()));
+  if (filterFunction == undefined) {
+    return records;
+  }
+  return records.filter(filterFunction);
+}
+export function applySorting(records, dataUnit, sorting) {
+  if (sorting == undefined || sorting.length == 0) {
+    return records;
+  }
+  const sortingFunction = PreloadManager.getSortingFunction(dataUnit, sorting);
+  if (sortingFunction == undefined) {
+    return records;
+  }
+  return records.sort(sortingFunction);
+}
+export function buildPaginationInfo(records, offset = 0, limit = 0) {
+  const lastRecord = Math.min(offset + limit, records.length);
+  return {
+    currentPage: limit === 0 ? 0 : Math.ceil(offset / limit),
+    firstRecord: offset,
+    lastRecord: lastRecord,
+    total: records.length,
+    hasMore: !!(records.length - lastRecord),
+  };
+}

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

@@ -275,7 +275,6 @@ export class DataFetcher {
         if (http.readyState == 4 && http.status == 200) {
           try {
             const jsonResp = JSON.parse(http.responseText);
-            await this.processServiceBrokerClientEvents({ clientEvents: jsonResp === null || jsonResp === void 0 ? void 0 : jsonResp.clientEvents, serviceName, payloadJson, accept, reject });
             /**
              * Este trecho difere do projeto HTML5 devido à decisão de adotar uma abordagem síncrona para esta chamada. Isso é justificado pelo fato de que, no cenário em questão, a abordagem assíncrona teria impactos negativos.
              *
@@ -286,8 +285,10 @@ export class DataFetcher {
             if (this.isServiceBrokerError(jsonResp)) {
               reject(this.processServiceBrokerErrorInfo(jsonResp));
             }
-            else if (jsonResp.status == DataFetcher.SERVICE_BROKER_STATUS.SERVICE_CANCELED && jsonResp.statusMessage) {
-              console.debug(`[DataFetcher] ${jsonResp.statusMessage}`);
+            else if (jsonResp.status == DataFetcher.SERVICE_BROKER_STATUS.SERVICE_CANCELED) {
+              if (jsonResp.statusMessage) {
+                console.debug(`[DataFetcher] ${jsonResp.statusMessage}`);
+              }
             }
             else {
               accept(jsonResp.responseBody);
@@ -295,6 +296,7 @@ export class DataFetcher {
                 (_a = this.application) === null || _a === void 0 ? void 0 : _a.info(jsonResp.statusMessage);
               }
             }
+            this.processServiceBrokerClientEvents({ clientEvents: jsonResp === null || jsonResp === void 0 ? void 0 : jsonResp.clientEvents, serviceName, payloadJson, accept, reject });
           }
           catch (err) {
             console.warn(`Erro ao executar serviço: ${err}`);