@zat-design/sisyphus-react 4.3.0-beta.8 → 4.3.0-beta.9

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

@@ -75,58 +75,58 @@ 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>;
-    status?: "" | "success" | "warning" | "error" | "validating";
+    id?: string;
     className?: string;
+    children?: React.ReactNode | ((form: FormInstance<any>) => React.ReactNode);
     hidden?: boolean;
-    id?: string;
     style?: React.CSSProperties;
-    children?: React.ReactNode | ((form: FormInstance<any>) => React.ReactNode);
     onReset?: () => void;
     prefixCls?: string;
     rootClassName?: string;
-    colon?: boolean;
+    layout?: import("antd/es/form/Form").FormItemLayout;
+    help?: React.ReactNode;
+    vertical?: boolean;
+    preserve?: boolean;
+    trim?: boolean;
+    normalize?: (value: any, prevValue: any, allValues: import("@rc-component/form/lib/interface").Store) => any;
     htmlFor?: string;
+    trigger?: string;
+    isView?: boolean;
+    status?: "" | "warning" | "error" | "success" | "validating";
+    getValueProps?: ((value: any) => Record<string, unknown>) & ((value: any) => Record<string, unknown>);
+    desensitization?: [number, number] | ReactiveFunction<any, [number, number]>;
+    validateTrigger?: string | false | string[];
+    clearNotShow?: boolean;
     labelAlign?: import("antd/es/form/interface").FormLabelAlign;
+    colon?: boolean;
     labelCol?: import("antd").ColProps;
-    vertical?: boolean;
+    wrapperCol?: import("antd").ColProps;
     getValueFromEvent?: (...args: import("@rc-component/form/lib/interface").EventArgs) => any;
-    normalize?: (value: any, prevValue: any, allValues: import("@rc-component/form/lib/interface").Store) => 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;
     hasFeedback?: boolean | {
         icons: import("antd/es/form/FormItem").FeedbackIcons;
     };
-    validateStatus?: "" | "success" | "warning" | "error" | "validating";
-    layout?: import("antd/es/form/Form").FormItemLayout;
-    wrapperCol?: import("antd").ColProps;
-    help?: React.ReactNode;
+    validateStatus?: "" | "warning" | "error" | "success" | "validating";
     fieldId?: string;
     valueType?: import("../../../render/propsType").ProFormValueType;
+    switchValue?: [any, any];
     viewRender?: (value: any, record: any, { form, index, namePath, }: {
         [key: string]: any;
         form: FormInstance<any>;
         index?: number;
     }) => string | React.ReactElement<any, any>;
-    desensitization?: [number, number] | ReactiveFunction<any, [number, number]>;
-    isView?: boolean;
-    switchValue?: [any, any];
     viewType?: import("../../../render/propsType").ViewType;
-    trim?: boolean;
     upperCase?: boolean;
     toISOString?: boolean;
     toCSTString?: boolean;
-    clearNotShow?: boolean;
     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, "valueType" | "precision" | "format" | "switchValue" | "dependNames" | "toISOString" | "toCSTString" | "clearNotShow">;
