@zat-design/sisyphus-react 4.2.0-beta.3 → 4.2.0-beta.4

package/es/ProEnum/hooks/useEnum.js

@@ -1,11 +1,7 @@
 /* eslint-disable no-redeclare */
-import { useState, useEffect } from 'react';
+import { useState, useEffect, useRef } from 'react';
 import { useProConfig } from "../../ProConfigProvider";
-import { getEnumData } from "../utils";
-let baseEnumStorage = (window.localStorage.getItem('zat-design-pro-component-cacheKey') && JSON.parse(window.localStorage.getItem('zat-design-pro-component-cacheKey'))) ?? null;
-
-// 模块级缓存，用于存储正在进行的 IndexedDB 读取 Promise，避免重复读取
-const indexedDBLoadingCache = new Map();
+import { getEnumData, baseCacheKey, baseStorage } from "../utils";
 
 /**
  * input code output [DataOption[],getEnumLabel]
@@ -44,17 +40,15 @@ const indexedDBLoadingCache = new Map();
 
 function useEnum(codes, value, compose) {
   const {
-    storage = 'localStorage',
-    cacheKey = 'zat-design-pro-component-cacheKey',
+    storage = baseStorage,
+    cacheKey = baseCacheKey,
     fieldNames = {},
     clear = true,
     dics = {}
   } = useProConfig('ProEnum') || {};
 
-  // 存在子应用自管理枚举时，需要根据其指定的cacheKey进行缓存
-  if (cacheKey !== 'zat-design-pro-component-cacheKey') {
-    baseEnumStorage = null;
-  }
+  // 用 ref 记录哪些 cacheKey 已触发过加载，防止 enumData 变化导致重复 I/O
+  const hasLoadedRef = useRef(new Set());
 
   // 使用 state 来存储异步加载的数据
   const [enumData, setEnumData] = useState(() => {
@@ -70,7 +64,7 @@ function useEnum(codes, value, compose) {
         data: {}
       };
     }
-    return getEnumData(storage, cacheKey, baseEnumStorage) || {
+    return getEnumData(storage, cacheKey) || {
       data: {}
     };
   });
@@ -79,7 +73,6 @@ function useEnum(codes, value, compose) {
   useEffect(() => {
     if (storage === 'indexedDB' && dics && Object.keys(dics).length > 0) {
       setEnumData(prevData => {
-        // 只有当 dics 有数据且与当前数据不同时才更新
         if (JSON.stringify(dics) !== JSON.stringify(prevData?.data)) {
           return {
             data: dics
@@ -90,67 +83,25 @@ function useEnum(codes, value, compose) {
     }
   }, [storage, cacheKey, dics]);
 
-  // 异步加载 IndexedDB 数据
+  // 异步加载 IndexedDB 数据（每个 cacheKey 只触发一次，由 hasLoadedRef 防重）
   useEffect(() => {
-    if (storage === 'indexedDB') {
-      // 使用模块级缓存避免重复读取
-      let loadPromise = indexedDBLoadingCache.get(cacheKey);
-      if (!loadPromise) {
-        loadPromise = Promise.resolve(getEnumData(storage, cacheKey, baseEnumStorage)).then(data => {
-          // 读取完成后，从缓存中移除
-          indexedDBLoadingCache.delete(cacheKey);
-          return data;
-        }).catch(error => {
-          // 读取失败后，从缓存中移除
-          indexedDBLoadingCache.delete(cacheKey);
-          // 错误已在 getEnumData 中处理，这里返回空数据
-          return {
-            data: {}
-          };
+    if (storage === 'indexedDB' && !hasLoadedRef.current.has(cacheKey)) {
+      hasLoadedRef.current.add(cacheKey);
+      Promise.resolve(getEnumData(storage, cacheKey)).then(data => {
+        setEnumData(prevData => {
+          if (data && JSON.stringify(data) !== JSON.stringify(prevData)) {
+            return data || {
+              data: {}
+            };
+          }
+          return prevData;
         });
-        indexedDBLoadingCache.set(cacheKey, loadPromise);
-      }
-      loadPromise.then(data => {
-        // 如果数据为空或无效，且当前 enumData 也是空的，尝试重新读取
-        if ((!data || !data.data || Object.keys(data.data).length === 0) && (!enumData || !enumData.data || Object.keys(enumData.data).length === 0)) {
-          // 延迟重试，给 IndexedDB 一些时间
-          setTimeout(() => {
-            // 清除缓存，允许重新读取
-            indexedDBLoadingCache.delete(cacheKey);
-            Promise.resolve(getEnumData(storage, cacheKey, baseEnumStorage)).then(retryData => {
-              if (retryData && retryData.data && Object.keys(retryData.data).length > 0) {
-                setEnumData(prevData => {
-                  if (retryData && JSON.stringify(retryData) !== JSON.stringify(prevData)) {
-                    baseEnumStorage = retryData;
-                    return retryData;
-                  }
-                  return prevData;
-                });
-              }
-            }).catch(() => {
-              // 重试失败，保持空数据
-            });
-          }, 100);
-        } else {
-          setEnumData(prevData => {
-            if (data && JSON.stringify(data) !== JSON.stringify(prevData)) {
-              baseEnumStorage = data;
-              return data || {
-                data: {}
-              };
-            }
-            return prevData;
-          });
-        }
+      }).catch(() => {
+        // 错误已在 getEnumData 中处理
       });
     }
-  }, [storage, cacheKey, enumData]);
-  const catchData = storage === 'indexedDB' ? enumData : getEnumData(storage, cacheKey, baseEnumStorage);
-
-  // 默认枚举缓存数据（仅同步存储）
-  if (storage !== 'indexedDB') {
-    baseEnumStorage = catchData;
-  }
+  }, [storage, cacheKey]);
+  const catchData = storage === 'indexedDB' ? enumData : getEnumData(storage, cacheKey);
   if (!codes) {
     return catchData;
   }

package/es/ProEnum/hooks/useEnumRequest.js

@@ -1,9 +1,8 @@
 import { useEffect } from 'react';
 import { useDeepCompareEffect, useRequest as useRequestFunc } from 'ahooks';
-import { diffCode, getEnumData, setEnumData, removeEnumData, cacheFieldNames, baseCacheKey } from "../utils";
+import { diffCode, getEnumData, setEnumData, removeEnumData, cacheFieldNames, baseCacheKey, baseStorage } from "../utils";
 import locale from "../../locale";
 import "../utils/eventCenter";
-const baseEnumStorage = (window.localStorage.getItem(baseCacheKey) && JSON.parse(window.localStorage.getItem(baseCacheKey))) ?? null;
 const useEnumRequest = (props, dispatch) => {
   const {
     main = false,
@@ -16,7 +15,7 @@ const useEnumRequest = (props, dispatch) => {
     },
     cacheKey = baseCacheKey,
     requestRefresh = false,
-    storage = 'localStorage',
+    storage = baseStorage,
     dataSource = {},
     useRequest,
     transformResponse,
@@ -74,7 +73,7 @@ const useEnumRequest = (props, dispatch) => {
       }
 
       // 获取缓存数据（支持异步）
-      const cacheData = await Promise.resolve(getEnumData(storage, cacheKey, baseEnumStorage) || {
+      const cacheData = await Promise.resolve(getEnumData(storage, cacheKey) || {
         data: {}
       });
 
@@ -106,7 +105,7 @@ const useEnumRequest = (props, dispatch) => {
     },
     getCache: () => {
       // 支持异步读取
-      const cachePromise = Promise.resolve(getEnumData(storage, cacheKey, baseEnumStorage) || {
+      const cachePromise = Promise.resolve(getEnumData(storage, cacheKey) || {
         data: {}
       });
 
@@ -132,7 +131,7 @@ const useEnumRequest = (props, dispatch) => {
       }
 
       // 同步存储的处理
-      const res = getEnumData(storage, cacheKey, baseEnumStorage) || {
+      const res = getEnumData(storage, cacheKey) || {
         data: {}
       };
       dispatch({
@@ -162,7 +161,7 @@ const useEnumRequest = (props, dispatch) => {
     }
   });
   const mergeData = async () => {
-    const cacheData = await Promise.resolve(getEnumData(storage, cacheKey, baseEnumStorage) || {
+    const cacheData = await Promise.resolve(getEnumData(storage, cacheKey) || {
       data: {}
     });
     if (typeof cacheData === 'object') {
@@ -244,7 +243,7 @@ const useEnumRequest = (props, dispatch) => {
         // TODO 这段代码目前看起来是没啥用的、没起到作用
         mergeData();
       } else if (Object.keys(dataSource)) {
-        const res = await Promise.resolve(getEnumData(storage, cacheKey, baseEnumStorage) || {
+        const res = await Promise.resolve(getEnumData(storage, cacheKey) || {
           data: {}
         });
         dispatch({
@@ -255,7 +254,7 @@ const useEnumRequest = (props, dispatch) => {
           }
         });
       } else {
-        const res = await Promise.resolve(getEnumData(storage, cacheKey, baseEnumStorage) || {
+        const res = await Promise.resolve(getEnumData(storage, cacheKey) || {
           data: {}
         });
         dispatch({
@@ -270,7 +269,7 @@ const useEnumRequest = (props, dispatch) => {
   }, [useRequest?.options]);
   const shareProEnumDic = async cacheData => {
     logDebug(cacheData);
-    const storageData = await Promise.resolve(getEnumData(storage, cacheKey, baseEnumStorage) || {
+    const storageData = await Promise.resolve(getEnumData(storage, cacheKey) || {
       data: {}
     });
     dispatch({

package/es/ProEnum/hooks/useFrequentEnumRequest.js

@@ -1,12 +1,13 @@
 import { useDeepCompareEffect, useRequest as useRequestFunc } from 'ahooks';
 import { replaceFrequentEnumCache } from "../utils/frequentEnum";
+import { baseCacheKey } from "../utils";
 const useFrequentEnumRequest = (props, dispatch) => {
   const {
     frequentEnums,
     fieldNames,
     clear = true,
     storage = 'localStorage',
-    cacheKey = 'zat-design-pro-component-cacheKey',
+    cacheKey = baseCacheKey,
     dics,
     dataSource
   } = props;

package/es/ProEnum/index.d.ts

@@ -1,8 +1,10 @@
 import useEnum from './hooks/useEnum';
+import getEnum from './utils/getEnum';
 import type { ProEnumType } from './propsType';
 declare const ProEnum: {
     (props: ProEnumType): import("react/jsx-runtime").JSX.Element;
     getEnumLabel: (code: string | string[], value: any, compose?: boolean, fieldNameLabel?: string, fieldNameValue?: string) => import("react/jsx-runtime").JSX.Element;
     useEnum: typeof useEnum;
+    getEnum: typeof getEnum;
 };
 export default ProEnum;

package/es/ProEnum/index.js

@@ -12,9 +12,10 @@ import { useProConfig } from "../ProConfigProvider";
 import ProEnumTag from "./components/Tag";
 import ProEnumGroup from "./components/Group";
 import Container from "../ProForm/components/Container";
-import { isObject } from "./utils";
+import { isObject, baseCacheKey } from "./utils";
 import getEnumLabel from "./utils/getEnumLabel";
 import useEnum from "./hooks/useEnum";
+import getEnum from "./utils/getEnum";
 import locale from "../locale";
 import { useFieldProps } from "../ProForm/utils/useFieldProps";
 import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
@@ -42,7 +43,7 @@ const ProEnum = props => {
   const {
     fieldNames,
     clear = true,
-    cacheKey = 'zat-design-pro-component-cacheKey',
+    cacheKey = baseCacheKey,
     showCodeName,
     ...resProps
   } = useProConfig('ProEnum') || {};
@@ -282,4 +283,5 @@ const ProEnum = props => {
 };
 ProEnum.getEnumLabel = getEnumLabel;
 ProEnum.useEnum = useEnum;
+ProEnum.getEnum = getEnum;
 export default ProEnum;

package/es/ProEnum/style/index.less

@@ -1,4 +1,3 @@
-
 @zaui-disabled-bg: var(--zaui-disabled-bg);
 
 .pro-enum {

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

@@ -1,5 +1,5 @@
+import type { StorageType } from './index';
 import type { FrequentEnumConfig } from '../propsType';
-type StorageType = 'localStorage' | 'sessionStorage' | 'indexedDB';
 /**
  * 替换频繁枚举缓存数据的参数接口
  */
