@nocobase/client-v2 2.2.0-beta.1 → 2.2.0-beta.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/client-v2",
-  "version": "2.2.0-beta.1",
+  "version": "2.2.0-beta.10",
   "license": "Apache-2.0",
   "main": "lib/index.js",
   "module": "es/index.mjs",
@@ -27,11 +27,11 @@
     "@formily/antd-v5": "1.2.3",
     "@formily/react": "^2.2.27",
     "@formily/shared": "^2.2.27",
-    "@nocobase/evaluators": "2.2.0-beta.1",
-    "@nocobase/flow-engine": "2.2.0-beta.1",
-    "@nocobase/sdk": "2.2.0-beta.1",
-    "@nocobase/shared": "2.2.0-beta.1",
-    "@nocobase/utils": "2.2.0-beta.1",
+    "@nocobase/evaluators": "2.2.0-beta.10",
+    "@nocobase/flow-engine": "2.2.0-beta.10",
+    "@nocobase/sdk": "2.2.0-beta.10",
+    "@nocobase/shared": "2.2.0-beta.10",
+    "@nocobase/utils": "2.2.0-beta.10",
     "ahooks": "^3.7.2",
     "antd": "5.24.2",
     "antd-style": "3.7.1",
@@ -46,5 +46,5 @@
     "react-i18next": "^11.15.1",
     "react-router-dom": "^6.30.1"
   },
-  "gitHead": "f82fa9d0c3aa8e00e53dd94e404a312483b4866b"
+  "gitHead": "d572beec24de46df948f28db72b25303a63bf62d"
 }

package/src/BaseApplication.tsx

@@ -30,6 +30,7 @@ import AntdAppProvider from './theme/AntdAppProvider';
 import { GlobalThemeProvider } from './theme';
 import { AIManager } from './ai';
 import { AppError, AppMaintaining, AppMaintainingDialog, AppNotFound, AppSpin, BlankComponent } from './components';
+import { EntryActionManager } from './entry-actions';
 import { SystemSettingsSource } from './flow/system-settings';
 import { LayoutManager } from './layout-manager/LayoutManager';
 import type { PluginClass, PluginManager, PluginType } from './PluginManager';
@@ -126,6 +127,7 @@ export abstract class BaseApplication<
   public pluginManager: TPluginManager;
   public pluginSettingsManager: TPluginSettingsManager;
   public layoutManager: LayoutManager<this>;
+  public entryActionManager = new EntryActionManager();
   public aiManager!: AIManager;
   public devDynamicImport?: DevDynamicImport;
   public requirejs!: RequireJS;
@@ -431,6 +433,10 @@ export abstract class BaseApplication<
     return getSubAppName(this.getPublicPath()) || null;
   }
 
