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

package/es/ProEnum/hooks/useEnum.js

@@ -1,22 +1,7 @@
-var _ref;
-function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
-function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 /* eslint-disable no-redeclare */
-import { useState, useEffect } from 'react';
+import { useState, useEffect, useRef } from 'react';
 import { useProConfig } from "../../ProConfigProvider";
-import { getEnumData } from "../utils";
-var baseEnumStorage = (_ref = window.localStorage.getItem('zat-design-pro-component-cacheKey') && JSON.parse(window.localStorage.getItem('zat-design-pro-component-cacheKey'))) !== null && _ref !== void 0 ? _ref : null;
-
-// 模块级缓存，用于存储正在进行的 IndexedDB 读取 Promise，避免重复读取
-var indexedDBLoadingCache = new Map();
+import { getEnumData, baseCacheKey, baseStorage } from "../utils";
 
 /**
  * input code output [DataOption[],getEnumLabel]
@@ -54,51 +39,41 @@ var indexedDBLoadingCache = new Map();
  */
 
 function useEnum(codes, value, compose) {
-  var _ref2 = useProConfig('ProEnum') || {},
-    _ref2$storage = _ref2.storage,
-    storage = _ref2$storage === void 0 ? 'localStorage' : _ref2$storage,
-    _ref2$cacheKey = _ref2.cacheKey,
-    cacheKey = _ref2$cacheKey === void 0 ? 'zat-design-pro-component-cacheKey' : _ref2$cacheKey,
-    _ref2$fieldNames = _ref2.fieldNames,
-    fieldNames = _ref2$fieldNames === void 0 ? {} : _ref2$fieldNames,
-    _ref2$clear = _ref2.clear,
-    clear = _ref2$clear === void 0 ? true : _ref2$clear,
-    _ref2$dics = _ref2.dics,
-    dics = _ref2$dics === void 0 ? {} : _ref2$dics;
+  const {
+    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 来存储异步加载的数据
-  var _useState = useState(() => {
-      // 优先使用全局状态中的 dics 数据（如果存在）
-      if (storage === 'indexedDB' && dics && Object.keys(dics).length > 0) {
-        return {
-          data: dics
-        };
-      }
-      // 初始化：对于同步存储，直接返回数据；对于 IndexedDB，返回空数据
-      if (storage === 'indexedDB') {
-        return {
-          data: {}
-        };
-      }
-      return getEnumData(storage, cacheKey, baseEnumStorage) || {
+  const [enumData, setEnumData] = useState(() => {
+    // 优先使用全局状态中的 dics 数据（如果存在）
+    if (storage === 'indexedDB' && dics && Object.keys(dics).length > 0) {
+      return {
+        data: dics
+      };
+    }
+    // 初始化：对于同步存储，直接返回数据；对于 IndexedDB，返回空数据
+    if (storage === 'indexedDB') {
+      return {
         data: {}
       };
-    }),
-    _useState2 = _slicedToArray(_useState, 2),
-    enumData = _useState2[0],
-    setEnumData = _useState2[1];
+    }
+    return getEnumData(storage, cacheKey) || {
+      data: {}
+    };
+  });
 
   // 监听全局状态中的 dics 变化，优先使用 dics 数据
   useEffect(() => {
     if (storage === 'indexedDB' && dics && Object.keys(dics).length > 0) {
       setEnumData(prevData => {
-        // 只有当 dics 有数据且与当前数据不同时才更新
-        if (JSON.stringify(dics) !== JSON.stringify(prevData === null || prevData === void 0 ? void 0 : prevData.data)) {
+        if (JSON.stringify(dics) !== JSON.stringify(prevData?.data)) {
           return {
             data: dics
           };
@@ -108,86 +83,43 @@ function useEnum(codes, value, compose) {
     }
   }, [storage, cacheKey, dics]);
 
-  // 异步加载 IndexedDB 数据
+  // 异步加载 IndexedDB 数据（每个 cacheKey 只触发一次，由 hasLoadedRef 防重）
   useEffect(() => {
-    if (storage === 'indexedDB') {
-      // 使用模块级缓存避免重复读取
-      var 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]);
-  var 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;
   }
-  var fieldLabel = '';
-  var fieldValue = '';
+  let fieldLabel = '';
+  let fieldValue = '';
   if (fieldNames && Object.keys(fieldNames).length) {
-    fieldLabel = fieldNames === null || fieldNames === void 0 ? void 0 : fieldNames.label;
-    fieldValue = fieldNames === null || fieldNames === void 0 ? void 0 : fieldNames.value;
+    fieldLabel = fieldNames?.label;
+    fieldValue = fieldNames?.value;
   }
   if (clear) {
     fieldLabel = 'label';
     fieldValue = 'value';
   }
   if (typeof codes === 'string') {
-    var _catchData$data;
-    var options = (catchData === null || catchData === void 0 || (_catchData$data = catchData.data) === null || _catchData$data === void 0 ? void 0 : _catchData$data[codes]) || [];
+    const options = catchData?.data?.[codes] || [];
 
     // 获取 children 字段名
-    var fieldChildren = 'children';
+    let fieldChildren = 'children';
     if (fieldNames && Object.keys(fieldNames).length && fieldNames.children) {
       fieldChildren = fieldNames.children;
     }
@@ -196,14 +128,14 @@ function useEnum(codes, value, compose) {
     }
 
     // 递归查找函数：在嵌套结构中查找选项
-    var findOptionInNested = (opts, targetValue, fValue, fChildren) => {
+    const findOptionInNested = (opts, targetValue, fValue, fChildren) => {
       // 当前层级查找
-      var foundInCurrentLevel = opts.find(option => String(option[fValue]) === String(targetValue));
+      const foundInCurrentLevel = opts.find(option => String(option[fValue]) === String(targetValue));
       if (foundInCurrentLevel) {
         return foundInCurrentLevel;
       }
       // 递归查找子级
-      var foundInChildren = opts.reduce((found, option) => {
+      const foundInChildren = opts.reduce((found, option) => {
         if (found) return found;
         if (option[fChildren] && Array.isArray(option[fChildren])) {
           return findOptionInNested(option[fChildren], targetValue, fValue, fChildren);
@@ -214,13 +146,15 @@ function useEnum(codes, value, compose) {
     };
 
     // 清理选项：移除 children，保留数据源中的其他所有字段（包括 parentCode 等业务字段）
-    var cleanOption = option => {
-      var _ = option[fieldChildren],
-        restOption = _objectWithoutProperties(option, [fieldChildren].map(_toPropertyKey));
+    const cleanOption = option => {
+      const {
+        [fieldChildren]: _,
+        ...restOption
+      } = option;
       return restOption;
     };
-    var getEnumLabel = (v, composezTow) => {
-      var option = findOptionInNested(options, v, fieldValue, fieldChildren);
+    const getEnumLabel = (v, composezTow) => {
+      const option = findOptionInNested(options, v, fieldValue, fieldChildren);
       if (option) {
         return composezTow ? `${v}-${option[fieldLabel]}` : option[fieldLabel];
       }
@@ -229,16 +163,16 @@ function useEnum(codes, value, compose) {
 
     // 处理数组值的情况
     if (value && Array.isArray(value)) {
-      var labels = [];
-      var foundOptions = [];
+      const labels = [];
+      const foundOptions = [];
       value.forEach(v => {
-        var option = findOptionInNested(options, v, fieldValue, fieldChildren);
+        const option = findOptionInNested(options, v, fieldValue, fieldChildren);
         if (option) {
-          var cleanedOption = cleanOption(option);
+          const cleanedOption = cleanOption(option);
           foundOptions.push(cleanedOption);
           labels.push(compose ? `${v}-${option[fieldLabel]}` : option[fieldLabel]);
         } else {
-          var emptyOption = {
+          const emptyOption = {
             label: '',
             value: ''
           };
@@ -251,9 +185,9 @@ function useEnum(codes, value, compose) {
 
     // 处理单个值的情况（保持向后兼容）
     if (value && !Array.isArray(value) && Array.isArray(options)) {
-      var option = findOptionInNested(options, value, fieldValue, fieldChildren);
+      const option = findOptionInNested(options, value, fieldValue, fieldChildren);
       if (option) {
-        var cleanedOption = cleanOption(option);
+        const cleanedOption = cleanOption(option);
         return [compose ? `${value}-${option[fieldLabel]}` : option[fieldLabel], cleanedOption];
       }
       return [options];
@@ -261,15 +195,14 @@ function useEnum(codes, value, compose) {
     return [options, getEnumLabel];
   }
   if (Array.isArray(codes)) {
-    var _options = {};
+    const options = {};
     codes.forEach(code => {
-      var _catchData$data2;
-      var values = catchData === null || catchData === void 0 || (_catchData$data2 = catchData.data) === null || _catchData$data2 === void 0 ? void 0 : _catchData$data2[code];
+      const values = catchData?.data?.[code];
       if (Array.isArray(values) && values.length) {
-        _options[code] = values;
+        options[code] = values;
       }
     });
-    return _options;
+    return options;
   }
   return [];
 }