@@ -37,4 +37,3 @@ export declare function validateFrequentEnumConfig(config: FrequentEnumConfig):
  * @returns 合并后的数据
  */
 export declare function mergeFrequentEnumData(cacheData: any, dics: any, dataSource: any): any;
-export {};

package/es/ProEnum/utils/frequentEnum.js

@@ -1,4 +1,4 @@
-import { getEnumData, setEnumData, cacheFieldNames } from "./index";
+import { getEnumData, setEnumData, cacheFieldNames, baseCacheKey } from "./index";
 
 /**
  * 替换频繁枚举缓存数据的参数接口
@@ -52,7 +52,7 @@ async function replaceFrequentEnumCacheAsync(params) {
 export function replaceFrequentEnumCache(params) {
   const {
     storage = 'localStorage',
-    cacheKey = 'zat-design-pro-component-cacheKey',
+    cacheKey = baseCacheKey,
     enums = [],
     newData = {},
     fieldNames = {

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

@@ -0,0 +1,47 @@
+import type { StorageType } from './index';
+export interface GetEnumParams {
+    /** 单个枚举 code */
+    code?: string;
+    /** 多个枚举 code，与 code 互斥 */
+    codes?: string[];
+    /** 单值查询，返回 [label, option]，与 values 互斥 */
+    value?: string | number;
+    /** 多值查询，返回 [labels[], options[]]，与 value 互斥 */
+    values?: (string | number)[];
+    /** 为 true 时返回 value-label 组合形式 */
+    compose?: boolean;
+    /** 存储类型，默认 indexedDB */
+    storage?: StorageType;
+    /** 缓存 key，默认 zat-design-pro-component-cacheKey */
+    cacheKey?: string;
+}
+/**
+ * 在函数/回调中获取枚举数据，无需在 React 组件内使用。
+ *
+ * 枚举数据由 ProConfigProvider 初始化时写入 storage。
+ *
+ * **同步优先策略**：
+ * - 内存缓存命中时直接返回值，无需 `await`
+ * - localStorage/sessionStorage 首次调用同步读取并预热内存缓存
+ * - indexedDB 首次调用（内存未命中）返回 Promise，需 `await` 兜底
+ *
+ * 典型用法：在 ProConfigProvider 初始化完成后，事件回调/工具函数中直接调用无需 await：
+ *
+ * @example
+ * // 获取全部枚举（内存命中时同步返回）
+ * const allEnums = getEnum(config);
+ *
+ * // 获取单个枚举 options
+ * const [cityOptions, getLabel] = getEnum({ code: 'city', ...config });
+ *
+ * // 获取多个枚举
+ * const { city, status } = getEnum({ codes: ['city', 'status'], ...config });
+ *
+ * // 根据值查询 label
+ * const [label, option] = getEnum({ code: 'city', value: 'sh', ...config });
+ *
+ * // indexedDB 首次加载时兜底（数据未预热时需 await）
+ * const allEnums = await getEnum(config);
+ */
+declare function getEnum(params?: GetEnumParams): any;
+export default getEnum;