+  getCdnUrl() {
+    return window['__webpack_public_path__'] || this.getPublicPath();
+  }
+
   getPublicPath() {
     let publicPath = this.options.publicPath || '/';
     if (!publicPath.endsWith('/')) {

package/src/PluginSettingsManager.ts

@@ -97,6 +97,7 @@ interface InternalPageItemRecord extends PluginSettingsPageItemOptions {
 export class PluginSettingsManager<TApp extends BaseApplication<any> = BaseApplication<any>> {
   protected menus: Record<string, InternalMenuItemRecord> = {};
   protected pages: Record<string, InternalPageItemRecord> = {};
+  protected pluginSettingsLinks: Record<string, string> = {};
   protected aclSnippets: string[] = [];
   public app: TApp;
 
@@ -294,6 +295,58 @@ export class PluginSettingsManager<TApp extends BaseApplication<any> = BaseAppli
     return !!(this.menus[name] || this.pages[name]);
   }
 
+  /**
+   * 绑定插件管理列表中的 plugin name 到实际 settings 入口。
+   *
+   * 插件管理列表使用 applicationPlugins.name 判断是否显示 Settings 入口，
+   * 但部分插件会把设置页挂到共享菜单或历史路径下。
+   *
+   * @param pluginName 插件管理列表中的插件名
+   * @param settingsName menu 或 page 名称
+   * @returns {void}
+   */
+  setPluginSettingsLink(pluginName: string, settingsName: string) {
+    if (!pluginName) {
+      throw new Error('Plugin settings link pluginName is required');
+    }
+
+    if (!settingsName) {
+      throw new Error('Plugin settings link settingsName is required');
+    }
+
+    this.pluginSettingsLinks[pluginName] = settingsName;
+  }
+
+  /**
+   * 获取插件管理列表中的 plugin name 对应的 settings 名称。
+   *
+   * @param pluginName 插件管理列表中的插件名
+   * @returns {string} settings 名称
+   */
+  getPluginSettingsName(pluginName: string) {
+    return this.pluginSettingsLinks[pluginName] || pluginName;
+  }
+
+  /**
+   * 判断插件管理列表中的插件是否有可跳转的 settings 入口。
+   *
+   * @param pluginName 插件管理列表中的插件名
+   * @returns {boolean} 是否已注册 settings 入口
+   */
+  hasPluginSettings(pluginName: string) {
+    return this.has(this.getPluginSettingsName(pluginName));
+  }
+
+  /**
+   * 获取插件管理列表中的插件对应的 settings 路径。
+   *
+   * @param pluginName 插件管理列表中的插件名
+   * @returns {string} settings 绝对路径
+   */
+  getPluginSettingsRoutePath(pluginName: string) {
+    return this.getRoutePath(this.getPluginSettingsName(pluginName));
+  }
+
   /**
    * 获取单个 menu 或 page 的只读快照。
    *

package/src/RouteRepository.ts

@@ -9,15 +9,24 @@
 
 import { APIClient } from '@nocobase/sdk';
 import type { NocoBaseDesktopRoute } from './flow-compat';
+import { ADMIN_LAYOUT_MODEL_UID } from './flow/admin-shell/admin-layout/constants';
 
 type RouteSubscriber = () => void;
 type RouteCreateValues = Partial<NocoBaseDesktopRoute>;
 type RouteUpdateValues = Partial<NocoBaseDesktopRoute>;
+type RouteLayoutLike = {
+  uid?: unknown;
+};
 
 type RouteMutationOptions = {
   refreshAfterMutation?: boolean;
 };
 
+type AccessibleRouteCache = {
+  accessibleLoaded: boolean;
+  routes: NocoBaseDesktopRoute[];
+};
+
 type MoveRouteOptions = {
   sourceId: string | number;
   targetId?: string | number;
@@ -30,21 +39,47 @@ type MoveRouteOptions = {
 
 export class RouteRepository {
   routes: NocoBaseDesktopRoute[] = [];
-  protected subscribers = new Set<RouteSubscriber>();
-  protected accessibleLoaded = false;
-  protected accessibleLoadingPromise: Promise<NocoBaseDesktopRoute[]> | null = null;
+  protected subscribers = new Map<RouteSubscriber, string>();
+  protected accessibleLoadingPromises = new Map<string, Promise<NocoBaseDesktopRoute[]>>();
+  private layoutActivations: Array<{ token: symbol; uid: string }> = [];
+  private routeCaches = new Map<string, AccessibleRouteCache>();
+  private refreshRequestIds = new Map<string, number>();
+  private notifiedLayoutUid: string | undefined;
 
   constructor(protected ctx: { api?: APIClient }) {}
 
+  activateLayout(layout?: RouteLayoutLike) {
+    const uid = this.normalizeLayoutUid(layout?.uid);
+    const token = Symbol('route-layout');
+
+    this.layoutActivations.push({
+      token,
+      uid,
+    });
+    this.syncRoutesProperty();
+
+    return () => {
+      const index = this.layoutActivations.findIndex((item) => item.token === token);
+      if (index >= 0) {
+        this.layoutActivations.splice(index, 1);
+      }
+      this.syncRoutesProperty();
+    };
+  }
+
   /**
    * 同步当前可访问桌面路由，并通知订阅方刷新。
    *
    * @param routes 最新的桌面路由树
    */
-  setRoutes(routes: NocoBaseDesktopRoute[]) {
-    this.routes = routes;
-    this.accessibleLoaded = true;
-    this.emitChange();
+  setRoutes(routes: NocoBaseDesktopRoute[], layoutUid = this.getCurrentLayoutUid()) {
+    const cache = this.getRouteCache(layoutUid);
+    cache.routes = routes;
+    cache.accessibleLoaded = true;
+    if (layoutUid === this.getCurrentLayoutUid()) {
+      this.routes = routes;
+    }
+    this.emitChange(layoutUid);
   }
 
   /**
@@ -53,7 +88,9 @@ export class RouteRepository {
    * @returns 当前缓存的路由数组
    */
   listAccessible() {
-    return this.routes;
+    const routes = this.getRouteCache(this.getReadableLayoutUid()).routes;
+    this.routes = routes;
+    return routes;
   }
 
   /**
@@ -62,7 +99,7 @@ export class RouteRepository {
    * @returns {boolean} 是否已初始化完成
    */
   isAccessibleLoaded() {
-    return this.accessibleLoaded;
+    return this.getRouteCache().accessibleLoaded;
   }
 
   /**
@@ -71,12 +108,20 @@ export class RouteRepository {
    * @returns 最新的路由数组
    */
   async refreshAccessible() {
+    const layoutUid = this.getCurrentLayoutUid();
+    return this.refreshAccessibleByLayout(layoutUid);
+  }
+
+  private async refreshAccessibleByLayout(layoutUid: string) {
+    const requestId = this.nextRefreshRequestId(layoutUid);
     const response = await this.getAPIClient().request({
       url: '/desktopRoutes:listAccessible',
-      params: { tree: true, sort: 'sort' },
+      params: { tree: true, sort: 'sort', layout: layoutUid },
     });
     const routes = response?.data?.data || [];
-    this.setRoutes(routes);
+    if (requestId === this.getRefreshRequestId(layoutUid)) {
+      this.setRoutes(routes, layoutUid);
+    }
     return routes;
   }
 
@@ -86,19 +131,26 @@ export class RouteRepository {
    * @returns 当前可访问的路由数组
    */
   async ensureAccessibleLoaded() {
-    if (this.accessibleLoaded) {
-      return this.routes;
+    const layoutUid = this.getCurrentLayoutUid();
+    const cache = this.getRouteCache(layoutUid);
+    if (cache.accessibleLoaded) {
+      this.routes = cache.routes;
+      return cache.routes;
     }
 
-    if (this.accessibleLoadingPromise) {
-      return this.accessibleLoadingPromise;
+    const existingLoadingPromise = this.accessibleLoadingPromises.get(layoutUid);
+    if (existingLoadingPromise) {
+      return existingLoadingPromise;
     }
 
-    this.accessibleLoadingPromise = this.refreshAccessible().finally(() => {
-      this.accessibleLoadingPromise = null;
+    const loadingPromise = this.refreshAccessibleByLayout(layoutUid).finally(() => {
+      if (this.accessibleLoadingPromises.get(layoutUid) === loadingPromise) {
+        this.accessibleLoadingPromises.delete(layoutUid);
+      }
     });
+    this.accessibleLoadingPromises.set(layoutUid, loadingPromise);
 
-    return this.accessibleLoadingPromise;
+    return loadingPromise;
   }
 
   /**
@@ -108,7 +160,7 @@ export class RouteRepository {
    * @returns 取消订阅函数
    */
   subscribe(subscriber: RouteSubscriber) {
-    this.subscribers.add(subscriber);
+    this.subscribers.set(subscriber, this.getCurrentLayoutUid());
     return () => {
       this.subscribers.delete(subscriber);
     };
@@ -132,7 +184,10 @@ export class RouteRepository {
    */
   async createRoute(values: RouteCreateValues, options: RouteMutationOptions = {}) {
     const { refreshAfterMutation = true } = options;
-    const res = await this.getResource('desktopRoutes').create({ values });
+    const res = await this.getResource('desktopRoutes').create({
+      values,
+      layout: this.getCurrentLayoutUid(),
+    });
     if (refreshAfterMutation) {
       await this.refreshAccessible();
     }
@@ -210,7 +265,17 @@ export class RouteRepository {
    * @returns 匹配到的路由节点
    */
   getRouteBySchemaUid(schemaUid: string): NocoBaseDesktopRoute | undefined {
-    return this.findRoute(this.routes, schemaUid);
+    return this.findRoute(this.listAccessible(), schemaUid);
+  }
+
+  /**
+   * 通过路由 id 反查对应路由节点。
+   *
+   * @param routeId 桌面路由主键
+   * @returns 匹配到的路由节点
+   */
+  getRouteById(routeId: string | number): NocoBaseDesktopRoute | undefined {
+    return this.findRouteById(this.listAccessible(), routeId);
   }
 
   protected getAPIClient(): APIClient {
@@ -224,12 +289,59 @@ export class RouteRepository {
     return this.getAPIClient().resource(collectionName);
   }
 
-  protected emitChange() {
-    this.subscribers.forEach((subscriber) => {
-      subscriber();
+  protected emitChange(layoutUid = this.getCurrentLayoutUid()) {
+    this.subscribers.forEach((subscriberLayoutUid, subscriber) => {
+      if (subscriberLayoutUid !== layoutUid) {
+        return;
+      }
+      const previousNotifiedLayoutUid = this.notifiedLayoutUid;
+      this.notifiedLayoutUid = layoutUid;
+      try {
+        subscriber();
+      } finally {
+        this.notifiedLayoutUid = previousNotifiedLayoutUid;
+      }
     });
   }
 
+  private getCurrentLayoutUid() {
+    return this.layoutActivations[this.layoutActivations.length - 1]?.uid || ADMIN_LAYOUT_MODEL_UID;
+  }
+
+  private normalizeLayoutUid(uid: unknown) {
+    return typeof uid === 'string' && uid.trim() ? uid : ADMIN_LAYOUT_MODEL_UID;
+  }
+
+  private getReadableLayoutUid() {
+    return this.notifiedLayoutUid || this.getCurrentLayoutUid();
+  }
+
+  private getRouteCache(layoutUid = this.getCurrentLayoutUid()) {
+    let cache = this.routeCaches.get(layoutUid);
+    if (!cache) {
+      cache = {
+        accessibleLoaded: false,
+        routes: [],
+      };
+      this.routeCaches.set(layoutUid, cache);
+    }
+    return cache;
+  }
+
+  private syncRoutesProperty() {
+    this.routes = this.getRouteCache().routes;
+  }
+
+  private nextRefreshRequestId(layoutUid: string) {
+    const requestId = this.getRefreshRequestId(layoutUid) + 1;
+    this.refreshRequestIds.set(layoutUid, requestId);
+    return requestId;
+  }
+
+  private getRefreshRequestId(layoutUid: string) {
+    return this.refreshRequestIds.get(layoutUid) || 0;
+  }
+
   private findRoute(routes: NocoBaseDesktopRoute[], schemaUid: string): NocoBaseDesktopRoute | undefined {
     for (const route of routes) {
       if (route.schemaUid === schemaUid) {
@@ -244,4 +356,19 @@ export class RouteRepository {
     }
     return undefined;
   }
+
+  private findRouteById(routes: NocoBaseDesktopRoute[], routeId: string | number): NocoBaseDesktopRoute | undefined {
+    for (const route of routes) {
+      if (route.id != null && String(route.id) === String(routeId)) {
+        return route;
+      }
+      if (route.children) {
+        const found = this.findRouteById(route.children, routeId);
+        if (found) {
+          return found;
+        }
+      }
+    }
+    return undefined;
+  }
 }

package/src/RouterManager.tsx

@@ -26,6 +26,7 @@ import type { BaseApplication } from './BaseApplication';
 import { BlankComponent, RouterContextCleaner } from './components';
 import { RouterBridge } from './components/RouterBridge';
 import { Router } from '@remix-run/router';
+import { getV2EffectiveBasePath } from './authRedirect';
 
 export interface BrowserRouterOptions extends Omit<BrowserRouterProps, 'children'> {
   type?: 'browser';
@@ -55,6 +56,87 @@ export interface RouteType extends Omit<RouteObject, 'children' | 'Component'> {
 export type RenderComponentType = (Component: ComponentTypeAndString, props?: any) => React.ReactNode;
 export type RouterComponentType = React.FC<{ BaseLayout?: ComponentType }>;
 
+const DEFAULT_ADMIN_ROUTE_PATH = '/admin';
+
+type AdminRouteNavigationTarget = {
+  currentPathname?: string;
+  targetPathname: unknown;
+  basePath?: string;
+  adminRoutePath?: string;
+  replace?: boolean;
+};
+
+function trimPathSearchAndHash(pathname: string) {
+  return pathname.split(/[?#]/)[0];
+}
+
+function splitPathSearchAndHash(pathname: string) {
+  const match = pathname.match(/^([^?#]*)(.*)$/);
+  return {
+    pathname: match?.[1] || '',
+    suffix: match?.[2] || '',
+  };
+}
+
+function normalizeRootPath(pathname?: string) {
+  const trimmed = trimPathSearchAndHash(pathname || '').trim();
+  if (!trimmed || trimmed === '/') {
+    return '/';
+  }
+  return `/${trimmed.replace(/^\/+|\/+$/g, '')}`;
+}
+
+function isRootRelativePath(pathname: string) {
+  return pathname.startsWith('/') && !pathname.startsWith('//') && !pathname.startsWith('/\\');
+}
+
+function removeBasePath(pathname: string, basePath?: string) {
+  const normalizedPathname = normalizeRootPath(pathname);
+  const normalizedBasePath = normalizeRootPath(basePath);
+
+  if (normalizedBasePath === '/') {
+    return normalizedPathname;
+  }
+  if (normalizedPathname === normalizedBasePath) {
+    return '/';
+  }
+  if (normalizedPathname.startsWith(`${normalizedBasePath}/`)) {
+    return normalizeRootPath(normalizedPathname.slice(normalizedBasePath.length));
+  }
+  return normalizedPathname;
+}
+
+function removeAppSegment(pathname: string) {
+  return normalizeRootPath(pathname).replace(/^\/(?:apps|_app)\/[^/]+(?=\/|$)/, '') || '/';
+}
+
+function normalizePortalRoutePath(pathname: string, basePath?: string) {
+  return removeAppSegment(removeBasePath(pathname, basePath));
+}
+
+function isSameOrChildPath(pathname: string, basePath: string) {
+  const normalizedPathname = normalizeRootPath(pathname);
+  const normalizedBasePath = normalizeRootPath(basePath);
+  return normalizedPathname === normalizedBasePath || normalizedPathname.startsWith(`${normalizedBasePath}/`);
+}
+
+export function shouldOpenAdminRouteInNewWindow(options: AdminRouteNavigationTarget) {
+  if (options.replace || typeof options.targetPathname !== 'string') {
+    return false;
+  }
+
+  const targetPathname = options.targetPathname.trim();
+  if (!isRootRelativePath(targetPathname)) {
+    return false;
+  }
+
+  const adminRoutePath = normalizeRootPath(options.adminRoutePath || DEFAULT_ADMIN_ROUTE_PATH);
+  const currentRoutePath = normalizePortalRoutePath(options.currentPathname || '/', options.basePath);
+  const targetRoutePath = normalizePortalRoutePath(targetPathname, options.basePath);
+
+  return !isSameOrChildPath(currentRoutePath, adminRoutePath) && isSameOrChildPath(targetRoutePath, adminRoutePath);
+}
+
 function removeBasename(pathname: string, basename?: string) {
   if (!basename || basename === '/') {
     return pathname;
@@ -72,6 +154,7 @@ function removeBasename(pathname: string, basename?: string) {
 export class RouterManager<TApp extends BaseApplication<any> = BaseApplication<any>> {
   protected routes: Record<string, RouteType> = {};
   protected options: RouterOptions;
+  private routerNavigate?: Router['navigate'];
   public app: TApp;
   public router!: Router;
   get basename() {
@@ -81,7 +164,7 @@ export class RouterManager<TApp extends BaseApplication<any> = BaseApplication<a
     return this.router.state;
   }
   get navigate() {
-    return this.router.navigate;
+    return this.navigateWithPortalPolicy;
   }
 
   constructor(options: RouterOptions = {}, app: TApp) {
@@ -90,6 +173,62 @@ export class RouterManager<TApp extends BaseApplication<any> = BaseApplication<a
     this.routes = options.routes || {};
   }
 
+  private navigateWithPortalPolicy: Router['navigate'] = ((to, opts) => {
+    if (this.shouldOpenAdminRouteInNewWindow(to, opts)) {
+      window.open(this.getAdminRouteNavigationHref(to as string), '_blank', 'noopener,noreferrer');
+      return Promise.resolve();
+    }
+
+    const navigate = this.routerNavigate || this.router.navigate.bind(this.router);
+    return navigate(to, opts);
+  }) as Router['navigate'];
+
+  private shouldOpenAdminRouteInNewWindow(
+    to: Parameters<Router['navigate']>[0],
+    opts?: Parameters<Router['navigate']>[1],
+  ) {
+    if (this.options.type && this.options.type !== 'browser') {
+      return false;
+    }
+
+    return shouldOpenAdminRouteInNewWindow({
+      currentPathname:
+        typeof window !== 'undefined' ? window.location.pathname : this.router?.state?.location?.pathname,
+      targetPathname: to,
+      basePath: this.getRuntimeBasePath(),
+      adminRoutePath: this.getAdminRoutePath(),
+      replace: opts?.replace,
+    });
+  }
+
+  private getRuntimeBasePath() {
+    return getV2EffectiveBasePath(this.app);
+  }
+
+  private getAdminRoutePath() {
+    try {
+      return this.app.layoutManager?.getLayout?.('admin')?.routePath || DEFAULT_ADMIN_ROUTE_PATH;
+    } catch {
+      return DEFAULT_ADMIN_ROUTE_PATH;
+    }
+  }
+
+  private getAdminRouteNavigationHref(pathname: string) {
+    const { pathname: rawPathname, suffix } = splitPathSearchAndHash(pathname.trim());
+    const normalizedPathname = normalizeRootPath(rawPathname);
+    const runtimeBasePath = this.getRuntimeBasePath();
+    const normalizedBasePath = normalizeRootPath(runtimeBasePath);
+
+    if (
+      normalizedBasePath !== '/' &&
+      (normalizedPathname === normalizedBasePath || normalizedPathname.startsWith(`${normalizedBasePath}/`))
+    ) {
+      return `${normalizedPathname}${suffix}`;
+    }
+
+    return `${this.app.getHref(normalizePortalRoutePath(normalizedPathname, runtimeBasePath))}${suffix}`;
+  }
+
   protected resolveLoadedComponent(moduleOrComponent: ComponentLoaderResult): ComponentTypeAndString | undefined {
     if (!moduleOrComponent) {
       return undefined;
@@ -257,6 +396,8 @@ export class RouterManager<TApp extends BaseApplication<any> = BaseApplication<a
       ],
       opts,
     );
+    this.routerNavigate = this.router.navigate.bind(this.router) as Router['navigate'];
+    this.router.navigate = this.navigateWithPortalPolicy;
 
     const RenderRouter: RouterComponentType = ({ BaseLayout = BlankComponent }) => {
       return (

package/src/__tests__/PluginSettingsManager.test.ts

@@ -78,6 +78,19 @@ describe('PluginSettingsManager v2', () => {
     expect(app.router.get('admin.settings.demo.advanced')).toMatchObject({ path: 'advanced' });
   });
 
+  it('should resolve plugin settings links for plugin manager entries', () => {
+    const app = createMockClient();
+
+    app.pluginSettingsManager.addMenuItem({ key: 'shared', title: 'Shared' });
+    app.pluginSettingsManager.addPageTabItem({ menuKey: 'shared', key: 'target', title: 'Target' });
+    app.pluginSettingsManager.setPluginSettingsLink('demo-plugin', 'shared.target');
+
+    expect(app.pluginSettingsManager.has('demo-plugin')).toBe(false);
+    expect(app.pluginSettingsManager.hasPluginSettings('demo-plugin')).toBe(true);
+    expect(app.pluginSettingsManager.getPluginSettingsName('demo-plugin')).toBe('shared.target');
+    expect(app.pluginSettingsManager.getPluginSettingsRoutePath('demo-plugin')).toBe('/admin/settings/shared/target');
+  });
+
   it('should render string icon on both menu and page tab via renderIcon', () => {
     // Previously `renderPage` spread the raw `icon` string straight to the antd
     // Menu item, which displayed "LockOutlinedTitle" as text. Both `renderMenuItem`