@sankhyalabs/sankhyablocks 0.0.0-bugfix-dev-KB-131882.2 → 0.0.0-bugfix-dev-KB-174860.0

package/dist/esm/FormConfigHelper-efc29480.js

@@ -0,0 +1,328 @@
+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, 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 = 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 === 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 ? TAB_NAMES.main : generalTabName;
+}
+function handleFieldsTabNames(allFields, dataUnit, generalTabName = 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: 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) {
+  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 = 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, buildChildrenGuides as a, buildGuides as b, buildCustomGuides as c, buildGuidesMap as d, buildNewGuideName as e, getFieldsStructure as f, getFieldsToSave as g, getValidatedFieldValue as h, getEnabledByProperty as i, getValueByProperty as j, getIconName as k, updateTabInFieldsFromGroupList as u };

package/dist/esm/{ISave-498c4831.js → ISave-f5704813.js}

@@ -1,5 +1,5 @@
 import { UserInterface, DataType, ApplicationContext, ErrorException } from '@sankhyalabs/core';
-import { d as dist, D as DataFetcher } from './DataFetcher-1dd7e8c0.js';
+import { d as dist, D as DataFetcher } from './DataFetcher-70de9419.js';
 
 function buildGridMetadata(rawValue) {
   const fieldsMetadata = buildFieldsMetadata(rawValue.fieldsMetadata);

package/dist/esm/{ImageUtils-8fc8d905.js → ImageUtils-efbea0e4.js}

@@ -100,7 +100,7 @@ function getPKs(dataUnit) {
   const fields = dataUnit.metadata.fields;
   const selectedRecord = dataUnit.getSelectedRecord();
   fields.forEach((field) => {
-    if (field.properties['isPrimaryKey']) {
+    if (field.properties['isPrimaryKey'] && selectedRecord) {
       pk[field.name] = selectedRecord[field.name];
     }
   });
@@ -116,19 +116,21 @@ async function imageBlobToBase64(blob) {
     reader.readAsDataURL(blob);
   });
 }
-async function downloadImage(pks, fieldName, entityName) {
+async function downloadImage(pks, fieldName, entityName, signal) {
   const uploadUrl = getBaseUrl(pks, entityName, fieldName);
   if (!uploadUrl) {
     return;
   }
   try {
-    const response = await fetch(uploadUrl);
+    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);
   }
 }

package/dist/esm/{PersonalizedFilterUtils-d2439a9a.js → PersonalizedFilterUtils-45b5803c.js}

@@ -1,6 +1,53 @@
 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-8acbae97.js';
+
+var FilterGroupCondition;
+(function (FilterGroupCondition) {
+  FilterGroupCondition["AND"] = "AND";
+  FilterGroupCondition["OR"] = "OR";
+})(FilterGroupCondition || (FilterGroupCondition = {}));
+
+var FilterConfigType;
+(function (FilterConfigType) {
+  FilterConfigType["SYSTEM_CONFIG"] = "S";
+  FilterConfigType["USER_CONFIG"] = "E";
+})(FilterConfigType || (FilterConfigType = {}));
+var FilterUserConfigTypes;
+(function (FilterUserConfigTypes) {
+  FilterUserConfigTypes["DATE"] = "D";
+  FilterUserConfigTypes["HORA"] = "H";
+  FilterUserConfigTypes["TEXT"] = "S";
+  FilterUserConfigTypes["INTEGER"] = "I";
+  FilterUserConfigTypes["DECIMAL"] = "F";
+  FilterUserConfigTypes["NUMBER"] = "NUMBER";
+})(FilterUserConfigTypes || (FilterUserConfigTypes = {}));
+var FilterOperand;
+(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"] = "<=";
+})(FilterOperand || (FilterOperand = {}));
+var FilterEntities;
+(function (FilterEntities) {
+  FilterEntities["FIELD"] = "Campo";
+  FilterEntities["INSTANCE"] = "Instancia";
+})(FilterEntities || (FilterEntities = {}));
+var DefaultFilter;
+(function (DefaultFilter) {
+  DefaultFilter["name"] = "Filtro padr\u00E3o";
+  DefaultFilter["id"] = "DEFAULT_FILTER";
+})(DefaultFilter || (DefaultFilter = {}));
 
 class PersonalizedFilterUtils {
   /**
@@ -235,4 +282,4 @@ class PersonalizedFilterUtils {
   }
 }
 
-export { PersonalizedFilterUtils as P };
+export { DefaultFilter as D, FilterOperand as F, PersonalizedFilterUtils as P, FilterGroupCondition as a, FilterConfigType as b, FilterEntities as c, FilterUserConfigTypes as d };

package/dist/esm/{SnkFormConfigManager-86befa68.js → SnkFormConfigManager-e7f05f79.js}

@@ -1,6 +1,6 @@
 import { ObjectUtils, StringUtils } from '@sankhyalabs/core';
-import { C as ConfigStorage } from './ConfigStorage-d15d2014.js';
-import { F as FormConfigFetcher } from './form-config-fetcher-fcc7b62f.js';
+import { C as ConfigStorage } from './ConfigStorage-0d1c0695.js';
+import { F as FormConfigFetcher } from './form-config-fetcher-98c42169.js';
 import { a as TAB_NAMES } from './constants-7b422de0.js';
 
 class SnkFormConfigManager {