@lingxiteam/ebe-utils 0.2.4 → 0.2.5

package/lib/pcpublic/src/components/pcfactory/src/DynamicDataContainer/index.tsx

@@ -1,316 +1,264 @@
-import {
-  DynamicDataFieldItem,
-  DynamicDataType,
-  LingxiForwardRef,
-} from '@lingxiteam/types';
+import { DynamicDataFieldItem, DynamicDataType, LingxiForwardRef } from '@lingxiteam/types';
 import { Form, FormInstance, Spin } from 'antd';
-import {
-  CSSProperties,
-  useEffect,
-  useImperativeHandle,
-  useMemo,
-  useRef,
-  useState,
-} from 'react';
+import { CSSProperties, useEffect, useImperativeHandle, useMemo, useRef, useState } from 'react';
 import { DynamicDataContext, DynamicDataProvider } from '../utils';
 import { useDynamicDataContainer } from './useDynamicDataContainer';
 
-type RuleParameter = {
+type RuleParamsItem = {
   paramId: string;
   valueCode?: string;
   originValueCode?: string;
+  paramCode?: string;
 };
 export interface DynamicDataContainerProps {
   className: string;
   style: CSSProperties;
   'data-compid'?: string;
-  engineRule?: Array<Array<RuleParameter>>;
+  engineRule?: Array<{
+    conditionId: string;
+    rules?: RuleParamsItem[];
+  }>;
   name: string;
-  scene?: 'edit' | 'readonly';
   visible?: boolean;
+  readOnly?: boolean;
   boxSpace?: string;
 
   /**
    * 编码
    */
   dynamicCode: string;
-  onValuesChange?: (
-    formCode: string,
-    changedFieldName: string,
-    changedFieldValue: any,
-    allValues: Record<string, Record<string, any>>,
-  ) => void;
+  onValuesChange?: (formCode: string, changedFieldName: string, changedFieldValue: any, allValues: Record<string, Record<string, any>>) => void;
 }
 
-const DynamicDataContainer = LingxiForwardRef<any, DynamicDataContainerProps>(
-  (props, ref) => {
-    const {
-      className,
-      getEngineApis,
-      style = {},
-      engineRule,
-      $$componentItem,
-      name,
-      onValuesChange,
-      dynamicCode,
-      boxSpace,
-    } = props || {};
-    const engineApis = getEngineApis?.() || {};
-    const [loading, setLoading] = useState<boolean>(false);
-    const { service, dynamicDataUtils, renderDynamicPage } = engineApis;
-    const { dynamicData2DSL, diffChange } = dynamicDataUtils || {};
-    const formsRef = useRef<
-      Record<
-        string,
-        {
-          form: FormInstance;
-          validateFormAndScroll?: () => Promise<any>;
-          getFieldsValue?: FormInstance['getFieldsValue'];
-          setFieldsValue?: (values: any, refs: Record<string, any>) => void;
-          resetFields?: FormInstance['resetFields'];
-          setDisabled?: (v: boolean) => void;
-          setReadOnly?: (v: boolean) => void;
-        }
-      >
-    >({});
-    const [pageData, setPageData] = useState<any>();
-    const dynamicHelperRef = useRef<ReturnType<typeof dynamicData2DSL>>();
-
-    const {
-      dynamicPageRef,
-      staticAttrKeys,
-      yieldMethod,
-      readyComplete,
-      engineliftCycle,
-    } = useDynamicDataContainer({
-      dynamicHelper: dynamicHelperRef.current,
-    });
-
-    const getDynamicData = async (
-      rules: DynamicDataContainerProps['engineRule'],
-    ) => {
-      try {
-        setLoading(true);
-        if (rules && rules?.length) {
-          const res = await service.batchMatchDynamicData({
-            terminalType: 'pc',
-            findDataDetail: true,
-            paramGroupList: rules,
-          });
-          if (res && typeof dynamicData2DSL === 'function') {
-            const dataHelper = dynamicData2DSL(
-              res as DynamicDataType[],
-              { uid: $$componentItem.uid, name },
-              (
-                DSLCore,
-                dynamicData: DynamicDataType | DynamicDataFieldItem,
-              ) => {
-                if ('dataId' in dynamicData) {
-                  const node = DSLCore?.query?.(`Card_${dynamicData.dataId}`);
-                  if (node && boxSpace) {
-                    node?.setStyle?.({
-                      margin: `0 0 ${boxSpace} 0`,
-                    });
-                  }
-                }
-              },
-            );
-            setPageData(dataHelper.pageDSL);
-            dynamicHelperRef.current = dataHelper;
+const DynamicDataContainer = LingxiForwardRef<any, DynamicDataContainerProps>((props, ref) => {
+  const { className, getEngineApis, style = {}, engineRule, $$componentItem, name, onValuesChange, dynamicCode, boxSpace, readOnly } = props || {};
+  const engineApis = getEngineApis?.() || {};
+  const [loading, setLoading] = useState<boolean>(false);
+  const { service, dynamicDataUtils, renderDynamicPage } = engineApis;
+  const { dynamicData2DSL, diffChange, combineRules } = dynamicDataUtils || {};
+  const formsRef = useRef<
+    Record<
+      string,
+      {
+        form: FormInstance;
+        validateFormAndScroll?:() => Promise<any>;
+        getFieldsValue?: FormInstance['getFieldsValue'];
+        setFieldsValue?: (values: any, refs: Record<string, any>) => void;
+        resetFields?: FormInstance['resetFields'];
+        setDisabled?: (v: boolean) => void;
+        setReadOnly?: (v: boolean) => void;
           }
-        }
-      } finally {
-        setLoading(false);
-      }
-    };
+          >
+          >({});
+  const [pageData, setPageData] = useState<any>();
+  const dynamicHelperRef = useRef<ReturnType<typeof dynamicData2DSL>>();
 
-    useEffect(() => {
-      getDynamicData(engineRule);
-    }, [engineRule]);
+  const { dynamicPageRef, staticAttrKeys, yieldMethod, readyComplete, engineliftCycle } = useDynamicDataContainer({
+    dynamicHelper: dynamicHelperRef.current,
+  });
 
-    const getDynamicFormValue = () => {
-      const allValues: Record<string, any> = {};
-      if (formsRef.current) {
-        Object.keys(formsRef.current).forEach((formCode) => {
-          const form = formsRef.current[formCode] || {};
-          allValues[formCode] = form?.getFieldsValue?.();
+  const getDynamicData = async (rules: Array<Array<RuleParamsItem>>) => {
+    try {
+      setLoading(true);
+      if (rules && rules?.length) {
+        const res = await service.batchMatchDynamicData({
+          terminalType: 'pc',
+          findDataDetail: true,
+          paramGroupList: rules,
         });
+        if (res && typeof dynamicData2DSL === 'function') {
+          const dataHelper = dynamicData2DSL(
+            res as DynamicDataType[],
+            { uid: $$componentItem.uid, name },
+            (DSLCore, dynamicData: DynamicDataType | DynamicDataFieldItem) => {
+              if ('dataId' in dynamicData) {
+                const node = DSLCore?.query?.(`Card_${dynamicData.dataId}`);
+                if (node && boxSpace) {
+                  node?.setStyle?.({
+                    margin: `0 0 ${boxSpace} 0`,
+                  });
+                }
+              }
+            }
+          );
+          setPageData(dataHelper.pageDSL);
+          dynamicHelperRef.current = dataHelper;
+        }
       }
-      return allValues;
-    };
+    } finally {
+      setLoading(false);
+    }
+  };
 
-    const resetFields = () => {
-      if (formsRef.current) {
-        const beforeData = getDynamicFormValue();
-        Object.keys(formsRef.current).forEach((formCode) => {
-          const form = formsRef.current[formCode] || {};
-          form?.resetFields?.();
-        });
-        const updateData = getDynamicFormValue();
-        const { event } = dynamicHelperRef.current || {};
-        diffChange(beforeData, updateData, (diff) => {
-          // 执行事件处理变更联动
-          event?.eval(diff.formCode, diff.changeFieldName);
-        });
-      }
-    };
+  useEffect(() => {
+    if (engineRule && engineRule?.length) {
+      getDynamicData(combineRules(engineRule));
+    }
+  }, [engineRule]);
 
-    const setFieldsValue = (
-      assignData: Record<string, unknown>,
-      format: boolean = true,
-    ) => {
-      let formalFormData = assignData;
-      const { assign2FormData } = dynamicHelperRef.current || {};
-      if (format) {
-        // 解析赋值数据
-        formalFormData = assign2FormData?.(assignData) || {};
-      }
+  const getDynamicFormValue = () => {
+    const allValues: Record<string, any> = {};
+    if (formsRef.current) {
+      Object.keys(formsRef.current).forEach(formCode => {
+        const form = formsRef.current[formCode] || {};
+        allValues[formCode] = form?.getFieldsValue?.();
+      });
+    }
+    return allValues;
+  };
 
+  const resetFields = () => {
+    if (formsRef.current) {
       const beforeData = getDynamicFormValue();
-      if (formsRef.current) {
-        Object.keys(formsRef.current).forEach((formCode) => {
-          const form = formsRef.current[formCode] || {};
-          form?.setFieldsValue?.(
-            formalFormData[formCode] || {},
-            dynamicPageRef?.current?.sandboxContext?.refs,
-          );
-        });
-      }
+      Object.keys(formsRef.current).forEach(formCode => {
+        const form = formsRef.current[formCode] || {};
+        form?.resetFields?.();
+      });
       const updateData = getDynamicFormValue();
       const { event } = dynamicHelperRef.current || {};
-
-      diffChange(beforeData, updateData, (diff) => {
+      diffChange(beforeData, updateData, diff => {
         // 执行事件处理变更联动
         event?.eval(diff.formCode, diff.changeFieldName);
       });
-    };
+    }
+  };
 
-    useImperativeHandle(ref, () => ({
-      formCode: dynamicCode,
-      // 加载动态数据
-      setRules: (newRules: DynamicDataContainerProps['engineRule']) => {
-        return getDynamicData(newRules);
-      },
-      // 获取动态数据表单转换协议后的值
-      getFieldsValue: () => {
-        const allValues = getDynamicFormValue();
+  const setFieldsValue = (assignData: Record<string, unknown>, format: boolean = true) => {
+    let formalFormData = assignData;
+    const { assign2FormData } = dynamicHelperRef.current || {};
+    if (format) {
+      // 解析赋值数据
+      formalFormData = assign2FormData?.(assignData) || {};
+    }
+
+    const beforeData = getDynamicFormValue();
+    if (formsRef.current) {
+      Object.keys(formsRef.current).forEach(formCode => {
+        const form = formsRef.current[formCode] || {};
+        form?.setFieldsValue?.(formalFormData[formCode] || {}, dynamicPageRef?.current?.sandboxContext?.refs);
+      });
+    }
+    const updateData = getDynamicFormValue();
+    const { event } = dynamicHelperRef.current || {};
+
+    diffChange(beforeData, updateData, diff => {
+      // 执行事件处理变更联动
+      event?.eval(diff.formCode, diff.changeFieldName);
+    });
+  };
+
+  useImperativeHandle(ref, () => ({
+    formCode: dynamicCode,
+    // 加载动态数据
+    setRules: (newRules: Array<Array<RuleParamsItem>>) => {
+      return getDynamicData(newRules);
+    },
+    // 获取动态数据表单转换协议后的值
+    getFieldsValue: () => {
+      const allValues = getDynamicFormValue();
+      const { formData2Retrieve } = dynamicHelperRef.current || {};
+      return formData2Retrieve?.(allValues) || allValues;
+    },
+    // 获取动态数据表单原始值
+    getOriginValue: () => {
+      return getDynamicFormValue();
+    },
+
+    resetFields,
+    // 校验表单并取值
+    validateFormAndScroll: async () => {
+      const allValues: Record<string, any> = {};
+      if (formsRef.current) {
+        const validatePromiseList = Object.keys(formsRef.current).map(formCode => {
+          const form = formsRef.current[formCode] || {};
+          return form?.validateFormAndScroll?.().then((res: any) => {
+            allValues[formCode] = res;
+          });
+        });
+        await Promise.all(validatePromiseList);
         const { formData2Retrieve } = dynamicHelperRef.current || {};
         return formData2Retrieve?.(allValues) || allValues;
-      },
-      // 获取动态数据表单原始值
-      getOriginValue: () => {
-        return getDynamicFormValue();
-      },
+      }
+      return undefined;
+    },
+    setFieldsValue: (assignData: Record<string, unknown>) => {
+      if (readyComplete) {
+        return setFieldsValue(assignData, true);
+      }
+      return yieldMethod.appendTo('setFieldsValue', setFieldsValue, [assignData]);
+    },
+  }));
 
-      resetFields,
-      // 校验表单并取值
-      validateFormAndScroll: async () => {
-        const allValues: Record<string, any> = {};
-        if (formsRef.current) {
-          const validatePromiseList = Object.keys(formsRef.current).map(
-            (formCode) => {
-              const form = formsRef.current[formCode] || {};
-              return form?.validateFormAndScroll?.().then((res: any) => {
-                allValues[formCode] = res;
-              });
-            },
-          );
-          await Promise.all(validatePromiseList);
-          const { formData2Retrieve } = dynamicHelperRef.current || {};
-          return formData2Retrieve?.(allValues) || allValues;
+  useEffect(() => {
+    if (formsRef.current) {
+      Object.keys(formsRef.current).forEach(key => {
+        const form = formsRef.current[key];
+        if (form?.setReadOnly) {
+          form.setReadOnly(!!readOnly);
+        }
+      });
+    }
+  }, [readOnly]);
+
+  const providerValue: DynamicDataContext = useMemo(() => {
+    return {
+      onFormChange: (formName, changedFieldName, changedFieldValue) => {
+        const { formData2Retrieve, event } = dynamicHelperRef.current || {};
+        const allValues = getDynamicFormValue();
+        event?.eval(formName, changedFieldName);
+        if (typeof onValuesChange === 'function') {
+          onValuesChange(formName, changedFieldName, changedFieldValue, formData2Retrieve?.(allValues) || allValues);
         }
-        return undefined;
       },
-      setFieldsValue: (assignData: Record<string, unknown>) => {
-        if (readyComplete) {
-          return setFieldsValue(assignData, true);
+      _innerDynamicDataContainer: true,
+      get formsRefMap() {
+        return formsRef.current;
+      },
+      updateFormChildRef: (formCode, formRef) => {
+        if (readOnly) {
+          // 只读时每次上报设置表单控件为只读状态
+          formRef?.setReadOnly(readOnly);
         }
-        return yieldMethod.appendTo('setFieldsValue', setFieldsValue, [
-          assignData,
-        ]);
+        formsRef.current[formCode] = formRef;
       },
-    }));
-
-    useEffect(() => {
-      if (formsRef.current) {
-        Object.keys(formsRef.current).forEach((key) => {
-          const form = formsRef.current[key];
-          if (form?.setReadOnly) {
-            form.setReadOnly(props.scene === 'readonly');
-          }
-        });
-      }
-    }, [props.scene]);
 
-    const providerValue: DynamicDataContext = useMemo(() => {
-      return {
-        onFormChange: (formName, changedFieldName, changedFieldValue) => {
-          const { formData2Retrieve, event } = dynamicHelperRef.current || {};
-          const allValues = getDynamicFormValue();
-          event?.eval(formName, changedFieldName);
-          if (typeof onValuesChange === 'function') {
-            onValuesChange(
-              formName,
-              changedFieldName,
-              changedFieldValue,
-              formData2Retrieve?.(allValues) || allValues,
-            );
-          }
-        },
-        _innerDynamicDataContainer: true,
-        get formsRefMap() {
-          return formsRef.current;
-        },
-        updateFormChildRef: (formCode, formRef) => {
-          if (props.scene === 'readonly') {
-            // 只读时每次上报设置表单控件为只读状态
-            formRef?.setReadOnly(props?.scene === 'readonly');
-          }
-          formsRef.current[formCode] = formRef;
+      form: {
+        getFieldsValue: () => getDynamicFormValue(),
+        resetFields,
+        setFieldsValue: (assignData: Record<string, unknown>) => {
+          return setFieldsValue(assignData, false);
         },
 
-        form: {
-          getFieldsValue: () => getDynamicFormValue(),
-          resetFields,
-          setFieldsValue: (assignData: Record<string, unknown>) => {
-            return setFieldsValue(assignData, false);
-          },
-
-          useWatch: (formCode: string, fieldCode: string) => {
-            return Form.useWatch(fieldCode, formsRef.current[formCode]?.form);
-          },
+        useWatch: (formCode: string, fieldCode: string) => {
+          return Form.useWatch(fieldCode, formsRef.current[formCode]?.form);
         },
-      };
-    }, [props.scene]);
-
-    const dynamicStyle = {
-      ...(style || {}),
-      display: props?.visible ? undefined : 'none',
+      },
     };
+  }, [readOnly]);
+
+  const dynamicStyle = {
+    ...(style || {}),
+    display: props?.visible ? undefined : 'none',
+  };
 
-    return (
-      <div
-        className={className}
-        data-compid={props?.['data-compid']}
-        style={dynamicStyle}
-      >
-        <Spin spinning={loading}>
-          <DynamicDataProvider value={providerValue}>
-            {pageData &&
-              renderDynamicPage(
-                pageData,
-                { uid: $$componentItem.uid },
-                {
-                  ref: dynamicPageRef,
-                  staticAttrKeys,
-                  engineliftCycle,
-                },
-              )}
-          </DynamicDataProvider>
-        </Spin>
-      </div>
-    );
-  },
-);
+  return (
+    <div className={className} data-compid={props?.['data-compid']} style={dynamicStyle}>
+      <Spin spinning={loading}>
+        <DynamicDataProvider value={providerValue}>
+          {pageData &&
+            renderDynamicPage(
+              pageData,
+              { uid: $$componentItem.uid },
+              {
+                ref: dynamicPageRef,
+                staticAttrKeys,
+                engineliftCycle,
+              }
+            )}
+        </DynamicDataProvider>
+      </Spin>
+    </div>
+  );
+});
 
 export default DynamicDataContainer;

package/lib/pcpublic/src/components/pcfactory/src/DynamicDataContainer/useDynamicDataContainer.ts

@@ -1,19 +1,13 @@
 import { useEffect, useMemo, useRef, useState } from 'react';
 import YieldMethod from './YieldMethod';
 
-export const useDynamicDataContainer = ({
-  dynamicHelper,
-}: {
-  dynamicHelper?: any;
-}) => {
+export const useDynamicDataContainer = ({ dynamicHelper }: { dynamicHelper?: any }) => {
   const dynamicPageRef = useRef<any>(null);
   const [readyComplete, setReadyComplete] = useState(false);
   const yieldMethod = useMemo(() => new YieldMethod(), []);
 
   useEffect(() => {
-    dynamicHelper?.updateSandboxContext(
-      () => dynamicPageRef.current?.sandboxContext,
-    );
+    dynamicHelper?.updateSandboxContext(() => dynamicPageRef.current?.sandboxContext);
   }, [dynamicHelper, dynamicPageRef.current]);
 
   const staticAttrKeys = useMemo(() => {

package/lib/pcpublic/src/components/pcfactory/src/DynamicTabs/PropsType.ts

@@ -21,6 +21,7 @@ export interface DynamicTabsProps {
   type: 'line' | 'card' | 'editable-card';
   tabPosition: 'left' | 'right' | 'top' | 'bottom';
   size: 'large' | 'middle' | 'small';
+  closeAll?: boolean;
   style?: React.CSSProperties | any;
   animated: boolean;
   $$componentItem: EngineBaseProps['$$componentItem'];
@@ -28,4 +29,5 @@ export interface DynamicTabsProps {
   visible?: boolean;
   onTabChange?: (key: string, data: any) => void;
   onTabDeleteChange?: (key: string) => void;
+  onDeleteAll?: () => void;
 }

package/lib/pcpublic/src/components/pcfactory/src/DynamicTabs/TabPage.tsx

@@ -12,16 +12,8 @@ interface TabPageProps {
   reloadPageKey?: string;
 }
 
-const TabPage: React.FC<TabPageProps> = (props) => {
-  const {
-    getEngineApis,
-    $$componentItem,
-    activeKey,
-    lcdpParentRenderId,
-    item,
-    index,
-    reloadPageKey,
-  } = props;
+const TabPage: React.FC<TabPageProps> = props => {
+  const { getEngineApis, $$componentItem, activeKey, lcdpParentRenderId, item, index, reloadPageKey } = props;
   const { PageView } = getEngineApis();
   const [load, setLoad] = useState(false);