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

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

@@ -71,8 +71,12 @@ export interface UseTabsStateReturn {
     removeTab: (tabId: string) => void;
     /** 更新指定 id 的标签页字段（替换语义；找不到时 no-op） */
     updateTab: (tabId: string, updates: UpdateTabParams) => void;
+    /** 更新页签当前 URL，保持 tab.id 不变 */
+    updateTabUrl: (tabId: string, url: string) => void;
     /** 切换标签页 */
     switchTab: (tabId: string) => void;
+    /** URL 导航未提交时回滚本次激活 */
+    rollbackTabActivation: (previousTabId: string, attemptedTabId: string, removeAttemptedTab: boolean) => void;
     /** 关闭其他标签页 */
     closeOtherTabs: (currentTabId: string) => void;
     /** 关闭右侧标签页 */

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

@@ -1,15 +1,7 @@
-// TabsManager组件Props
-
-// 右键菜单组件Props
-
-// 状态管理Hook选项
-
-// 状态管理Hook返回值
-
-// 缓存管理器接口
-
-// 默认配置
-export const DEFAULT_TABS_CONFIG = {
-  storage: 'localStorage',
-  cacheKey: 'pro-layout-tabs'
-};
+const DEFAULT_TABS_CONFIG = {
+  storage: "localStorage",
+  cacheKey: "pro-layout-tabs"
+};
+export {
+  DEFAULT_TABS_CONFIG
+};

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

@@ -171,7 +171,7 @@
       padding: 4px 0 5px !important;
       margin-right: 8px !important;
       margin-left: 0;
-      background: #F5F5F5;
+      background: #f5f5f5;
       transition: none;
       border-color: #e7e8ee;
       &.@{ant-prefix}-tabs-tab-active {

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

@@ -0,0 +1,7 @@
+export type HistoryLocationChangeSource = 'push' | 'replace' | 'pop' | 'hash';
+type HistoryLocationListener = (source: HistoryLocationChangeSource) => void;
+/**
+ * 共享对原生 History 的唯一包装，避免多个 ProLayout 实例互相覆盖和泄漏。
+ */
+export declare const subscribeHistoryLocation: (listener: HistoryLocationListener) => (() => void);
+export {};

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

@@ -0,0 +1,65 @@
+const listeners = /* @__PURE__ */ new Set();
+let originalPushState;
+let originalReplaceState;
+let wrappedPushState;
+let wrappedReplaceState;
+let installationSequence = 0;
+let activeInstallation = 0;
+const notify = (source) => {
+  listeners.forEach((listener) => listener(source));
+};
+const handlePopState = () => notify("pop");
+const handleHashChange = () => notify("hash");
+const install = () => {
+  const browserHistory = window.history;
+  const installation = installationSequence + 1;
+  installationSequence = installation;
+  activeInstallation = installation;
+  originalPushState = browserHistory.pushState;
+  originalReplaceState = browserHistory.replaceState;
+  const installedPushState = originalPushState;
+  const installedReplaceState = originalReplaceState;
+  wrappedPushState = function pushState(...args) {
+    installedPushState.apply(browserHistory, args);
+    if (activeInstallation === installation)
+      notify("push");
+  };
+  wrappedReplaceState = function replaceState(...args) {
+    installedReplaceState.apply(browserHistory, args);
+    if (activeInstallation === installation)
+      notify("replace");
+  };
+  browserHistory.pushState = wrappedPushState;
+  browserHistory.replaceState = wrappedReplaceState;
+  window.addEventListener("popstate", handlePopState);
+  window.addEventListener("hashchange", handleHashChange);
+};
+const uninstall = () => {
+  const browserHistory = window.history;
+  activeInstallation = 0;
+  if (wrappedPushState && originalPushState && browserHistory.pushState === wrappedPushState) {
+    browserHistory.pushState = originalPushState;
+  }
+  if (wrappedReplaceState && originalReplaceState && browserHistory.replaceState === wrappedReplaceState) {
+    browserHistory.replaceState = originalReplaceState;
+  }
+  window.removeEventListener("popstate", handlePopState);
+  window.removeEventListener("hashchange", handleHashChange);
+  originalPushState = void 0;
+  originalReplaceState = void 0;
+  wrappedPushState = void 0;
+  wrappedReplaceState = void 0;
+};
+const subscribeHistoryLocation = (listener) => {
+  if (listeners.size === 0)
+    install();
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+    if (listeners.size === 0)
+      uninstall();
+  };
+};
+export {
+  subscribeHistoryLocation
+};

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

@@ -5,7 +5,20 @@ import { AddTabParams, TabItem, MenusType } from '../../../propTypes';
  */
 export declare const getMenuRoute: (menuItem: MenusType) => string;
 export declare const hasRelationKey: (relationKey: MenusType['relationKey']) => relationKey is string | number;
-export declare const findExistingTab: (tabsList: TabItem[], menuItem: MenusType) => TabItem | undefined;
+/**
+ * 将同源 URL 规范化为应用内地址，保留 search 和 hash。
+ * 返回 undefined 表示 URL 无效或跨域。
+ */
+export declare const normalizeTabUrl: (value?: string) => string | undefined;
+/** 仅允许将跨域 HTTP(S) URL 交给浏览器外部打开。 */
+export declare const isSafeExternalUrl: (value?: string) => boolean;
+export declare const isSafeHttpUrl: (value?: string) => boolean;
+export declare const getCurrentTabUrl: () => string;
+export declare const getTabUrlPathname: (value?: string) => string | undefined;
+export interface FindExistingTabOptions {
+    urlSync?: boolean;
+}
+export declare const findExistingTab: (tabsList: TabItem[], menuItem: MenusType, options?: FindExistingTabOptions) => TabItem | undefined;
 /**
  * 根据菜单项生成TabItem
  */
@@ -21,7 +34,7 @@ export declare const shouldOpenExternal: (menuItem: MenusType, target?: string)
 /**
  * 处理外部跳转
  */
-export declare const handleExternalOpen: (menuItem: MenusType) => void;
+export declare const handleExternalOpen: (menuItem: MenusType, secure?: boolean) => void;
 /**
  * 检查是否超出最大标签页限制
  * @param currentTabs 当前标签页列表

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

@@ -1,25 +1,66 @@
-/**
- * 获取菜单实际用于路由/签页的路径
- * 约定优先使用 redirectUrl，其次回退 url
- */
-export const getMenuRoute = menuItem => {
-  return menuItem.redirectUrl || menuItem.url || '';
-};
-export const hasRelationKey = relationKey => relationKey !== undefined && relationKey !== null && relationKey !== '';
-export const findExistingTab = (tabsList, menuItem) => {
+const getMenuRoute = (menuItem) => {
+  return menuItem.redirectUrl || menuItem.url || "";
+};
+const hasRelationKey = (relationKey) => relationKey !== void 0 && relationKey !== null && relationKey !== "";
+const resolveHttpUrl = (value) => {
+  if (!value || typeof window === "undefined")
+    return void 0;
+  try {
+    const resolved = new URL(value, window.location.origin);
+    return resolved.protocol === "http:" || resolved.protocol === "https:" ? resolved : void 0;
+  } catch (_error) {
+    return void 0;
+  }
+};
+const normalizeTabUrl = (value) => {
+  if (!value)
+    return void 0;
+  if (typeof window === "undefined") {
+    return value.startsWith("/") && !value.startsWith("//") ? value : void 0;
+  }
+  const resolved = resolveHttpUrl(value);
+  if (!resolved || resolved.origin !== window.location.origin)
+    return void 0;
+  return `${resolved.pathname}${resolved.search}${resolved.hash}`;
+};
+const isSafeExternalUrl = (value) => {
+  const resolved = resolveHttpUrl(value);
+  return !!resolved && resolved.origin !== window.location.origin;
+};
+const isSafeHttpUrl = (value) => !!resolveHttpUrl(value);
+const getCurrentTabUrl = () => `${window.location.pathname}${window.location.search}${window.location.hash}`;
+const getTabUrlPathname = (value) => {
+  const normalized = normalizeTabUrl(value);
+  if (!normalized || typeof window === "undefined")
+    return void 0;
+  return new URL(normalized, window.location.origin).pathname;
+};
+const findExistingTab = (tabsList, menuItem, options = {}) => {
+  if (options.urlSync) {
+    const targetUrl = normalizeTabUrl(getMenuRoute(menuItem));
+    if (!targetUrl)
+      return void 0;
+    return tabsList.find((tab) => normalizeTabUrl(tab.url) === targetUrl);
+  }
   if (hasRelationKey(menuItem.relationKey)) {
-    return tabsList.find(tab => tab.relationKey === menuItem.relationKey || tab.menuItem?.relationKey === menuItem.relationKey);
+    return tabsList.find(
+      (tab) => {
+        var _a;
+        return tab.relationKey === menuItem.relationKey || ((_a = tab.menuItem) == null ? void 0 : _a.relationKey) === menuItem.relationKey;
+      }
+    );
   }
   const menuRoute = getMenuRoute(menuItem);
-  return tabsList.find(tab => tab.menuItem?.code === menuItem.code || tab.url === menuRoute);
+  const hasCode = menuItem.code !== void 0 && menuItem.code !== null && menuItem.code !== "";
+  return tabsList.find(
+    (tab) => {
+      var _a;
+      return hasCode && ((_a = tab.menuItem) == null ? void 0 : _a.code) === menuItem.code || tab.url === menuRoute;
+    }
+  );
 };
-
-/**
- * 根据菜单项生成TabItem
- */
-export const createTabFromMenu = (menuItem, index = 0) => {
+const createTabFromMenu = (menuItem, index = 0) => {
   const route = getMenuRoute(menuItem);
-  // pinned 优先取菜单显式声明，否则由 closable===false 推导（声明式固定标签）
   const pinned = menuItem.pinned ?? menuItem.closable === false;
   const result = {
     id: String(menuItem.id || menuItem.code || menuItem.url || index),
@@ -31,74 +72,51 @@ export const createTabFromMenu = (menuItem, index = 0) => {
     pinned,
     menuItem,
     icon: menuItem.icon || menuItem.imgUrl,
-    relationKey: menuItem.relationKey
+    relationKey: menuItem.relationKey,
+    menuCodeSource: menuItem.menuCodeSource
   };
   return result;
 };
-
-/**
- * 生成唯一的tab ID
- */
-export const generateTabId = (menuItem, existingIds) => {
+const generateTabId = (menuItem, existingIds) => {
   const baseId = String(menuItem.id || menuItem.code || menuItem.url);
   let finalId = baseId;
   let counter = 1;
-
-  // 如果ID已存在，则添加数字后缀
   while (existingIds.includes(finalId)) {
     finalId = `${baseId}_${counter}`;
     counter += 1;
   }
   return finalId;
 };
-
-/**
- * 检查菜单项是否应该外部跳转
- */
-export const shouldOpenExternal = (menuItem, target) => {
-  const menuTarget = menuItem?.target || target;
-  return menuTarget === '_blank' || menuItem.type === 'EXTERNAL';
-};
-
-/**
- * 处理外部跳转
- */
-export const handleExternalOpen = menuItem => {
+const shouldOpenExternal = (menuItem, target) => {
+  const menuTarget = (menuItem == null ? void 0 : menuItem.target) || target;
+  return menuTarget === "_blank" || menuItem.type === "EXTERNAL";
+};
+const handleExternalOpen = (menuItem, secure = false) => {
   const url = getMenuRoute(menuItem);
-  if (url) {
-    window.open(url, menuItem.target || '_blank');
+  if (!url)
+    return;
+  const target = menuItem.target || "_blank";
+  if (secure && target === "_blank") {
+    window.open(url, target, "noopener,noreferrer");
+    return;
   }
+  window.open(url, target);
 };
-
-/**
- * 检查是否超出最大标签页限制
- * @param currentTabs 当前标签页列表
- * @param maxTabs 最大标签页数量，如果为 undefined 或 null，表示无限制
- * @returns 如果超出限制返回 true，否则返回 false
- */
-export const checkTabLimit = (currentTabs, maxTabs) => {
-  // 如果 maxTabs 为 undefined 或 null，表示无限制
-  if (maxTabs === undefined || maxTabs === null) {
+const checkTabLimit = (currentTabs, maxTabs) => {
+  if (maxTabs === void 0 || maxTabs === null) {
     return false;
   }
   return currentTabs.length >= maxTabs;
 };
-
-/**
- * 获取右侧标签页
- */
-export const getRightTabs = (tabs, currentTabId) => {
-  const currentIndex = tabs.findIndex(tab => tab.id === currentTabId);
-  if (currentIndex === -1) return [];
+const getRightTabs = (tabs, currentTabId) => {
+  const currentIndex = tabs.findIndex((tab) => tab.id === currentTabId);
+  if (currentIndex === -1)
+    return [];
   return tabs.slice(currentIndex + 1);
 };
-
-/**
- * 扁平化菜单数据
- */
-export const flattenMenuData = (menus = []) => {
+const flattenMenuData = (menus = []) => {
   let flatMenus = [];
-  menus.forEach(item => {
+  menus.forEach((item) => {
     flatMenus.push(item);
     if (item.children) {
       flatMenus = [...flatMenus, ...flattenMenuData(item.children)];
@@ -106,141 +124,120 @@ export const flattenMenuData = (menus = []) => {
   });
   return flatMenus;
 };
-
-/**
- * 将公开 addTab 参数解析为内部菜单项，统一 initialTabs 与实例 API 的匹配规则。
- */
-export const resolveTabMenuItem = (params, menus = []) => {
-  const matchedMenu = flattenMenuData(menus).find(item => item.code === params.code);
+const resolveTabMenuItem = (params, menus = []) => {
+  var _a, _b;
+  const matchedMenu = flattenMenuData(menus).find((item) => item.code === params.code);
+  const menuCodeSource = ((_a = params.menuCodeSource) == null ? void 0 : _a.trim()) || ((_b = matchedMenu == null ? void 0 : matchedMenu.menuCodeSource) == null ? void 0 : _b.trim()) || void 0;
   if (matchedMenu) {
     return {
       ...matchedMenu,
       name: params.name || matchedMenu.name,
+      ...params.url !== void 0 && { url: params.url, redirectUrl: void 0 },
       extra: params.extra ?? matchedMenu.extra,
-      relationKey: params.relationKey ?? matchedMenu.relationKey
+      relationKey: params.relationKey ?? matchedMenu.relationKey,
+      menuCodeSource
     };
   }
   return {
     id: Date.now(),
     code: params.code,
     name: params.name,
-    url: `/${params.code}`,
+    url: params.url || `/${params.code}`,
     extra: params.extra,
-    relationKey: params.relationKey
+    relationKey: params.relationKey,
+    menuCodeSource
   };
 };
-
-/**
- * 判断菜单项是否为最后一级（叶子节点）
- * 只有当菜单项没有子菜单或子菜单为空时，才认为是叶子节点
- */
-export const isLeafMenuItem = menuItem => {
-  const {
-    children
-  } = menuItem || {};
-  // 如果 children 不存在、为 null、为 undefined，或者为空数组，则认为是叶子节点
+const isLeafMenuItem = (menuItem) => {
+  const { children } = menuItem || {};
   return !children || Array.isArray(children) && children.length === 0;
 };
-
-/**
- * 判断菜单项是否可以在 Tabs 模式下打开
- * 规则：只有叶子节点（无 children）才可打开
- */
-export const canOpenAsTab = menuItem => {
-  if (!menuItem) return false;
-  if (!(menuItem.url || menuItem.redirectUrl)) return false;
+const canOpenAsTab = (menuItem) => {
+  if (!menuItem)
+    return false;
+  if (!(menuItem.url || menuItem.redirectUrl))
+    return false;
   return isLeafMenuItem(menuItem);
 };
-
-/**
- * 推导标签页是否处于固定状态。
- * pinned 为本质状态；未显式设置 pinned 的旧缓存标签，用 closable===false 推导。
- */
-export const derivePinned = tab => tab.pinned ?? tab.closable === false;
-
-/**
- * 分区边界：第一个「非固定标签」的下标，等于固定标签的数量。
- * 约定固定区始终排在普通区左侧，故边界即两区分界点。
- */
-export const getPinnedBoundary = tabs => {
-  const index = tabs.findIndex(tab => !derivePinned(tab));
+const derivePinned = (tab) => tab.pinned ?? tab.closable === false;
+const getPinnedBoundary = (tabs) => {
+  const index = tabs.findIndex((tab) => !derivePinned(tab));
   return index === -1 ? tabs.length : index;
 };
-
-/**
- * 不依赖外部库的数组移动（immutable）。
- * from/to 越界时返回原数组的浅拷贝。
- */
 const moveItem = (list, from, to) => {
   const result = [...list];
-  if (from < 0 || from >= result.length || to < 0 || to >= result.length) return result;
+  if (from < 0 || from >= result.length || to < 0 || to >= result.length)
+    return result;
   const [removed] = result.splice(from, 1);
   result.splice(to, 0, removed);
   return result;
 };
-
-/**
- * 固定标签：将目标标签设为 pinned=true / closable=false，并移动到固定区末尾。
- * - 已固定则幂等（顺序不变）
- * - tabId 不存在时返回原数组引用
- */
-export const pinTab = (tabs, tabId) => {
-  const index = tabs.findIndex(tab => tab.id === tabId);
-  if (index === -1) return tabs;
-  if (derivePinned(tabs[index])) return tabs;
-  const pinnedTab = {
-    ...tabs[index],
-    pinned: true,
-    closable: false
-  };
-  // 移除目标后计算固定区末尾位置（= 剩余标签中的固定数量）
+const pinTab = (tabs, tabId) => {
+  const index = tabs.findIndex((tab) => tab.id === tabId);
+  if (index === -1)
+    return tabs;
+  if (derivePinned(tabs[index]))
+    return tabs;
+  const pinnedTab = { ...tabs[index], pinned: true, closable: false };
   const rest = tabs.filter((_, i) => i !== index);
   const insertAt = getPinnedBoundary(rest);
   return [...rest.slice(0, insertAt), pinnedTab, ...rest.slice(insertAt)];
 };
-
-/**
- * 取消固定：将目标标签设为 pinned=false / closable=true，并移动到普通区最前
- * （即剩余固定区之后的第一位）。
- * - 已是普通标签则幂等（顺序不变）
- * - tabId 不存在时返回原数组引用
- */
-export const unpinTab = (tabs, tabId) => {
-  const index = tabs.findIndex(tab => tab.id === tabId);
-  if (index === -1) return tabs;
-  if (!derivePinned(tabs[index])) return tabs;
-  const normalTab = {
-    ...tabs[index],
-    pinned: false,
-    closable: true
-  };
+const unpinTab = (tabs, tabId) => {
+  const index = tabs.findIndex((tab) => tab.id === tabId);
+  if (index === -1)
+    return tabs;
+  if (!derivePinned(tabs[index]))
+    return tabs;
+  const normalTab = { ...tabs[index], pinned: false, closable: true };
   const rest = tabs.filter((_, i) => i !== index);
   const insertAt = getPinnedBoundary(rest);
   return [...rest.slice(0, insertAt), normalTab, ...rest.slice(insertAt)];
 };
-
-/**
- * 约束重排：在普通 arrayMove 基础上，钳制落点以维持「固定区在左、普通区在右」不变量。
- * - 被拖动的普通标签：落点钳制到 >= boundary（不进固定区）
- * - 被拖动的固定标签：落点钳制到 <= boundary-1（不出固定区）
- * - 钳制后落点等于原位、或 id 相同/无效时，返回原数组引用（避免无效更新）
- */
-export const reorderWithPinConstraint = (tabs, activeId, overId) => {
-  if (activeId === overId) return tabs;
-  const activeIndex = tabs.findIndex(tab => tab.id === activeId);
-  const overIndex = tabs.findIndex(tab => tab.id === overId);
-  if (activeIndex === -1 || overIndex === -1) return tabs;
+const reorderWithPinConstraint = (tabs, activeId, overId) => {
+  if (activeId === overId)
+    return tabs;
+  const activeIndex = tabs.findIndex((tab) => tab.id === activeId);
+  const overIndex = tabs.findIndex((tab) => tab.id === overId);
+  if (activeIndex === -1 || overIndex === -1)
+    return tabs;
   const boundary = getPinnedBoundary(tabs);
   const activePinned = derivePinned(tabs[activeIndex]);
   let targetIndex = overIndex;
   if (activePinned) {
-    // 固定标签只能落在固定区内：[0, boundary-1]
     const maxIndex = boundary - 1;
-    if (targetIndex > maxIndex) targetIndex = maxIndex;
+    if (targetIndex > maxIndex)
+      targetIndex = maxIndex;
   } else {
-    // 普通标签只能落在普通区内：[boundary, length-1]
-    if (targetIndex < boundary) targetIndex = boundary;
+    if (targetIndex < boundary)
+      targetIndex = boundary;
   }
-  if (targetIndex === activeIndex) return tabs;
+  if (targetIndex === activeIndex)
+    return tabs;
   return moveItem(tabs, activeIndex, targetIndex);
-};
+};
+export {
+  canOpenAsTab,
+  checkTabLimit,
+  createTabFromMenu,
+  derivePinned,
+  findExistingTab,
+  flattenMenuData,
+  generateTabId,
+  getCurrentTabUrl,
+  getMenuRoute,
+  getPinnedBoundary,
+  getRightTabs,
+  getTabUrlPathname,
+  handleExternalOpen,
+  hasRelationKey,
+  isLeafMenuItem,
+  isSafeExternalUrl,
+  isSafeHttpUrl,
+  normalizeTabUrl,
+  pinTab,
+  reorderWithPinConstraint,
+  resolveTabMenuItem,
+  shouldOpenExternal,
+  unpinTab
+};

package/es/ProLayout/components/index.js

@@ -1,3 +1,8 @@
-export { default as ProCollapse } from "./ProCollapse";
-export { default as ProFooter } from "./ProFooter";
-export { default as ProHeader } from "./ProHeader";
+import { default as default2 } from "./ProCollapse";
+import { default as default3 } from "./ProFooter";
+import { default as default4 } from "./ProHeader";
+export {
+  default2 as ProCollapse,
+  default3 as ProFooter,
+  default4 as ProHeader
+};