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

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

@@ -13,8 +13,9 @@ import {
   flattenMenuData,
   canOpenAsTab,
   getMenuRoute,
-  hasRelationKey,
   findExistingTab,
+  getUrlSyncTabIdentity,
+  getComparableTabUrl,
   normalizeTabUrl,
   isSafeExternalUrl,
   isSafeHttpUrl,
@@ -30,6 +31,7 @@ const useTabsState = (options) => {
   const finalConfig = { ...DEFAULT_TABS_CONFIG, ...config };
   const urlSyncEnabled = finalConfig.urlSync === true || typeof finalConfig.urlSync === "object" && finalConfig.urlSync !== null;
   const urlSyncIdentity = typeof finalConfig.urlSync === "object" && finalConfig.urlSync !== null ? finalConfig.urlSync.identity || "url" : "url";
+  const urlSyncBasename = typeof finalConfig.urlSync === "object" && finalConfig.urlSync !== null ? finalConfig.urlSync.basename : void 0;
   const [state, setState] = useState(() => ({
     tabsList: [],
     activeKey: "",
@@ -67,15 +69,20 @@ const useTabsState = (options) => {
         const retainedTabByIdentity = /* @__PURE__ */ new Map();
         const retainedIdByOriginalId = /* @__PURE__ */ new Map();
         restoredState.tabsList.forEach((tab) => {
-          var _a2;
           const normalizedUrl = normalizeTabUrl(tab.url);
           if (!normalizedUrl)
             return;
-          const relationKey = tab.relationKey ?? ((_a2 = tab.menuItem) == null ? void 0 : _a2.relationKey);
-          const identity = urlSyncIdentity === "relationKey" && hasRelationKey(relationKey) ? `relationKey:${typeof relationKey}:${String(relationKey)}` : `url:${normalizedUrl}`;
+          const comparableUrl = getComparableTabUrl(normalizedUrl, urlSyncBasename);
+          if (!comparableUrl)
+            return;
+          const identity = getUrlSyncTabIdentity(
+            { ...tab, url: normalizedUrl },
+            { identity: urlSyncIdentity, basename: urlSyncBasename }
+          );
+          if (!identity)
+            return;
           const retainedTab = retainedTabByIdentity.get(identity);
           if (retainedTab) {
-            retainedTabByIdentity.set(identity, { ...retainedTab, url: normalizedUrl });
             retainedIdByOriginalId.set(tab.id, retainedTab.id);
             return;
           }
@@ -93,7 +100,7 @@ const useTabsState = (options) => {
       setState(restoredState);
     }
     setIsInitialized(true);
-  }, [restoreFromCache, urlSyncEnabled, urlSyncIdentity]);
+  }, [restoreFromCache, urlSyncEnabled, urlSyncIdentity, urlSyncBasename]);
   const lastActiveKeyRef = useRef("");
   const shouldSkipSaveRef = useRef(false);
   const initialTabsAppliedRef = useRef(false);
@@ -132,7 +139,8 @@ const useTabsState = (options) => {
       if (urlSyncEnabled || !forceNew) {
         const existingTab = findExistingTab(state.tabsList, menuItem, {
           urlSync: urlSyncEnabled,
-          identity: urlSyncIdentity
+          identity: urlSyncIdentity,
+          basename: urlSyncBasename
         });
         if (existingTab) {
           return true;
@@ -143,7 +151,7 @@ const useTabsState = (options) => {
       }
       return true;
     },
-    [state.tabsList, finalConfig, urlSyncEnabled, urlSyncIdentity]
+    [state.tabsList, finalConfig, urlSyncEnabled, urlSyncIdentity, urlSyncBasename]
   );
   const addTab = useCallback(
     (menuItem, options2) => {
@@ -170,16 +178,12 @@ const useTabsState = (options) => {
         const resolvedMenuItem = normalizedUrl ? { ...menuItem, url: normalizedUrl, redirectUrl: void 0 } : menuItem;
         const existingTab = urlSyncEnabled || !forceNew ? findExistingTab(prevState.tabsList, resolvedMenuItem, {
           urlSync: urlSyncEnabled,
-          identity: urlSyncIdentity
+          identity: urlSyncIdentity,
+          basename: urlSyncBasename
         }) : void 0;
         if (existingTab) {
           const shouldFixClosable = resolvedMenuItem.closable === false && existingTab.closable !== false;
-          const shouldUpdateUrl = urlSyncIdentity === "relationKey" && normalizedUrl !== void 0 && existingTab.url !== normalizedUrl;
-          const correctedTab = shouldFixClosable || shouldUpdateUrl ? {
-            ...existingTab,
-            ...shouldFixClosable ? { closable: false } : {},
-            ...shouldUpdateUrl ? { url: normalizedUrl } : {}
-          } : existingTab;
+          const correctedTab = shouldFixClosable ? { ...existingTab, closable: false } : existingTab;
           const updatedTabsList = correctedTab !== existingTab ? prevState.tabsList.map((t) => t.id === existingTab.id ? correctedTab : t) : prevState.tabsList;
           return {
             ...prevState,
@@ -216,7 +220,7 @@ const useTabsState = (options) => {
         };
       });
     },
-    [finalConfig, urlSyncEnabled, urlSyncIdentity]
+    [finalConfig, urlSyncEnabled, urlSyncIdentity, urlSyncBasename]
   );
   useEffect(() => {
     const initialTabs = finalConfig.initialTabs;
@@ -250,7 +254,10 @@ const useTabsState = (options) => {
         ...updates.icon !== void 0 && { icon: updates.icon },
         ...updates.extra !== void 0 && { extra: updates.extra },
         ...updates.closable !== void 0 && { closable: updates.closable },
-        ...updates.pinned !== void 0 && { pinned: updates.pinned }
+        ...updates.pinned !== void 0 && { pinned: updates.pinned },
+        ...updates.menuCodeSource !== void 0 && {
+          menuCodeSource: updates.menuCodeSource
+        }
       } : target.menuItem;
       const nextTab = {
         ...target,
@@ -258,6 +265,9 @@ const useTabsState = (options) => {
         ...updates.icon !== void 0 && { icon: updates.icon },
         ...updates.closable !== void 0 && { closable: updates.closable },
         ...updates.pinned !== void 0 && { pinned: updates.pinned },
+        ...updates.menuCodeSource !== void 0 && {
+          menuCodeSource: updates.menuCodeSource
+        },
         menuItem: nextMenuItem
       };
       const newTabsList = [...prevState.tabsList];

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

@@ -3,6 +3,9 @@ import * as ReactRouterDom from "react-router-dom";
 import {
   canOpenAsTab,
   flattenMenuData,
+  findExistingTab,
+  getBrowserTabUrl,
+  getComparableTabUrl,
   getCurrentTabUrl,
   getMenuRoute,
   getTabUrlPathname,
@@ -92,6 +95,8 @@ const useTabsUrlSync = ({
   const navigator = navigationContext == null ? void 0 : navigationContext.navigator;
   const enabled = config.urlSync === true || typeof config.urlSync === "object" && config.urlSync !== null;
   const historyMode = typeof config.urlSync === "object" ? config.urlSync.history || "replace" : "replace";
+  const basename = typeof config.urlSync === "object" ? config.urlSync.basename : void 0;
+  const identity = typeof config.urlSync === "object" ? config.urlSync.identity : void 0;
   const bootstrappedRef = useRef(false);
   const writingUrlRef = useRef(false);
   const preserveUrlInteractionRef = useRef(null);
@@ -156,11 +161,14 @@ const useTabsUrlSync = ({
     if (!enabled || !isInitialized || typeof window === "undefined")
       return;
     const currentUrl = normalizeTabUrl(locationChange.url);
-    if (!currentUrl)
+    const comparableCurrentUrl = getComparableTabUrl(currentUrl, basename);
+    if (!currentUrl || !comparableCurrentUrl)
       return;
     if (handledLocationSequenceRef.current === locationChange.sequence)
       return;
-    const exactTab = state.tabsList.find((tab) => normalizeTabUrl(tab.url) === currentUrl);
+    const exactTab = state.tabsList.find(
+      (tab) => getComparableTabUrl(tab.url, basename) === comparableCurrentUrl
+    );
     if (exactTab) {
       handledLocationSequenceRef.current = locationChange.sequence;
       bootstrappedRef.current = true;
@@ -170,16 +178,16 @@ const useTabsUrlSync = ({
       }
       return;
     }
-    const currentPathname = getTabUrlPathname(currentUrl);
+    const currentPathname = getTabUrlPathname(comparableCurrentUrl);
     const sourceMenus = getSourceMenus(dataSource);
     const activeTab = state.tabsList.find((tab) => tab.id === state.activeKey);
     const activeCode = ((_a = activeTab == null ? void 0 : activeTab.menuItem) == null ? void 0 : _a.code) || (activeTab == null ? void 0 : activeTab.code);
     const activeSourceMenu = activeCode ? sourceMenus.find((item) => item.code === activeCode) : void 0;
     const activeMenuItem = activeSourceMenu || (activeTab == null ? void 0 : activeTab.menuItem);
-    const activeBasePathname = activeMenuItem ? getTabUrlPathname(getMenuRoute(activeMenuItem)) : getTabUrlPathname(activeTab == null ? void 0 : activeTab.url);
+    const activeBasePathname = activeMenuItem ? getTabUrlPathname(getComparableTabUrl(getMenuRoute(activeMenuItem), basename)) : getTabUrlPathname(getComparableTabUrl(activeTab == null ? void 0 : activeTab.url, basename));
     const targetMenu = (_b = sourceMenus.map((item) => ({
       item,
-      pathname: getTabUrlPathname(getMenuRoute(item))
+      pathname: getTabUrlPathname(getComparableTabUrl(getMenuRoute(item), basename))
     })).filter(
       (entry) => !!entry.pathname && isSameOrNestedPath(entry.pathname, currentPathname)
     ).sort((left, right) => right.pathname.length - left.pathname.length)[0]) == null ? void 0 : _b.item;
@@ -195,7 +203,21 @@ const useTabsUrlSync = ({
       handledLocationSequenceRef.current = locationChange.sequence;
       bootstrappedRef.current = true;
       preserveUrlInteractionRef.current = interactionSequence;
-      addTab({ ...targetMenu, url: currentUrl, redirectUrl: void 0 });
+      const resolvedTargetMenu = { ...targetMenu, url: currentUrl, redirectUrl: void 0 };
+      const existingTargetTab = findExistingTab(state.tabsList, resolvedTargetMenu, {
+        urlSync: true,
+        identity,
+        basename
+      });
+      if (existingTargetTab) {
+        if (getComparableTabUrl(existingTargetTab.url, basename) !== comparableCurrentUrl) {
+          updateTabUrl(existingTargetTab.id, currentUrl);
+        }
+        if (state.activeKey !== existingTargetTab.id)
+          switchTab(existingTargetTab.id);
+        return;
+      }
+      addTab(resolvedTargetMenu);
       return;
     }
     if (!bootstrappedRef.current) {
@@ -223,7 +245,9 @@ const useTabsUrlSync = ({
     addTab,
     switchTab,
     updateTabUrl,
-    interactionSequence
+    interactionSequence,
+    basename,
+    identity
   ]);
   useEffect(() => {
     if (!enabled || !isInitialized || !bootstrappedRef.current || typeof window === "undefined") {
@@ -231,13 +255,14 @@ const useTabsUrlSync = ({
     }
     const activeTab = state.tabsList.find((tab) => tab.id === state.activeKey);
     const targetUrl = normalizeTabUrl(activeTab == null ? void 0 : activeTab.url);
+    const browserTargetUrl = getBrowserTabUrl(targetUrl, basename);
     const commitActiveTab = () => {
       committedActiveKeyRef.current = state.activeKey;
       committedTabIdsRef.current = new Set(state.tabsList.map((tab) => tab.id));
     };
     if (preserveUrlInteractionRef.current !== null) {
       if (preserveUrlInteractionRef.current === interactionSequence) {
-        if (targetUrl === getCurrentTabUrl()) {
+        if (browserTargetUrl === getCurrentTabUrl()) {
           preserveUrlInteractionRef.current = null;
         }
         commitActiveTab();
@@ -245,7 +270,7 @@ const useTabsUrlSync = ({
       }
       preserveUrlInteractionRef.current = null;
     }
-    if (!targetUrl || targetUrl === getCurrentTabUrl()) {
+    if (!targetUrl || !browserTargetUrl || browserTargetUrl === getCurrentTabUrl()) {
       const pendingNavigation = pendingDataNavigationRef.current;
       navigationAttemptRef.current += 1;
       pendingDataNavigationRef.current = false;
@@ -286,30 +311,34 @@ const useTabsUrlSync = ({
           pendingDataNavigationRef.current = false;
           pendingDataNavigationUrlRef.current = null;
           const currentUrl = getCurrentTabUrl();
-          if (targetUrl === currentUrl || committedDataNavigationUrl === currentUrl) {
+          if (browserTargetUrl === currentUrl || committedDataNavigationUrl === currentUrl) {
             commitActiveTab();
             return;
           }
           rollbackTabActivation(previousActiveKey, attemptedActiveKey, removeAttemptedTab);
         };
         pendingDataNavigationRef.current = true;
-        pendingDataNavigationUrlRef.current = targetUrl;
-        void dataRouterContext.router.navigate(getDataRouterUrl(targetUrl, dataRouterContext.basename), {
+        pendingDataNavigationUrlRef.current = browserTargetUrl;
+        void dataRouterContext.router.navigate(getDataRouterUrl(browserTargetUrl, dataRouterContext.basename), {
           replace: historyMode === "replace",
           state: routerState
         }).then(settleNavigation);
       } else if (navigator) {
         if (historyMode === "push") {
-          navigator.push(targetUrl, routerState);
+          navigator.push(browserTargetUrl, routerState);
         } else {
-          navigator.replace(targetUrl, routerState);
+          navigator.replace(browserTargetUrl, routerState);
         }
         commitActiveTab();
       } else if (historyMode === "push") {
-        window.history.pushState(createPushHistoryState(window.history.state), "", targetUrl);
+        window.history.pushState(
+          createPushHistoryState(window.history.state),
+          "",
+          browserTargetUrl
+        );
         commitActiveTab();
       } else {
-        window.history.replaceState(window.history.state, "", targetUrl);
+        window.history.replaceState(window.history.state, "", browserTargetUrl);
         commitActiveTab();
       }
     } finally {
@@ -324,7 +353,8 @@ const useTabsUrlSync = ({
     interactionSequence,
     navigator,
     dataRouterContext,
-    rollbackTabActivation
+    rollbackTabActivation,
+    basename
   ]);
 };
 export {

package/es/ProLayout/components/TabsManager/style/index.less

@@ -86,13 +86,6 @@
       border-bottom: none;
     }
 
-    // 横线右端缩短，空出圆角半径，让横线在圆弧起点处结束
-    // 用属性选择器提升权重，确保覆盖 antd :where() 规则
-    .@{ant-prefix}-tabs-nav[class]::before {
-      right: var(--zaui-border-radius, 8px) !important;
-      left: 0 !important;
-    }
-
     // 覆盖 nav-list 样式，使其匹配 pro-layout-tab-list
     .@{ant-prefix}-tabs-nav-list {
       display: flex;
@@ -167,6 +160,13 @@
 
 .pro-layout-tabs-antd {
   &.@{ant-prefix}-tabs {
+    // TabsHeader 通过 Portal 渲染到 ProLayout 挂载点，需要在全局作用域截断横线。
+    // 右侧空出一个圆角半径，与内容区圆弧的顶部边线无缝连接。
+    .@{ant-prefix}-tabs-nav[class]::before {
+      right: var(--zaui-border-radius, 8px) !important;
+      left: 0 !important;
+    }
+
     .@{ant-prefix}-tabs-tab {
       padding: 4px 0 5px !important;
       margin-right: 8px !important;

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

@@ -14,11 +14,18 @@ export declare const normalizeTabUrl: (value?: string) => string | undefined;
 export declare const isSafeExternalUrl: (value?: string) => boolean;
 export declare const isSafeHttpUrl: (value?: string) => boolean;
 export declare const getCurrentTabUrl: () => string;
+/** 将浏览器地址和 Tab 内部地址转为同一身份，仅按完整路径段移除 basename。 */
+export declare const getComparableTabUrl: (value?: string, basename?: string) => string | undefined;
+/** 将 Tab 内部地址转为浏览器地址，已带 basename 时不重复添加。 */
+export declare const getBrowserTabUrl: (value?: string, basename?: string) => string | undefined;
 export declare const getTabUrlPathname: (value?: string) => string | undefined;
 export interface FindExistingTabOptions {
     urlSync?: boolean;
     identity?: TabsUrlSyncConfig['identity'];
+    basename?: TabsUrlSyncConfig['basename'];
 }
+/** URL 同步模式的唯一身份；relationKey 模式兼容无关联键的旧菜单 code。 */
+export declare const getUrlSyncTabIdentity: (item: MenusType | TabItem, options?: Pick<FindExistingTabOptions, 'identity' | 'basename'>) => string | undefined;
 export declare const findExistingTab: (tabsList: TabItem[], menuItem: MenusType, options?: FindExistingTabOptions) => TabItem | undefined;
 /**
  * 根据菜单项生成TabItem

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

@@ -29,26 +29,108 @@ const isSafeExternalUrl = (value) => {
 };
 const isSafeHttpUrl = (value) => !!resolveHttpUrl(value);
 const getCurrentTabUrl = () => `${window.location.pathname}${window.location.search}${window.location.hash}`;
+const normalizeTabsBasename = (basename) => {
+  const normalized = String(basename ?? "").trim();
+  if (!normalized || normalized === "/")
+    return "";
+  return `/${normalized.replace(/^\/+|\/+$/g, "")}`;
+};
+const splitNormalizedTabUrl = (url) => {
+  const pathnameEnd = [url.indexOf("?"), url.indexOf("#")].filter((index) => index >= 0).reduce((current, index) => Math.min(current, index), url.length);
+  return {
+    pathname: url.slice(0, pathnameEnd),
+    suffix: url.slice(pathnameEnd)
+  };
+};
+const hasPathBasename = (pathname, basename) => {
+  const lowerPathname = pathname.toLowerCase();
+  const lowerBasename = basename.toLowerCase();
+  return lowerPathname === lowerBasename || lowerPathname.startsWith(`${lowerBasename}/`);
+};
+const getComparableTabUrl = (value, basename) => {
+  const normalizedUrl = normalizeTabUrl(value);
+  if (!normalizedUrl)
+    return void 0;
+  const normalizedBasename = normalizeTabsBasename(basename);
+  if (!normalizedBasename)
+    return normalizedUrl;
+  const { pathname, suffix } = splitNormalizedTabUrl(normalizedUrl);
+  if (!hasPathBasename(pathname, normalizedBasename))
+    return normalizedUrl;
+  const barePathname = pathname.slice(normalizedBasename.length) || "/";
+  return `${barePathname}${suffix}`;
+};
+const getBrowserTabUrl = (value, basename) => {
+  const normalizedUrl = normalizeTabUrl(value);
+  if (!normalizedUrl)
+    return void 0;
+  const normalizedBasename = normalizeTabsBasename(basename);
+  if (!normalizedBasename)
+    return normalizedUrl;
+  const { pathname, suffix } = splitNormalizedTabUrl(normalizedUrl);
+  if (hasPathBasename(pathname, normalizedBasename))
+    return normalizedUrl;
+  return `${normalizedBasename}${pathname}${suffix}`;
+};
 const getTabUrlPathname = (value) => {
   const normalized = normalizeTabUrl(value);
   if (!normalized || typeof window === "undefined")
     return void 0;
   return new URL(normalized, window.location.origin).pathname;
 };
+const getIdentityRelationKey = (item) => {
+  var _a;
+  return item.relationKey ?? ("menuItem" in item ? (_a = item.menuItem) == null ? void 0 : _a.relationKey : void 0);
+};
+const getIdentityCode = (item) => {
+  var _a;
+  return item.code ?? ("menuItem" in item ? (_a = item.menuItem) == null ? void 0 : _a.code : void 0);
+};
+const getTypedIdentity = (prefix, value) => `${prefix}:${typeof value}:${String(value)}`;
+const isTabItem = (item) => typeof item.id === "string";
+const getUrlSyncTabIdentity = (item, options = {}) => {
+  if (options.identity === "relationKey") {
+    const relationKey = getIdentityRelationKey(item);
+    if (hasRelationKey(relationKey))
+      return getTypedIdentity("relationKey", relationKey);
+    const code = getIdentityCode(item);
+    if (code !== void 0 && code !== null && code !== "") {
+      return getTypedIdentity("code", code);
+    }
+  }
+  const route = isTabItem(item) ? item.url : getMenuRoute(item);
+  const comparableUrl = getComparableTabUrl(route, options.basename);
+  return comparableUrl ? `url:${comparableUrl}` : void 0;
+};
 const findExistingTab = (tabsList, menuItem, options = {}) => {
   if (options.urlSync) {
-    if (options.identity === "relationKey" && hasRelationKey(menuItem.relationKey)) {
-      return tabsList.find(
-        (tab) => {
-          var _a;
-          return tab.relationKey === menuItem.relationKey || ((_a = tab.menuItem) == null ? void 0 : _a.relationKey) === menuItem.relationKey;
+    if (options.identity === "relationKey") {
+      const relationKey = getIdentityRelationKey(menuItem);
+      if (hasRelationKey(relationKey)) {
+        const relatedTab = tabsList.find(
+          (tab) => getIdentityRelationKey(tab) === relationKey
+        );
+        if (relatedTab)
+          return relatedTab;
+        const legacyCode = getIdentityCode(menuItem);
+        if (legacyCode !== void 0 && legacyCode !== null && legacyCode !== "") {
+          return tabsList.find(
+            (tab) => !hasRelationKey(getIdentityRelationKey(tab)) && getIdentityCode(tab) === legacyCode
+          );
         }
-      );
+        return void 0;
+      }
+      const code = getIdentityCode(menuItem);
+      if (code !== void 0 && code !== null && code !== "") {
+        return tabsList.find((tab) => getIdentityCode(tab) === code);
+      }
     }
-    const targetUrl = normalizeTabUrl(getMenuRoute(menuItem));
+    const targetUrl = getComparableTabUrl(getMenuRoute(menuItem), options.basename);
     if (!targetUrl)
       return void 0;
-    return tabsList.find((tab) => normalizeTabUrl(tab.url) === targetUrl);
+    return tabsList.find(
+      (tab) => getComparableTabUrl(tab.url, options.basename) === targetUrl
+    );
   }
   if (hasRelationKey(menuItem.relationKey)) {
     return tabsList.find(
@@ -232,11 +314,14 @@ export {
   findExistingTab,
   flattenMenuData,
   generateTabId,
+  getBrowserTabUrl,
+  getComparableTabUrl,
   getCurrentTabUrl,
   getMenuRoute,
   getPinnedBoundary,
   getRightTabs,
   getTabUrlPathname,
+  getUrlSyncTabIdentity,
   handleExternalOpen,
   hasRelationKey,
   isLeafMenuItem,

package/es/ProLayout/propTypes.d.ts

@@ -369,10 +369,15 @@ export interface TabsUrlSyncConfig {
      */
     history?: 'replace' | 'push';
     /**
-     * @description 页签复用身份。url 保持既有完整 URL 唯一语义；relationKey 在显式传入时优先按业务关联键复用
+     * @description 页签复用身份。url 保持完整 URL 唯一语义；relationKey 按关联键、无关联键的菜单 code、完整 URL 依次匹配
      * @default 'url'
      */
     identity?: 'url' | 'relationKey';
+    /**
+     * @description 浏览器地址中的显式基础路径；Tab 内部 URL 可以不带该前缀
+     * @example '/wjs'
+     */
+    basename?: string;
 }
 /**
  * @description 添加标签页的业务参数
@@ -420,7 +425,7 @@ export interface AddTabOptions {
     silent?: boolean;
 }
 /**
- * @description 更新标签页的字段（仅允许更新展示与扩展数据）
+ * @description 更新标签页的展示、扩展数据与来源菜单身份
  */
 export interface UpdateTabParams {
     /**
@@ -443,6 +448,10 @@ export interface UpdateTabParams {
      * @description 是否固定标签（本质状态，driven closable）
      */
     pinned?: boolean;
+    /**
+     * @description 最初打开当前业务标签链路的左侧菜单 code；用于兼容性迁移已缓存的来源身份
+     */
+    menuCodeSource?: string;
 }
 /**
  * @description 获取标签页信息返回值

package/es/ProLayout/style/index.less

@@ -327,24 +327,6 @@
       overflow: hidden;
       min-height: 0;
     }
-
-    // 稳定遮住 ant-tabs-nav::before 横线的右端，使其在内容区圆弧起点处截止
-    &.tabs-visible::before {
-      content: '';
-      position: absolute;
-      bottom: 0;
-      right: 0;
-      width: var(--zaui-border-radius, 8px);
-      height: 2px;
-      background-color: #f7f9fd;
-      background-image: var(--header-bg-image);
-      background-repeat: no-repeat;
-      background-position: top center;
-      background-size: 100% auto;
-      background-attachment: fixed;
-      z-index: 1;
-      pointer-events: none;
-    }
   }
 
   /** 内容区 */
@@ -370,17 +352,19 @@
       border-top-color: transparent;
       border-radius: 0;
       padding-top: var(--zaui-space-size-md, 16px);
-      border-top-right-radius: var(--zaui-border-radius, 8px);
 
       // 圆弧由内容区独立绘制并随内容滚动；sticky Tab 栏始终保持在其上方。
-      // ::before 在子内容之前绘制，ProStep / ProHeader 仍可完整覆盖圆弧。
+      // 与内容区外边框对齐，同时遮住底层直角，避免缩放时出现断线或双重圆弧。
       &::before {
         content: '';
         position: absolute;
-        top: 0;
-        right: 0;
+        box-sizing: border-box;
+        top: -1px;
+        right: -1px;
         width: var(--zaui-border-radius, 8px);
         height: var(--zaui-border-radius, 8px);
+        background: #ffffff;
+        border-top: 1px solid rgb(235 236 238);
         border-right: 1px solid rgb(235 236 238);
         border-top-right-radius: var(--zaui-border-radius, 8px);
         pointer-events: none;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zat-design/sisyphus-react",
-  "version": "4.6.0-beta.2",
+  "version": "4.6.0-beta.4",
   "license": "MIT",
   "publishConfig": {
     "access": "public",