+    componentProps: import("lodash").Omit<any, "format" | "clearNotShow" | "valueType" | "switchValue" | "dependNames" | "toISOString" | "toCSTString" | "precision">;
     formItemTransform: {
         getValueProps: any;
         normalize: any;

package/es/ProLayout/components/TabsManager/hooks/useTabsState.js

@@ -143,49 +143,41 @@ export const useTabsState = options => {
       forceNew = false
     } = options || {};
     setState(prevState => {
-      // 非叶子节点默认不入签，仅根节点特例可入签
-      if (!canOpenAsTab(menuItem)) {
-        return prevState;
-      }
-
-      // 检查是否需要外部跳转
+      if (!canOpenAsTab(menuItem)) return prevState;
       if (shouldOpenExternal(menuItem)) {
         handleExternalOpen(menuItem);
         return prevState;
       }
-      const existingIds = prevState.tabsList.map(tab => tab.id);
-      const tabId = generateTabId(menuItem, existingIds);
 
-      // 如果 forceNew = false（默认），检查是否已存在相同的标签页
-      if (!forceNew) {
-        const menuRoute = getMenuRoute(menuItem);
-        const existingTab = prevState.tabsList.find(tab => tab.menuItem?.code === menuItem.code || tab.url === menuRoute);
-        if (existingTab) {
-          // 如果已存在，直接切换到该标签页
-          const newState = {
-            ...prevState,
-            activeKey: existingTab.id,
-            activeTabInfo: existingTab,
-            activeComponent: existingTab.menuItem?.code || existingTab.id
-          };
-          return newState;
-        }
+      // 非强制新建时，查找已存在的标签页并切换
+      const menuRoute = getMenuRoute(menuItem);
+      const existingTab = !forceNew ? prevState.tabsList.find(tab => tab.menuItem?.code === menuItem.code || tab.url === menuRoute) : undefined;
+      if (existingTab) {
+        // 若来源菜单明确标记 closable: false 而已有 tab 未继承，则修正
+        const correctedTab = menuItem.closable === false && existingTab.closable !== false ? {
+          ...existingTab,
+          closable: false
+        } : existingTab;
+        const updatedTabsList = correctedTab !== existingTab ? prevState.tabsList.map(t => t.id === existingTab.id ? correctedTab : t) : prevState.tabsList;
+        return {
+          ...prevState,
+          tabsList: updatedTabsList,
+          activeKey: existingTab.id,
+          activeTabInfo: correctedTab,
+          activeComponent: existingTab.menuItem?.code || existingTab.id
+        };
       }
-
-      // 检查是否超出限制
       if (checkTabLimit(prevState.tabsList, finalConfig.max)) {
-        // 达到最大值时，不添加新标签页，显示提示信息
-        const messageText = formatMessage(locale.ProLayout.tabMaxLimitMessage, {
+        message.info(formatMessage(locale.ProLayout.tabMaxLimitMessage, {
           max: finalConfig.max
-        });
-        message.info(messageText);
+        }));
         return prevState;
       }
-
-      // 创建新标签页
+      const existingIds = prevState.tabsList.map(tab => tab.id);
+      const tabId = generateTabId(menuItem, existingIds);
       const newTab = createTabFromMenu(menuItem, prevState.newTabIndex);
       newTab.id = tabId;
-      const newState = {
+      return {
         ...prevState,
         tabsList: [...prevState.tabsList, newTab],
         activeKey: tabId,
@@ -193,7 +185,6 @@ export const useTabsState = options => {
         newTabIndex: prevState.newTabIndex + 1,
         activeComponent: menuItem.code || tabId
       };
-      return newState;
     });
   }, [finalConfig]);
 
@@ -319,17 +310,18 @@ export const useTabsState = options => {
       shouldSkipSaveRef.current = true;
       clearCache();
 
-      // 如果关闭后没有标签页了，直接调用 onTabChange
-      if (newTabs.length === 0 && finalConfig.onTabChange) {
+      // 直接调用 onTabChange（useEffect 因 shouldSkipSaveRef 会跳过）
+      if (finalConfig.onTabChange) {
+        const firstTab = newTabs.length > 0 ? newTabs[0] : undefined;
         setTimeout(() => {
-          finalConfig.onTabChange('', undefined, []);
+          finalConfig.onTabChange(firstTab?.id ?? '', firstTab, newTabs);
         }, 0);
       }
       return {
         ...prevState,
         tabsList: newTabs,
         activeKey: newActiveKey,
-        activeTabInfo: undefined,
+        activeTabInfo: newTabs.length > 0 ? newTabs[0] : undefined,
         activeComponent: newActiveComponent
       };
     });
@@ -365,40 +357,23 @@ export const useTabsState = options => {
   // 监听 URL 变化并同步 Tabs (仅在初始化和 location 变化时)
   // 放在最后以确保可以使用 addTab 和 switchTab
   useEffect(() => {
-    // 确保数据源存在
     if (!dataSource || !('menus' in dataSource)) return;
     const currentPath = window.location.pathname;
-
-    // 如果当前没有 activeKey 或者 activeKey 对应的 URL 与当前 URL 不一致
     const activeTab = state.tabsList.find(tab => tab.id === state.activeKey);
-
-    // 如果当前已经在正确的 Tab 上，无需处理
     if (activeTab && activeTab.url === currentPath) return;
-
-    // 在菜单中查找当前 URL 对应的菜单项
     const flatMenus = flattenMenuData(dataSource.menus || []);
     const targetMenu = flatMenus.find(item => getMenuRoute(item) === currentPath);
-    if (targetMenu) {
-      // 非叶子节点默认不入签，仅根节点特例可入签
-      if (!canOpenAsTab(targetMenu)) {
-        return;
-      }
-
-      // 检查是否已在 Tabs 中
-      const existingTab = state.tabsList.find(tab => tab.menuItem?.code === targetMenu.code || tab.url === getMenuRoute(targetMenu));
-      if (existingTab) {
-        // 如果已存在，切换到该 Tab
-        if (state.activeKey !== existingTab.id) {
-          switchTab(existingTab.id);
-        }
-      } else {
-        // 如果不存在，添加新 Tab
-        addTab(targetMenu);
-      }
+    if (!targetMenu || !canOpenAsTab(targetMenu)) return;
+    const existingTab = state.tabsList.find(tab => tab.menuItem?.code === targetMenu.code || tab.url === getMenuRoute(targetMenu));
+    if (existingTab) {
+      if (state.activeKey !== existingTab.id) switchTab(existingTab.id);
+      return;
     }
+    addTab(targetMenu);
   }, [dataSource, state.tabsList, state.activeKey, addTab, switchTab]);
   return {
     state,
+    isInitialized,
     addTab,
     canAddTab,
     removeTab,

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

@@ -1,6 +1,7 @@
-import { useCallback, useMemo, forwardRef, useImperativeHandle, useState, useEffect } from 'react';
+import { useCallback, useMemo, forwardRef, useImperativeHandle, useState, useEffect, useRef } from 'react';
 import { createPortal } from 'react-dom';
 import { useTabsState } from "./hooks/useTabsState";
+import { flattenMenuData } from "./utils";
 import { TabItemComponent } from "./components/TabItem";
 import { TabsHeader } from "./components/TabsHeader";
 import { TabsContext } from "./components/TabsContext";
@@ -19,6 +20,7 @@ const TabsManager = /*#__PURE__*/forwardRef(({
 }, ref) => {
   const {
     state,
+    isInitialized,
     addTab,
     canAddTab,
     removeTab,
@@ -52,6 +54,29 @@ const TabsManager = /*#__PURE__*/forwardRef(({
     onTabsChange?.(state.tabsList.length > 0);
   }, [state.tabsList.length, onTabsChange]);
 
+  // 处理声明式固定标签页：config.fixed 中的 code 在初始化完成后自动添加，强制 closable=false
+  // 用 ref 持有 addTab，避免 addTab 引用变化引起无限循环
+  const addTabRef = useRef(addTab);
+  addTabRef.current = addTab;
+  useEffect(() => {
+    if (!isInitialized || !config.fixed || config.fixed.length === 0) return;
+    const sourceMenus = Array.isArray(dataSource?.menus) ? flattenMenuData(dataSource.menus) : [];
+    config.fixed.forEach(code => {
+      const matchedMenu = sourceMenus.find(item => item.code === code);
+      const menuItem = matchedMenu ? {
+        ...matchedMenu,
+        closable: false
+      } : {
+        id: Date.now(),
+        code,
+        name: code,
+        url: `/${code}`,
+        closable: false
+      };
+      addTabRef.current(menuItem);
+    });
+  }, [isInitialized, config.fixed, dataSource]);
+
   // 处理菜单点击 - 拦截原有的菜单点击逻辑
   const handleMenuClick = useCallback(params => {
     if (params.item) {
@@ -68,7 +93,14 @@ const TabsManager = /*#__PURE__*/forwardRef(({
         name,
         extra
       } = params;
-      const menuItem = {
+      const sourceMenus = Array.isArray(dataSource?.menus) ? flattenMenuData(dataSource.menus) : [];
+      const matchedMenu = sourceMenus.find(item => item.code === code);
+      const menuItem = matchedMenu ? {
+        ...matchedMenu,
+        // 允许外部覆盖展示名称和附加数据，但保留菜单原始 closable/url 等配置
+        name: name || matchedMenu.name,
+        extra: extra ?? matchedMenu.extra
+      } : {
         id: Date.now(),
         code,
         name,
@@ -83,7 +115,7 @@ const TabsManager = /*#__PURE__*/forwardRef(({
       activeTabInfo: state.tabsList.find(tab => tab.id === state.activeKey),
       activeComponent: state.activeComponent
     })
-  }), [addTab, removeTab, state.tabsList, state.activeKey, state.activeComponent]);
+  }), [addTab, removeTab, state.tabsList, state.activeKey, state.activeComponent, dataSource]);
   const handleTabChange = useCallback(activeKey => {
     switchTab(activeKey);
   }, [switchTab]);
@@ -164,8 +196,9 @@ const TabsManager = /*#__PURE__*/forwardRef(({
   }) : null;
   useImperativeHandle(ref, () => ({
     handleMenuClick,
-    canAddTab
-  }), [handleMenuClick, canAddTab]);
+    canAddTab,
+    getTabInfo: tabsInstance.getTabInfo
+  }), [handleMenuClick, canAddTab, tabsInstance]);
   return /*#__PURE__*/_jsxs(TabsContext.Provider, {
     value: tabsInstance,
     children: [tabsBarContainer ? /*#__PURE__*/createPortal(tabsHeaderNode, tabsBarContainer) : tabsHeaderNode, /*#__PURE__*/_jsx("div", {

package/es/ProLayout/components/TabsManager/propTypes.d.ts

@@ -51,6 +51,8 @@ export interface UseTabsStateOptions {
 export interface UseTabsStateReturn {
     /** 当前状态 */
     state: TabsState;
+    /** 缓存是否已恢复完成 */
+    isInitialized: boolean;
     /** 添加标签页 */
     addTab: (menuItem: MenusType, options?: AddTabOptions) => void;
     /** 检查是否可以添加标签页 */

package/es/ProLayout/components/TabsManager/utils/index.d.ts

@@ -50,6 +50,6 @@ export declare const isLeafMenuItem: (menuItem: MenusType) => boolean;
 export declare const isRootMenuItem: (menuItem: MenusType) => boolean;
 /**
  * 判断菜单项是否可以在 Tabs 模式下打开
- * 规则：叶子节点可打开；有 children 时仅根节点可打开
+ * 规则：只有叶子节点（无 children）才可打开
  */
 export declare const canOpenAsTab: (menuItem: MenusType) => boolean;

package/es/ProLayout/components/TabsManager/utils/index.js

@@ -11,7 +11,7 @@ export const getMenuRoute = menuItem => {
  */
 export const createTabFromMenu = (menuItem, index = 0) => {
   const route = getMenuRoute(menuItem);
-  return {
+  const result = {
     id: String(menuItem.id || menuItem.code || menuItem.url || index),
     code: menuItem.code,
     name: menuItem.name,
@@ -21,6 +21,7 @@ export const createTabFromMenu = (menuItem, index = 0) => {
     menuItem,
     icon: menuItem.icon || menuItem.imgUrl
   };
+  return result;
 };
 
 /**
@@ -134,13 +135,10 @@ export const isRootMenuItem = menuItem => {
 
 /**
  * 判断菜单项是否可以在 Tabs 模式下打开
- * 规则：叶子节点可打开；有 children 时仅根节点可打开
+ * 规则：只有叶子节点（无 children）才可打开
  */
 export const canOpenAsTab = menuItem => {
   if (!menuItem) return false;
   if (!(menuItem.url || menuItem.redirectUrl)) return false;
-  if (isLeafMenuItem(menuItem)) {
-    return true;
-  }
-  return isRootMenuItem(menuItem);
+  return isLeafMenuItem(menuItem);
 };

package/es/ProLayout/index.js

@@ -82,9 +82,22 @@ const ProLayout = props => {
       menus: menuData
     });
   }, [dataSource]);
-  const menuDataSource = useMemo(() => Array.isArray(menus) ? {
-    menus
-  } : menus, [menus]);
+  const menuDataSource = useMemo(() => {
+    // menus 已通过 useDeepCompareEffect 填充，直接使用
+    if (Array.isArray(menus) && menus.length > 0) {
+      return {
+        menus
+      };
+    }
+    // menus state 尚未填充（初始为 []），直接用 dataSource 原始 menus，
+    // 确保 tabsInstance 第一次创建时就能查到完整菜单数据（含 closable 等属性）
+    if (!Array.isArray(dataSource) && Array.isArray(dataSource?.menus)) {
+      return dataSource;
+    }
+    return {
+      menus: menus || []
+    };
+  }, [menus, dataSource]);
   const enhancedTabsConfig = useMemo(() => {
     if (!isTabsLayout || !tabs) {
       return tabs;
@@ -138,9 +151,9 @@ const ProLayout = props => {
       return true;
     }
 
-    // 根节点可入签；中间层级（有 children）不激活；叶子入签
+    // 只有叶子节点（无 children）可入签；有 children 的节点不激活
     if (!canOpenAsTab(params.item)) {
-      return true;
+      return false;
     }
 
     // 可入签节点：检查是否可以添加标签页（检查 max 限制、_blank 等）

package/es/ProLayout/propTypes.d.ts

@@ -429,6 +429,11 @@ export interface TabsConfig {
         tab: TabItem;
         tabs: TabItem[];
     }) => void;
+    /**
+     * @description 声明式固定标签页，传入菜单 code 数组，这些 tab 会在初始化时自动添加且不可关闭
+     * @example fixed: ['Workspace', 'PolicyInput']
+     */
+    fixed?: string[];
 }
 export type ProLayoutMode = 'normal' | 'tabs';
 export interface ProLayoutTabsProps extends ProLayoutBaseProps {

package/package.json

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