@sankhyalabs/sankhyablocks 10.1.0-dev.6 → 10.1.0-dev.61

package/dist/cjs/FormConfigHelper-c5f5473a.js

@@ -0,0 +1,342 @@
+'use strict';
+
+const core = require('@sankhyalabs/core');
+const constants = require('./constants-6d82e405.js');
+
+const iconMap = new Map([
+  [core.UserInterface.DATE, 'calendar'],
+  [core.UserInterface.DATETIME, 'calendar-clock'],
+  [core.UserInterface.ELAPSEDTIME, 'timer-outline'],
+  [core.UserInterface.TIME, 'timer-outline'],
+  [core.UserInterface.DECIMALNUMBER, 'number'],
+  [core.UserInterface.INTEGERNUMBER, 'number'],
+  [core.UserInterface.FILE, 'zip'],
+  [core.UserInterface.IMAGE, 'pdf'],
+  [core.UserInterface.HTML, 'tag_code'],
+  [core.UserInterface.SEARCH, 'search'],
+  [core.UserInterface.SEARCHPLUS, 'search'],
+  [core.UserInterface.OPTIONSELECTOR, 'list'],
+  [core.UserInterface.CHECKBOX, 'list'],
+  [core.UserInterface.SWITCH, 'boolean'],
+  [core.UserInterface.PASSWORD, 'eye-off'],
+]);
+const ID_AVAILABLE_FIELDS = 'container-available-fields';
+exports.SORTABLE_PATH = void 0;
+(function (SORTABLE_PATH) {
+  SORTABLE_PATH["FROM"] = "from";
+  SORTABLE_PATH["TO"] = "to";
+})(exports.SORTABLE_PATH || (exports.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 !== core.DataType.OBJECT &&
+    dataType !== core.DataType.DATE &&
+    typeof fieldValue === 'object';
+  const processedValue = isNonObjectValue ? fieldValue.value : fieldValue;
+  return dataType === core.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, getMessage) {
+  var _a, _b;
+  const newGuideText = getMessage('snkFormConfig.form.newGuide');
+  const qtdWithNewGuideName = (_b = (_a = guidesList.filter(g => g.name.includes(newGuideText))) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+  return qtdWithNewGuideName === 0 ? newGuideText : `${newGuideText} (${qtdWithNewGuideName})`;
+}
+function getFieldsToSave(guidesMap) {
+  const fieldsToSave = [];
+  guidesMap.forEach((groups, guideName) => {
+    groups.forEach(({ fields }) => {
+      fields === null || fields === void 0 ? void 0 : fields.forEach((fieldConfig) => {
+        fieldsToSave.push(buildFieldToSave(Object.assign(Object.assign({}, fieldConfig), { tab: guideName })));
+      });
+    });
+  });
+  return fieldsToSave;
+}
+function buildGuidesMap(rawFields, tabs, dataUnit, generalTab) {
+  const fields = handleFieldsTabNames(rawFields, dataUnit, generalTab);
+  const guidesMap = initGuidesMap(tabs);
+  if (!(fields === null || fields === void 0 ? void 0 : fields.length))
+    return guidesMap;
+  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, dataUnit, generalTabName = constants.TAB_NAMES.general) {
+  const normalizedFields = handleFieldsTabNames(config === null || config === void 0 ? void 0 : config.fields, dataUnit, generalTabName);
+  let tabs = config.tabs ? [...config.tabs] : buildTabsFromFields(normalizedFields);
+  tabs = getPossibleGuides(tabs);
+  tabs = initializeTabsNames(tabs);
+  const guides = handleMainTab(tabs, mainArea);
+  return ensureFieldResolvedGuides(guides, normalizedFields);
+}
+/**
+ * Garante que exista uma guia para cada aba referenciada pelos campos (após a resolução feita
+ * em resolveFieldTab). É necessário porque a "Geral" não é uma UITabName e, portanto, pode não
+ * estar presente em config.tabs (que pode inclusive vir como array vazio); sem esta garantia os
+ * campos "Geral" seriam descartados. A área principal (__main) é tratada por handleMainTab e
+ * ignorada aqui. Guias já existentes (por nome ou rótulo) não são duplicadas.
+ */
+function ensureFieldResolvedGuides(tabs, normalizedFields) {
+  const result = [...tabs];
+  let nextOrder = result.length;
+  const seen = new Set();
+  (normalizedFields !== null && normalizedFields !== void 0 ? normalizedFields : []).forEach(field => {
+    const tabName = field.tab;
+    if (!tabName || tabName === constants.TAB_NAMES.main || seen.has(tabName)) {
+      return;
+    }
+    seen.add(tabName);
+    const alreadyExists = result.some(guide => guide.name === tabName || guide.label === tabName);
+    if (alreadyExists) {
+      return;
+    }
+    result.push({ name: tabName, label: tabName, visible: true, order: nextOrder++ });
+  });
+  return result;
+}
+function buildChildrenGuides(dataUnit, initialOrderIndex = 0, guidesList) {
+  var _a;
+  if (!dataUnit || !dataUnit.metadata) {
+    return [];
+  }
+  const children = ((_a = dataUnit.metadata) === null || _a === void 0 ? void 0 : _a.children) || [];
+  const childrenWithNoGuide = [];
+  for (const child of children) {
+    const guideOnConfig = guidesList.find(guide => child.label === guide.label);
+    if (guideOnConfig) {
+      guideOnConfig.isCustom = true;
+      continue;
+    }
+    childrenWithNoGuide.push({
+      label: child.label,
+      name: child.name,
+      visible: true,
+      isCustom: true,
+      order: initialOrderIndex++
+    });
+  }
+  return childrenWithNoGuide;
+}
+function buildCustomGuides(customGuidesList, guidesList) {
+  let initialOrderIndex = guidesList.length;
+  const customGuidesToAdd = getCustomGuidesNotIncludedInList(customGuidesList, guidesList);
+  return customGuidesToAdd.map(guide => {
+    return {
+      name: guide.id,
+      label: guide.label,
+      visible: true,
+      isCustom: true,
+      order: initialOrderIndex++
+    };
+  });
+}
+function isCustomGuideIncludedInList(guidesList, guide) {
+  return guidesList.some(fromList => fromList.name === guide.id || fromList.label === guide.label);
+}
+function getCustomGuidesNotIncludedInList(customGuidesList, guidesList) {
+  return customGuidesList.filter(guide => !isCustomGuideIncludedInList(guidesList, guide));
+}
+/**
+ * Define a aba efetiva de um campo seguindo as MESMAS regras do formulário renderizado
+ * (ezui buildFormMetadata/handleFields):
+ * - Campo com aba explícita mantém a aba.
+ * - Campo sem aba que seja chave primária vai para a área principal (__main).
+ * - Demais campos sem aba vão para a aba "Geral" (aba secundária), e não para a área principal.
+ *
+ * Usa-se o literal TAB_NAMES.general ("Geral"), e não a mensagem traduzida, para manter o
+ * configurador em sintonia com o ezui (que utiliza o literal "Geral") em qualquer idioma.
+ */
+function resolveFieldTab(field, dataUnit, generalTabName) {
+  var _a, _b;
+  if (field.tab) {
+    return getTabName(field.tab, generalTabName);
+  }
+  const isPrimaryKey = !!((_b = (_a = dataUnit === null || dataUnit === void 0 ? void 0 : dataUnit.getField(field.name)) === null || _a === void 0 ? void 0 : _a.properties) === null || _b === void 0 ? void 0 : _b.isPrimaryKey);
+  return isPrimaryKey ? constants.TAB_NAMES.main : generalTabName;
+}
+function handleFieldsTabNames(allFields, dataUnit, generalTabName = constants.TAB_NAMES.general) {
+  return (allFields !== null && allFields !== void 0 ? allFields : []).map(field => (Object.assign(Object.assign({}, field), { tab: resolveFieldTab(field, dataUnit, generalTabName) })));
+}
+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: constants.TAB_NAMES.main, label: mainTabName, visible: true };
+  const hasTabMain = tabs.some((tab) => tab.name === constants.TAB_NAMES.main);
+  if (hasTabMain) {
+    tabs = tabs.map(tab => tab.name === constants.TAB_NAMES.main ? mainTab : tab);
+  }
+  else {
+    tabs.unshift(mainTab);
+  }
+  return tabs;
+}
+function getPossibleGuides(tabs) {
+  return [...tabs];
+}
+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 = constants.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(constants.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 === constants.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: constants.DEFAULT_TYPE.fixed,
+        value: fieldConfig.defaultValue,
+      };
+    }
+    else {
+      fieldToSave.defaultValue = fieldConfig.defaultValue;
+    }
+  }
+  return fieldToSave;
+}
+
+exports.ID_AVAILABLE_FIELDS = ID_AVAILABLE_FIELDS;
+exports.buildChildrenGuides = buildChildrenGuides;
+exports.buildCustomGuides = buildCustomGuides;
+exports.buildGuides = buildGuides;
+exports.buildGuidesMap = buildGuidesMap;
+exports.buildNewGuideName = buildNewGuideName;
+exports.getEnabledByProperty = getEnabledByProperty;
+exports.getFieldsStructure = getFieldsStructure;
+exports.getFieldsToSave = getFieldsToSave;
+exports.getIconName = getIconName;
+exports.getValidatedFieldValue = getValidatedFieldValue;
+exports.getValueByProperty = getValueByProperty;
+exports.updateTabInFieldsFromGroupList = updateTabInFieldsFromGroupList;

