@zat-design/sisyphus-react 4.5.9 → 4.5.10-beta.2

package/es/ProEnum/hooks/useEnum.js

@@ -1,156 +1,91 @@
-/* eslint-disable no-redeclare */
-import { useState, useEffect, useRef } from 'react';
+import { useState, useEffect, useRef } from "react";
 import { useProConfig } from "../../ProConfigProvider";
 import { getEnumData, baseCacheKey, baseStorage } from "../utils";
-
-/**
- * input code output [DataOption[],getEnumLabel]
- * @param code
- * const [options,fn] = useEnum("code")
- */
-
-/**
- * input codes output { code1:DataOption[],code2:DataOption[] }
- * @param codes
- * const dicsMap = useEnum(["code1","code2"])
- */
-
-/**
- * input code、value output label
- * @param code
- * @param value
- * @param compose 展示 value-label
- */
-
-/**
- * input code、values array output [labels array, options array]
- * @param code
- * @param values 值数组
- * @param compose 展示 value-label
- * @returns [标签数组, 选项数组]
- */
-
-/**
- * 根据 code 从枚举缓存取出对应的 options 、以及回显
- * @param codes
- * @param value
- * @param compose
- * @returns
- */
-
 function useEnum(codes, value, compose) {
+  var _a;
   const {
     storage = baseStorage,
     cacheKey = baseCacheKey,
     fieldNames = {},
     clear = true,
     dics = {}
-  } = useProConfig('ProEnum') || {};
-
-  // 用 ref 记录哪些 cacheKey 已触发过加载，防止 enumData 变化导致重复 I/O
-  const hasLoadedRef = useRef(new Set());
-
-  // 使用 state 来存储异步加载的数据
+  } = useProConfig("ProEnum") || {};
+  const hasLoadedRef = useRef(/* @__PURE__ */ new Set());
   const [enumData, setEnumData] = useState(() => {
-    // 优先使用全局状态中的 dics 数据（如果存在）
-    if (storage === 'indexedDB' && dics && Object.keys(dics).length > 0) {
-      return {
-        data: dics
-      };
+    if (storage === "indexedDB" && dics && Object.keys(dics).length > 0) {
+      return { data: dics };
     }
-    // 初始化：对于同步存储，直接返回数据；对于 IndexedDB，返回空数据
-    if (storage === 'indexedDB') {
-      return {
-        data: {}
-      };
+    if (storage === "indexedDB") {
+      return { data: {} };
     }
-    return getEnumData(storage, cacheKey) || {
-      data: {}
-    };
+    return getEnumData(storage, cacheKey) || { data: {} };
   });
-
-  // 监听全局状态中的 dics 变化，优先使用 dics 数据
   useEffect(() => {
-    if (storage === 'indexedDB' && dics && Object.keys(dics).length > 0) {
-      setEnumData(prevData => {
-        if (JSON.stringify(dics) !== JSON.stringify(prevData?.data)) {
-          return {
-            data: dics
-          };
+    if (storage === "indexedDB" && dics && Object.keys(dics).length > 0) {
+      setEnumData((prevData) => {
+        if (JSON.stringify(dics) !== JSON.stringify(prevData == null ? void 0 : prevData.data)) {
+          return { data: dics };
         }
         return prevData;
       });
     }
   }, [storage, cacheKey, dics]);
-
-  // 异步加载 IndexedDB 数据（每个 cacheKey 只触发一次，由 hasLoadedRef 防重）
   useEffect(() => {
-    if (storage === 'indexedDB' && !hasLoadedRef.current.has(cacheKey)) {
+    if (storage === "indexedDB" && !hasLoadedRef.current.has(cacheKey)) {
       hasLoadedRef.current.add(cacheKey);
-      Promise.resolve(getEnumData(storage, cacheKey)).then(data => {
-        setEnumData(prevData => {
+      Promise.resolve(getEnumData(storage, cacheKey)).then((data) => {
+        setEnumData((prevData) => {
           if (data && JSON.stringify(data) !== JSON.stringify(prevData)) {
-            return data || {
-              data: {}
-            };
+            return data || { data: {} };
           }
           return prevData;
         });
       }).catch(() => {
-        // 错误已在 getEnumData 中处理
       });
     }
   }, [storage, cacheKey]);
-  const catchData = storage === 'indexedDB' ? enumData : getEnumData(storage, cacheKey);
+  const catchData = storage === "indexedDB" ? enumData : getEnumData(storage, cacheKey);
   if (!codes) {
     return catchData;
   }
-  let fieldLabel = '';
-  let fieldValue = '';
+  let fieldLabel = "";
+  let fieldValue = "";
   if (fieldNames && Object.keys(fieldNames).length) {
-    fieldLabel = fieldNames?.label;
-    fieldValue = fieldNames?.value;
+    fieldLabel = fieldNames == null ? void 0 : fieldNames.label;
+    fieldValue = fieldNames == null ? void 0 : fieldNames.value;
   }
   if (clear) {
-    fieldLabel = 'label';
-    fieldValue = 'value';
+    fieldLabel = "label";
+    fieldValue = "value";
   }
-  if (typeof codes === 'string') {
-    const options = catchData?.data?.[codes] || [];
-
-    // 获取 children 字段名
-    let fieldChildren = 'children';
+  if (typeof codes === "string") {
+    const options = ((_a = catchData == null ? void 0 : catchData.data) == null ? void 0 : _a[codes]) || [];
+    let fieldChildren = "children";
     if (fieldNames && Object.keys(fieldNames).length && fieldNames.children) {
       fieldChildren = fieldNames.children;
     }
     if (clear) {
-      fieldChildren = 'children';
+      fieldChildren = "children";
     }
-
-    // 递归查找函数：在嵌套结构中查找选项
     const findOptionInNested = (opts, targetValue, fValue, fChildren) => {
-      // 当前层级查找
-      const foundInCurrentLevel = opts.find(option => String(option[fValue]) === String(targetValue));
+      const foundInCurrentLevel = opts.find(
+        (option) => String(option[fValue]) === String(targetValue)
+      );
       if (foundInCurrentLevel) {
         return foundInCurrentLevel;
       }
-      // 递归查找子级
       const foundInChildren = opts.reduce((found, option) => {
-        if (found) return found;
+        if (found)
+          return found;
         if (option[fChildren] && Array.isArray(option[fChildren])) {
           return findOptionInNested(option[fChildren], targetValue, fValue, fChildren);
         }
-        return undefined;
-      }, undefined);
+        return void 0;
+      }, void 0);
       return foundInChildren;
     };
-
-    // 清理选项：移除 children，保留数据源中的其他所有字段（包括 parentCode 等业务字段）
-    const cleanOption = option => {
-      const {
-        [fieldChildren]: _,
-        ...restOption
-      } = option;
+    const cleanOption = (option) => {
+      const { [fieldChildren]: _, ...restOption } = option;
       return restOption;
     };
     const getEnumLabel = (v, composezTow) => {
@@ -158,32 +93,25 @@ function useEnum(codes, value, compose) {
       if (option) {
         return composezTow ? `${v}-${option[fieldLabel]}` : option[fieldLabel];
       }
-      return undefined;
+      return void 0;
     };
-
-    // 处理数组值的情况
     if (value && Array.isArray(value)) {
       const labels = [];
       const foundOptions = [];
-      value.forEach(v => {
+      value.forEach((v) => {
         const option = findOptionInNested(options, v, fieldValue, fieldChildren);
         if (option) {
           const cleanedOption = cleanOption(option);
           foundOptions.push(cleanedOption);
           labels.push(compose ? `${v}-${option[fieldLabel]}` : option[fieldLabel]);
         } else {
-          const emptyOption = {
-            label: '',
-            value: ''
-          };
+          const emptyOption = { label: "", value: "" };
           foundOptions.push(emptyOption);
-          labels.push('');
+          labels.push("");
         }
       });
       return [labels, foundOptions];
     }
-
-    // 处理单个值的情况（保持向后兼容）
     if (value && !Array.isArray(value) && Array.isArray(options)) {
       const option = findOptionInNested(options, value, fieldValue, fieldChildren);
       if (option) {
@@ -196,12 +124,16 @@ function useEnum(codes, value, compose) {
   }
   if (Array.isArray(codes)) {
     const options = {};
-    codes.forEach(code => {
-      const values = catchData?.data?.[code];
+    codes.forEach((code) => {
+      var _a2;
+      const values = (_a2 = catchData == null ? void 0 : catchData.data) == null ? void 0 : _a2[code];
       options[code] = Array.isArray(values) ? values : [];
     });
     return options;
   }
   return [];
 }
-export default useEnum;
+var useEnum_default = useEnum;
+export {
+  useEnum_default as default
+};