@sankhyalabs/sankhyablocks 0.0.0-bugfix-dev-KB-86600.1 → 0.0.0-bugfix-dev-KB-86904.0

package/dist/components/taskbar-split-button.d.ts

@@ -0,0 +1,11 @@
+import type { Components, JSX } from "../types/components";
+
+interface TaskbarSplitButton extends Components.TaskbarSplitButton, HTMLElement {}
+export const TaskbarSplitButton: {
+  prototype: TaskbarSplitButton;
+  new (): TaskbarSplitButton;
+};
+/**
+ * Used to define this component and all nested components recursively.
+ */
+export const defineCustomElement: () => void;

package/dist/components/taskbar-split-button.js

@@ -0,0 +1,6 @@
+import { T as TaskbarSplitButton$1, d as defineCustomElement$1 } from './taskbar-split-button2.js';
+
+const TaskbarSplitButton = TaskbarSplitButton$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { TaskbarSplitButton, defineCustomElement };

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

@@ -0,0 +1,87 @@
+import { proxyCustomElement, HTMLElement, h, Host } from '@stencil/core/internal/client';
+
+const taskbarSplitButtonCss = "";
+
+const TaskbarSplitButton = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
+  constructor() {
+    super();
+    this.__registerHost();
+    this._showDropdown = false;
+    this.iconName = undefined;
+    this.action = undefined;
+    this.name = undefined;
+    this.className = undefined;
+    this.dataElementId = undefined;
+    this.title = undefined;
+    this.enabled = undefined;
+    this.actions = undefined;
+  }
+  initializeEagerItems() {
+    var _a;
+    (_a = this.actions) === null || _a === void 0 ? void 0 : _a.forEach(action => {
+      var _a;
+      if (action && action.eagerInitialize && action.itemBuilder) {
+        (_a = action.itemBuilder) === null || _a === void 0 ? void 0 : _a.call(action, this._splitButtonRef, action);
+      }
+    });
+  }
+  componentDidLoad() {
+    this.initializeEagerItems();
+  }
+  dropdownItemBuilder(item, _level) {
+    const itemAction = this.actions.find(action => action.value === item.id);
+    if (!itemAction || !itemAction.itemBuilder) {
+      return undefined;
+    }
+    const customContent = itemAction.itemBuilder(this._splitButtonRef, itemAction);
+    if (typeof customContent === 'string') {
+      return h("div", { innerHTML: customContent });
+    }
+    return customContent;
+  }
+  loadItems() {
+    return this.actions.filter(action => action !== undefined).map(action => {
+      var _a;
+      return {
+        id: action.value,
+        label: action.label,
+        value: action.value,
+        type: (_a = action.type) !== null && _a !== void 0 ? _a : 'item',
+        children: action.children,
+        iconName: action.iconName,
+        subAction: action.subAction,
+        group: action.group,
+        disableCloseOnSelect: action.disableCloseOnSelect,
+      };
+    });
+  }
+  render() {
+    return (h(Host, null, h("ez-split-button", { ref: (ref) => this._splitButtonRef = ref, key: this.dataElementId, class: `${this.className} "ez-split-button--tertiary ez-padding--medium"`, items: this.loadItems(), mode: "icon-only", iconName: this.iconName, enabled: this.enabled, show: this._showDropdown, onButtonClick: () => this.action(this.name), itemBuilder: (item, level) => this.dropdownItemBuilder(item, level) })));
+  }
+  static get style() { return taskbarSplitButtonCss; }
+}, [2, "taskbar-split-button", {
+    "iconName": [1, "icon-name"],
+    "action": [16],
+    "name": [1],
+    "className": [1, "class-name"],
+    "dataElementId": [1, "data-element-id"],
+    "title": [1],
+    "enabled": [4],
+    "actions": [16],
+    "_showDropdown": [32]
+  }]);
+function defineCustomElement() {
+  if (typeof customElements === "undefined") {
+    return;
+  }
+  const components = ["taskbar-split-button"];
+  components.forEach(tagName => { switch (tagName) {
+    case "taskbar-split-button":
+      if (!customElements.get(tagName)) {
+        customElements.define(tagName, TaskbarSplitButton);
+      }
+      break;
+  } });
+}
+
+export { TaskbarSplitButton as T, defineCustomElement as d };