package/es/ProEnum/utils/getEnum.js

@@ -0,0 +1,151 @@
+import { getEnumData, getEnumDataSync, baseCacheKey, baseStorage } from "./index";
+const FIELD_VALUE = 'value';
+const FIELD_LABEL = 'label';
+const FIELD_CHILDREN = 'children';
+
+/** 递归在嵌套结构中查找选项 */
+function findOption(opts, target) {
+  const found = opts.find(opt => String(opt[FIELD_VALUE]) === String(target));
+  if (found) return found;
+  return opts.reduce((acc, opt) => {
+    if (acc) return acc;
+    const children = opt[FIELD_CHILDREN];
+    return Array.isArray(children) ? findOption(children, target) : undefined;
+  }, undefined);
+}
+
+/** 移除 children 字段 */
+function omitChildren(option) {
+  const {
+    [FIELD_CHILDREN]: _,
+    ...rest
+  } = option;
+  return rest;
+}
+
+/** 格式化单个 label */
+function formatLabel(opt, v, compose) {
+  return compose ? `${v}-${opt[FIELD_LABEL]}` : opt[FIELD_LABEL];
+}
+
+/** 将 allData 按查询参数转换为最终结果 */
+function resolveEnumResult(allData, params) {
+  const {
+    code,
+    codes,
+    value,
+    values,
+    compose
+  } = params;
+  if (!code && !codes) {
+    return allData;
+  }
+  if (codes) {
+    return codes.reduce((acc, c) => {
+      const opts = allData[c];
+      if (Array.isArray(opts) && opts.length) acc[c] = opts;
+      return acc;
+    }, {});
+  }
+  const options = allData[code] ?? [];
+  const getLabelFn = (v, composeFn) => {
+    const found = findOption(options, v);
+    return found ? formatLabel(found, v, composeFn) : undefined;
+  };
+  if (values !== undefined) {
+    const labels = [];
+    const foundOptions = [];
+    values.forEach(v => {
+      const found = findOption(options, v);
+      if (found) {
+        foundOptions.push(omitChildren(found));
+        labels.push(formatLabel(found, v, compose));
+      } else {
+        foundOptions.push({
+          label: '',
+          value: ''
+        });
+        labels.push('');
+      }
+    });
+    return [labels, foundOptions];
+  }
+  if (value !== undefined) {
+    const found = findOption(options, value);
+    if (found) {
+      return [formatLabel(found, value, compose), omitChildren(found)];
+    }
+    return [undefined, undefined];
+  }
+  return [options, getLabelFn];
+}
+
+/**
+ * 在函数/回调中获取枚举数据，无需在 React 组件内使用。
+ *
+ * 枚举数据由 ProConfigProvider 初始化时写入 storage。
+ *
+ * **同步优先策略**：
+ * - 内存缓存命中时直接返回值，无需 `await`
+ * - localStorage/sessionStorage 首次调用同步读取并预热内存缓存
+ * - indexedDB 首次调用（内存未命中）返回 Promise，需 `await` 兜底
+ *
+ * 典型用法：在 ProConfigProvider 初始化完成后，事件回调/工具函数中直接调用无需 await：
+ *
+ * @example
+ * // 获取全部枚举（内存命中时同步返回）
+ * const allEnums = getEnum(config);
+ *
+ * // 获取单个枚举 options
+ * const [cityOptions, getLabel] = getEnum({ code: 'city', ...config });
+ *
+ * // 获取多个枚举
+ * const { city, status } = getEnum({ codes: ['city', 'status'], ...config });
+ *
+ * // 根据值查询 label
+ * const [label, option] = getEnum({ code: 'city', value: 'sh', ...config });
+ *
+ * // indexedDB 首次加载时兜底（数据未预热时需 await）
+ * const allEnums = await getEnum(config);
+ */
+function getEnum(params) {
+  const {
+    code,
+    codes,
+    value,
+    values,
+    compose,
+    storage = baseStorage,
+    cacheKey = baseCacheKey
+  } = params ?? {};
+  if (code && codes) {
+    console.error('[getEnum] code 和 codes 不能同时传入');
+    return undefined;
+  }
+  if (value !== undefined && values !== undefined) {
+    console.error('[getEnum] value 和 values 不能同时传入');
+    return undefined;
+  }
+  const syncResult = getEnumDataSync(storage, cacheKey);
+  if (syncResult !== undefined) {
+    return resolveEnumResult(syncResult.data ?? {}, {
+      code,
+      codes,
+      value,
+      values,
+      compose
+    });
+  }
+
+  // indexedDB 首次加载兜底，返回 Promise
+  return getEnumData(storage, cacheKey).then(res => {
+    return resolveEnumResult(res?.data ?? {}, {
+      code,
+      codes,
+      value,
+      values,
+      compose
+    });
+  });
+}
+export default getEnum;

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

