@zat-design/sisyphus-react 4.0.12 → 4.0.14

package/es/ProEditLabel/index.js

@@ -67,6 +67,11 @@ var ProEditLabel = _ref => {
     _Form$useForm4 = _slicedToArray(_Form$useForm3, 1),
     viewForm = _Form$useForm4[0];
   var inputRef = useRef(null);
+
+  // 类型断言：antd FormInstance 确实有这些方法（setFieldsValue, validateFields等）
+  // 使用类型断言解决 TypeScript 类型检查问题
+  var formInstance = form;
+  var viewFormInstance = viewForm;
   var onPress = e => {
     var element = e.target;
     if (e.key === 'Enter') {
@@ -82,9 +87,16 @@ var ProEditLabel = _ref => {
     if (mode === 'popup') {
       // 兼容老写法
       if (!popupProps.columns) {
-        form.setFieldValue((popupProps === null || popupProps === void 0 ? void 0 : popupProps.type) || 'Input', confirmValue);
+        if (!(popupProps !== null && popupProps !== void 0 && popupProps.type)) {
+          console.warn('ProEditLabel: popupProps.type is required when using old API (without columns)');
+          return;
+        }
+        formInstance.setFieldsValue({
+          [popupProps.type]: confirmValue
+        });
       } else {
-        form.setFieldsValue(confirmValue || {});
+        var matchedValue = matchFormValue(confirmValue, popupProps.columns);
+        formInstance.setFieldsValue(matchedValue || {});
       }
       // 弹窗同步最新value数据，解决Popconfirm空白处关闭数据不同步问题
       setState({
@@ -112,13 +124,21 @@ var ProEditLabel = _ref => {
     if (mode === 'popup' && props.value) {
       // 兼容老写法
       if (!popupProps.columns) {
-        form.setFieldValue((popupProps === null || popupProps === void 0 ? void 0 : popupProps.type) || 'Input', props.value);
+        if (!(popupProps !== null && popupProps !== void 0 && popupProps.type)) {
+          console.warn('ProEditLabel: popupProps.type is required when using old API (without columns)');
+          return;
+        }
+        formInstance.setFieldsValue({
+          [popupProps.type]: props.value
+        });
         // 文本模式初始化赋值
-        viewForm.setFieldValue((popupProps === null || popupProps === void 0 ? void 0 : popupProps.type) || 'Input', props.value);
+        viewFormInstance.setFieldsValue({
+          [popupProps.type]: props.value
+        });
       } else {
-        form.setFieldsValue(matchFormValue(props.value, popupProps.columns) || {});
+        formInstance.setFieldsValue(matchFormValue(props.value, popupProps.columns) || {});
         // 文本模式初始化赋值
-        viewForm.setFieldsValue(matchFormValue(props.value, popupProps.columns) || {});
+        viewFormInstance.setFieldsValue(matchFormValue(props.value, popupProps.columns) || {});
       }
     }
   }, [props.value, mode]);
@@ -129,9 +149,15 @@ var ProEditLabel = _ref => {
     if (mode === 'popup' && confirmValue !== props.value) {
       // 兼容老写法
       if (!popupProps.columns) {
-        viewForm.setFieldValue((popupProps === null || popupProps === void 0 ? void 0 : popupProps.type) || 'Input', confirmValue);
+        if (!(popupProps !== null && popupProps !== void 0 && popupProps.type)) {
+          console.warn('ProEditLabel: popupProps.type is required when using old API (without columns)');
+          return;
+        }
+        viewFormInstance.setFieldsValue({
+          [popupProps.type]: confirmValue
+        });
       } else {
-        viewForm.setFieldsValue(matchFormValue(confirmValue, popupProps.columns) || {});
+        viewFormInstance.setFieldsValue(matchFormValue(confirmValue, popupProps.columns) || {});
       }
     }
   }, [confirmValue, mode]);
@@ -150,53 +176,71 @@ var ProEditLabel = _ref => {
    */
   var onConfirmHandle = /*#__PURE__*/function () {
     var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
-      var res, value;
+      var res, value, fieldName;
       return _regeneratorRuntime().wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
             _context.next = 2;
-            return form.validateFields();
+            return formInstance.validateFields();
           case 2:
             res = _context.sent;
-            // 兼容老写法
-            if (!popupProps.columns) {
-              value = res[(popupProps === null || popupProps === void 0 ? void 0 : popupProps.type) || 'Input'];
+            if (popupProps.columns) {
+              _context.next = 10;
+              break;
+            }
+            if (popupProps !== null && popupProps !== void 0 && popupProps.type) {
+              _context.next = 7;
+              break;
             }
-            value = res;
-            _context.prev = 5;
+            console.warn('ProEditLabel: popupProps.type is required when using old API (without columns)');
+            return _context.abrupt("return", Promise.reject(new Error('popupProps.type is required')));
+          case 7:
+            value = res[popupProps.type];
+            _context.next = 11;
+            break;
+          case 10:
+            // 新写法：如果只有一个字段，提取单个值；否则使用整个对象
+            if (popupProps.columns.length === 1) {
+              fieldName = popupProps.columns[0].name || popupProps.columns[0].type;
+              value = res[fieldName];
+            } else {
+              value = res;
+            }
+          case 11:
+            _context.prev = 11;
             _context.t0 = onFinish;
             if (!_context.t0) {
-              _context.next = 10;
+              _context.next = 16;
               break;
             }
-            _context.next = 10;
+            _context.next = 16;
             return onFinish(value);
-          case 10:
+          case 16:
             _context.t1 = onConfirm;
             if (!_context.t1) {
-              _context.next = 14;
+              _context.next = 20;
               break;
             }
-            _context.next = 14;
+            _context.next = 20;
             return onConfirm(value);
-          case 14:
-            _context.next = 16;
+          case 20:
+            _context.next = 22;
             return setState({
               confirmValue: value,
               popValue: value
             });
-          case 16:
-            _context.next = 21;
+          case 22:
+            _context.next = 27;
             break;
-          case 18:
-            _context.prev = 18;
-            _context.t2 = _context["catch"](5);
+          case 24:
+            _context.prev = 24;
+            _context.t2 = _context["catch"](11);
             return _context.abrupt("return", Promise.reject());
-          case 21:
+          case 27:
           case "end":
             return _context.stop();
         }
-      }, _callee, null, [[5, 18]]);
+      }, _callee, null, [[11, 24]]);
     }));
     return function onConfirmHandle() {
       return _ref2.apply(this, arguments);
@@ -209,9 +253,15 @@ var ProEditLabel = _ref => {
   var onCancelHandle = () => {
     // 兼容老写法
     if (!popupProps.columns) {
-      form.setFieldValue((popupProps === null || popupProps === void 0 ? void 0 : popupProps.type) || 'Input', props.value);
+      if (!(popupProps !== null && popupProps !== void 0 && popupProps.type)) {
+        console.warn('ProEditLabel: popupProps.type is required when using old API (without columns)');
+        return;
+      }
+      formInstance.setFieldsValue({
+        [popupProps.type]: props.value
+      });
     } else {
-      form.setFieldsValue(matchFormValue(props.value, popupProps.columns) || {});
+      formInstance.setFieldsValue(matchFormValue(props.value, popupProps.columns) || {});
     }
     setState({
       popValue: props.value

package/es/ProEditLabel/propsType.d.ts

@@ -2,7 +2,7 @@ import { InputProps } from 'antd/es/input';
 import { PopconfirmProps } from 'antd/es/popconfirm';
 import { FormInstance } from 'antd/es/form';
 import React from 'react';
-import type { ProFormColumnType } from '../index';
+import type { ProFormColumnType } from '../ProForm/propsType';
 export interface ContainerType {
     /**
      * @description 触发方式
@@ -77,13 +77,13 @@ export interface PopupType {
      * @description 列配置
      * @default -
      */
-    columns?: ProFormColumnType;
+    columns?: ProFormColumnType[];
     /**
      * @description 允许扩展字段
      */
     [key: string]: any;
 }
-export interface LabelType extends InputProps {
+export interface LabelType extends Omit<InputProps, 'onChange'> {
     /**
      * @description 是否打开
      * @default false
@@ -98,7 +98,7 @@ export interface LabelType extends InputProps {
      * @description 值变化回调
      * @default -
      */
-    onChange?: (value: React.ChangeEvent<HTMLInputElement>) => void;
+    onChange?: (value: any) => void;
     /**
      * @description 是否可编辑
      * @default false

package/es/ProEnum/hooks/useEnum.js

@@ -15,6 +15,9 @@ 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();
+
 /**
  * input code output [DataOption[],getEnumLabel]
  * @param code
@@ -59,7 +62,9 @@ function useEnum(codes, value, compose) {
     _ref2$fieldNames = _ref2.fieldNames,
     fieldNames = _ref2$fieldNames === void 0 ? {} : _ref2$fieldNames,
     _ref2$clear = _ref2.clear,
-    clear = _ref2$clear === void 0 ? true : _ref2$clear;
+    clear = _ref2$clear === void 0 ? true : _ref2$clear,
+    _ref2$dics = _ref2.dics,
+    dics = _ref2$dics === void 0 ? {} : _ref2$dics;
 
   // 存在子应用自管理枚举时，需要根据其指定的cacheKey进行缓存
   if (cacheKey !== 'zat-design-pro-component-cacheKey') {
@@ -68,6 +73,12 @@ function useEnum(codes, value, compose) {
 
   // 使用 state 来存储异步加载的数据
   var _useState = useState(() => {
+      // 优先使用全局状态中的 dics 数据（如果存在）
+      if (storage === 'indexedDB' && dics && Object.keys(dics).length > 0) {
+        return {
+          data: dics
+        };
+      }
       // 初始化：对于同步存储，直接返回数据；对于 IndexedDB，返回空数据
       if (storage === 'indexedDB') {
         return {
@@ -82,27 +93,76 @@ function useEnum(codes, value, compose) {
     enumData = _useState2[0],
     setEnumData = _useState2[1];
 
+  // 监听全局状态中的 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)) {
+          return {
+            data: dics
+          };
+        }
+        return prevData;
+      });
+    }
+  }, [storage, cacheKey, dics]);
+
   // 异步加载 IndexedDB 数据
   useEffect(() => {
     if (storage === 'indexedDB') {
-      Promise.resolve(getEnumData(storage, cacheKey, baseEnumStorage)).then(data => {
-        setEnumData(prevData => {
-          if (data && JSON.stringify(data) !== JSON.stringify(prevData)) {
-            baseEnumStorage = data;
-            return data || {
-              data: {}
-            };
-          }
-          return prevData;
-        });
-      }).catch(() => {
-        // 错误已在 getEnumData 中处理，这里只设置空数据
-        setEnumData({
-          data: {}
+      // 使用模块级缓存避免重复读取
+      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: {}
+          };
         });
+        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;
+          });
+        }
       });
     }
-  }, [storage, cacheKey]);
+  }, [storage, cacheKey, enumData]);
   var catchData = storage === 'indexedDB' ? enumData : getEnumData(storage, cacheKey, baseEnumStorage);
 
   // 默认枚举缓存数据（仅同步存储）

package/es/ProEnum/propsType.d.ts

@@ -79,7 +79,12 @@ export interface ProEnumConfigType {
      * @description 字段别名
      * @default { label: 'label', value: 'value', children: 'children' }
      */
-    fieldNames?: Record<'label' | 'value' | 'children', string>;
+    fieldNames?: {
+        label?: string;
+        value?: string;
+        children?: string;
+        [key: string]: string | undefined;
+    };
     /**
      * @description 缓存的key、默认 zat-design-pro-component-cacheKey
      * @default "zat-design-pro-component-cacheKey"

package/es/ProEnum/utils/index.js

@@ -376,10 +376,12 @@ export function cacheFieldNames(fieldNames, dataSource) {
     restFieldNames = _objectWithoutProperties(fieldNames, _excluded);
   var result = {};
   Object.keys(restFieldNames).forEach(key => {
-    if (![undefined, null].includes(dataSource[restFieldNames[key]])) {
-      result[key] = dataSource[restFieldNames[key]];
-    } else {
-      result[key] = dataSource[key];
+    var sourceKey = restFieldNames[key];
+    var sourceVal = dataSource[sourceKey];
+    var fallbackVal = dataSource[key];
+    var val = ![undefined, null, ''].includes(sourceVal) ? sourceVal : fallbackVal;
+    if (![undefined, null, ''].includes(val)) {
+      result[key] = val;
     }
   });
   // 递归去对数据进行清洗

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

@@ -76,34 +76,35 @@ export declare const useFormItemProps: (column: FlexibleGroupColumnType, context
     show?: boolean | ReactiveFunction<any, boolean>;
     component?: React.ReactNode | ReactiveFunction<any, React.ReactNode>;
     children?: React.ReactNode | ((form: FormInstance<any>) => React.ReactNode);
-    id?: string;
-    prefixCls?: string;
-    className?: string;
     style?: React.CSSProperties;
+    className?: string;
     rootClassName?: string;
-    status?: "" | "warning" | "error" | "success" | "validating";
-    isView?: boolean;
-    getValueProps?: ((value: any) => Record<string, unknown>) & ((value: any) => Record<string, unknown>);
-    hidden?: boolean;
-    onReset?: () => void;
-    vertical?: boolean;
-    desensitization?: [number, number] | ReactiveFunction<any, [number, number]>;
     trim?: boolean;
     normalize?: (value: any, prevValue: any, allValues: import("@rc-component/form/lib/interface").Store) => any;
-    colon?: boolean;
+    hidden?: boolean;
+    layout?: import("antd/es/form/Form").FormItemLayout;
+    help?: React.ReactNode;
+    vertical?: boolean;
+    preserve?: boolean;
+    id?: string;
+    onReset?: () => void;
+    prefixCls?: string;
     htmlFor?: string;
+    trigger?: string;
+    status?: "" | "warning" | "error" | "success" | "validating";
+    isView?: boolean;
+    colon?: boolean;
     labelAlign?: import("antd/es/form/interface").FormLabelAlign;
     labelCol?: import("antd").ColProps;
     getValueFromEvent?: (...args: import("@rc-component/form/lib/interface").EventArgs) => 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;
@@ -111,11 +112,8 @@ 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;
-    toCSTString?: boolean;
     valueType?: import("../../../render/propsType").ProFormValueType;
     switchValue?: [any, any];
     viewRender?: (value: any, record: any, { form, index, namePath, }: {
@@ -126,7 +124,9 @@ export declare const useFormItemProps: (column: FlexibleGroupColumnType, context
     viewType?: import("../../../render/propsType").ViewType;
     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, "toCSTString" | "format" | "valueType" | "switchValue" | "dependNames" | "toISOString" | "clearNotShow" | "precision">;
+    componentProps: import("lodash").Omit<any, "format" | "valueType" | "switchValue" | "dependNames" | "toISOString" | "toCSTString" | "clearNotShow" | "precision">;
     formItemTransform: {
         getValueProps: any;
         normalize: any;

package/es/ProLayout/components/Layout/Menu/FoldMenu/index.js

@@ -108,13 +108,25 @@ var FoldMenu = props => {
               var menuItem = findMenuItemByKey(menus, String(id));
               var menuKeyPath = menuItem !== null && menuItem !== void 0 && menuItem.keyIdPath ? menuItem.keyIdPath.map(id => String(id)) : [String(id)];
 
-              // 调用用户传入的onMenuClick回调
+              // 调用用户传入的onMenuClick回调，获取返回值（是否应该激活菜单）
+              var shouldActivate = true;
               if (onMenuClick) {
-                onMenuClick({
+                var result = onMenuClick({
                   item: menuItem,
                   key: String(id),
                   keyPath: menuKeyPath
                 });
+                // 如果返回 false，表示不应该激活菜单
+                if (result === false) {
+                  shouldActivate = false;
+                }
+              }
+
+              // 只有在 shouldActivate 为 true 时才设置选中状态
+              if (shouldActivate) {
+                onSelected({
+                  selectedPath: toPath
+                });
               }
             },
             children: LiNode
@@ -128,17 +140,26 @@ var FoldMenu = props => {
               var menuItem = findMenuItemByKey(menus, String(id));
               var menuKeyPath = menuItem !== null && menuItem !== void 0 && menuItem.keyIdPath ? menuItem.keyIdPath.map(id => String(id)) : [String(id)];
 
-              // 调用用户传入的onMenuClick回调
+              // 调用用户传入的onMenuClick回调，获取返回值（是否应该激活菜单）
+              var shouldActivate = true;
               if (onMenuClick) {
-                onMenuClick({
+                var result = onMenuClick({
                   item: menuItem,
                   key: String(id),
                   keyPath: menuKeyPath
                 });
+                // 如果返回 false，表示不应该激活菜单
+                if (result === false) {
+                  shouldActivate = false;
+                }
+              }
+
+              // 只有在 shouldActivate 为 true 时才设置选中状态
+              if (shouldActivate) {
+                onSelected({
+                  selectedPath: toPath
+                });
               }
-              onSelected({
-                selectedPath: toPath
-              });
             },
             children: /*#__PURE__*/_jsx(Link, {
               to: toPath,
@@ -151,13 +172,25 @@ var FoldMenu = props => {
             var menuItem = findMenuItemByKey(menus, String(id));
             var menuKeyPath = menuItem !== null && menuItem !== void 0 && menuItem.keyIdPath ? menuItem.keyIdPath.map(id => String(id)) : [String(id)];
 
-            // 调用用户传入的onMenuClick回调
+            // 调用用户传入的onMenuClick回调，获取返回值（是否应该激活菜单）
+            var shouldActivate = true;
             if (onMenuClick) {
-              onMenuClick({
+              var result = onMenuClick({
                 item: menuItem,
                 key: String(id),
                 keyPath: menuKeyPath
               });
+              // 如果返回 false，表示不应该激活菜单
+              if (result === false) {
+                shouldActivate = false;
+              }
+            }
+
+            // 只有在 shouldActivate 为 true 时才设置选中状态
+            if (shouldActivate) {
+              onSelected({
+                selectedPath: toPath
+              });
             }
           },
           children: /*#__PURE__*/_jsx(Link, {

package/es/ProLayout/components/Layout/Menu/OpenMenu/index.js

@@ -156,26 +156,27 @@ var OpenMenu = props => {
           keyPath = _ref2.keyPath,
           key = _ref2.key,
           domEvent = _ref2.domEvent;
-        // console.log('item', item);
-        // console.log('keyPath', keyPath);
-        // console.log('key', key);
-        // console.log('domEvent', domEvent);
-
         // 查找完整的菜单项数据
         var menuItem = findMenuItemByKey(menus, key);
         var menuKeyPath = menuItem !== null && menuItem !== void 0 && menuItem.keyIdPath ? menuItem.keyIdPath.map(id => String(id)) : keyPath;
 
-        // 调用用户传入的onMenuClick回调
+        // 调用用户传入的onMenuClick回调，获取返回值（是否应该激活菜单）
+        var shouldActivate = true;
         if (onMenuClick) {
-          onMenuClick({
+          var result = onMenuClick({
             item: menuItem,
             key,
             keyPath: menuKeyPath
           });
+          // 如果返回 false，表示不应该激活菜单
+          if (result === false) {
+            shouldActivate = false;
+          }
         }
 
         // 只有最后一级菜单（叶子节点）才设置选中状态和路径
-        if (menuItem && isLeafMenuItem(menuItem)) {
+        // 并且只有在 shouldActivate 为 true 时才设置
+        if (menuItem && isLeafMenuItem(menuItem) && shouldActivate) {
           var _item$props, _item$props2;
           setState({
             selectedKeys: keyPath,

package/es/ProLayout/components/TabsManager/components/TabItem.js

@@ -22,6 +22,14 @@ var TabItemComponent = _ref => {
     e.stopPropagation();
     _onClose();
   };
+
+  // 作为 antd Tabs label 使用时，不需要阻止事件冒泡
+  // antd Tabs 会通过 onChange 处理切换，我们的 onClick 作为备用
+  var handleLabelClick = e => {
+    // 不阻止冒泡，让 antd Tabs 处理切换
+    // 但我们也调用 onClick 以确保状态同步
+    onClick();
+  };
   return /*#__PURE__*/_jsx(TabContextMenu, {
     tabId: tab.id,
     closable: tab.closable,
@@ -35,7 +43,7 @@ var TabItemComponent = _ref => {
     tabMenuClick: tabMenuClick,
     children: /*#__PURE__*/_jsx("div", {
       className: `pro-layout-tab-item ${active ? 'active' : ''} ${tab.closable ? 'closable' : ''}`,
-      onClick: onClick,
+      onClick: handleLabelClick,
       "data-testid": `tab-${tab.id}`,
       children: /*#__PURE__*/_jsxs("div", {
         className: "pro-layout-tab-content",