package/dist/cjs/{ISave-ebf6b4ed.js → ISave-55d9dcc3.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 const core = require('@sankhyalabs/core');
-const DataFetcher = require('./DataFetcher-991b0349.js');
+const DataFetcher = require('./DataFetcher-d13b4637.js');
 
 function buildGridMetadata(rawValue) {
   const fieldsMetadata = buildFieldsMetadata(rawValue.fieldsMetadata);

package/dist/cjs/ImageUtils-d6139911.js

@@ -0,0 +1,144 @@
+'use strict';
+
+const core = require('@sankhyalabs/core');
+
+async function base64ToBlob(base64) {
+  const response = await fetch(base64);
+  return await response.blob();
+}
+function buildFileKey(entityName, fieldName) {
+  if (entityName) {
+    return `${entityName}_${fieldName}`;
+  }
+  else {
+    return fieldName;
+  }
+}
+function hasSpecialCharacters(value) {
+  const specialChars = /[ !@#$%^&*()+\-=\[\]{};':"\\|,.<>\/?]/;
+  return specialChars.test(value);
+}
+/**
+ * Gera a URL base para upload de sessão
+ */
+function getSessionUploadBaseUrl(fileKey, context = 'mge') {
+  let url = `/${context}/sessionUpload.${context}?sessionkey=${fileKey}`;
+  // Verifica se precisa processar caracteres especiais
+  if (canProcessSpecialKeys(context) && hasSpecialCharacters(fileKey)) {
+    url += `&encodedKey=${btoa(encodeURI(fileKey))}`;
+  }
+  return url;
+}
+/**
+ * Verifica se pode processar chaves especiais
+ * Baseado no método canProcessSpecialKeys do sessionfileupload.service.js
+ */
+async function canProcessSpecialKeys(context) {
+  var _a;
+  const application = core.ApplicationContext.getContextValue("__SNK__APPLICATION__");
+  if (!application)
+    return false;
+  const resourceId = await ((_a = application.getResourceID) === null || _a === void 0 ? void 0 : _a.call(application)) || '';
+  const adPrefix = "br.com.sankhya.menu.adicional";
+  return context === 'mge' && resourceId.startsWith(adPrefix);
+}
+/**
+ * Constrói a URL de upload
+ * Baseado no método buildUploadURL do sessionfileupload.service.js
+ */
+function buildUploadURL(fileKey) {
+  let url = getSessionUploadBaseUrl(fileKey);
+  url += "&fitem=S&salvar=S&useCache=N";
+  return url;
+}
+/**
+ * Faz upload de arquivo para a sessão usando XMLHttpRequest
+ * Baseado no método uploadSessionFile do sessionfileupload.service.js
+ */
+async function sessionFileUpload(blob, entityName, fieldName, onProgress) {
+  const fileKey = buildFileKey(entityName, fieldName);
+  const uploadUrl = buildUploadURL(fileKey);
+  return new Promise((resolve, reject) => {
+    const formData = new FormData();
+    formData.append('arquivo', blob);
+    const http = new XMLHttpRequest();
+    http.addEventListener("load", () => {
+      if (http.status >= 200 && http.status < 300) {
+        resolve(`/mge/UPLOADING_${fileKey}.dbimage`);
+      }
+      else {
+        reject(new Error(`Upload failed: ${http.statusText}`));
+      }
+    });
+    http.addEventListener("error", () => {
+      reject(new Error('Upload error'));
+    });
+    if (onProgress) {
+      http.upload.addEventListener("progress", onProgress);
+    }
+    http.open("POST", uploadUrl);
+    http.send(formData);
+  });
+}
+function getUrlBase() {
+  return window.location.origin;
+}
+function getBaseUrl(pk, entityName, fieldName) {
+  if (!pk)
+    return undefined;
+  const baseUrl = getUrlBase();
+  let url = `${baseUrl}/mge/${entityName}@${fieldName}`;
+  for (const pkField in pk) {
+    url += `@${pkField}=${pk[pkField]}`;
+  }
+  url += '.dbimage';
+  return url;
+}
+function getPKs(dataUnit) {
+  if (!dataUnit) {
+    return undefined;
+  }
+  const pk = {};
+  const fields = dataUnit.metadata.fields;
+  const selectedRecord = dataUnit.getSelectedRecord();
+  fields.forEach((field) => {
+    if (field.properties['isPrimaryKey'] && selectedRecord) {
+      pk[field.name] = selectedRecord[field.name];
+    }
+  });
+  return pk;
+}
+async function imageBlobToBase64(blob) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onloadend = () => {
+      resolve(reader.result);
+    };
+    reader.onerror = reject;
+    reader.readAsDataURL(blob);
+  });
+}
+async function downloadImage(pks, fieldName, entityName, signal) {
+  const uploadUrl = getBaseUrl(pks, entityName, fieldName);
+  if (!uploadUrl) {
+    return;
+  }
+  try {
+    const response = await fetch(uploadUrl, { signal });
+    if (response.ok) {
+      const blob = await response.blob();
+      return await imageBlobToBase64(blob);
+    }
+  }
+  catch (error) {
+    if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+      return;
+    console.error('Error downloading image:', error);
+  }
+}
+
+exports.base64ToBlob = base64ToBlob;
+exports.buildFileKey = buildFileKey;
+exports.downloadImage = downloadImage;
+exports.getPKs = getPKs;
+exports.sessionFileUpload = sessionFileUpload;