@@ -1,6 +1,10 @@
 import { DataOptionType } from '../propsType';
-type StorageType = 'localStorage' | 'sessionStorage' | 'indexedDB';
+export type StorageType = 'localStorage' | 'sessionStorage' | 'indexedDB';
 export declare const baseCacheKey = "zat-design-pro-component-cacheKey";
+/** v4 默认存储类型 */
+export declare const baseStorage: StorageType;
+/** 模块级内存缓存，key 为 cacheKey，替代原单例 baseEnumStorage 变量 */
+export declare const enumMemoryCache: Map<string, any>;
 interface EnumRes {
     data: Record<string, DataOptionType[]>;
     [key: string]: any;
@@ -9,10 +13,9 @@ interface EnumRes {
  * 获取枚举数据
  * @param storage
  * @param cacheKey
- * @param baseEnumStorage
  * @returns
  */
-export declare function getEnumData(storage: StorageType, cacheKey: string, baseEnumStorage?: any): EnumRes | Promise<EnumRes>;
+export declare function getEnumData(storage: StorageType, cacheKey: string): EnumRes | Promise<EnumRes>;
 /**
  * 设置枚举数据
  * @param storage
@@ -26,6 +29,13 @@ export declare function setEnumData(storage: StorageType, cacheKey: string, data
  * @param cacheKey
  */
 export declare function removeEnumData(storage: StorageType, cacheKey: string): Promise<void>;
+/**
+ * 从内存缓存或同步存储中同步读取枚举数据，不触发任何异步 I/O。
+ * - 内存缓存命中时直接返回
+ * - localStorage/sessionStorage 同步读取并预热内存缓存
+ * - indexedDB 未命中时返回 undefined（需异步兜底）
+ */
+export declare function getEnumDataSync(storage: StorageType, cacheKey: string): EnumRes | undefined;
 /**
  * 判断枚举列表是否存在
  * @param storage

package/es/ProEnum/utils/index.js

@@ -1,6 +1,12 @@
 import { get, set, del } from 'idb-keyval';
 export const baseCacheKey = 'zat-design-pro-component-cacheKey';
 
+/** v4 默认存储类型 */
+export const baseStorage = 'indexedDB';
+
+/** 模块级内存缓存，key 为 cacheKey，替代原单例 baseEnumStorage 变量 */
+export const enumMemoryCache = new Map();
+
 // IndexedDB 可用性检测缓存
 let indexedDBAvailable = null;
 
@@ -73,22 +79,23 @@ async function setToIndexedDB(key, value) {
  * 获取枚举数据
  * @param storage
  * @param cacheKey
- * @param baseEnumStorage
  * @returns
  */
-export function getEnumData(storage, cacheKey, baseEnumStorage) {
-  // IndexedDB 返回 Promise
+export function getEnumData(storage, cacheKey) {
+  // IndexedDB：先查内存缓存，命中则同步返回，避免实际 I/O
   if (storage === 'indexedDB') {
-    return getFromIndexedDB(cacheKey);
+    if (enumMemoryCache.has(cacheKey)) {
+      return Promise.resolve(enumMemoryCache.get(cacheKey));
+    }
+    return getFromIndexedDB(cacheKey).then(data => {
+      enumMemoryCache.set(cacheKey, data);
+      return data;
+    });
   }
 
   // localStorage/sessionStorage 保持同步
-  if (baseEnumStorage && window.localStorage.getItem(cacheKey) && cacheKey === baseCacheKey) {
-    return baseEnumStorage;
-  }
   if (storage === 'localStorage') {
     const data = JSON.parse(window.localStorage.getItem(cacheKey) || '{}');
-    // 确保返回的数据格式正确，包含 data 字段
     if (data && typeof data === 'object' && 'data' in data) {
       return data;
     }
@@ -98,7 +105,6 @@ export function getEnumData(storage, cacheKey, baseEnumStorage) {
   }
   if (storage === 'sessionStorage') {
     const data = JSON.parse(window.sessionStorage.getItem(cacheKey) || '{}');
-    // 确保返回的数据格式正确，包含 data 字段
     if (data && typeof data === 'object' && 'data' in data) {
       return data;
     }
@@ -122,8 +128,9 @@ export function setEnumData(storage, cacheKey, data) {
     return;
   }
 
-  // IndexedDB 返回 Promise
+  // IndexedDB：同步写内存缓存，异步持久化到 IndexedDB
   if (storage === 'indexedDB') {
+    enumMemoryCache.set(cacheKey, data);
     return setToIndexedDB(cacheKey, data);
   }
 
@@ -158,6 +165,33 @@ export async function removeEnumData(storage, cacheKey) {
   }
 }
 
+/**
+ * 从内存缓存或同步存储中同步读取枚举数据，不触发任何异步 I/O。
+ * - 内存缓存命中时直接返回
+ * - localStorage/sessionStorage 同步读取并预热内存缓存
+ * - indexedDB 未命中时返回 undefined（需异步兜底）
+ */
+export function getEnumDataSync(storage, cacheKey) {
+  if (enumMemoryCache.has(cacheKey)) return enumMemoryCache.get(cacheKey);
+  if (storage === 'localStorage') {
+    const d = JSON.parse(window.localStorage.getItem(cacheKey) || '{}');
+    const res = d?.data ? d : {
+      data: {}
+    };
+    enumMemoryCache.set(cacheKey, res);
+    return res;
+  }
+  if (storage === 'sessionStorage') {
+    const d = JSON.parse(window.sessionStorage.getItem(cacheKey) || '{}');
+    const res = d?.data ? d : {
+      data: {}
+    };
+    enumMemoryCache.set(cacheKey, res);
+    return res;
+  }
+  return undefined;
+}
+
 /**
  * 判断枚举列表是否存在
  * @param storage

package/es/ProForm/components/base/SwitchCheckbox/style/index.less

@@ -1,13 +1,12 @@
-
 .switch-checkbox-view {
-  display    : flex;
+  display: flex;
   align-items: center;
 
   .switch-checkbox-view-label {
-    flex         : 0 0 @zaui-form-label-width;
-    overflow   : initial;
+    flex: 0 0 @zaui-form-label-width;
+    overflow: initial;
     line-height: 1;
     white-space: pre-wrap;
-    color      : var(--zaui-aide-text, #939599);
+    color: var(--zaui-aide-text, #939599);
   }
 }

package/es/ProForm/components/base/TimePicker/style/index.less

@@ -1,4 +1,3 @@
-
 /* 适配antd 5.x，不再导入antd样式 */
 
 .ant-picker-time {