@nocobase/client-v2 2.1.11 → 2.2.0-alpha.2

package/src/flow/admin-shell/admin-layout/AdminLayoutMenuUtils.tsx

@@ -38,7 +38,11 @@ import {
   VariableScope,
   withTooltipComponent,
 } from './AdminLayoutCompat';
-import { toRouterNavigationPath } from './resolveAdminRouteRuntimeTarget';
+import {
+  type AdminLayoutRoutePathLike,
+  joinAdminLayoutRoutePath,
+  toRouterNavigationPath,
+} from './resolveAdminRouteRuntimeTarget';
 
 export type AdminLayoutMenuRenderType = 'item' | 'group';
 
@@ -122,8 +126,30 @@ type AdminLayoutMenuItemsParent = FlowModel & {
  * @param identity 节点身份
  * @returns 唯一占位路径
  */
-export const getAdminLayoutMenuVirtualPath = (type: 'link' | 'designer', identity: string | number) => {
-  return `/admin/__admin_layout__/${type}/${encodeURIComponent(String(identity))}`;
+export const getAdminLayoutMenuVirtualPath = (
+  type: 'link' | 'designer',
+  identity: string | number,
+  layout?: AdminLayoutRoutePathLike | null,
+) => {
+  return joinAdminLayoutRoutePath(layout, `__admin_layout__/${type}/${encodeURIComponent(String(identity))}`);
+};
+
+const getLayoutRoutePathFromModel = (model: FlowModel): AdminLayoutRoutePathLike | undefined => {
+  const contextLayout = model.context.layout as AdminLayoutRoutePathLike | undefined;
+  if (contextLayout?.routePath) {
+    return contextLayout;
+  }
+
+  let current: FlowModel | undefined = model;
+  while (current) {
+    const propsLayout = current.props?.layout as AdminLayoutRoutePathLike | undefined;
+    if (propsLayout?.routePath) {
+      return propsLayout;
+    }
+    current = current.parent as FlowModel | undefined;
+  }
+
+  return undefined;
 };
 
 const menuItemStyle = { display: 'flex', alignItems: 'center', justifyContent: 'space-between' };
@@ -225,6 +251,41 @@ export const resolveAdminLayoutMenuLink = async (options: {
   return appendQueryStringToUrl(String(resolvedHref ?? href ?? ''), qs.stringify(query));
 };
 
+function normalizeRouterBasename(basename?: string) {
+  if (!basename || basename === '/') {
+    return '';
+  }
+
+  return `/${basename.replace(/^\/+/, '').replace(/\/+$/, '')}`;
+}
+
+function isStandaloneDocumentUrl(url: string) {
+  return /^[a-z][a-z\d+\-.]*:/i.test(url) || url.startsWith('//') || url.startsWith('#') || url.startsWith('?');
+}
+
+function toDocumentUrlWithRouterBasename(url: string, basename?: string) {
+  if (!url || isStandaloneDocumentUrl(url)) {
+    return url;
+  }
+
+  const normalizedBasename = normalizeRouterBasename(basename);
+  if (!normalizedBasename) {
+    return url;
+  }
+
+  const rootRelativeUrl = url.startsWith('/') ? url : `/${url}`;
+  if (
+    rootRelativeUrl === normalizedBasename ||
+    rootRelativeUrl.startsWith(`${normalizedBasename}/`) ||
+    rootRelativeUrl.startsWith(`${normalizedBasename}?`) ||
+    rootRelativeUrl.startsWith(`${normalizedBasename}#`)
+  ) {
+    return rootRelativeUrl;
+  }
+
+  return `${normalizedBasename}${rootRelativeUrl}`;
+}
+
 export const openAdminLayoutMenuLink = async (options: {
   context: FlowModel['context'];
   href: string;
@@ -249,7 +310,7 @@ export const openAdminLayoutMenuLink = async (options: {
       if (isMobile) {
         closeMobileMenu();
       }
-      window.open(url, '_blank', 'noopener,noreferrer');
+      window.open(toDocumentUrlWithRouterBasename(url, basenameOfCurrentRouter), '_blank', 'noopener,noreferrer');
       return;
     }
 
@@ -265,7 +326,7 @@ export const openAdminLayoutMenuLink = async (options: {
     if (isMobile) {
       closeMobileMenu();
     }
-    window.open(href, '_blank', 'noopener,noreferrer');
+    window.open(toDocumentUrlWithRouterBasename(href, basenameOfCurrentRouter), '_blank', 'noopener,noreferrer');
   }
 };
 
@@ -551,7 +612,7 @@ const GroupItem: FC<{ item: AdminLayoutMenuNode; options?: AdminLayoutMenuRender
         },
       });
     },
-    [closeMobileMenu, item, item._navigationMode, navigate, props.options?.isMobile, runtimePath, spaRuntimePath],
+    [closeMobileMenu, item, navigate, props.options?.isMobile, runtimePath, spaRuntimePath],
   );
 
   const landingEntryAriaLabel = ariaLabel ? `${ariaLabel}-landing-entry` : 'group-landing-entry';
@@ -699,7 +760,7 @@ const MenuItem: FC<{ item: AdminLayoutMenuNode; options?: AdminLayoutMenuRenderO
         },
       });
     },
