@sankhyalabs/sankhyablocks 8.15.0-dev.4 → 8.15.0-dev.40

package/dist/components/snk-taskbar2.js

@@ -1,5 +1,5 @@
 import { h, proxyCustomElement, HTMLElement, createEvent, Host } from '@stencil/core/internal/client';
-import { StringUtils, ApplicationContext, ElementIDUtils } from '@sankhyalabs/core';
+import { StringUtils, ApplicationContext, OVERFLOWED_CLASS_NAME, OverflowWatcher, OverflowDirection, ElementIDUtils } from '@sankhyalabs/core';
 import { A as AuthorizationConfig } from './AuthorizationConfig.js';
 import { P as PresentationMode } from './index2.js';
 import { s as store } from './index3.js';
@@ -93,35 +93,35 @@ const buildElem = (element, className, dataElementId, getTitle, action, isEnable
     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) },
+  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;
 }
 
-const snkTaskbarCss = ".sc-snk-taskbar-h{display:flex}";
+const snkTaskbarCss = ".sc-snk-taskbar-h{display:flex;flex-wrap:wrap}.no-wrap.sc-snk-taskbar-h{flex-wrap:nowrap}.full-width.sc-snk-taskbar-h{width:100%}.align-right.sc-snk-taskbar-h{justify-content:flex-end}.overflowed.sc-snk-taskbar{display:none}";
 
 const SnkTaskbar = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
   constructor() {
@@ -129,6 +129,9 @@ const SnkTaskbar = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
     this.__registerHost();
     this.actionClick = createEvent(this, "actionClick", 7);
     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",
@@ -146,11 +149,15 @@ const SnkTaskbar = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
       [TaskbarElement.ATTACH]: "snkTaskbar.titleAttach",
     };
     this._permissions = undefined;
+    this._overFlowedElements = [];
     this._customElements = undefined;
     this._customElementsId = undefined;
     this._slotContainer = undefined;
+    this._hiddenActionsList = [];
+    this.alignRigth = false;
     this.customSlotId = "TASKBAR_CUSTOM_ELEMENTS";
     this.customContainerId = undefined;
+    this.overflowStrategy = 'hiddenItems';
     this.configName = undefined;
     this.resourceID = undefined;
     this.buttons = undefined;
@@ -164,6 +171,13 @@ const SnkTaskbar = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
   }
   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();
   }
   // Internal methods
   elementsFromString(strButtons) {
@@ -259,12 +273,19 @@ const SnkTaskbar = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
     }
     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);
   }
@@ -305,11 +326,13 @@ const SnkTaskbar = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
     });
   }
   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;
@@ -344,15 +367,76 @@ const SnkTaskbar = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
     }
     this.validatePresentationMode();
   }
+  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();
   }
   disconnectedCallback() {
+    var _a;
     this.unlinkAllCustomElements();
+    (_a = this._overFlowWatcher) === null || _a === void 0 ? void 0 : _a.destroy();
   }
   unlinkAllCustomElements() {
     var _a;
@@ -370,14 +454,9 @@ const SnkTaskbar = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
       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]);
       }
