@lingxiteam/ebe-utils 0.5.11 → 0.6.1

package/lib/pcpublic/src/components/pcfactory/src/Table/hooks/ED/useSelection.ts

@@ -0,0 +1,27 @@
+const useSelection = (props: any) => {
+  const {
+    selectType,
+    rowSelection,
+  } = props;
+
+  const handleRowSelection: any = () => {
+    if (rowSelection) {
+      if (['radio', 'checkbox'].includes(rowSelection as any as string)) {
+        return {
+          type: rowSelection,
+        };
+      }
+
+      if (typeof rowSelection === 'boolean') {
+        return {
+          type: selectType,
+        };
+      }
+    }
+    return undefined;
+  };
+
+  return handleRowSelection();
+};
+
+export default useSelection;

package/lib/pcpublic/src/components/pcfactory/src/Table/hooks/useCMDActions.ts

@@ -1,7 +1,8 @@
-import { useState, useImperativeHandle } from 'react';
+import { useState, useImperativeHandle, useRef } from 'react';
 import { createEmptyRow, EMPTY_ROW_TEMP_KEY_ATTR, deleteTempRowProperties } from '../utils';
 import { EngineApisType } from '@lingxiteam/types';
 import merge from 'lodash/merge';
+import { getRegExp } from '../../utils/common';
 
 interface UseCommonCMDAction {
   ref: any,
@@ -68,6 +69,8 @@ const useCMDAction = (props: UseCMDActionPropsType) => {
     setTableRowKey, // 主键生成方法
   } = props;
 
+  const tableRef = useRef<any>(null);
+
   // 表格编辑格式为下拉框时，绑定的服务对应的数据
   const [colServiceDataForEdit, setColServiceDataForEdit] = useState({});
 
@@ -96,6 +99,151 @@ const useCMDAction = (props: UseCMDActionPropsType) => {
       });
   };
 