package/dist/cjs/{PersonalizedFilterUtils-7259cf65.js → PersonalizedFilterUtils-263e4d24.js}

@@ -2,7 +2,54 @@
 
 const core = require('@sankhyalabs/core');
 const filterItemType_enum = require('./filter-item-type.enum-a7ffdaa6.js');
-const index = require('./index-62760a9c.js');
+
+exports.FilterGroupCondition = void 0;
+(function (FilterGroupCondition) {
+  FilterGroupCondition["AND"] = "AND";
+  FilterGroupCondition["OR"] = "OR";
+})(exports.FilterGroupCondition || (exports.FilterGroupCondition = {}));
+
+exports.FilterConfigType = void 0;
+(function (FilterConfigType) {
+  FilterConfigType["SYSTEM_CONFIG"] = "S";
+  FilterConfigType["USER_CONFIG"] = "E";
+})(exports.FilterConfigType || (exports.FilterConfigType = {}));
+exports.FilterUserConfigTypes = void 0;
+(function (FilterUserConfigTypes) {
+  FilterUserConfigTypes["DATE"] = "D";
+  FilterUserConfigTypes["HORA"] = "H";
+  FilterUserConfigTypes["TEXT"] = "S";
+  FilterUserConfigTypes["INTEGER"] = "I";
+  FilterUserConfigTypes["DECIMAL"] = "F";
+  FilterUserConfigTypes["NUMBER"] = "NUMBER";
+})(exports.FilterUserConfigTypes || (exports.FilterUserConfigTypes = {}));
+exports.FilterOperand = void 0;
+(function (FilterOperand) {
+  FilterOperand["AND"] = "AND";
+  FilterOperand["OR"] = "OR";
+  FilterOperand["IN"] = "IN";
+  FilterOperand["DIFFERENT"] = "<>";
+  FilterOperand["LIKE"] = "LIKE";
+  FilterOperand["START_WITH"] = "LIKE_START";
+  FilterOperand["FINISHED_WITH"] = "LIKE_END";
+  FilterOperand["NULL"] = "NULL";
+  FilterOperand["NOT_NULL"] = "NOT NULL";
+  FilterOperand["EQUAL"] = "=";
+  FilterOperand["LARGER"] = ">";
+  FilterOperand["LARGER_EQUAL"] = ">=";
+  FilterOperand["SMALLER"] = "<";
+  FilterOperand["SMALLER_EQUAL"] = "<=";
+})(exports.FilterOperand || (exports.FilterOperand = {}));
+exports.FilterEntities = void 0;
+(function (FilterEntities) {
+  FilterEntities["FIELD"] = "Campo";
+  FilterEntities["INSTANCE"] = "Instancia";
+})(exports.FilterEntities || (exports.FilterEntities = {}));
+exports.DefaultFilter = void 0;
+(function (DefaultFilter) {
+  DefaultFilter["name"] = "Filtro padr\u00E3o";
+  DefaultFilter["id"] = "DEFAULT_FILTER";
+})(exports.DefaultFilter || (exports.DefaultFilter = {}));
 
 class PersonalizedFilterUtils {
   /**
@@ -23,11 +70,11 @@ class PersonalizedFilterUtils {
     }
     switch (expressionItem.operand) {
       case "IN":
-        expression += ` ${index.FilterOperand[expressionItem.operand]} (${value})`;
+        expression += ` ${exports.FilterOperand[expressionItem.operand]} (${value})`;
         break;
       case "NULL":
       case "NOT_NULL":
-        expression += ` IS ${index.FilterOperand[expressionItem.operand]}`;
+        expression += ` IS ${exports.FilterOperand[expressionItem.operand]}`;
         break;
       case "LIKE":
         expression += ` LIKE '%${value}%'`;
@@ -40,7 +87,7 @@ class PersonalizedFilterUtils {
         break;
       default:
         if (expressionItem.operand) {
-          expression += ` ${index.FilterOperand[expressionItem.operand]}`;
+          expression += ` ${exports.FilterOperand[expressionItem.operand]}`;
         }
         if (['string', 'number'].includes(typeof value)) {
           value = isNaN(value) ? `${commas}${value}${commas}` : value;
@@ -61,7 +108,7 @@ class PersonalizedFilterUtils {
     if (expressionItem.paramVariable) {
       return this.proccessVarialbeParameter(expressionItem);
     }
-    if (expressionItem.operand !== index.FilterOperand.NULL && expressionItem.operand !== "NOT_NULL") {
+    if (expressionItem.operand !== exports.FilterOperand.NULL && expressionItem.operand !== "NOT_NULL") {
       let value = expressionItem.value;
       const type = expressionItem.type;
       /*
@@ -78,6 +125,9 @@ class PersonalizedFilterUtils {
       }
       else if (core.DataType.DATE == type) {
         value = this.convertDataValue(value);
+        if (value === undefined) {
+          return;
+        }
       }
       else if (core.DataType.BOOLEAN == type) {
         value = value ? "S" : "N";
@@ -103,9 +153,19 @@ class PersonalizedFilterUtils {
     return `?:{entidade=${expressionItem.entityName || ""};campo=${expressionItem.fieldName || ""}}`;
   }
   static convertDataValue(value) {
+    if (value == null || value === '' || value === undefined) {
+      return;
+    }
     if (typeof value == 'string') {
+      const trimmedValue = value.trim();
+      if (trimmedValue === '' || trimmedValue === '/' || trimmedValue === '  /  /') {
+        return;
+      }
       value = new Date(value);
     }
+    if (value instanceof Date && isNaN(value.getTime())) {
+      return;
+    }
     return core.DateUtils.formatDate(value);
   }
   /*

package/dist/cjs/{SnkFormConfigManager-cdbb29d4.js → SnkFormConfigManager-5cb9a39c.js}

@@ -1,8 +1,8 @@
 'use strict';
 
 const core = require('@sankhyalabs/core');
-const ConfigStorage = require('./ConfigStorage-72f34bd4.js');
-const formConfigFetcher = require('./form-config-fetcher-c7af90d8.js');
+const ConfigStorage = require('./ConfigStorage-156bfcac.js');
+const formConfigFetcher = require('./form-config-fetcher-bbebdcb8.js');
 const constants = require('./constants-6d82e405.js');
 
 class SnkFormConfigManager {
@@ -181,7 +181,7 @@ class SnkFormConfigManager {
     return Array.isArray(object) ? object : [object];
   }
   buildFormMetadataUITabs(config, forceEmptyConfig = false) {
-    var _a;
+    var _a, _b, _c;
     const hasConfig = this.hasConfig(config);
     if (!forceEmptyConfig && (!this._dataUnit || hasConfig)) {
       return config;
@@ -190,10 +190,10 @@ class SnkFormConfigManager {
     config.tabs = this.parseObjectList(config.tabs);
     config.emptyConfig = false;
     config.defaultConfiguration = true;
-    const fields = this._dataUnit.metadata.fields;
+    const fields = (_b = (_a = this._dataUnit.metadata) === null || _a === void 0 ? void 0 : _a.fields) !== null && _b !== void 0 ? _b : [];
     for (const currentField of fields) {
       const field = config.fields.find(field => field.name === currentField.name);
-      const uiTabName = (_a = currentField.properties) === null || _a === void 0 ? void 0 : _a.UITabName;
+      const uiTabName = (_c = currentField.properties) === null || _c === void 0 ? void 0 : _c.UITabName;
       if (!uiTabName || uiTabName === constants.TAB_NAMES.main) {
         continue;
       }