package/dist/esm/{ClientSideExporterProvider-b3871edb.js → ClientSideExporterProvider-3ed744fd.js}

@@ -7,9 +7,9 @@ import { UserInterface as UserInterface$1 } from '@sankhyalabs/core/dist/datauni
 import { P as PreloadManager } from './dataunit-fetcher-0e025732.js';
 import './filter-item-type.enum-d45e026f.js';
 import './form-config-fetcher-fa208a6c.js';
-import './constants-7db1128a.js';
+import './constants-7b422de0.js';
 import InMemoryFilterColumnDataSource from '@sankhyalabs/ezui/dist/collection/components/ez-grid/utils/InMemoryFilterColumnDataSource';
-import { h } from './index-a7d3d3f1.js';
+import { h } from './index-479e1293.js';
 import { g as getSelectedRecordsIDsInfo } from './GetSelectedRecordsIDsInfo-9fa41508.js';
 import { I as IExportType } from './IFetchDataExporterParams-d73bed3d.js';
 

package/dist/esm/{ConfigStorage-71e6766f.js → ConfigStorage-79b9e180.js}

@@ -182,16 +182,30 @@ class FilterBarConfigFetcher extends ResourceFetcher {
 
 class PersonalizedFilterFetcher {
   constructor() {
+    this.DEFAULT_RESOURCE = '_default';
     this.templateByQuery = new Map();
     this.buildTemplates();
   }
-  resolveURI(resourceID, configName) {
+  resolveURI(resourceID, configName, isDefault) {
     let uri = "filter-assistent-config://" + resourceID;
     if (configName) {
       uri += "." + configName;
     }
+    if (isDefault) {
+      uri += this.DEFAULT_RESOURCE;
+    }
     return uri;
   }
+  resolveLegacyConfigName(legacyConfigName, isDefault) {
+    if (!legacyConfigName) {
+      return '';
+    }
+    let legacyConfig = `?legacyResourceID=${legacyConfigName}`;
+    if (isDefault) {
+      legacyConfig += this.DEFAULT_RESOURCE;
+    }
+    return legacyConfig;
+  }
   buildTemplates() {
     this.templateByQuery.set("fetchFilterFields", dist.gql `
     query($name: String!) {
@@ -254,11 +268,14 @@ class PersonalizedFilterFetcher {
       }
     }`);
   }
-  async loadPersonalizedFilter(resourceID, filterID, configName, legacyConfigName) {
+  async loadDefaultFilter(resourceID, filterID, configName, legacyConfigName) {
+    return this.loadPersonalizedFilter(resourceID, filterID, configName, legacyConfigName, true);
+  }
+  async loadPersonalizedFilter(resourceID, filterID, configName, legacyConfigName, isDefault) {
     return new Promise((resolve, reject) => {
       DataFetcher.get()
         .callGraphQL({
-        values: { name: this.resolveURI(resourceID, configName) + "/" + filterID + this.resolveLegacyConfigName(legacyConfigName) },
+        values: { name: this.resolveURI(resourceID, configName, isDefault) + "/" + filterID + this.resolveLegacyConfigName(legacyConfigName, isDefault) },
         query: this.templateByQuery.get("fetchFilterAssistent"),
       })
         .then((resp) => {
@@ -270,10 +287,10 @@ class PersonalizedFilterFetcher {
       });
     });
   }
-  resolveLegacyConfigName(legacyConfigName) {
-    return legacyConfigName ? `?legacyResourceID=${legacyConfigName}` : '';
+  async saveDefaultFilter(personalizedFilter, resourceID, configName) {
+    return this.savePersonalizedFilter(personalizedFilter, resourceID, configName, true);
   }
-  async savePersonalizedFilter(personalizedFilter, resourceID, configName) {
+  async savePersonalizedFilter(personalizedFilter, resourceID, configName, isDefault) {
     if (!personalizedFilter || Object.keys(personalizedFilter).length == 0) {
       return Promise.reject(new Error("personalizedFilter não pode ser vazio"));
     }
@@ -282,7 +299,7 @@ class PersonalizedFilterFetcher {
     return new Promise((resolve, reject) => {
       DataFetcher.get()
         .callGraphQL({
-        values: { name: this.resolveURI(resourceID, configName), filterAssistent: personalizedFilterParsed },
+        values: { name: this.resolveURI(resourceID, configName, isDefault), filterAssistent: personalizedFilterParsed },
         query: this.templateByQuery.get("savePersonalizedFilter"),
       })
         .then((resp) => {
@@ -293,11 +310,14 @@ class PersonalizedFilterFetcher {
       });
     });
   }
-  async removePersonalizedFilter(personalizedFilter, resourceID, configName) {
+  removeDefaultFilter(personalizedFilter, resourceID, configName) {
+    return this.removePersonalizedFilter(personalizedFilter, resourceID, configName, true);
+  }
+  async removePersonalizedFilter(personalizedFilter, resourceID, configName, isDefault) {
     return new Promise((resolve, reject) => {
       DataFetcher.get()
         .callGraphQL({
-        values: { name: this.resolveURI(resourceID, configName), filterId: personalizedFilter.id },
+        values: { name: this.resolveURI(resourceID, configName, isDefault), filterId: personalizedFilter.id },
         query: this.templateByQuery.get("deletePersonalizedFilter"),
       })
         .then((resp) => {
@@ -362,15 +382,15 @@ var CONFIG_SOURCE;
 })(CONFIG_SOURCE || (CONFIG_SOURCE = {}));
 class ConfigStorage {
   static addFilterBarLegacyConfig(configName, legacyConfigName) {
-    this.validateConfigName(configName, legacyConfigName);
+    this.validateResourceId(legacyConfigName);
     this.filterBarLegacyConfig.set(configName, legacyConfigName);
   }
   static addFormLegacyConfig(configName, legacyConfigName) {
-    this.validateConfigName(configName, legacyConfigName);
+    this.validateResourceId(legacyConfigName);
     this.formLegacyConfig.set(configName, legacyConfigName);
   }
   static addGridLegacyConfig(configName, legacyConfigName) {
-    this.validateConfigName(configName, legacyConfigName);
+    this.validateResourceId(legacyConfigName);
     this.gridLegacyConfig.set(configName, legacyConfigName);
   }
   static preload(resourceID, configName, legacyConfigs) {
@@ -427,6 +447,10 @@ class ConfigStorage {
     await this.deleteGridConfigCache(name, resourceID);
     return this.gridConfigFetcher.saveConfig(config, name, resourceID);
   }
+  static async loadDefaultFilter(filterId, resourceID, configName) {
+    const legacyConfigName = this.filterBarLegacyConfig.get(configName);
+    return this.personalizedFilterFetcher.loadDefaultFilter(resourceID, filterId, configName, legacyConfigName);
+  }
   static async loadPersonalizedFilter(filterId, resourceID, configName) {
     const legacyConfigName = this.filterBarLegacyConfig.get(configName);
     return this.personalizedFilterFetcher.loadPersonalizedFilter(resourceID, filterId, configName, legacyConfigName);
@@ -437,6 +461,13 @@ class ConfigStorage {
     await this.deleteFilterBarConfigCache(configName, resourceID);
     return this.personalizedFilterFetcher.savePersonalizedFilter(personalizedFilter, resourceID, configName);
   }
+  static async saveDefaultFilter(personalizedFilter, resourceID, configName) {
+    await this.deleteFilterBarConfigCache(configName, resourceID);
+    return this.personalizedFilterFetcher.saveDefaultFilter(personalizedFilter, resourceID, configName);
+  }
+  static async removeDefaultFilter(personalizedFilter, resourceID, configName) {
+    return this.personalizedFilterFetcher.removeDefaultFilter(personalizedFilter, resourceID, configName);
+  }
   static async removePersonalizedFilter(personalizedFilter, resourceID, configName) {
     return this.personalizedFilterFetcher.removePersonalizedFilter(personalizedFilter, resourceID, configName);
   }
@@ -452,10 +483,8 @@ class ConfigStorage {
   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)
+  static validateResourceId(resourceId) {
+    if (!resourceId)
       throw Error(this.LEGACY_CONFIG_NAME_ERROR_MESSAGE);
   }
   static handleLegacyConfig(configName, configSource, urlParams) {
@@ -495,7 +524,6 @@ 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();

package/dist/esm/FormConfigHelper-49fe72ca.js

@@ -0,0 +1,248 @@
+import { UserInterface, DataType } from '@sankhyalabs/core';
+import { a as TAB_NAMES, G as GROUP_NAMES, D as DEFAULT_TYPE } from './constants-7b422de0.js';
+
+const iconMap = new Map([
+  [UserInterface.DATE, 'calendar'],
+  [UserInterface.DATETIME, 'calendar-clock'],
+  [UserInterface.ELAPSEDTIME, 'timer-outline'],
+  [UserInterface.TIME, 'timer-outline'],
+  [UserInterface.DECIMALNUMBER, 'number'],
+  [UserInterface.INTEGERNUMBER, 'number'],
+  [UserInterface.FILE, 'zip'],
+  [UserInterface.IMAGE, 'pdf'],
+  [UserInterface.HTML, 'tag_code'],
+  [UserInterface.SEARCH, 'search'],
+  [UserInterface.SEARCHPLUS, 'search'],
+  [UserInterface.OPTIONSELECTOR, 'list'],
+  [UserInterface.CHECKBOX, 'list'],
+  [UserInterface.SWITCH, 'boolean'],
+  [UserInterface.PASSWORD, 'eye-off'],
+]);
+const ID_AVAILABLE_FIELDS = 'container-available-fields';
+var SORTABLE_PATH;
+(function (SORTABLE_PATH) {
+  SORTABLE_PATH["FROM"] = "from";
+  SORTABLE_PATH["TO"] = "to";
+})(SORTABLE_PATH || (SORTABLE_PATH = {}));
+function getFieldsStructure(evt, path, group, tab) {
+  var _a;
+  const htmlStructure = (_a = evt === null || evt === void 0 ? void 0 : evt[path]) === null || _a === void 0 ? void 0 : _a.children;
+  if (!htmlStructure)
+    return [];
+  return Array.from(htmlStructure).map(({ fieldConfig }) => {
+    return Object.assign(Object.assign({}, fieldConfig), { group, tab });
+  });
+}
+function updateTabInFieldsFromGroupList(guideGroups, updatedName) {
+  return guideGroups.map(group => {
+    return Object.assign(Object.assign({}, group), { fields: group.fields.map(field => (Object.assign(Object.assign({}, field), { tab: updatedName }))) });
+  });
+}
+function getValidatedFieldValue(fieldValue, dataUnit, fieldName) {
+  var _a;
+  if (fieldValue == undefined || !dataUnit || !fieldName)
+    return;
+  const dataType = (_a = dataUnit.getField(fieldName)) === null || _a === void 0 ? void 0 : _a.dataType;
+  if (dataType == undefined)
+    return;
+  if ((fieldValue === null || fieldValue === void 0 ? void 0 : fieldValue.waitmessage) !== undefined)
+    return undefined;
+  const isNonObjectValue = dataType !== DataType.OBJECT &&
+    dataType !== DataType.DATE &&
+    typeof fieldValue === 'object';
+  const processedValue = isNonObjectValue ? fieldValue.value : fieldValue;
+  return dataType === DataType.OBJECT
+    ? JSON.stringify(processedValue)
+    : processedValue;
+}
+function getEnabledByProperty(attribName, propertyName, fieldDescriptor) {
+  if (!fieldDescriptor)
+    return true;
+  const fieldProperties = fieldDescriptor.properties || {};
+  const fromAttribName = fieldDescriptor[attribName] !== true;
+  return fieldProperties.hasOwnProperty(propertyName)
+    ? fieldProperties[propertyName] !== 'S'
+    : fromAttribName;
+}
+function getValueByProperty(property, fieldDescriptor, defaultValue) {
+  if (fieldDescriptor && fieldDescriptor[property] === true) {
+    return true;
+  }
+  return defaultValue;
+}
+function getIconName(userInterface) {
+  return iconMap.get(userInterface) || 'text';
+}
+function buildNewGuideName(guidesList) {
+  var _a, _b;
+  const qtdWithNewGuideName = (_b = (_a = guidesList.filter(g => g.name.includes(TAB_NAMES.newGuide))) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+  return qtdWithNewGuideName === 0
+    ? TAB_NAMES.newGuide
+    : `${TAB_NAMES.newGuide} (${qtdWithNewGuideName})`;
+}
+function getFieldsToSave(guidesMap) {
+  const fieldsToSave = [];
+  guidesMap.forEach(groups => {
+    groups.forEach(({ fields }) => {
+      fields === null || fields === void 0 ? void 0 : fields.forEach((fieldConfig) => {
+        fieldsToSave.push(buildFieldToSave(fieldConfig));
+      });
+    });
+  });
+  return fieldsToSave;
+}
+function buildGuidesMap(rawFields, tabs, dataUnit, generalTab) {
+  const fields = handleFieldsTabNames(rawFields);
+  const guidesMap = initGuidesMap(tabs);
+  if (!(fields === null || fields === void 0 ? void 0 : fields.length))
+    return;
+  for (let guideName of guidesMap.keys()) {
+    const fieldsFromGuide = getFieldsFromGuide(fields, guideName, generalTab);
+    const fieldsByGroupMap = getGroupsFromGuide(fieldsFromGuide, dataUnit, generalTab);
+    const groupsList = parserGroupMapIntoList(fieldsByGroupMap);
+    guidesMap.set(guideName, groupsList);
+  }
+  return guidesMap;
+}
+function buildGuides(config, mainArea) {
+  let tabs = config.tabs ? [...config.tabs] : buildTabsFromFields(config === null || config === void 0 ? void 0 : config.fields);
+  tabs = getPossibleGuides(tabs);
+  tabs = initializeTabsNames(tabs);
+  return handleMainTab(tabs, mainArea);
+}
+function handleFieldsTabNames(allFields) {
+  // Campos que não fazem parte de nenhuma aba ou da aba "Geral", devem ser movidos para a aba __main.
+  return allFields.map(field => {
+    const tabName = field.tab;
+    return Object.assign(Object.assign({}, field), { tab: (!tabName || tabName === TAB_NAMES.general) ? TAB_NAMES.main : field.tab });
+  });
+}
+function initializeTabsNames(tabs) {
+  return tabs.map((tab) => {
+    return Object.assign(Object.assign({}, tab), { name: tab.name ? tab.name : tab.label });
+  });
+}
+function handleMainTab(tabs, mainTabName) {
+  const mainTab = { name: TAB_NAMES.main, label: mainTabName, visible: true };
+  const hasTabMain = tabs.some((tab) => tab.name === TAB_NAMES.main);
+  if (hasTabMain) {
+    tabs = tabs.map(tab => tab.name === TAB_NAMES.main ? mainTab : tab);
+  }
+  else {
+    tabs.unshift(mainTab);
+  }
+  return tabs;
+}
+function getPossibleGuides(tabs) {
+  //O usuário não pode criar uma guia com o nome "Geral".
+  // Nesses casos, precisamos mover os campos dessa guia, para a guia __main.
+  return [...tabs.filter(tab => tab.label !== TAB_NAMES.general)];
+}
+function initGuidesMap(tabs) {
+  const map = new Map();
+  let possibleGuides = getPossibleGuides(tabs);
+  possibleGuides.forEach(tab => {
+    map.set(tab.name, []);
+  });
+  return map;
+}
+function handleFieldLabel(field, fieldDescriptor) {
+  if (!field.label) {
+    field.label = fieldDescriptor.label;
+  }
+}
+function handleFieldTab(field, generalTabName) {
+  if (!field.tab) {
+    field.tab = generalTabName;
+  }
+}
+function handleFieldGroup(field) {
+  if (!field.group) {
+    field.group = GROUP_NAMES.noGroup;
+  }
+}
+function isVisibleOnConfig(fieldDescriptor) {
+  var _a;
+  /**
+   * Quando um campo é ocultado pelo dev, mas queremos manter ele na config precisamos fazer essa tratativa.
+   */
+  return ((_a = fieldDescriptor === null || fieldDescriptor === void 0 ? void 0 : fieldDescriptor.properties) === null || _a === void 0 ? void 0 : _a.visibleOnConfig) === true && (fieldDescriptor === null || fieldDescriptor === void 0 ? void 0 : fieldDescriptor.visible) === false;
+}
+function getGroupsFromGuide(fieldsFromGuide, dataUnit, generalTabName) {
+  const groupsMap = new Map();
+  groupsMap.set(GROUP_NAMES.noGroup, []);
+  for (let field of fieldsFromGuide) {
+    const fieldDescriptor = dataUnit.getField(field.name);
+    if (!(fieldDescriptor === null || fieldDescriptor === void 0 ? void 0 : fieldDescriptor.visible) && !isVisibleOnConfig(fieldDescriptor))
+      continue;
+    handleFieldLabel(field, fieldDescriptor);
+    handleFieldTab(field, generalTabName);
+    handleFieldGroup(field);
+    if (groupsMap.has(field.group)) {
+      groupsMap.get(field.group).push(field);
+    }
+    else {
+      groupsMap.set(field.group, [field]);
+    }
+  }
+  return groupsMap;
+}
+function getFieldsFromGuide(fields, guideName, generalTabName) {
+  return fields.filter(field => {
+    const fieldTab = getTabName(field.tab, generalTabName);
+    return fieldTab === guideName;
+  });
+}
+function getTabName(tab, generalTabName) {
+  var _a;
+  if (typeof tab === 'string')
+    return tab;
+  return (_a = tab === null || tab === void 0 ? void 0 : tab.label) !== null && _a !== void 0 ? _a : generalTabName;
+}
+function parserGroupMapIntoList(groupsMap) {
+  const groupsList = [];
+  for (let groupName of groupsMap.keys()) {
+    groupsList.push({ name: groupName, fields: groupsMap.get(groupName) });
+  }
+  return groupsList;
+}
+function canAddTab(tab, guideList) {
+  return tab && !(guideList.map(g => g.name).includes(tab));
+}
+function buildTabsFromFields(fields) {
+  const guideList = [];
+  let order = 1;
+  fields === null || fields === void 0 ? void 0 : fields.forEach((field) => {
+    const tab = field.tab;
+    if (canAddTab(tab, guideList)) {
+      guideList.push({ name: tab, label: tab, visible: true, order });
+      order = order + 1;
+    }
+  });
+  return guideList;
+}
+function buildFieldToSave(fieldConfig) {
+  const fieldToSave = {
+    cleanOnCopy: fieldConfig.cleanOnCopy || false,
+    group: fieldConfig.group === GROUP_NAMES.noGroup ? undefined : fieldConfig.group,
+    label: fieldConfig.label,
+    name: fieldConfig.name,
+    required: fieldConfig.required,
+    readOnly: fieldConfig.readOnly,
+    tab: fieldConfig.tab,
+  };
+  if (fieldConfig.defaultValue != undefined) {
+    if (fieldConfig.defaultValue.type == undefined) {
+      fieldToSave.defaultValue = {
+        type: DEFAULT_TYPE.fixed,
+        value: fieldConfig.defaultValue,
+      };
+    }
+    else {
+      fieldToSave.defaultValue = fieldConfig.defaultValue;
+    }
+  }
+  return fieldToSave;
+}
+
+export { ID_AVAILABLE_FIELDS as I, SORTABLE_PATH as S, buildGuidesMap as a, buildGuides as b, buildNewGuideName as c, getFieldsStructure as d, getValidatedFieldValue as e, getEnabledByProperty as f, getFieldsToSave as g, getValueByProperty as h, getIconName as i, updateTabInFieldsFromGroupList as u };

package/dist/esm/{PersonalizedFilterUtils-e2b38ef7.js → PersonalizedFilterUtils-2db38ff2.js}

@@ -1,6 +1,6 @@
 import { DataType, NumberUtils, DateUtils, UserInterface } from '@sankhyalabs/core';
 import { F as FilterItemType } from './filter-item-type.enum-d45e026f.js';
-import { F as FilterOperand } from './index-ae591a44.js';
+import { F as FilterOperand } from './index-8acbae97.js';
 
 class PersonalizedFilterUtils {
   /**

package/dist/esm/{SnkFormConfigManager-be490a33.js → SnkFormConfigManager-b4b93298.js}

@@ -1,7 +1,7 @@
-import { C as ConfigStorage } from './ConfigStorage-71e6766f.js';
+import { C as ConfigStorage } from './ConfigStorage-79b9e180.js';
 import { ObjectUtils, StringUtils } from '@sankhyalabs/core';
 import { F as FormConfigFetcher } from './form-config-fetcher-fa208a6c.js';
-import { c as TAB_NAMES } from './constants-7db1128a.js';
+import { a as TAB_NAMES } from './constants-7b422de0.js';
 
 class SnkFormConfigManager {
   constructor(configName, resourceID, onConfigChange, dataUnit) {
@@ -29,8 +29,7 @@ class SnkFormConfigManager {
     });
   }
   getEmptyConfig() {
-    const config = this.buildFormMetadataUITabs({ fields: [], emptyConfig: true }, true);
-    return config;
+    return this.buildFormMetadataUITabs({ fields: [], emptyConfig: true }, true);
   }
   saveConfig(config) {
     const configToSave = ObjectUtils.copy(config);

package/dist/esm/{SnkMessageBuilder-12f5fe1a.js → SnkMessageBuilder-9c269caf.js}

@@ -83,6 +83,12 @@ const snkFilterBarMessages = {
     "cancelButtonLabel": "Limpar tudo",
     "customFilters": "Filtros personalizados",
     "quickFilters": "Filtros rápidos",
+    "defaultFilter": {
+      "title": "Filtro padrão",
+      "edit": "Editar filtro",
+      "remove": "Excluir filtro",
+      "create": "Criar filtro padrão",
+    },
     "validations": {
       "notFullFilled": {
         "title": "Filtro parcialmente preenchido",
@@ -147,12 +153,13 @@ const snkCrudMessages = {
     update: "Alterar registro",
     clean: "{{ENTITY_NAME}}"
   },
-  findColumn: "Buscar campos",
+  findColumn: "Buscar campos (Ctrl+F)",
   goBackTitle: "Voltar"
 };
 
 const snkSimpleCrudMessages = {
-  findColumn: "Busca de colunas",
+  findColumn: "Busca de colunas (Ctrl+F)",
+  findFields: "Busca de campos (Ctrl+F)",
   formConfigUnavaliable: {
     title: "Aviso",
     message: 'A opção "Configurar formulário" será disponibilizada em breve. Enquanto isso, acesse a configuração do fomulário através dos layouts anteriores, HTML5 ou Flex.'
@@ -210,23 +217,37 @@ const snkFormConfigMessages = {
     mainArea: "Área principal",
     tabGeneral: "Geral"
   },
+  configs: {
+    buttonLabel: "Configurações",
+    selectedConfig: "configuração selecionada"
+  },
   confirm: {
     title: "Aviso",
     deleteTab: "Você realmente deseja excluir a aba",
+    deleteGuide: "Deseja realmente excluir a guia <b>{0}</b>?",
     cancel: "As alterações realizadas serão descartadas.<br/><br/><b>Gostaria de continuar?</b>",
     exit: "Ao sair as alterações serão descartadas.<br/><br/><b>Você realmente gostaria de sair?</b>",
-    apply: "A <b>{0}</b> irá substituir a sua configuração {1}!<br/><br/><b>Deseja continuar?</b>",
+    apply: "A <b>{0}</b> irá substituir a configuração atual!<br/><br/><b>Deseja continuar?</b>",
     group: "Não é possível salvar as configurações com um grupo vazio!",
     labelCancel: "Cancelar",
     labelDelete: "Excluir"
   },
+  noGuideSelected: {
+    title: "Atenção",
+    message: "Selecione uma guia para iniciar a configuração!"
+  },
   alert: {
     titleGroupExists: "Já existe um grupo com título",
+    titleGroupEditing: "Há um <b>grupo<b/> em edição. <br/> Finalize a edição para salvar as configurações.",
+    titleGuideExists: "Já existe uma guia com título",
+    titleGuideEditing: "Há uma <b>guia<b/> em edição. <br/> Finalize a edição para salvar as configurações.",
+    titleGuideReservedName: "Este título é reservado para configurações internas do sistema e não pode ser utilizado.",
     infoValidTitle: "Por favor, digite um título válido.",
     inTab: "na aba"
   },
   info: {
-    successfullyConfigSaved: "As configurações foram salvas com sucesso!"
+    successfullyConfigSaved: "As configurações foram salvas com sucesso!",
+    successfullyGuideDeleted: 'A guia "{0}" foi excluída. Salve para confirmar a alteração.'
   }
 };
 const snkFieldConfigMessages = {
@@ -251,7 +272,7 @@ const snkConfiguratorMessages = {
 };
 
 const snkGridMessages = {
-  findColumn: "Busca de colunas",
+  findColumn: "Busca de colunas (Ctrl+F)",
   cancelConfirmation: {
     title: "Aviso",
     message: "As alterações realizadas serão descartadas<br/><br/><b>Você realmente gostaria de cancelar?</b>",
@@ -394,6 +415,8 @@ const snkPersonalizedFilterMessages = {
   info: {
     titleEdit: "Editar filtro personalizado",
     titleAdd: "Criar filtro personalizado",
+    titleCreateDefault: "Aplicar filtro padrão",
+    titleEditDefault: "Editar filtro padrão",
     titleCollapsible: "Expressão a ser aplicada (gerada pelo assistente)",
     labelSearchField: "Buscar campo",
     labelOperator: "Operador",
@@ -416,7 +439,10 @@ const snkPersonalizedFilterMessages = {
     applyExpression: "Expressão a ser aplicada:",
     tooltipDisabledAssistentMode: "Expressão não suportada pelo assistente.",
     activeModeAdvanced: "Ativar modo avançado",
-    activeModeAssistent: "Ativar modo assistente"
+    activeModeAssistent: "Ativar modo assistente",
+    textInputDisabled: "Campo desabilitado para filtros padrões",
+    checkVariableDisabled: "Filtro padrão não pode ser variável.",
+    deleteDefaultFilterConfirm: "Deseja excluir o <b>filtro padrão</b>?",
   },
   confirmExpression: {
     title: "Aviso",