cloud-web-corejs 1.0.54-dev.688 → 1.0.54-dev.689

package/src/components/xform/utils/dynamicSchemaUtil.js

@@ -0,0 +1,312 @@
+/**
+ * 后台动态定义（表头后台字段 / 数据表格动态列）共用协议。
+ *
+ * 单条定义顶层字段：
+ * - 通用：keyName、type、label、optionItems、required 等字段级属性、options
+ * - 表头：colspan
+ * - 数据表格：width、formatS（展示列）、children（多级表头）、dropdownItems（dropdown 操作列）
+ *
+ * 请求体：{ formData, ...extra }
+ * 响应体：objx 数组，或 { fields: [] } / { columns: [] }
+ */
+
+/** 顶层字段白名单 */
+export const DYNAMIC_SCHEMA_CORE_KEYS = [
+  "keyName",
+  "type",
+  "label",
+  "optionItems",
+  "options",
+];
+
+/** 字段级属性：写顶层，不写 options（与表头 dynamicFieldMixin 一致） */
+export const DYNAMIC_SCHEMA_WIDGET_FLAG_KEYS = [
+  "required",
+  "readonly",
+  "disabled",
+  "hidden",
+  "defaultValue",
+  "placeholder",
+];
+
+export const DYNAMIC_SCHEMA_TABLE_HEADER_KEYS = ["colspan"];
+
+export const DYNAMIC_SCHEMA_COLUMN_EXTRA_KEYS = [
+  "width",
+  "align",
+  "sortable",
+  "filterable",
+  "show",
+  "fixed",
+  "formatS",
+  "render",
+  "utcTransformEnabled",
+  "children",
+  "dropdownItems",
+];
+
+export const DYNAMIC_SCHEMA_OPTION_KEYS = {
+  scriptCode: ["dynamicSchemaScriptCode", "dynamicColumnScriptCode"],
+  scriptParam: ["dynamicSchemaScriptParam", "dynamicColumnScriptParam"],
+  convert: ["dynamicSchemaConvert"],
+  mode: ["dynamicSchemaMode", "dynamicColumnMode"],
+};
+
+export const widgetTypeToEditFormatMap = {
+  input: "editInput",
+  number: "editNumber",
+  date: "editDate",
+  select: "editSelect",
+  vabsearch: "editSearch",
+  baseAttachment: "editAttachment",
+  status: "editStatus",
+  text: "text",
+  checkbox: "checkbox",
+  radio: "radio",
+  textarea: "textarea",
+  "script-input": "editScriptInput",
+  "a-text": "aText",
+  "a-link": "aLink",
+  button: "button",
+  dropdown: "dropdown",
+};
+
+const ACTION_COLUMN_FORMATS = new Set(["aLink", "button", "dropdown"]);
+
+export function buildDropdownWidgetFromDef(def, index = 0) {
+  const options = def?.options;
+  const dropdownItems = def?.dropdownItems;
+  if (!Array.isArray(dropdownItems) || !dropdownItems.length) return null;
+
+  const ts = `${Date.now()}_${index}`;
+  const widgetList = dropdownItems.map((entry, i) => ({
+    type: "dropdown-item",
+    id: `dropdownitem_${ts}_${i}`,
+    options: {
+      label: entry.label || "",
+      onClick: entry.onClick || "",
+      disabled: !!entry.disabled,
+      hidden: !!entry.hidden,
+    },
+  }));
+
+  return {
+    type: "dropdown",
+    id: `dropdown_${ts}`,
+    options: {
+      label: def.label || "操作",
+      dropdownType: options?.dropdownType || "link",
+      dropdownTrigger: options?.dropdownTrigger || "hover",
+      dropdownFlag: 1,
+    },
+    widgetList,
+  };
+}
+
+function isActionColumn(item, formatS) {
+  return isActionColumnFormat(formatS, item?.type);
+}
+
+export function isActionColumnFormat(formatS, type) {
+  if (ACTION_COLUMN_FORMATS.has(formatS)) return true;
+  return ["a-link", "button", "dropdown"].includes(type);
+}
+
+function isActionOrGroupColumn(item, formatS) {
+  if (Array.isArray(item.children) && item.children.length) return true;
+  return isActionColumn(item, formatS);
+}
+
+function buildWidgetOptions(item, formatS, label) {
+  let widgetOptions =
+    item.options && typeof item.options === "object"
+      ? { ...item.options }
+      : null;
+
+  if (widgetOptions) {
+    delete widgetOptions.dropdownItems;
+  }
+
+  DYNAMIC_SCHEMA_WIDGET_FLAG_KEYS.forEach((key) => {
+    if (item[key] !== undefined) {
+      widgetOptions = widgetOptions || {};
+      widgetOptions[key] = item[key];
+    }
+  });
+
+  if (label) {
+    widgetOptions = widgetOptions || {};
+    if (!widgetOptions.label) {
+      widgetOptions.label = label;
+    }
+  }
+
+  if (!isActionColumn(item, formatS)) {
+    widgetOptions = widgetOptions || {};
+    widgetOptions.labelHidden = true;
+  }
+
+  return widgetOptions;
+}
+
+export function getDynamicSchemaOption(options, key) {
+  if (!options) return null;
+  const keys = DYNAMIC_SCHEMA_OPTION_KEYS[key] || [];
+  for (let i = 0; i < keys.length; i++) {
+    const val = options[keys[i]];
+    if (val !== undefined && val !== null && val !== "") {
+      return val;
+    }
+  }
+  return null;
+}
+
+export function resolveDynamicSchemaExtra(paramScript, handleCustomEvent) {
+  if (!paramScript || !handleCustomEvent) return {};
+  const result = handleCustomEvent(paramScript);
+  return result && typeof result === "object" && !Array.isArray(result)
+    ? result
+    : {};
+}
+
+export function buildDynamicSchemaRequestData(
+  formModel,
+  paramScript,
+  handleCustomEvent,
+  wrapContext
+) {
+  const extra = resolveDynamicSchemaExtra(paramScript, handleCustomEvent);
+  const payload = {
+    formData: formModel || {},
+    ...extra,
+  };
+  if (!wrapContext) {
+    return payload;
+  }
+  const { formCode, formVersion, taBm, dataId } = wrapContext;
+  return {
+    formCode,
+    formVersion,
+    taBm,
+    formData: payload.formData,
+    dataId,
+    data: {
+      dataId,
+      ...payload,
+    },
+  };
+}
+
+/** 从 objx 或转换脚本结果中提取定义数组 */
+export function extractDynamicSchemaItems(source) {
+  if (!source) return [];
+  if (Array.isArray(source)) return source;
+  if (typeof source !== "object") return [];
+  if (Array.isArray(source.fields)) return source.fields;
+  if (Array.isArray(source.columns)) return source.columns;
+  return [];
+}
+
+export function resolveDynamicSchemaResponse(res, convertScript, handleCustomEvent) {
+  if (convertScript && handleCustomEvent) {
+    const result = handleCustomEvent(convertScript, ["res"], [res]);
+    return extractDynamicSchemaItems(result);
+  }
+  return extractDynamicSchemaItems(res && res.objx);
+}
+
+export function normalizeDynamicFieldKey(item) {
+  if (!item || typeof item !== "object") return undefined;
+  return item.keyName;
+}
+
+export function normalizeDynamicColumnItem(item, index) {
+  if (!item || typeof item !== "object") {
+    return null;
+  }
+
+  const keyName = normalizeDynamicFieldKey(item);
+  const label = item.label;
+  let formatS = item.formatS || null;
+  if (!formatS && item.type) {
+    formatS = widgetTypeToEditFormatMap[item.type] || item.type;
+  }
+
+  let editFormatS = null;
+  if (formatS && String(formatS).startsWith("edit")) {
+    editFormatS = formatS;
+  }
+
+  const widgetOptions = buildWidgetOptions(item, formatS, label);
+
+  let widget = null;
+  let widgetList = null;
+  if (
+    (item.type === "dropdown" || formatS === "dropdown") &&
+    Array.isArray(item.dropdownItems) &&
+    item.dropdownItems.length
+  ) {
+    widget = buildDropdownWidgetFromDef(item, index);
+    if (widget && label) {
+      widget.options.label = label;
+    }
+    if (widget?.widgetList?.length) {
+      widgetList = widget.widgetList;
+    }
+  }
+
+  if (!keyName && !isActionOrGroupColumn(item, formatS)) {
+    return null;
+  }
+
+  const isAction = isActionColumn(item, formatS);
+
+  const widgetFlags = {};
+  DYNAMIC_SCHEMA_WIDGET_FLAG_KEYS.forEach((key) => {
+    if (item[key] !== undefined) {
+      widgetFlags[key] = item[key];
+    } else if (widgetOptions?.[key] !== undefined) {
+      widgetFlags[key] = widgetOptions[key];
+    }
+  });
+
+  const children = Array.isArray(item.children)
+    ? item.children
+        .map((child, childIndex) =>
+          normalizeDynamicColumnItem(child, index * 1000 + childIndex)
+        )
+        .filter(Boolean)
+    : item.children;
+
+  return {
+    columnId: item.columnId || `${Date.now()}_${index}`,
+    type: item.type,
+    prop: keyName || undefined,
+    label,
+    width: item.width ?? 150,
+    show: item.show !== false,
+    sortable: isAction ? item.sortable === true : item.sortable !== false,
+    filterable: isAction ? item.filterable === true : item.filterable !== false,
+    ...(item.align ? { align: item.align } : {}),
+    fixed: item.fixed,
+    formatS,
+    editFormatS: editFormatS || undefined,
+    optionItems: item.optionItems,
+    widget,
+    widgetList,
+    widgetOptions,
+    children: children,
+    render: item.render,
+    utcTransformEnabled: item.utcTransformEnabled,
+    ...widgetFlags,
+  };
+}
+
+export function normalizeDynamicColumns(columns) {
+  if (!Array.isArray(columns)) {
+    return [];
+  }
+  return columns
+    .map((item, index) => normalizeDynamicColumnItem(item, index))
+    .filter(Boolean);
+}

