@zat-design/sisyphus-react 4.3.4 → 4.3.5-beta.3

package/es/ProEnum/hooks/useEnum.js

@@ -198,9 +198,7 @@ function useEnum(codes, value, compose) {
     const options = {};
     codes.forEach(code => {
       const values = catchData?.data?.[code];
-      if (Array.isArray(values) && values.length) {
-        options[code] = values;
-      }
+      options[code] = Array.isArray(values) ? values : [];
     });
     return options;
   }

package/es/ProEnum/hooks/useEnumRequest.js

@@ -64,13 +64,14 @@ const useEnumRequest = (props, dispatch) => {
       // 缓存命中时跳过 transformResponse 和重复处理，直接 dispatch
       if (fromCacheRef.current) {
         const cachedData = fromCacheRef.current;
+        const mergedPayload = {
+          ...dics,
+          ...cachedData,
+          ...dataSource
+        };
         dispatch({
           type: 'setProEnumDic',
-          payload: {
-            ...dics,
-            ...dataSource,
-            ...cachedData
-          }
+          payload: mergedPayload
         });
         if (main) {
           setTimeout(() => {
@@ -132,13 +133,14 @@ const useEnumRequest = (props, dispatch) => {
       await Promise.resolve(setEnumData(storage, cacheKey, res));
 
       // 同步数据到全局
+      const mergedPayload = {
+        ...dics,
+        ...res.data,
+        ...dataSource
+      };
       dispatch({
         type: 'setProEnumDic',
-        payload: {
-          ...dics,
-          ...dataSource,
-          ...res.data
-        }
+        payload: mergedPayload
       });
       if (main) {
         setTimeout(() => {
@@ -157,13 +159,14 @@ const useEnumRequest = (props, dispatch) => {
       const res = getEnumData(storage, cacheKey) || {
         data: {}
       };
+      const mergedPayload = {
+        ...dics,
+        ...res?.data,
+        ...dataSource
+      };
       dispatch({
         type: 'setProEnumDic',
-        payload: {
-          ...dics,
-          ...dataSource,
-          ...res?.data
-        }
+        payload: mergedPayload
       });
       if (main) {
         setTimeout(() => {
@@ -229,18 +232,25 @@ const useEnumRequest = (props, dispatch) => {
             type: 'setProEnumDic',
             payload: {
               ...dics,
-              ...dataSource,
-              ...cacheData.data
+              ...cacheData.data,
+              ...dataSource
             }
           });
         } else if (dataSource && Object.keys(dataSource).length > 0) {
-          // 子系统也可能会有 dataSource
+          // 子系统也可能会有 dataSource，并需要同步写入缓存
+          const mergedPayload = {
+            ...dics,
+            ...cacheData.data,
+            ...dataSource
+          };
+          await Promise.resolve(setEnumData(storage, cacheKey, {
+            ...cacheData,
+            data: mergedPayload,
+            time: Date.now()
+          }));
           dispatch({
             type: 'setProEnumDic',
-            payload: {
-              ...dics,
-              ...dataSource
-            }
+            payload: mergedPayload
           });
         }
       }
@@ -266,12 +276,18 @@ const useEnumRequest = (props, dispatch) => {
         const res = await Promise.resolve(getEnumData(storage, cacheKey) || {
           data: {}
         });
+        const mergedData = {
+          ...res?.data,
+          ...dataSource
+        };
+        await Promise.resolve(setEnumData(storage, cacheKey, {
+          ...res,
+          data: mergedData,
+          time: Date.now()
+        }));
         dispatch({
           type: 'setProEnumDic',
-          payload: {
-            ...dataSource,
-            ...res?.data
-          }
+          payload: mergedData
         });
       } else {
         const res = await Promise.resolve(getEnumData(storage, cacheKey) || {

package/es/ProEnum/index.js

@@ -1,4 +1,3 @@
-import _isNumber from "lodash/isNumber";
 import _omit from "lodash/omit";
 import _isArray from "lodash/isArray";
 import _isString from "lodash/isString";
@@ -36,7 +35,7 @@ const ProEnum = props => {
   const {
     viewEmpty
   } = otherProps || {};
-  const _defalutValue = props?.defaultValue;
+  const _defaultValue = props?.defaultValue;
   const {
     isView: configIsView
   } = useFieldProps() || {};
@@ -68,8 +67,8 @@ const ProEnum = props => {
     fieldValue = 'value';
   }
 
-  // 这种时候优先级最高、完全走自定义
-  if (useRequest?.service && props.fieldNames) {
+  // 组件显式传入 fieldNames 时优先级最高，必须覆盖 clear 默认映射
+  if (props.fieldNames && Object.keys(props.fieldNames).length) {
     if (props.fieldNames?.label) label = props.fieldNames.label;
     if (props.fieldNames?.value) fieldValue = props.fieldNames.value;
   }
@@ -264,7 +263,7 @@ const ProEnum = props => {
     return _isFunction(props.optionRender) && record.length ? _optionRender() : labelList?.join('，');
   };
   if (_isView) {
-    const __value = value || _defalutValue;
+    const __value = value ?? _defaultValue;
     if (Array.isArray(__value)) {
       return /*#__PURE__*/_jsx(Container, {
         tooltip: true,
@@ -274,7 +273,7 @@ const ProEnum = props => {
     }
     return /*#__PURE__*/_jsx(Container, {
       viewEmpty: viewEmpty,
-      children: __value || _isNumber(__value) ? transToLabel([__value]) : null
+      children: __value != null ? transToLabel([__value]) : null
     });
   }
   return /*#__PURE__*/_jsx(_Fragment, {

package/es/ProEnum/utils/frequentEnum.js

@@ -1,4 +1,4 @@
-import { getEnumData, setEnumData, cacheFieldNames, baseCacheKey } from "./index";
+import { getEnumData, setEnumData, cacheFieldNames, baseCacheKey, normalizeEnumCacheData } from "./index";
 
 /**
  * 替换频繁枚举缓存数据的参数接口
@@ -16,9 +16,9 @@ async function replaceFrequentEnumCacheAsync(params) {
     fieldNames,
     clear
   } = params;
-  const cacheData = await Promise.resolve(getEnumData(storage, cacheKey) || {
+  const cacheData = normalizeEnumCacheData(await Promise.resolve(getEnumData(storage, cacheKey) || {
     data: {}
-  });
+  }));
 
   // 确保cacheData.data存在
   if (!cacheData.data) {
@@ -40,8 +40,9 @@ async function replaceFrequentEnumCacheAsync(params) {
       cacheData.time = Date.now();
     }
   });
-  await Promise.resolve(setEnumData(storage, cacheKey, cacheData));
-  return cacheData;
+  const normalizedCacheData = normalizeEnumCacheData(cacheData);
+  await Promise.resolve(setEnumData(storage, cacheKey, normalizedCacheData));
+  return normalizedCacheData;
 }
 
 /**
@@ -86,9 +87,9 @@ export function replaceFrequentEnumCache(params) {
   const cacheDataResult = getEnumData(storage, cacheKey);
   // getEnumData 对于非 indexedDB 返回同步值，对于 indexedDB 返回 Promise
   // 这里 storage 不是 indexedDB，所以是同步值
-  const cacheData = cacheDataResult || {
+  const cacheData = normalizeEnumCacheData(cacheDataResult || {
     data: {}
-  };
+  });
 
   // 确保cacheData.data存在
   if (!cacheData.data) {
@@ -110,8 +111,9 @@ export function replaceFrequentEnumCache(params) {
       cacheData.time = Date.now();
     }
   });
-  setEnumData(storage, cacheKey, cacheData);
-  return cacheData;
+  const normalizedCacheData = normalizeEnumCacheData(cacheData);
+  setEnumData(storage, cacheKey, normalizedCacheData);
+  return normalizedCacheData;
 }
 
 /**

package/es/ProEnum/utils/getEnum.js

@@ -43,7 +43,7 @@ function resolveEnumResult(allData, params) {
   if (codes) {
     return codes.reduce((acc, c) => {
       const opts = allData[c];
-      if (Array.isArray(opts) && opts.length) acc[c] = opts;
+      acc[c] = Array.isArray(opts) ? opts : [];
       return acc;
     }, {});
   }

package/es/ProEnum/utils/index.d.ts

@@ -5,10 +5,15 @@ export declare const baseCacheKey = "zat-design-pro-component-cacheKey";
 export declare const baseStorage: StorageType;
 /** 模块级内存缓存，key 为 cacheKey，替代原单例 baseEnumStorage 变量 */
 export declare const enumMemoryCache: Map<string, any>;
+/**
+ * 从 IndexedDB 读取数据
+ */
 interface EnumRes {
     data: Record<string, DataOptionType[]>;
+    dataLength?: number;
     [key: string]: any;
 }
+export declare function normalizeEnumCacheData(cacheData: any): EnumRes;
 /**
  * 获取枚举数据
  * @param storage
@@ -43,7 +48,7 @@ export declare function getEnumDataSync(storage: StorageType, cacheKey: string):
  * @param code
  * @returns
  */
-export declare function hasEnumList(storage: StorageType, cacheKey: any, code: string): false | DataOptionType[];
+export declare function hasEnumList(storage: StorageType, cacheKey: string, code: string): false | DataOptionType[];
 /**
  * 判断是否是对象
  * @param obj
@@ -57,7 +62,7 @@ export declare function isObject(obj: any): boolean;
  * @param cacheKey
  * @param responseData
  */
-export declare function mergeCacheData(storage: string, code: string, cacheKey: string, responseData: any): Promise<void>;
+export declare function mergeCacheData(storage: StorageType, code: string, cacheKey: string, responseData: any): Promise<void>;
 /**
  * diff code 差异
  * @param cacheCodes

package/es/ProEnum/utils/index.js

@@ -33,6 +33,24 @@ async function checkIndexedDBSupport() {
 /**
  * 从 IndexedDB 读取数据
  */
+
+function getEnumCodeLength(data) {
+  if (!data || typeof data !== 'object' || Array.isArray(data)) {
+    return 0;
+  }
+  return Object.keys(data).length;
+}
+export function normalizeEnumCacheData(cacheData) {
+  const rawData = cacheData?.data && typeof cacheData.data === 'object' && !Array.isArray(cacheData.data) ? cacheData.data : {};
+  const data = {
+    ...rawData
+  };
+  return {
+    ...(cacheData || {}),
+    data,
+    dataLength: getEnumCodeLength(data)
+  };
+}
 async function getFromIndexedDB(key) {
   const available = await checkIndexedDBSupport();
   if (!available) {
@@ -61,7 +79,8 @@ async function setToIndexedDB(key, value) {
   if (!available) {
     return;
   }
-  if (!Object.keys(value?.data || {}).length) {
+  const normalizedValue = normalizeEnumCacheData(value);
+  if (!Object.keys(normalizedValue.data || {}).length) {
     return;
   }
   try {
@@ -69,12 +88,13 @@ async function setToIndexedDB(key, value) {
     const {
       params,
       ...cleanValue
-    } = value;
+    } = normalizedValue;
     await set(key, cleanValue);
   } catch (error) {
     console.warn('ProEnum: IndexedDB write failed:', error);
   }
 }
+
 /**
  * 获取枚举数据
  * @param storage
@@ -124,21 +144,22 @@ export function getEnumData(storage, cacheKey) {
  * @param data
  */
 export function setEnumData(storage, cacheKey, data) {
-  if (!Object.keys(data?.data || {}).length) {
+  const normalizedData = normalizeEnumCacheData(data);
+  if (!Object.keys(normalizedData.data || {}).length) {
     return;
   }
 
   // IndexedDB：同步写内存缓存，异步持久化到 IndexedDB
   if (storage === 'indexedDB') {
-    enumMemoryCache.set(cacheKey, data);
-    return setToIndexedDB(cacheKey, data);
+    enumMemoryCache.set(cacheKey, normalizedData);
+    return setToIndexedDB(cacheKey, normalizedData);
   }
 
   // localStorage/sessionStorage 保持同步
   if (storage === 'localStorage') {
-    window.localStorage.setItem(cacheKey, JSON.stringify(data));
+    window.localStorage.setItem(cacheKey, JSON.stringify(normalizedData));
   } else if (storage === 'sessionStorage') {
-    window.sessionStorage.setItem(cacheKey, JSON.stringify(data));
+    window.sessionStorage.setItem(cacheKey, JSON.stringify(normalizedData));
   }
 }
 
@@ -148,6 +169,7 @@ export function setEnumData(storage, cacheKey, data) {
  * @param cacheKey
  */
 export async function removeEnumData(storage, cacheKey) {
+  enumMemoryCache.delete(cacheKey);
   if (storage === 'indexedDB') {
     const available = await checkIndexedDBSupport();
     if (!available) {
@@ -228,20 +250,18 @@ export function isObject(obj) {
  * @param responseData
  */
 export async function mergeCacheData(storage, code, cacheKey, responseData) {
+  const buildNextCacheData = cacheData => {
+    const normalizedCacheData = normalizeEnumCacheData(cacheData);
+    normalizedCacheData.data[code] = responseData;
+    return normalizeEnumCacheData(normalizedCacheData);
+  };
   if (storage === 'indexedDB') {
-    const cacheData = await getFromIndexedDB(cacheKey);
-    if (cacheData && cacheData.data) {
-      cacheData.data[code] = responseData;
-    }
-    await setToIndexedDB(cacheKey, cacheData);
+    const cacheData = enumMemoryCache.has(cacheKey) ? enumMemoryCache.get(cacheKey) : await getFromIndexedDB(cacheKey);
+    await Promise.resolve(setEnumData('indexedDB', cacheKey, buildNextCacheData(cacheData)));
   } else {
     const cacheStorage = storage === 'localStorage' ? 'localStorage' : 'sessionStorage';
     const cacheData = JSON.parse(window?.[cacheStorage]?.getItem(cacheKey) || '{}');
-    // 合并枚举到总数据源上
-    if (cacheData && cacheData.data) {
-      cacheData.data[code] = responseData;
-    }
-    window?.[cacheStorage]?.setItem(cacheKey, JSON.stringify(cacheData));
+    await Promise.resolve(setEnumData(cacheStorage, cacheKey, buildNextCacheData(cacheData)));
   }
 }
 

package/es/ProForm/components/base/InputNumber/index.js

@@ -148,7 +148,7 @@ const InputNumber = props => {
         }
       }
     }
-    return [_min ?? min ?? valueProps?.min, _max ?? max ?? valueProps?.max];
+    return [_min ?? min ?? valueProps?.min ?? initialConfig?.min, _max ?? max ?? valueProps?.max ?? initialConfig?.max];
   }, [range, min, max, rest.precision]);
   const _className = classNames({
     'full-form-item': true,

package/es/ProForm/components/combination/Group/utils/index.d.ts

@@ -75,39 +75,33 @@ export declare const useFormItemProps: (column: FlexibleGroupColumnType, context
     confirm?: boolean | import("antd").ModalFuncProps | import("../../../render/propsType").FunctionArgs<any, boolean | import("antd").ModalFuncProps>;
     show?: boolean | ReactiveFunction<any, boolean>;
     component?: React.ReactNode | ReactiveFunction<any, React.ReactNode>;
-    trigger?: string;
-    style?: React.CSSProperties;
+    id?: string;
+    className?: string;
     hidden?: boolean;
-    layout?: import("antd/es/form/Form").FormItemLayout;
-    help?: React.ReactNode;
-    vertical?: boolean;
-    preserve?: boolean;
+    style?: React.CSSProperties;
     children?: React.ReactNode | ((form: FormInstance<any>) => React.ReactNode);
-    isView?: boolean;
-    trim?: boolean;
-    normalize?: (value: any, prevValue: any, allValues: import("@rc-component/form/lib/interface").Store) => any;
-    className?: string;
-    status?: "" | "warning" | "error" | "success" | "validating";
+    onReset?: () => void;
     prefixCls?: string;
     rootClassName?: string;
-    id?: string;
-    onReset?: () => void;
-    getValueProps?: ((value: any) => Record<string, unknown>) & ((value: any) => Record<string, unknown>);
-    desensitization?: [number, number] | ReactiveFunction<any, [number, number]>;
-    validateTrigger?: string | false | string[];
-    clearNotShow?: boolean;
-    labelAlign?: import("antd/es/form/interface").FormLabelAlign;
+    status?: "" | "warning" | "error" | "success" | "validating";
+    vertical?: boolean;
+    isView?: boolean;
     colon?: boolean;
-    labelCol?: import("antd").ColProps;
-    wrapperCol?: import("antd").ColProps;
     htmlFor?: string;
+    labelAlign?: import("antd/es/form/interface").FormLabelAlign;
+    labelCol?: import("antd").ColProps;
     getValueFromEvent?: (...args: import("@rc-component/form/lib/interface").EventArgs) => any;
+    normalize?: (value: any, prevValue: any, allValues: import("@rc-component/form/lib/interface").Store) => any;
     shouldUpdate?: import("@rc-component/form/lib/Field").ShouldUpdate<any>;
+    trigger?: string;
+    validateTrigger?: string | false | string[];
     validateDebounce?: number;
     valuePropName?: string;
+    getValueProps?: ((value: any) => Record<string, unknown>) & ((value: any) => Record<string, unknown>);
     messageVariables?: Record<string, string>;
     initialValue?: any;
     onMetaChange?: (meta: import("@rc-component/form/lib/Field").MetaEvent) => void;
+    preserve?: boolean;
     isListField?: boolean;
     isList?: boolean;
     noStyle?: boolean;
@@ -115,6 +109,9 @@ export declare const useFormItemProps: (column: FlexibleGroupColumnType, context
         icons: import("antd/es/form/FormItem").FeedbackIcons;
     };
     validateStatus?: "" | "warning" | "error" | "success" | "validating";
+    layout?: import("antd/es/form/Form").FormItemLayout;
+    wrapperCol?: import("antd").ColProps;
+    help?: React.ReactNode;
     fieldId?: string;
     valueType?: import("../../../render/propsType").ProFormValueType;
     switchValue?: [any, any];
@@ -124,9 +121,12 @@ export declare const useFormItemProps: (column: FlexibleGroupColumnType, context
         index?: number;
     }) => string | React.ReactElement<any, any>;
     viewType?: import("../../../render/propsType").ViewType;
+    trim?: boolean;
     upperCase?: boolean;
     toISOString?: boolean;
     toCSTString?: boolean;
+    clearNotShow?: boolean;
+    desensitization?: [number, number] | ReactiveFunction<any, [number, number]>;
     name: any;
     dependencies: any[];
     tooltip: string | {
@@ -141,7 +141,7 @@ export declare const useFormItemProps: (column: FlexibleGroupColumnType, context
  * 创建组件属性
  */
 export declare const createComponentProps: (column: FlexibleGroupColumnType, formItemProps: any) => {
-    componentProps: import("lodash").Omit<any, "format" | "clearNotShow" | "valueType" | "switchValue" | "dependNames" | "toISOString" | "toCSTString" | "precision">;
+    componentProps: import("lodash").Omit<any, "format" | "valueType" | "switchValue" | "dependNames" | "toISOString" | "toCSTString" | "clearNotShow" | "precision">;
     formItemTransform: {
         getValueProps: any;
         normalize: any;

package/es/ProForm/components/render/ConfirmWrapper.js

@@ -22,7 +22,7 @@ const ConfirmWrapper = props => {
     name,
     index,
     listName
-  } = ProForm.useFieldProps();
+  } = ProForm.useFieldProps() || {};
   const handleChange = async (value, ...other) => {
     const _value = value?.target ? value.target.value : value;
     const confirmProps = _isFunction(confirm) ? await confirm(value, form.getFieldsValue(), {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zat-design/sisyphus-react",
-  "version": "4.3.4",
+  "version": "4.3.5-beta.3",
   "license": "MIT",
   "files": [
     "es",