@@ -387,17 +466,26 @@ const SnkTaskbar = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
       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' : ""}`;
   }
   get _element() { return this; }
   static get watchers() { return {
-    "buttons": ["observeButtons"]
+    "buttons": ["observeButtons"],
+    "disabledButtons": ["observeDisabledButtons"]
   }; }
   static get style() { return snkTaskbarCss; }
 }, [6, "snk-taskbar", {
+    "alignRigth": [4, "align-rigth"],
     "customSlotId": [1, "custom-slot-id"],
     "customContainerId": [1, "custom-container-id"],
+    "overflowStrategy": [1, "overflow-strategy"],
     "configName": [1, "config-name"],
     "resourceID": [1, "resource-i-d"],
     "buttons": [1],
@@ -409,9 +497,11 @@ const SnkTaskbar = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
     "presentationMode": [1537, "presentation-mode"],
     "messagesBuilder": [1040],
     "_permissions": [32],
+    "_overFlowedElements": [32],
     "_customElements": [32],
     "_customElementsId": [32],
-    "_slotContainer": [32]
+    "_slotContainer": [32],
+    "_hiddenActionsList": [32]
   }]);
 function defineCustomElement() {
   if (typeof customElements === "undefined") {

package/dist/components/taskbar-actions-button2.js

@@ -67,12 +67,28 @@ const TaskbarActionsButton = /*@__PURE__*/ proxyCustomElement(class extends HTML
     return this._showDropdown && ((_a = this.actions) === null || _a === void 0 ? void 0 : _a.length) > 0;
   }
   onSelectAction(iAction) {
-    const selectedAction = this.actions.find(action => action.value === iAction.id);
+    const actions = this.actions.map(action => (Object.assign(Object.assign({}, action), { id: action.value })));
+    const selectedAction = this.getSelectedAction(iAction.id, actions);
     this.taskbarActionSelected.emit(selectedAction);
     if (!selectedAction.disableCloseOnSelect) {
       this._showDropdown = false;
     }
   }
+  getSelectedAction(id, actions) {
+    let selectedItem = null;
+    for (const item of actions) {
+      if (item.id === id) {
+        selectedItem = item;
+        break;
+      }
+      if (!(item === null || item === void 0 ? void 0 : item.children))
+        continue;
+      selectedItem = this.getSelectedAction(id, item.children);
+      if (selectedItem)
+        break;
+    }
+    return selectedItem;
+  }
   dropdownItemBuilder(item, _level) {
     const itemAction = this.actions.find(action => action.value === item.id);
     if (!itemAction || !itemAction.itemBuilder) {
@@ -110,7 +126,7 @@ const TaskbarActionsButton = /*@__PURE__*/ proxyCustomElement(class extends HTML
     this.taskbarActionsButtonDisconnected.emit();
   }
   render() {
-    return (h(Host, null, h("div", { class: `ez-padding-left--medium ${this.canShowDropdown() ? ' ez-elevation--16' : ''}` }, h("ez-button", { title: this.title, mode: 'icon', iconName: 'dots-vertical', size: 'small', enabled: this.enabled, onClick: () => this.controlDropdown() }), this.canShowDropdown() && h("ez-dropdown", { items: this.loadItems(), onEzClick: (evt) => this.onSelectAction(evt.detail), onEzOutsideClick: () => this._showDropdown = false, itemBuilder: (item, level) => this.dropdownItemBuilder(item, level) }))));
+    return (h(Host, null, h("div", { class: `${this.canShowDropdown() ? ' ez-elevation--16' : ''}` }, h("ez-button", { title: this.title, mode: 'icon', iconName: 'dots-vertical', size: 'small', enabled: this.enabled, onClick: () => this.controlDropdown() }), this.canShowDropdown() && h("ez-dropdown", { items: this.loadItems(), onEzClick: (evt) => this.onSelectAction(evt.detail), onEzOutsideClick: () => this._showDropdown = false, itemBuilder: (item, level) => this.dropdownItemBuilder(item, level) }))));
   }
   get _element() { return this; }
   static get style() { return taskbarActionsButtonCss; }

package/dist/esm/{ConfigStorage-1244b8b0.js → ConfigStorage-101a2b4c.js}

@@ -1,7 +1,7 @@
-import { R as ResourceFetcher, F as FormConfigFetcher } from './form-config-fetcher-36219cd3.js';
+import { R as ResourceFetcher, F as FormConfigFetcher } from './form-config-fetcher-f121f880.js';
 import { F as FilterItemType } from './filter-item-type.enum-d45e026f.js';
 import { ObjectUtils } from '@sankhyalabs/core';
-import { d as dist, D as DataFetcher } from './DataFetcher-aa159c5a.js';
+import { d as dist, D as DataFetcher } from './DataFetcher-a650ae58.js';
 
 class GridConfigFetcher extends ResourceFetcher {
   constructor() {
@@ -232,7 +232,7 @@ class PersonalizedFilterFetcher {
         assistent
       }
     }`);
-    this.templateByQuery.set("savePersonalizedFilter", dist.gql ` 
+    this.templateByQuery.set("savePersonalizedFilter", dist.gql `
     mutation($name: String!, $filterAssistent: InputFilterAssistent!)  {
       $queryAlias$: savePersonalizedFilter(name: $name, filterAssistent: $filterAssistent) {
         id
@@ -254,11 +254,11 @@ class PersonalizedFilterFetcher {
       }
     }`);
   }
-  async loadPersonalizedFilter(resourceID, filterID, configName) {
+  async loadPersonalizedFilter(resourceID, filterID, configName, legacyConfigName) {
     return new Promise((resolve, reject) => {
       DataFetcher.get()
         .callGraphQL({
-        values: { name: this.resolveURI(resourceID, configName) + "/" + filterID },
+        values: { name: this.resolveURI(resourceID, configName) + "/" + filterID + this.resolveLegacyConfigName(legacyConfigName) },
         query: this.templateByQuery.get("fetchFilterAssistent"),
       })
         .then((resp) => {
@@ -270,6 +270,9 @@ class PersonalizedFilterFetcher {
       });
     });
   }
+  resolveLegacyConfigName(legacyConfigName) {
+    return legacyConfigName ? `?legacyResourceID=${legacyConfigName}` : '';
+  }
   async savePersonalizedFilter(personalizedFilter, resourceID, configName) {
     if (!personalizedFilter || Object.keys(personalizedFilter).length == 0) {
       return Promise.reject(new Error("personalizedFilter não pode ser vazio"));
@@ -351,17 +354,37 @@ class PersonalizedFilterFetcher {
   }
 }
 
-const CONFIG_SOURCE = {
-  form: "form",
-  grid: "grid",
-  filterBar: "filterBar"
-};
+var CONFIG_SOURCE;
+(function (CONFIG_SOURCE) {
+  CONFIG_SOURCE["form"] = "form";
+  CONFIG_SOURCE["grid"] = "grid";
+  CONFIG_SOURCE["filterBar"] = "filterBar";
+})(CONFIG_SOURCE || (CONFIG_SOURCE = {}));
 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));
@@ -369,6 +392,7 @@ 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));
@@ -376,6 +400,7 @@ 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));
@@ -383,13 +408,12 @@ 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) {
@@ -399,18 +423,17 @@ 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) {
@@ -419,6 +442,51 @@ 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}`;
@@ -426,6 +494,11 @@ 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/esm/{DataFetcher-aa159c5a.js → DataFetcher-a650ae58.js}

@@ -6786,7 +6786,6 @@ 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.
              *
@@ -6797,8 +6796,10 @@ 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);
@@ -6806,6 +6807,7 @@ 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}`);