package/src/components/xform/utils/tableCellValidateUtil.js

@@ -0,0 +1,148 @@
+import {
+  isEmptyStr,
+  isEmptyArrayFieldValue,
+  isArrayValueWidgetType,
+  isVabsearchWidgetType,
+  isVabsearchMultiWidget,
+} from "./util";
+import { resolveColumnRequiredFlag } from "./tableColumnHelper";
+
+/** 数据表格行内字段候选 key（column.prop 为权威存储字段） */
+export function getCellFieldKeys(fieldWidget, columnConfig) {
+  const keys = [];
+  const addKey = (key) => {
+    if (key && !keys.includes(key)) {
+      keys.push(key);
+    }
+  };
+
+  addKey(columnConfig?.prop);
+
+  if (!fieldWidget) {
+    return keys;
+  }
+
+  const options = fieldWidget.options || {};
+  if (
+    isVabsearchWidgetType(fieldWidget.type) &&
+    !isVabsearchMultiWidget(fieldWidget)
+  ) {
+    addKey(options.vabSearchName);
+    addKey(getWidgetFieldKey(fieldWidget));
+  } else {
+    addKey(getWidgetFieldKey(fieldWidget));
+  }
+
+  return keys;
+}
+
+export function getCellFieldKey(fieldWidget, columnConfig) {
+  const keys = getCellFieldKeys(fieldWidget, columnConfig);
+  return keys.length ? keys[0] : null;
+}
+
+export function getWidgetFieldKey(widget) {
+  if (!widget?.options) {
+    return null;
+  }
+  const o = widget.options.name;
+  return (widget.options.keyNameEnabled && widget.options.keyName) || o;
+}
+
+export function isCellFieldRequired(columnConfig, fieldWidget) {
+  if (!fieldWidget || fieldWidget.options?.hidden) {
+    return false;
+  }
+  if (fieldWidget.options?.required) {
+    return true;
+  }
+  return resolveColumnRequiredFlag(columnConfig);
+}
+
+export function shouldSkipCellValidation(fieldWidget) {
+  if (!fieldWidget) {
+    return true;
+  }
+  if (fieldWidget.options?.hidden) {
+    return true;
+  }
+  if (fieldWidget.options?.disabled) {
+    return true;
+  }
+  return false;
+}
+
+export function isEmptyCellValue(fieldWidget, value) {
+  if (!fieldWidget) {
+    return false;
+  }
+  const type = fieldWidget.type;
+  const options = fieldWidget.options || {};
+
+  if (type === "number") {
+    return value === null || value === undefined || value === "";
+  }
+
+  if (isArrayValueWidgetType(type, options)) {
+    return isEmptyArrayFieldValue(value, type, options);
+  }
+
+  if (type === "select" || type === "radio" || type === "status") {
+    if (value === null || value === undefined || value === "") {
+      return true;
+    }
+    if (typeof value === "string" && !/[^\s]/.test(value)) {
+      return true;
+    }
+    return false;
+  }
+
+  return isEmptyStr(value);
+}
+
+/** 从行数据中读取单元格值（兼容 column.prop 与 widget 字段名不一致） */
+export function getCellValueFromRow(row, fieldWidget, columnConfig) {
+  if (!row) {
+    return undefined;
+  }
+  const keys = getCellFieldKeys(fieldWidget, columnConfig);
+  if (!keys.length) {
+    return undefined;
+  }
+  let fallbackValue;
+  for (const key of keys) {
+    const value = row[key];
+    if (fallbackValue === undefined) {
+      fallbackValue = value;
+    }
+    if (!isEmptyCellValue(fieldWidget, value)) {
+      return value;
+    }
+  }
+  return fallbackValue;
+}
+
+export function isEmptyCellValueInRow(row, fieldWidget, columnConfig) {
+  return isEmptyCellValue(
+    fieldWidget,
+    getCellValueFromRow(row, fieldWidget, columnConfig)
+  );
+}
+
+export function buildCellRequiredHint(fieldWidget, columnConfig, t1Fn) {
+  const options = fieldWidget?.options || {};
+  if (options.requiredHint) {
+    return t1Fn(options.requiredHint);
+  }
+  const label = t1Fn(
+    options.label || columnConfig?.label || columnConfig?.prop || ""
+  );
+  return t1Fn("[{label}]不能为空", { label });
+}
+
+export function buildTableCellFormProp(tableFieldKeyName, rowIndex, fieldKey) {
+  if (!tableFieldKeyName || !fieldKey || rowIndex < 0) {
+    return null;
+  }
+  return `${tableFieldKeyName}.${rowIndex}.${fieldKey}`;
+}

