@nocobase/client-v2 2.1.0-beta.27 → 2.1.0-beta.30

package/src/flow/admin-shell/admin-layout/resolveAdminRouteRuntimeTarget.ts

@@ -8,15 +8,21 @@
  */
 
 import type { BaseApplication } from '../../../BaseApplication';
-import { convertV2AdminPathToLegacy } from '../../../authRedirect';
 import { NocoBaseDesktopRouteType, type NocoBaseDesktopRoute } from '../../../flow-compat';
 
 export type AdminRouteNavigationMode = 'spa' | 'document';
+export type AdminRouteRuntimeTargetReason =
+  | 'ok'
+  | 'missingSchemaUid'
+  | 'unsupportedV2Runtime'
+  | 'emptyGroup'
+  | 'unsupportedRouteType';
 
 export type AdminRouteRuntimeTarget = {
   runtimePath: string | null;
   navigationMode: AdminRouteNavigationMode;
   isLegacy: boolean;
+  reason: AdminRouteRuntimeTargetReason;
 };
 
 const V2_PUBLIC_PATH_SUFFIX = '/v2/';
@@ -45,6 +51,7 @@ const EMPTY_TARGET: AdminRouteRuntimeTarget = {
   runtimePath: null,
   navigationMode: 'spa',
   isLegacy: false,
+  reason: 'unsupportedRouteType',
 };
 
 function normalizeRootRelativePath(pathname: string) {
@@ -60,14 +67,8 @@ function normalizePublicPath(value = '/') {
   return normalized.endsWith('/') ? normalized : `${normalized}/`;
 }
 
-/**
- * 判断当前应用是否运行在需要兼容跳回 v1 的 `/v2/` 路径下。
- *
- * @param {ResolveAdminRouteRuntimeTargetOptions['app']} app 当前应用实例
- * @returns {boolean} 是否启用 v2 到 v1 的经典页跳转
- */
-function shouldUseLegacyDocumentNavigation(app: ResolveAdminRouteRuntimeTargetOptions['app']) {
-  return normalizePublicPath(app.getPublicPath()).endsWith(V2_PUBLIC_PATH_SUFFIX);
+export function isV2AdminRuntime(app?: ResolveAdminRouteRuntimeTargetOptions['app']) {
+  return !!app?.getPublicPath && normalizePublicPath(app.getPublicPath()).endsWith(V2_PUBLIC_PATH_SUFFIX);
 }
 
 export function toRouterNavigationPath(pathname: string, basename?: string) {
@@ -114,12 +115,6 @@ function appendLocationState(pathname: string, location?: LocationLike) {
   return `${pathname}${search}${hash}`;
 }
 
-function isSameOrDescendantPath(pathname: string, basePath: string) {
-  const normalizedPathname = normalizeRootRelativePath(pathname);
-  const normalizedBasePath = normalizeRootRelativePath(basePath);
-  return normalizedPathname === normalizedBasePath || normalizedPathname.startsWith(`${normalizedBasePath}/`);
-}
-
 function logInvalidTarget(
   logger: ResolveAdminRouteRuntimeTargetOptions['log'],
   reason: string,
@@ -134,6 +129,47 @@ function isSkippableRoute(route: NocoBaseDesktopRoute | undefined) {
   );
 }
 
+export function isV2MenuRoute(route: NocoBaseDesktopRoute | undefined): boolean {
+  if (!route || route.hidden === true || route.hideInMenu === true) {
+    return false;
+  }
+
+  if (route.type === NocoBaseDesktopRouteType.flowPage || route.type === NocoBaseDesktopRouteType.link) {
+    return true;
+  }
+
+  if (route.type === NocoBaseDesktopRouteType.group) {
+    return Array.isArray(route.children) && route.children.some((child) => isV2MenuRoute(child));
+  }
+
+  return false;
+}
+
+export function findFirstV2LandingRoute(routes: NocoBaseDesktopRoute[] | undefined): NocoBaseDesktopRoute | undefined {
+  if (!Array.isArray(routes)) {
+    return undefined;
+  }
+
+  for (const route of routes) {
+    if (!route || route.hidden === true || route.hideInMenu === true || route.type === NocoBaseDesktopRouteType.tabs) {
+      continue;
+    }
+
+    if (route.type === NocoBaseDesktopRouteType.flowPage) {
+      return route;
+    }
+
+    if (route.type === NocoBaseDesktopRouteType.group) {
+      const nested = findFirstV2LandingRoute(route.children);
+      if (nested) {
+        return nested;
+      }
+    }
+  }
+
+  return undefined;
+}
+
 export function findFirstAccessiblePageRoute(
   routes: NocoBaseDesktopRoute[] | undefined,
 ): NocoBaseDesktopRoute | undefined {
@@ -161,64 +197,44 @@ export function findFirstAccessiblePageRoute(
   return undefined;
 }
 
-function resolvePageRuntimeTarget(options: ResolveAdminRouteRuntimeTargetOptions, route: NocoBaseDesktopRoute) {
+function resolvePageRuntimeTarget(
+  options: ResolveAdminRouteRuntimeTargetOptions,
+  route: NocoBaseDesktopRoute,
+): AdminRouteRuntimeTarget {
   const { app, preserveLocationState, location, log = console.warn } = options;
 
   if (!route.schemaUid) {
     logInvalidTarget(log, 'Missing schemaUid.', route);
-    return EMPTY_TARGET;
-  }
-
-  if (route.type === NocoBaseDesktopRouteType.flowPage) {
     return {
-      runtimePath: getV2AdminPath(app, route.schemaUid),
-      navigationMode: 'spa' as const,
-      isLegacy: false,
+      ...EMPTY_TARGET,
+      reason: 'missingSchemaUid',
     };
   }
 
-  if (!shouldUseLegacyDocumentNavigation(app)) {
+  if (route.type === NocoBaseDesktopRouteType.flowPage) {
     return {
-      runtimePath:
-        preserveLocationState && location
-          ? appendLocationState(getV2AdminPath(app, route.schemaUid), location)
-          : getV2AdminPath(app, route.schemaUid),
+      runtimePath: getV2AdminPath(app, route.schemaUid),
       navigationMode: 'spa' as const,
       isLegacy: false,
+      reason: 'ok' as const,
     };
   }
 
-  const v2RuntimePath = getV2AdminPath(app, route.schemaUid);
-  const legacyPath = convertV2AdminPathToLegacy(app, v2RuntimePath);
-
-  if (!legacyPath) {
-    logInvalidTarget(log, 'Failed to resolve legacy runtimePath.', route);
-    return EMPTY_TARGET;
-  }
-
-  if (preserveLocationState && location) {
-    if (isSameOrDescendantPath(location.pathname, v2RuntimePath)) {
-      const correctedCurrentPath = convertV2AdminPathToLegacy(app, location);
-      if (correctedCurrentPath) {
-        return {
-          runtimePath: correctedCurrentPath,
-          navigationMode: 'document' as const,
-          isLegacy: true,
-        };
-      }
-    }
-
+  if (isV2AdminRuntime(app)) {
     return {
-      runtimePath: appendLocationState(legacyPath, location),
-      navigationMode: 'document' as const,
-      isLegacy: true,
+      ...EMPTY_TARGET,
+      reason: 'unsupportedV2Runtime',
     };
   }
 
   return {
-    runtimePath: legacyPath,
-    navigationMode: 'document' as const,
-    isLegacy: true,
+    runtimePath:
+      preserveLocationState && location
+        ? appendLocationState(getV2AdminPath(app, route.schemaUid), location)
+        : getV2AdminPath(app, route.schemaUid),
+    navigationMode: 'spa' as const,
+    isLegacy: false,
+    reason: 'ok' as const,
   };
 }
 
@@ -242,9 +258,14 @@ export function resolveAdminRouteRuntimeTarget(
   }
 
   if (route.type === NocoBaseDesktopRouteType.group) {
-    const firstAccessibleRoute = findFirstAccessiblePageRoute(route.children);
+    const firstAccessibleRoute = isV2AdminRuntime(options.app)
+      ? findFirstV2LandingRoute(route.children)
+      : findFirstAccessiblePageRoute(route.children);
     if (!firstAccessibleRoute) {
-      return EMPTY_TARGET;
+      return {
+        ...EMPTY_TARGET,
+        reason: 'emptyGroup',
+      };
     }
     return resolveAdminRouteRuntimeTarget({
       ...options,

package/src/flow/components/AdminLayout.tsx

@@ -14,7 +14,7 @@ import { useApp } from '../../hooks/useApp';
 import { useLocation, useNavigate, useParams } from 'react-router-dom';
 import { NocoBaseDesktopRouteType } from '../../flow-compat';
 import {
-  findFirstAccessiblePageRoute,
+  findFirstV2LandingRoute,
   resolveAdminRouteRuntimeTarget,
   toRouterNavigationPath,
 } from '../admin-shell/admin-layout/resolveAdminRouteRuntimeTarget';
@@ -92,7 +92,7 @@ const AdminLayoutEntryGuard: FC<{ children: React.ReactNode }> = ({ children })
         return;
       }
 
-      const firstAccessibleRoute = findFirstAccessiblePageRoute(routeRepository?.listAccessible?.() || []);
+      const firstAccessibleRoute = findFirstV2LandingRoute(routeRepository?.listAccessible?.() || []);
       if (!firstAccessibleRoute) {
         if (active) {
           setReady(true);

package/src/flow/components/FlowRoute.tsx

@@ -15,10 +15,12 @@ import { useParams } from 'react-router-dom';
 import { useApp } from '../../hooks/useApp';
 import { NocoBaseDesktopRouteType } from '../../flow-compat';
 import { resolveAdminRouteRuntimeTarget } from '../admin-shell/admin-layout/resolveAdminRouteRuntimeTarget';
+import { AppNotFound } from '../../components';
 
 type FlowRouteGuardState = {
   pending: boolean;
   allowBridge: boolean;
+  notFound: boolean;
 };
 
 const BridgeFlowRoute = ({ pageUid }: { pageUid: string }) => {
@@ -91,6 +93,7 @@ const FlowRoute = () => {
   const [guardState, setGuardState] = useState<FlowRouteGuardState>({
     pending: true,
     allowBridge: false,
+    notFound: false,
   });
   const replaceTriggeredRef = useRef(false);
   const requestIdRef = useRef(0);
@@ -104,14 +107,14 @@ const FlowRoute = () => {
     const requestId = ++requestIdRef.current;
 
     const run = async () => {
-      setGuardState({ pending: true, allowBridge: false });
+      setGuardState({ pending: true, allowBridge: false, notFound: false });
 
       if (!routeRepository?.isAccessibleLoaded?.()) {
         try {
           await routeRepository?.ensureAccessibleLoaded?.();
         } catch (_error) {
           if (active && requestId === requestIdRef.current) {
-            setGuardState({ pending: false, allowBridge: true });
+            setGuardState({ pending: false, allowBridge: true, notFound: false });
           }
           return;
         }
@@ -139,10 +142,17 @@ const FlowRoute = () => {
           window.location.replace(target.runtimePath);
           return;
         }
+
+        if (target.reason === 'unsupportedV2Runtime') {
+          if (active && requestId === requestIdRef.current) {
+            setGuardState({ pending: false, allowBridge: false, notFound: true });
+          }
+          return;
+        }
       }
 
       if (active && requestId === requestIdRef.current) {
-        setGuardState({ pending: false, allowBridge: true });
+        setGuardState({ pending: false, allowBridge: true, notFound: false });
       }
     };
 
@@ -159,11 +169,14 @@ const FlowRoute = () => {
     }
 
     if (!guardState.allowBridge) {
+      if (guardState.notFound) {
+        return <AppNotFound />;
+      }
       return null;
     }
 
     return <BridgeFlowRoute pageUid={pageUid} />;
-  }, [guardState.allowBridge, guardState.pending, pageUid]);
+  }, [guardState.allowBridge, guardState.notFound, guardState.pending, pageUid]);
 
   return content;
 };

package/src/flow/models/base/PageModel/PageModel.tsx

@@ -49,6 +49,17 @@ export class PageModel extends FlowModel<PageModelStructure> {
   private unmounted = false;
   private documentTitleUpdateVersion = 0;
 
+  /**
+   * 根页面标签页开关以路由表为准，避免 flow model 里的旧配置覆盖路由管理设置。
+   */
+  private getEnableTabs(): boolean {
+    const routeEnableTabs = (this.context as any)?.currentRoute?.enableTabs;
+    if (this.props.routeId != null && typeof routeEnableTabs === 'boolean') {
+      return routeEnableTabs;
+    }
+    return !!this.props.enableTabs;
+  }
+
   private getActiveTabKey(): string | undefined {
     const viewParams = this.context.view?.navigation?.viewParams;
     if (viewParams) {
@@ -193,7 +204,7 @@ export class PageModel extends FlowModel<PageModelStructure> {
     };
 
     let nextTitle = '';
-    if (this.props.enableTabs) {
+    if (this.getEnableTabs()) {
       const activeTabKey = preferredActiveTabKey || this.getActiveTabKey();
       const activeTabModel = activeTabKey
         ? (this.flowEngine.getModel(activeTabKey) as BasePageTabModel | undefined)
@@ -356,13 +367,14 @@ export class PageModel extends FlowModel<PageModelStructure> {
       headerStyle.paddingBlock = token.paddingSM;
       headerStyle.paddingInline = token.paddingLG;
     }
-    if (this.props.enableTabs) {
+    const enableTabs = this.getEnableTabs();
+    if (enableTabs) {
       headerStyle.paddingBottom = 0;
     }
     return (
       <>
         {this.props.displayTitle && <PageHeader title={this.props.title} style={headerStyle} />}
-        {this.props.enableTabs ? this.renderTabs() : this.renderFirstTab()}
+        {enableTabs ? this.renderTabs() : this.renderFirstTab()}
       </>
     );
   }

package/src/flow/models/base/PageModel/RootPageModel.tsx

@@ -17,6 +17,31 @@ import { PageModel } from './PageModel';
 export class RootPageModel extends PageModel {
   mounted = false;
 
+  /**
+   * 打开页面设置前，把标签页开关表单值同步为路由表中的当前状态。
+   */
+  private syncPageSettingsEnableTabsFromRoute() {
+    const routeEnableTabs = (this.context as any)?.currentRoute?.enableTabs;
+    if (typeof routeEnableTabs !== 'boolean') {
+      return;
+    }
+    this.setStepParams('pageSettings', 'general', {
+      enableTabs: routeEnableTabs,
+    });
+  }
+
+  /**
+   * 保存页面设置后立即同步当前页面状态，让标签页显隐无需等路由列表刷新或页面重载。
+   */
+  private syncEnableTabsToCurrentPage(enableTabs: boolean) {
+    const currentRoute = (this.context as any)?.currentRoute;
+    const routeId = this.props.routeId;
+    if (currentRoute && (routeId == null || currentRoute.id == null || String(currentRoute.id) === String(routeId))) {
+      currentRoute.enableTabs = enableTabs;
+    }
+    this.setProps('enableTabs', enableTabs);
+  }
+
   /**
    * 新建 tab 在首次保存完成前，前端 route 里可能还没有数据库 id。
    * 拖拽前兜底触发一次保存，确保 move 接口拿到真实主键。
@@ -65,18 +90,28 @@ export class RootPageModel extends PageModel {
     );
   }
 
+  async openFlowSettings(options?: Parameters<PageModel['openFlowSettings']>[0]) {
+    if (options?.flowKey === 'pageSettings' && options?.stepKey === 'general') {
+      this.syncPageSettingsEnableTabsFromRoute();
+    }
+    return super.openFlowSettings(options);
+  }
+
   async saveStepParams() {
     await super.saveStepParams();
 
     if (this.stepParams.pageSettings) {
+      const enableTabs = !!this.stepParams.pageSettings.general.enableTabs;
       // 更新路由
-      this.context.api.request({
+      await this.context.api.request({
         url: `desktopRoutes:update?filter[id]=${this.props.routeId}`,
         method: 'post',
         data: {
-          enableTabs: !!this.stepParams.pageSettings.general.enableTabs,
+          enableTabs,
         },
       });
+      this.syncEnableTabsToCurrentPage(enableTabs);
+      await this.context.refreshDesktopRoutes?.();
     }
   }
 

package/src/flow/models/base/PageModel/__tests__/PageModel.test.ts

@@ -412,6 +412,7 @@ describe('PageModel', () => {
   describe('render header spacing with tabs', () => {
     it('should compact page header bottom spacing when tabs are enabled', () => {
       pageModel.props = {
+        routeId: 'route-1',
         displayTitle: true,
         enableTabs: true,
         title: 'Title',
@@ -430,6 +431,7 @@ describe('PageModel', () => {
 
     it('should keep original header style when tabs are disabled', () => {
       pageModel.props = {
+        routeId: 'route-1',
         displayTitle: true,
         enableTabs: false,
         title: 'Title',
@@ -442,6 +444,57 @@ describe('PageModel', () => {
 
       expect(header.props.style).toEqual({ backgroundColor: 'var(--colorBgLayout)' });
     });
+
+    it('should use desktop route enableTabs=false before flow model props', () => {
+      pageModel.props = {
+        routeId: 'route-1',
+        displayTitle: true,
+        enableTabs: true,
+        title: 'Title',
+        headerStyle: { backgroundColor: 'var(--colorBgLayout)' },
+      } as any;
+      (pageModel as any).context = {
+        currentRoute: {
+          enableTabs: false,
+        },
+      };
+      pageModel.renderTabs = vi.fn(() => null);
+      pageModel.renderFirstTab = vi.fn(() => null);
+
+      const result = pageModel.render() as any;
+      const header = result.props.children[0];
+
+      expect(pageModel.renderTabs).not.toHaveBeenCalled();
+      expect(pageModel.renderFirstTab).toHaveBeenCalled();
+      expect(header.props.style).toEqual({ backgroundColor: 'var(--colorBgLayout)' });
+    });
+
+    it('should use desktop route enableTabs=true before flow model props', () => {
+      pageModel.props = {
+        routeId: 'route-1',
+        displayTitle: true,
+        enableTabs: false,
+        title: 'Title',
+        headerStyle: { backgroundColor: 'var(--colorBgLayout)' },
+      } as any;
+      (pageModel as any).context = {
+        currentRoute: {
+          enableTabs: true,
+        },
+      };
+      pageModel.renderTabs = vi.fn(() => null);
+      pageModel.renderFirstTab = vi.fn(() => null);
+
+      const result = pageModel.render() as any;
+      const header = result.props.children[0];
+
+      expect(pageModel.renderTabs).toHaveBeenCalled();
+      expect(pageModel.renderFirstTab).not.toHaveBeenCalled();
+      expect(header.props.style).toMatchObject({
+        backgroundColor: 'var(--colorBgLayout)',
+        paddingBottom: 0,
+      });
+    });
   });
 
   describe('dirty refresh signal', () => {
@@ -574,6 +627,26 @@ describe('PageModel', () => {
       expect(document.title).toBe('Resolved tab doc title');
     });
 
+    it('should use page documentTitle when desktop route disables tabs even if flow model enables tabs', async () => {
+      pageModel.props = { routeId: 'route-1', enableTabs: true, title: 'Route page title' } as any;
+      (pageModel as any).context.currentRoute = {
+        enableTabs: false,
+      };
+      (pageModel as any).stepParams = {
+        pageSettings: {
+          general: {
+            documentTitle: 'Route page doc title',
+          },
+        },
+      };
+      (pageModel as any).context.resolveJsonTemplate = vi.fn(async () => 'Resolved route page doc title');
+
+      await (pageModel as any).updateDocumentTitle();
+
+      expect((pageModel as any).context.resolveJsonTemplate).toHaveBeenCalledWith('Route page doc title');
+      expect(document.title).toBe('Resolved route page doc title');
+    });
+
     it('should fallback to tab title when active tab documentTitle is empty', async () => {
       pageModel.props = { enableTabs: true } as any;
       const activeTab = {

package/src/flow/models/base/PageModel/__tests__/RootPageModel.test.ts

@@ -12,10 +12,32 @@ import { RootPageModel } from '../RootPageModel';
 
 // Mock PageModel
 const mockPageModelSaveStepParams = vi.fn();
+const mockPageModelOpenFlowSettings = vi.fn();
 vi.mock('../PageModel', () => ({
   PageModel: class {
+    props: any = {};
+    stepParams: any = {};
+
     static registerFlow() {}
 
+    setProps(key: string, value: any) {
+      this.props[key] = value;
+    }
+
+    setStepParams(flowKey: string, stepKey: string, params: Record<string, any>) {
+      if (!this.stepParams[flowKey]) {
+        this.stepParams[flowKey] = {};
+      }
+      this.stepParams[flowKey][stepKey] = {
+        ...this.stepParams[flowKey][stepKey],
+        ...params,
+      };
+    }
+
+    async openFlowSettings(options?: any) {
+      return mockPageModelOpenFlowSettings(options);
+    }
+
     async saveStepParams() {
       return mockPageModelSaveStepParams();
     }
@@ -26,6 +48,7 @@ describe('RootPageModel', () => {
   let rootPageModel: RootPageModel;
   let mockContext: any;
   let mockApi: any;
+  let mockRefreshDesktopRoutes: any;
   let mockFlowEngine: any;
 
   beforeEach(() => {
@@ -35,6 +58,7 @@ describe('RootPageModel', () => {
     mockApi = {
       request: vi.fn().mockResolvedValue({ data: { success: true } }),
     };
+    mockRefreshDesktopRoutes = vi.fn().mockResolvedValue(undefined);
 
     // Mock FlowEngine
     mockFlowEngine = {
@@ -45,6 +69,11 @@ describe('RootPageModel', () => {
     // Mock context
     mockContext = {
       api: mockApi,
+      refreshDesktopRoutes: mockRefreshDesktopRoutes,
+      currentRoute: {
+        id: 'route-123',
+        enableTabs: true,
+      },
     };
 
     // Create RootPageModel instance
@@ -63,6 +92,65 @@ describe('RootPageModel', () => {
     };
   });
 
+  describe('openFlowSettings', () => {
+    it('should use desktop route enableTabs as settings dialog initial value', async () => {
+      mockContext.currentRoute.enableTabs = false;
+      (rootPageModel as any).stepParams = {
+        pageSettings: {
+          general: {
+            displayTitle: true,
+            enableTabs: true,
+          },
+        },
+      };
+
+      await rootPageModel.openFlowSettings({ flowKey: 'pageSettings', stepKey: 'general' } as any);
+
+      expect((rootPageModel as any).stepParams.pageSettings.general).toMatchObject({
+        displayTitle: true,
+        enableTabs: false,
+      });
+      expect(mockPageModelOpenFlowSettings).toHaveBeenCalledWith({
+        flowKey: 'pageSettings',
+        stepKey: 'general',
+      });
+    });
+
+    it('should keep flow model enableTabs when route status is unavailable', async () => {
+      mockContext.currentRoute = {};
+      (rootPageModel as any).stepParams = {
+        pageSettings: {
+          general: {
+            enableTabs: true,
+          },
+        },
+      };
+
+      await rootPageModel.openFlowSettings({ flowKey: 'pageSettings', stepKey: 'general' } as any);
+
+      expect((rootPageModel as any).stepParams.pageSettings.general.enableTabs).toBe(true);
+    });
+
+    it('should not sync enableTabs when opening other settings steps', async () => {
+      mockContext.currentRoute.enableTabs = false;
+      (rootPageModel as any).stepParams = {
+        pageSettings: {
+          general: {
+            enableTabs: true,
+          },
+        },
+      };
+
+      await rootPageModel.openFlowSettings({ flowKey: 'otherSettings', stepKey: 'general' } as any);
+
+      expect((rootPageModel as any).stepParams.pageSettings.general.enableTabs).toBe(true);
+      expect(mockPageModelOpenFlowSettings).toHaveBeenCalledWith({
+        flowKey: 'otherSettings',
+        stepKey: 'general',
+      });
+    });
+  });
+
   describe('saveStepParams', () => {
     it('should call parent saveStepParams method', async () => {
       await rootPageModel.saveStepParams();
@@ -89,6 +177,34 @@ describe('RootPageModel', () => {
         },
       });
     });
+
+    it('should refresh desktop routes after route update is persisted', async () => {
+      await rootPageModel.saveStepParams();
+
+      expect(mockApi.request).toHaveBeenCalledTimes(1);
+      expect(mockRefreshDesktopRoutes).toHaveBeenCalledTimes(1);
+      expect(mockApi.request.mock.invocationCallOrder[0]).toBeLessThan(
+        mockRefreshDesktopRoutes.mock.invocationCallOrder[0],
+      );
+    });
+
+    it('should apply enableTabs to current page immediately after route update is persisted', async () => {
+      (rootPageModel as any).stepParams = {
+        pageSettings: {
+          general: {
+            enableTabs: false,
+          },
+        },
+      };
+
+      await rootPageModel.saveStepParams();
+
+      expect(mockContext.currentRoute.enableTabs).toBe(false);
+      expect((rootPageModel as any).props.enableTabs).toBe(false);
+      expect(mockApi.request.mock.invocationCallOrder[0]).toBeLessThan(
+        mockRefreshDesktopRoutes.mock.invocationCallOrder[0],
+      );
+    });
   });
 
   describe('handleDragEnd', () => {