-    [props.options?.isMobile, closeMobileMenu, isDocumentNavigation, item, navigate, runtimePath, spaRuntimePath],
+    [props.options?.isMobile, closeMobileMenu, isDocumentNavigation, navigate, runtimePath, spaRuntimePath],
   );
 
   if (item._route?.type === NocoBaseDesktopRouteType.link) {
@@ -876,14 +937,16 @@ export function getAdminLayoutMenuInitializerButton(
   testId: string,
   launcherModel: FlowModel,
   parentRoute?: NocoBaseDesktopRoute,
+  layout?: AdminLayoutRoutePathLike | null,
 ): AdminLayoutMenuNode {
   const identity =
     parentRoute?.id ?? parentRoute?.schemaUid ?? parentRoute?.menuSchemaUid ?? parentRoute?.title ?? launcherModel.uid;
+  const menuLayout = layout || getLayoutRoutePathFromModel(launcherModel);
 
   return {
     key: 'x-designer-button',
     name: <MenuDesignerButton testId={testId} launcherModel={launcherModel} parentRoute={parentRoute} />,
-    path: getAdminLayoutMenuVirtualPath('designer', identity),
+    path: getAdminLayoutMenuVirtualPath('designer', identity, menuLayout),
     disabled: true,
     _route: {},
     _parentRoute: parentRoute,

package/src/flow/admin-shell/admin-layout/AdminLayoutModel.tsx

@@ -114,7 +114,7 @@ export class AdminLayoutModel extends BaseLayoutModel<AdminLayoutStructure> {
 
   render() {
     return (
-      <AdminLayoutEntryGuard>
+      <AdminLayoutEntryGuard model={this}>
         <AdminLayoutComponent {...this.props} model={this} />
       </AdminLayoutEntryGuard>
     );

package/src/flow/admin-shell/admin-layout/AdminLayoutSlotModels.tsx

@@ -16,10 +16,17 @@ import { useTranslation } from 'react-i18next';
 import { Outlet, useLocation, useMatches, useParams } from 'react-router-dom';
 import { KeepAlive } from '../../../components/KeepAlive';
 import { getLayoutContentRouteNames } from '../../../layout-manager/utils';
-import { isV2AdminRuntime, isV2MenuRoute } from './resolveAdminRouteRuntimeTarget';
+import {
+  getAdminLayoutRoutePath,
+  isV2AdminRuntime,
+  isV2MenuRoute,
+  type AdminLayoutRoutePathLike,
+} from './resolveAdminRouteRuntimeTarget';
 
 type AdminLayoutContentProps = {
   onContentElementChange?: (element: HTMLDivElement | null) => void;
+  layout?: (AdminLayoutRoutePathLike & { routeName?: string }) | null;
+  designable?: boolean;
 };
 
 const layoutContentClass = css`
@@ -49,8 +56,6 @@ const mobileHeight = {
   height: `calc(100dvh - var(--nb-header-height))`,
 };
 
-const adminLayoutContentRouteNames = getLayoutContentRouteNames('admin');
-
 /**
  * 检测当前浏览器是否支持 dvh，移动端支持时优先使用它计算可视区域高度。
  *
@@ -66,7 +71,7 @@ function isDvhSupported() {
   return testEl.style.height === '1dvh';
 }
 
-const ShowTipWhenNoPages = observer(() => {
+const ShowTipWhenNoPages = observer((props: { designable?: boolean; layout?: AdminLayoutRoutePathLike | null }) => {
   const flowEngine = useFlowEngine();
   const { token } = antdTheme.useToken();
   const { t } = useTranslation();
@@ -75,9 +80,14 @@ const ShowTipWhenNoPages = observer(() => {
   const visibleRoutes = isV2AdminRuntime(flowEngine.context.app)
     ? allAccessRoutes.filter((route) => isV2MenuRoute(route))
     : allAccessRoutes;
-  const designable = !!flowEngine.context.flowSettingsEnabled;
+  const designable = !!props.designable || !!flowEngine.context.flowSettingsEnabled;
+  const layoutRoutePath = getAdminLayoutRoutePath(props.layout);
 
-  if (visibleRoutes.length === 0 && !designable && ['/admin', '/admin/'].includes(location.pathname)) {
+  if (
+    visibleRoutes.length === 0 &&
+    !designable &&
+    (location.pathname === layoutRoutePath || location.pathname === `${layoutRoutePath}/`)
+  ) {
     return (
       <Result
         icon={<HighlightOutlined style={{ fontSize: '8em', color: token.colorText }} />}
@@ -95,13 +105,17 @@ const ShowTipWhenNoPages = observer(() => {
  *
  * 内容区不再依赖独立 FlowModel，而是通过回调把挂载目标同步给 root model。
  */
-export const AdminLayoutContent: FC<AdminLayoutContentProps> = ({ onContentElementChange }) => {
+export const AdminLayoutContent: FC<AdminLayoutContentProps> = ({ designable, onContentElementChange, layout }) => {
   const style = useMemo(() => (isDvhSupported() ? mobileHeight : undefined), []);
   const params = useParams();
   const matches = useMatches();
   const pageUid = params.name;
   const currentRouteId = matches.at(-1)?.id;
-  const shouldKeepAlive = !!pageUid && adminLayoutContentRouteNames.includes(currentRouteId || '');
+  const layoutContentRouteNames = useMemo(
+    () => getLayoutContentRouteNames(layout?.routeName || 'admin'),
+    [layout?.routeName],
+  );
+  const shouldKeepAlive = !!pageUid && layoutContentRouteNames.includes(currentRouteId || '');
   const bindLayoutContentRef = useCallback(
     (node: HTMLDivElement | null) => {
       // shell 直接渲染内容区时，仍需把挂载目标同步给 root model。
@@ -118,7 +132,7 @@ export const AdminLayoutContent: FC<AdminLayoutContentProps> = ({ onContentEleme
     >
       <div style={pageContentStyle}>
         {shouldKeepAlive && pageUid ? <KeepAlive uid={pageUid}>{() => <Outlet />}</KeepAlive> : <Outlet />}
-        <ShowTipWhenNoPages />
+        <ShowTipWhenNoPages designable={designable} layout={layout} />
       </div>
     </div>
   );

package/src/flow/admin-shell/admin-layout/__tests__/AdminLayoutComponent.test.tsx

@@ -0,0 +1,188 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { FlowEngine, FlowEngineProvider } from '@nocobase/flow-engine';
+import { act, render, screen, waitFor } from '@testing-library/react';
+import React, { useEffect } from 'react';
+import { createMemoryRouter, RouterProvider, useParams } from 'react-router-dom';
+import { describe, expect, it, vi } from 'vitest';
+import type { LayoutDefinition } from '../../../../layout-manager/types';
+import { AdminLayoutComponent } from '../AdminLayoutComponent';
+import { AdminLayoutModel } from '../AdminLayoutModel';
+import { AdminLayoutContent } from '../AdminLayoutSlotModels';
+
+vi.mock('@ant-design/pro-layout', async () => {
+  const ReactModule = await import('react');
+  const RouteContext = ReactModule.createContext({ isMobile: false });
+
+  return {
+    default: (props: { children?: React.ReactNode }) =>
+      ReactModule.createElement(
+        RouteContext.Provider,
+        { value: { isMobile: false } },
+        ReactModule.createElement('div', { 'data-testid': 'pro-layout' }, props.children),
+      ),
+    RouteContext,
+  };
+});
+
+vi.mock('../../../system-settings', () => ({
+  useSystemSettings: () => ({
+    loading: false,
+    data: {
+      data: {
+        title: 'NocoBase',
+      },
+    },
+  }),
+}));
+
+vi.mock('../useApplications', () => ({
+  useApplications: () => ({
+    appList: [],
+  }),
+}));
+
+vi.mock('../AppListRender', () => ({
+  useAppListRender: () => undefined,
+}));
+
+describe('AdminLayoutComponent', () => {
+  it('keeps custom admin layout pages alive by layout route name', async () => {
+    const layout: LayoutDefinition = {
+      routeName: 'admin2',
+      routePath: '/admin2',
+      rootRouteName: 'admin2',
+      uid: 'custom-admin-layout-model',
+      layoutModelClass: 'AdminLayoutModel',
+      rootPageModelClass: 'RootPageModel',
+      childPageModelClass: 'ChildPageModel',
+      authCheck: true,
+    };
+    const events: string[] = [];
+    const engine = new FlowEngine();
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        listAccessible: () => [],
+      },
+    });
+
+    const Page = () => {
+      const { name } = useParams();
+      useEffect(() => {
+        events.push(`mount:${name}`);
+        return () => {
+          events.push(`unmount:${name}`);
+        };
+      }, [name]);
+
+      return <div data-testid={`admin-layout-page-${name}`}>page {name}</div>;
+    };
+
+    const router = createMemoryRouter(
+      [
+        {
+          id: layout.routeName,
+          path: layout.routePath,
+          element: <AdminLayoutContent layout={layout} />,
+          children: [
+            {
+              id: 'admin2.__page',
+              path: ':name',
+              element: <Page />,
+            },
+          ],
+        },
+      ],
+      {
+        initialEntries: ['/admin2/page-a'],
+      },
+    );
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <RouterProvider router={router} />
+      </FlowEngineProvider>,
+    );
+
+    expect(await screen.findByTestId('admin-layout-page-page-a')).toBeInTheDocument();
+
+    await act(async () => {
+      await router.navigate('/admin2/page-b');
+    });
+
+    expect(await screen.findByTestId('admin-layout-page-page-b')).toBeInTheDocument();
+    expect(screen.getByTestId('admin-layout-page-page-a')).toBeInTheDocument();
+    expect(events).toEqual(['mount:page-a', 'mount:page-b']);
+  });
+
+  it('activates the current layout before loading accessible routes', async () => {
+    const layout: LayoutDefinition = {
+      routeName: 'admin2',
+      routePath: '/admin2',
+      rootRouteName: 'admin2',
+      uid: 'custom-admin-layout-model',
+      layoutModelClass: 'AdminLayoutModel',
+      rootPageModelClass: 'RootPageModel',
+      childPageModelClass: 'ChildPageModel',
+      authCheck: true,
+    };
+    const deactivateLayout = vi.fn();
+    const activateLayout = vi.fn(() => deactivateLayout);
+    const ensureAccessibleLoaded = vi.fn(async () => []);
+    const engine = new FlowEngine();
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        activateLayout,
+        ensureAccessibleLoaded,
+        listAccessible: () => [],
+        subscribe: vi.fn(),
+        unsubscribe: vi.fn(),
+      },
+    });
+    engine.context.defineProperty('t', {
+      value: (key: string) => key,
+    });
+    const model = engine.createModel<AdminLayoutModel>({
+      uid: layout.uid,
+      use: AdminLayoutModel,
+      props: {
+        layout,
+      },
+    });
+
+    const router = createMemoryRouter(
+      [
+        {
+          id: layout.routeName,
+          path: layout.routePath,
+          element: <AdminLayoutComponent model={model} />,
+        },
+      ],
+      {
+        initialEntries: ['/admin2'],
+      },
+    );
+    const { unmount } = render(
+      <FlowEngineProvider engine={engine}>
+        <RouterProvider router={router} />
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(ensureAccessibleLoaded).toHaveBeenCalled();
+    });
+    expect(activateLayout).toHaveBeenCalledWith(layout);
+    expect(activateLayout.mock.invocationCallOrder[0]).toBeLessThan(ensureAccessibleLoaded.mock.invocationCallOrder[0]);
+
+    unmount();
+
+    expect(deactivateLayout).toHaveBeenCalledTimes(1);
+  });
+});

package/src/flow/admin-shell/admin-layout/__tests__/AdminLayoutMenuModels.test.ts

@@ -318,6 +318,50 @@ describe('AdminLayoutModel menu items', () => {
     expect(route.children[1]._model).toBe(adminLayoutModel.subModels.menuItems?.[1]);
   });
 
+  it('should generate ProLayout route tree under a custom admin layout route path', () => {
+    const adminLayoutModel = engine.createModel<AdminLayoutModel>({
+      uid: 'admin2-layout-model',
+      use: AdminLayoutModel,
+      props: {
+        layout: {
+          routeName: 'admin2',
+          routePath: '/admin2',
+          uid: 'admin2-layout-model',
+          layoutModelClass: 'AdminLayoutModel',
+        },
+      },
+    });
+
+    adminLayoutModel.syncMenuRoutes([
+      {
+        id: 1,
+        title: 'Group',
+        type: NocoBaseDesktopRouteType.group,
+        children: [
+          {
+            id: 11,
+            title: 'Page 1',
+            schemaUid: 'page-1',
+            type: NocoBaseDesktopRouteType.flowPage,
+          },
+        ],
+      },
+    ]);
+
+    const route = adminLayoutModel.toProLayoutRoute({
+      designable: false,
+      isMobile: false,
+      t: (title) => title,
+    });
+
+    expect(route.children[0].path).toBe('/admin2/1');
+    expect(route.children[0].redirect).toBe('/admin2/page-1');
+    expect(route.children[0]._runtimePath).toBe('/apps/demo/v2/admin2/page-1');
+    expect(route.children[0].routes?.[0].path).toBe('/admin2/page-1');
+    expect(route.children[0].routes?.[0].redirect).toBe('/admin2/page-1');
+    expect(route.children[0].routes?.[0]._runtimePath).toBe('/apps/demo/v2/admin2/page-1');
+  });
+
   it('should filter legacy page menu routes but keep empty groups in v2 admin layout', () => {
     const adminLayoutModel = engine.createModel<AdminLayoutModel>({
       uid: 'admin-layout-model',
@@ -1128,6 +1172,46 @@ describe('AdminLayoutModel menu items', () => {
     expect(adminLayoutModel.menuRouteRefreshVersion).toBe(refreshBefore + 1);
   });
 
+  it('should refresh the owning admin layout when hiding custom layout menu routes dynamically', () => {
+    const defaultAdminLayoutModel = engine.createModel<AdminLayoutModel>({
+      uid: ADMIN_LAYOUT_MODEL_UID,
+      use: AdminLayoutModel,
+    });
+    const customAdminLayoutModel = engine.createModel<AdminLayoutModel>({
+      uid: 'custom-admin-layout-model',
+      use: AdminLayoutModel,
+      props: {
+        layout: {
+          routeName: 'admin2',
+          routePath: '/admin2',
+          rootRouteName: 'admin2',
+          uid: 'custom-admin-layout-model',
+          layoutModelClass: 'AdminLayoutModel',
+          rootPageModelClass: 'RootPageModel',
+          childPageModelClass: 'ChildPageModel',
+          authCheck: true,
+        },
+      },
+    });
+    const model = engine.createModel<AdminLayoutMenuItemModel>({
+      uid: 'menu-item-custom-layout-dynamic-hidden',
+      use: AdminLayoutMenuItemModel,
+      props: {
+        route: createRoute(),
+      },
+    });
+
+    model.setParent(customAdminLayoutModel);
+
+    const defaultRefreshBefore = defaultAdminLayoutModel.menuRouteRefreshVersion;
+    const customRefreshBefore = customAdminLayoutModel.menuRouteRefreshVersion;
+
+    model.setHidden(true);
+
+    expect(customAdminLayoutModel.menuRouteRefreshVersion).toBe(customRefreshBefore + 1);
+    expect(defaultAdminLayoutModel.menuRouteRefreshVersion).toBe(defaultRefreshBefore);
+  });
+
   it('should render hidden menu item with opacity and keep original title in config mode', () => {
     const model = engine.createModel<AdminLayoutMenuItemModel>({
       uid: 'menu-item-hidden-in-config',
@@ -2222,6 +2306,21 @@ describe('AdminLayoutModel menu items', () => {
     );
   });
 
+  it('should include router basename when opening same-origin links in a new window', async () => {
+    await openAdminLayoutMenuLink({
+      context: engine.context as any,
+      href: '/admin2/page',
+      params: [{ name: 'from', value: 'admin' }],
+      openInNewWindow: true,
+      isMobile: false,
+      closeMobileMenu: vi.fn(),
+      navigate: navigateMock,
+      basenameOfCurrentRouter: '/v',
+    });
+
+    expect(window.open).toHaveBeenCalledWith('/v/admin2/page?from=admin', '_blank', 'noopener,noreferrer');
+  });
+
   it('should resolve sibling move options for non-group drag target', () => {
     const activeModel = engine.createModel<AdminLayoutMenuItemModel>({
       uid: 'drag-source-page',

package/src/flow/admin-shell/admin-layout/__tests__/AdminLayoutModel.test.tsx

@@ -39,6 +39,7 @@ import {
   FlowEngine,
   FlowEngineProvider,
   FlowModelRenderer,
+  encodeOpenViewRouteState,
   useFlowEngine,
   type FlowModel,
 } from '@nocobase/flow-engine';
@@ -213,6 +214,87 @@ describe('AdminLayoutModel runtime', () => {
     });
   });
 
+  it('should parse RunJS openView route params into layout route view stack state', async () => {
+    const token = encodeOpenViewRouteState('popup', { mode: 'dialog', size: 'large' });
+    if (!token) {
+      throw new Error('Expected openView route state token.');
+    }
+    const engine = new FlowEngine();
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        getRouteBySchemaUid: (pageUid: string) => ({ title: pageUid }),
+      },
+    });
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <TestAdminLayoutHost />
+      </FlowEngineProvider>,
+    );
+    const model = engine.getModel<TestAdminLayoutModel>('admin-layout-model');
+    expect(model).toBeTruthy();
+
+    act(() => {
+      model.syncLayoutRoute({
+        name: getLayoutPageViewRouteName('admin'),
+        pathname: `/admin/page-1/view/popup/opts/${token}/filterbytk/1`,
+        layoutBasePathname: '/admin',
+      });
+    });
+
+    await waitFor(() => {
+      expect(model.context.layoutRoute).toMatchObject({
+        type: 'page',
+        pageUid: 'page-1',
+        viewStack: [
+          { viewUid: 'page-1' },
+          {
+            viewUid: 'popup',
+            openViewRouteState: { mode: 'dialog', size: 'large' },
+            filterByTk: '1',
+          },
+        ],
+      });
+    });
+  });
+
+  it('should reject malformed RunJS openView route params', async () => {
+    const wrongViewToken = encodeOpenViewRouteState('other-popup', { mode: 'dialog', size: 'large' });
+    if (!wrongViewToken) {
+      throw new Error('Expected openView route state token.');
+    }
+    const engine = new FlowEngine();
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <TestAdminLayoutHost />
+      </FlowEngineProvider>,
+    );
+    const model = engine.getModel<TestAdminLayoutModel>('admin-layout-model');
+    expect(model).toBeTruthy();
+
+    [
+      '/admin/page-1/sourceid',
+      '/admin/page-1/AbCdEfGh/filterbytk/1',
+      '/admin/page-1/view/popup/AbCdEfGh/filterbytk/1',
+      '/admin/page-1/view/popup/opts/AbCdEfGh/filterbytk/1',
+      '/admin/page-1/view/popup/openviewmode/dialog',
+      '/admin/page-1/view/popup/openviewsize/large',
+      `/admin/page-1/view/popup/opts/${wrongViewToken}/filterbytk/1`,
+    ].forEach((pathname) => {
+      expect(
+        model.resolveLayoutRoute({
+          name: getLayoutPageViewRouteName('admin'),
+          pathname,
+          layoutBasePathname: '/admin',
+        }),
+      ).toMatchObject({
+        type: 'notFound',
+        pathname,
+      });
+    });
+  });
+
   it('should not consume global routes that belong to nested layouts', async () => {
     const engine = new FlowEngine();
     const routeRef = observable.ref({