package/src/components/xform/utils/tableColumnHelper.js

@@ -43,6 +43,26 @@ function enrichColumnList(columns, configMap) {
 /**
  * Apply data-table column header icon config to vxe-table column definition.
  */
+export function resolveColumnRequiredFlag(columnConfig) {
+  if (!columnConfig) {
+    return false;
+  }
+  if (columnConfig.required) {
+    return true;
+  }
+  if (columnConfig.editWidget?.options?.required) {
+    return true;
+  }
+  if (columnConfig.widget?.options?.required) {
+    return true;
+  }
+  const widgetOptions =
+    columnConfig.widgetOptions ?? columnConfig.columnOption;
+  const editWidgetOptions =
+    columnConfig.editWidgetOptions ?? columnConfig.editColumnOption;
+  return !!(widgetOptions?.required || editWidgetOptions?.required);
+}
+
 export function applyColumnLabelIcon(col, columnConfig) {
   if (!col || !columnConfig) {
     return col;
@@ -51,7 +71,7 @@ export function applyColumnLabelIcon(col, columnConfig) {
   const iconClass = columnConfig.labelIconClass;
   const position = columnConfig.labelIconPosition || "rear";
   const tooltip = columnConfig.labelTooltip;
-  const required = !!columnConfig.required;
+  const required = resolveColumnRequiredFlag(columnConfig);
   const title = col.title;
 
   if (!iconClass && !required) {

package/src/components/xform/utils/util.js

@@ -19,6 +19,92 @@ export function isNotNull(value) {
   return value !== null && value !== undefined;
 }
 
+const ATTACHMENT_WIDGET_TYPES = ["vabUpload", "baseAttachment", "vabUpload2"];
+
+const PROJECT_TAG_WIDGET_TYPES = [
+  "project-tag",
+  "user-project-tag",
+  "saleOrg-project-tag",
+];
+
+const VABSEARCH_WIDGET_TYPES = ["vabsearch", "singerSearch", "multiSearch"];
+
+export function isAttachmentWidgetType(type) {
+  return ATTACHMENT_WIDGET_TYPES.includes(type);
+}
+
+export function isVabsearchWidgetType(type) {
+  return VABSEARCH_WIDGET_TYPES.includes(type);
+}
+
+export function isVabsearchMultiWidget(widget) {
+  if (!widget) {
+    return false;
+  }
+  const type = widget.type;
+  if (type === "multiSearch") {
+    return true;
+  }
+  if (!isVabsearchWidgetType(type)) {
+    return false;
+  }
+  const options = widget.options || {};
+  return !!(
+    options.multipleChoices || options.searchDialogConfig?.multipleChoices
+  );
+}
+
+/** 绑定值为数组的字段组件（含附件） */
+export function isArrayValueWidgetType(type, options = {}) {
+  if (isAttachmentWidgetType(type)) {
+    return true;
+  }
+  if (type === "checkbox") {
+    return true;
+  }
+  if (type === "select" && options.multiple) {
+    return true;
+  }
+  if (type === "time-range" || type === "date-range") {
+    return true;
+  }
+  if (type === "date" && options.type === "dates") {
+    return true;
+  }
+  if (PROJECT_TAG_WIDGET_TYPES.includes(type)) {
+    return true;
+  }
+  if (type === "multiSearch") {
+    return true;
+  }
+  if (
+    type === "vabsearch" &&
+    (options.multipleChoices || options.searchDialogConfig?.multipleChoices)
+  ) {
+    return true;
+  }
+  return false;
+}
+
+/** 数组类字段值是否为空（用于必填校验） */
+export function isEmptyArrayFieldValue(value, type, options = {}) {
+  if (value === null || value === undefined) {
+    return true;
+  }
+  if (type === "time-range" || type === "date-range") {
+    if (!Array.isArray(value) || value.length === 0) {
+      return true;
+    }
+    return value.every(
+      (item) => item === null || item === undefined || item === ""
+    );
+  }
+  if (!Array.isArray(value)) {
+    return true;
+  }
+  return value.length === 0;
+}
+
 export function isEmptyStr(str) {
   //return (str === undefined) || (!str) || (!/[^\s]/.test(str));
   return (
@@ -700,6 +786,7 @@ export const columnFormatMap = {
   radio: "radio",
   dropdown: "dropdown",
   textarea: "textarea",
+  editScriptInput: "script-input",
 };
 
 /** 列 widget 扩展选项：动态列 widgetOptions；设计器静态列 columnOption */
@@ -713,6 +800,45 @@ export function getColumnWidgetOptions(row, isEdit = false) {
   return row.widgetOptions ?? row.columnOption;
 }
 
+/** 将列级 label / keyName / required 同步到列内 field widget（动态列 label 在列顶层） */
+export function applyColumnMetaToFieldWidget(fieldWidget, row, isEdit = false) {
+  if (!fieldWidget || !row) {
+    return fieldWidget;
+  }
+  const widgetOptions = getColumnWidgetOptions(row, isEdit);
+  if (fieldWidget.options.hasOwnProperty("required")) {
+    fieldWidget.options.required = !!(row.required || widgetOptions?.required);
+  }
+  if (!fieldWidget.options.label && row.label) {
+    fieldWidget.options.label = row.label;
+  }
+  if (row.prop) {
+    if (fieldWidget.options.hasOwnProperty("keyName")) {
+      fieldWidget.options.keyName = row.prop;
+      fieldWidget.options.keyNameEnabled = true;
+    } else if (!fieldWidget.options.name) {
+      fieldWidget.options.name = row.prop;
+    }
+  }
+  if (fieldWidget.type !== "button" && fieldWidget.type !== "a-link") {
+    fieldWidget.options.labelHidden = true;
+  }
+  return fieldWidget;
+}
+
+/** 同步列 widget / editWidget 的列级元数据（含 labelHidden） */
+export function applyColumnMetaToColumnRow(row) {
+  if (!row) {
+    return;
+  }
+  if (row.widget) {
+    applyColumnMetaToFieldWidget(row.widget, row, false);
+  }
+  if (row.editWidget) {
+    applyColumnMetaToFieldWidget(row.editWidget, row, true);
+  }
+}
+
 export function getFieldWidgetById(widgetList, fieldId, staticWidgetsIncluded) {
   if (!widgetList) {
     return null;