package/dist/esm/{ISave-4412b20c.js → ISave-d8c8bc59.js}

@@ -3,6 +3,7 @@ var SaveErrorsEnum;
   SaveErrorsEnum["LINK_AND_FILE_AT_THE_SAME_TIME"] = "LINK_AND_FILE_AT_THE_SAME_TIME";
   SaveErrorsEnum["ANY_LINK_OR_FILE_FILLED"] = "ANY_LINK_OR_FILE_FILLED";
   SaveErrorsEnum["UNKNOWN"] = "UNKNOWN";
+  SaveErrorsEnum["DESCRIPTION_CANNOT_BE_CHANGED"] = "DESCRIPTION_CANNOT_BE_CHANGED";
 })(SaveErrorsEnum || (SaveErrorsEnum = {}));
 
 export { SaveErrorsEnum as S };

package/dist/esm/{SnkFormConfigManager-9be0e7d4.js → SnkFormConfigManager-02ecf57f.js}

@@ -1,6 +1,6 @@
-import { C as ConfigStorage } from './ConfigStorage-1244b8b0.js';
+import { C as ConfigStorage } from './ConfigStorage-101a2b4c.js';
 import { ObjectUtils, StringUtils } from '@sankhyalabs/core';
-import { F as FormConfigFetcher } from './form-config-fetcher-36219cd3.js';
+import { F as FormConfigFetcher } from './form-config-fetcher-f121f880.js';
 
 class SnkFormConfigManager {
   constructor(configName, resourceID, onConfigChange) {
@@ -8,6 +8,11 @@ class SnkFormConfigManager {
     this._configName = configName;
     this._onConfigChange = onConfigChange;
   }
+  addFormLegacyConfig(legacyConfigName) {
+    if (this._configName) {
+      ConfigStorage.addFormLegacyConfig(this._configName, legacyConfigName);
+    }
+  }
   async loadConfig() {
     return new Promise(resolve => {
       ConfigStorage.loadFormConfig(this._configName, this._resourceID)
@@ -93,16 +98,19 @@ class SnkFormConfigManager {
     const normalizedFilter = StringUtils.replaceAccentuatedCharsLower(descriptionFilter.toLocaleLowerCase());
     return normalizedText.includes(normalizedFilter);
   }
-  getInsertionConfig(dataUnit) {
-    const fields = this.getFieldsList(dataUnit).filter(field => {
-      if (dataUnit) {
-        const def = dataUnit.getField(field.name);
-        if (def && def.readOnly) {
-          return false;
+  getInsertionConfig(dataUnit, ignoreReadOnlyFormFields) {
+    let fields = this.getFieldsList(dataUnit);
+    if (ignoreReadOnlyFormFields) {
+      fields = fields.filter(field => {
+        if (dataUnit) {
+          const def = dataUnit.getField(field.name);
+          if (def && def.readOnly) {
+            return false;
+          }
         }
-      }
-      return !field.readOnly;
-    });
+        return !field.readOnly;
+      });
+    }
     return Object.assign(Object.assign({}, this._config), { fields });
   }
   setConfig(config) {
@@ -122,8 +130,8 @@ class SnkFormConfigManager {
       this._onConfigChange(Object.assign({}, this._config));
     }
   }
-  getConfig(insertionMode, dataUnit) {
-    return insertionMode ? this.getInsertionConfig(dataUnit) : Object.assign({}, this._config);
+  getConfig(insertionMode, dataUnit, ignoreReadOnlyFormFields) {
+    return insertionMode ? this.getInsertionConfig(dataUnit, ignoreReadOnlyFormFields !== null && ignoreReadOnlyFormFields !== void 0 ? ignoreReadOnlyFormFields : true) : Object.assign({}, this._config);
   }
   getFormConfigFetcher() {
     if (this._formConfigFetcher == undefined) {

package/dist/esm/{SnkMessageBuilder-ca843d1b.js → SnkMessageBuilder-9747ddd2.js}

@@ -286,7 +286,8 @@ const snkDataExporterMessages = {
   },
   message: {
     emailSuccess: "E-mail enviado com sucesso",
-    exportError: "Usuário sem permissão",
+    exportError: "Falha ao exportar dados",
+    unknownFailure: "O motivo da falha não pode ser identificado.",
     exportPermission: "O usuário não possui permissão para exportar o arquivo.",
   },
   title: {
@@ -351,11 +352,24 @@ const snkAttachMessages = {
     anyLinkOrFileFilled: {
       title: "Atenção",
       message: `É necessário preencher o campo "Link" ou anexar um arquivo.`
+    },
+    descriptionCannotBeChanged: {
+      title: "Atenção",
+      message: "O campo 'Descrição' não pode ser alterado."
     }
   },
   taskbar: {
     titleDownload: "Fazer download",
     titleLink: "Abrir link",
+  },
+  attachMetadata: {
+    lblCode: "Código",
+    lblDescription: "Descrição",
+    lblFileOrLink: "Arquivo / Link",
+    lblUser: "Usuário",
+    lblDate: "Data de alteração",
+    lblFile: "Arquivo",
+    lblSubTitle: "Clique para selecionar um arquivo",
   }
 };