+  // 校验其他页面数据，若不在当前页则跳转到对应页面，并触发表单的校验
+  const validateAndScrollToErrorPage = async(compId: string, dataIndex: number, callback: any = () => {}) => {
+    const { current, pageSize } = pagination || {};
+    const dataPageNum = Math.ceil(dataIndex / pageSize);
+    if (dataPageNum !== current) {
+      // 校验错误的数据不在同一页，跳转到对应页面并且触发表单的校验
+      setCurrent(dataPageNum);
+      setTimeout(() => {
+        validateFormAndScroll(compId, (err: any) => {
+          callback(err, innerDataSource);
+        });
+      }, 0);
+    } else {
+      validateFormAndScroll(compId, (err: any) => {
+        callback(err, innerDataSource);
+      });
+    }
+  };
+
+  // 收集校验规则
+  const collectValidationRules = () => {
+    const columns = tableRef.current?.getFinalColumns();
+    const validationRules: Record<string, any[]> = {};
+    
+    if (columns && Array.isArray(columns)) {
+      columns.forEach((column: any) => {
+        const { dataIndex, editoption } = column;
+        if (dataIndex && editoption?.rules && Array.isArray(editoption.rules)) {
+          const rules = editoption.rules.map((rule: any) => {
+            // 处理pattern字段，将字符串转换为正则表达式
+            if (rule.pattern && typeof rule.pattern === 'string') {
+              return {
+                ...rule,
+                pattern: getRegExp(rule.pattern),
+              };
+            }
+            return rule;
+          });
+          
+          // 移除干扰字段
+          const cleanRules = rules.map((rule: any) => {
+            const cleanRule = { ...rule };
+            delete cleanRule.type;
+            delete cleanRule.id;
+            delete cleanRule.title;
+            delete cleanRule.regexpType;
+            delete cleanRule.ruleType;
+            return cleanRule;
+          });
+          
+          validationRules[dataIndex] = cleanRules;
+        }
+      });
+    }
+    
+    return validationRules;
+  };
+
+  // 验证指定范围的数据
+  const validateDataRange = (data: any[], validationRules: Record<string, any[]>, startIndex: number, endIndex: number) => {
+    for (let i = startIndex; i < endIndex && i < data.length; i += 1) {
+      const rowData = data[i];
+      
+      for (const [dataIndex, rules] of Object.entries(validationRules)) {
+        const value = rowData[dataIndex];
+        
+        for (const rule of rules) {
+          // 必填校验
+          if (rule.required === true) {
+            if (value === undefined || value === null || value === '') {
+              return { isValid: false, errorIndex: i };
+            }
+          }
+          
+          // 正则校验
+          if (rule.pattern && rule.pattern instanceof RegExp) {
+            const stringValue = String(value || '');
+            if (!rule.pattern.test(stringValue)) {
+              return { isValid: false, errorIndex: i };
+            }
+          }
+          
+          // 类型校验
+          if (rule.type) {
+            const valueType = typeof value;
+            if (rule.type !== valueType) {
+              // 数字输入框时，格式为数字型字符串视为合法类型
+              if (!(rule.type === 'number' && valueType === 'string' && !isNaN(Number(value)))) {
+                return { isValid: false, errorIndex: i };
+              }
+            }
+          }
+        }
+      }
+    }
+    return { isValid: true };
+  };
+
+  // 前端分页时校验所有数据
+  const validateAllData = async(compId: string, callback: any = () => {}) => {
+    if (!page || (innerDataSource?.length === currentPageDataSource?.length)) {
+      // 非分页或者后端分页时则直接按照单页校验
+      validateFormAndScroll(compId, (err: any) => {
+        callback(err, innerDataSource);
+      });
+      return;
+    }
+    // 前端分页时，先校验当前页数据
+    validateFormAndScroll(compId, (err: any) => {
+      if (err) {
+        // 当前页校验失败，直接返回错误
+        callback(err, innerDataSource);
+        return;
+      }
+      
+      // 当前页校验通过，继续校验所有数据
+      const validationRules = collectValidationRules();
+      const { current = 1, pageSize = 10 } = pagination || {};
+      const currentPageStartIndex = (current - 1) * pageSize;
+      const currentPageEndIndex = current * pageSize;
+      
+      // 非第一页，校验当前页前面的数据
+      if (current > 1) {
+        const otherPagesResult = validateDataRange(innerDataSource, validationRules, 0, currentPageStartIndex);
+        if (!otherPagesResult.isValid) {
+          // 其他页数据校验失败，跳转到错误行
+          validateAndScrollToErrorPage(compId, otherPagesResult.errorIndex || 0, callback);
+          return;
+        }
+      }
+      // 当前页小于总数，不是最后一页
+      if (currentPageEndIndex < innerDataSource.length) {
+        const afterCurrentPageResult = validateDataRange(innerDataSource, validationRules, currentPageEndIndex, innerDataSource.length);
+        if (!afterCurrentPageResult.isValid) {
+          // 当前页之后的数据校验失败，跳转到错误行
+          validateAndScrollToErrorPage(compId, afterCurrentPageResult.errorIndex || 0, callback);
+          return;
+        }
+      }
+      
+      // 所有数据校验通过
+      callback(null, innerDataSource);
+    });
+  };
+
   useImperativeHandle(ref, () => ({
 
     /**
@@ -231,12 +379,19 @@ const useCMDAction = (props: UseCMDActionPropsType) => {
     /**
      * 新增一行数据
      */
-    addTableRowData: (newRowData: any) => {
+    addTableRowData: (newRowData: any, inlineeditnow: boolean) => {
       if (tableUpdateInnerDataSource) {
+        const data = {
+          ...newRowData,
+          ...createEmptyRow(false),
+        };
+        data[currentRowKey] = data[EMPTY_ROW_TEMP_KEY_ATTR];
+        if (inlineeditnow) {
+          setNowEditingData({ ...data });
+          setNowInlineEditKey(data[currentRowKey]);
+        }
         // 主键不存在时需补上
-        setInnerDataSource([newRowData, ...innerDataSource].map((c: any, idx: number) => {
-          return setTableRowKey(c, idx);
-        }));
+        setInnerDataSource([data, ...innerDataSource]);
         return;
       }
 
@@ -257,6 +412,9 @@ const useCMDAction = (props: UseCMDActionPropsType) => {
         if (type === '$row$') {
           return !Object.is(value, row);
         }
+        if (Array.isArray(value)) {
+          return !value.includes(row[currentRowKey]);
+        }
         return row[currentRowKey] !== value;
       });
 
@@ -281,6 +439,10 @@ const useCMDAction = (props: UseCMDActionPropsType) => {
         callback(err, currentPageDataSource);
       });
     },
+    // 校验所有表格数据
+    validateAllData: (compId: string, callback: any = () => {}) => {
+      validateAllData(compId, callback);
+    },
     validateTableRowData: (compId: string, callback: any = () => {}) => {
       validateFormAndScroll(compId, (err: any) => {
         callback(err);
@@ -313,6 +475,7 @@ const useCMDAction = (props: UseCMDActionPropsType) => {
     loading,
     colServiceData,
     colServiceDataForEdit,
+    tableRef,
   };
 };
 
@@ -340,7 +503,11 @@ const useCommonCMDAction = (props: UseCommonCMDAction) => {
 
   const [loading, setLoading] = useState(false);
   // 表格字段翻译绑定的服务对应的翻译数据
-  const [colServiceData, setColServiceData] = useState({});
+  const [colServiceData, setColServiceData] = useState<Record<string, {
+    data?: any[];
+    labelKey?: string;
+    valueKey?: string;
+  }>>({});
 
   // 是否只更新内部数据源，从3.8.1开始只更新内部数据源
   const { tableUpdateInnerDataSource } = engineApis?.compatConfig?.cmd || {};