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

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/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/combination/Group/utils/index.d.ts

@@ -75,29 +75,28 @@ 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;
-    hidden?: boolean;
-    layout?: import("antd/es/form/Form").FormItemLayout;
-    help?: React.ReactNode;
-    vertical?: boolean;
-    preserve?: boolean;
     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";
+    isView?: boolean;
+    id?: string;
     prefixCls?: string;
+    className?: string;
+    style?: React.CSSProperties;
     rootClassName?: string;
-    id?: string;
-    onReset?: () => void;
     getValueProps?: ((value: any) => Record<string, unknown>) & ((value: any) => Record<string, unknown>);
+    trim?: boolean;
+    normalize?: (value: any, prevValue: any, allValues: import("@rc-component/form/lib/interface").Store) => any;
+    vertical?: boolean;
+    trigger?: string;
+    hidden?: boolean;
+    onReset?: () => void;
     desensitization?: [number, number] | ReactiveFunction<any, [number, number]>;
     validateTrigger?: string | false | string[];
+    preserve?: boolean;
     clearNotShow?: boolean;
     labelAlign?: import("antd/es/form/interface").FormLabelAlign;
     colon?: boolean;
+    layout?: import("antd/es/form/Form").FormItemLayout;
     labelCol?: import("antd").ColProps;
     wrapperCol?: import("antd").ColProps;
     htmlFor?: string;
@@ -115,6 +114,7 @@ export declare const useFormItemProps: (column: FlexibleGroupColumnType, context
         icons: import("antd/es/form/FormItem").FeedbackIcons;
     };
     validateStatus?: "" | "warning" | "error" | "success" | "validating";
+    help?: React.ReactNode;
     fieldId?: string;
     valueType?: import("../../../render/propsType").ProFormValueType;
     switchValue?: [any, any];

package/package.json

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