@nocobase/client-v2 3.0.0-alpha.3 → 3.0.0-alpha.5

package/src/__tests__/settings-search-shortcut.test.tsx

@@ -0,0 +1,321 @@
+/**
+ * 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 { act, cleanup, fireEvent, render, screen } from '@testing-library/react';
+import React from 'react';
+import * as ReactRouterDOM from 'react-router-dom';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('../acl/aclCheckReadiness', () => ({
+  useACLCheckReady: () => true,
+}));
+
+vi.mock('../hooks/useApp', () => ({
+  useApp: () => ({
+    router: {
+      isSkippedAuthCheckRoute: () => false,
+    },
+  }),
+}));
+
+vi.mock('../settings-center/useSettingsSearch', () => ({
+  useSettingsSearch: () => ({
+    recentItems: [],
+    search: vi.fn(() => []),
+  }),
+}));
+
+vi.mock('react-i18next', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('react-i18next')>();
+  return {
+    ...actual,
+    useTranslation: () => ({ t: (key: string) => key }),
+  };
+});
+
+const platforms: Array<{
+  acceptedModifier: KeyboardEventInit;
+  label: string;
+  name: string;
+  platform: string;
+  rejectedModifier: KeyboardEventInit;
+}> = [
+  {
+    acceptedModifier: { metaKey: true },
+    label: '⌘F',
+    name: 'macOS',
+    platform: 'MacIntel',
+    rejectedModifier: { ctrlKey: true },
+  },
+  {
+    acceptedModifier: { ctrlKey: true },
+    label: 'Ctrl F',
+    name: 'Windows',
+    platform: 'Win32',
+    rejectedModifier: { metaKey: true },
+  },
+];
+
+async function renderSettingsSearch(platform: string) {
+  Object.defineProperty(window.navigator, 'platform', {
+    configurable: true,
+    value: platform,
+  });
+  vi.resetModules();
+  vi.doMock('react', () => ({ ...React, default: React }));
+  vi.doMock('react-router-dom', () => ReactRouterDOM);
+
+  const { SettingsSearch } = await import('../settings-app/SettingsSearch');
+  return render(
+    <ReactRouterDOM.MemoryRouter initialEntries={['/settings/system-settings']}>
+      <button type="button">Outside control</button>
+      <SettingsSearch />
+    </ReactRouterDOM.MemoryRouter>,
+  );
+}
+
+function dispatchShortcut(
+  init: KeyboardEventInit,
+  options: {
+    alreadyPrevented?: boolean;
+  } = {},
+) {
+  const event = new KeyboardEvent('keydown', {
+    bubbles: true,
+    cancelable: true,
+    ...init,
+  });
+  if (options.alreadyPrevented) {
+    event.preventDefault();
+  }
+  fireEvent(window, event);
+  return event;
+}
+
+describe('SettingsSearch shortcut', () => {
+  afterEach(() => {
+    cleanup();
+    vi.doUnmock('react');
+    vi.doUnmock('react-router-dom');
+    Reflect.deleteProperty(window.navigator, 'platform');
+  });
+
+  it.each(platforms)('displays $label on $name', async ({ label, platform }) => {
+    await renderSettingsSearch(platform);
+
+    expect(screen.getByTitle('Search settings')).toHaveTextContent(label);
+  });
+
+  it.each(platforms)(
+    'opens only for the exact platform shortcut on $name',
+    async ({ acceptedModifier, platform, rejectedModifier }) => {
+      await renderSettingsSearch(platform);
+
+      const rejectedShortcuts: Array<{
+        name: string;
+        init: KeyboardEventInit;
+        alreadyPrevented?: boolean;
+      }> = [
+        { name: 'F without a modifier', init: { key: 'f' } },
+        { name: 'the other platform modifier + F', init: { key: 'f', ...rejectedModifier } },
+        { name: 'Ctrl+K', init: { key: 'k', ctrlKey: true } },
+        { name: 'Meta+K', init: { key: 'k', metaKey: true } },
+        { name: 'Alt with the platform shortcut', init: { key: 'f', ...acceptedModifier, altKey: true } },
+        { name: 'Shift with the platform shortcut', init: { key: 'f', ...acceptedModifier, shiftKey: true } },
+        { name: 'Ctrl+Meta+F', init: { key: 'f', ctrlKey: true, metaKey: true } },
+        {
+          name: 'an already handled platform shortcut',
+          init: { key: 'f', ...acceptedModifier },
+          alreadyPrevented: true,
+        },
+      ];
+
+      for (const shortcut of rejectedShortcuts) {
+        const event = dispatchShortcut(shortcut.init, { alreadyPrevented: shortcut.alreadyPrevented });
+        expect(screen.queryByRole('dialog'), shortcut.name).not.toBeInTheDocument();
+        expect(event.defaultPrevented, shortcut.name).toBe(shortcut.alreadyPrevented === true);
+      }
+
+      const repeatEvent = dispatchShortcut({ key: 'f', ...acceptedModifier, repeat: true });
+      expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+      expect(repeatEvent.defaultPrevented).toBe(true);
+
+      const event = dispatchShortcut({ key: 'f', ...acceptedModifier });
+
+      expect(event.defaultPrevented).toBe(true);
+      expect(screen.getByRole('dialog')).toBeInTheDocument();
+    },
+  );
+
+  it.each([
+    { activation: 'click', key: null },
+    { activation: 'Enter', key: 'Enter' },
+    { activation: 'Space', key: ' ' },
+  ])('closes immediately with Escape after opening by $activation', async ({ key }) => {
+    await renderSettingsSearch('MacIntel');
+
+    const outsideControl = screen.getByRole('button', { name: 'Outside control' });
+    const trigger = screen.getByTitle('Search settings');
+    const event = new KeyboardEvent('keydown', { key: 'Escape', bubbles: true, cancelable: true });
+    if (key) {
+      trigger.focus();
+      fireEvent.keyDown(trigger, { key });
+      expect(trigger).toHaveFocus();
+      fireEvent(document.activeElement as Element, event);
+    } else {
+      outsideControl.focus();
+      trigger.focus();
+      fireEvent.click(trigger);
+      expect(trigger).toHaveFocus();
+      fireEvent(document.activeElement as Element, event);
+    }
+
+    expect(event.defaultPrevented).toBe(true);
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+    expect(trigger).toHaveFocus();
+
+    const closedEvent = new KeyboardEvent('keydown', { key: 'Escape', bubbles: true, cancelable: true });
+    fireEvent(trigger, closedEvent);
+    expect(closedEvent.defaultPrevented).toBe(false);
+  });
+
+  it('moves focus to the trigger before opening from the platform shortcut', async () => {
+    await renderSettingsSearch('MacIntel');
+
+    const outsideControl = screen.getByRole('button', { name: 'Outside control' });
+    const trigger = screen.getByTitle('Search settings');
+    outsideControl.focus();
+
+    const shortcutEvent = new KeyboardEvent('keydown', {
+      key: 'f',
+      metaKey: true,
+      bubbles: true,
+      cancelable: true,
+    });
+    fireEvent(outsideControl, shortcutEvent);
+
+    expect(shortcutEvent.defaultPrevented).toBe(true);
+    expect(screen.getByRole('dialog')).toBeInTheDocument();
+    expect(trigger).toHaveFocus();
+
+    const escapeEvent = new KeyboardEvent('keydown', { key: 'Escape', bubbles: true, cancelable: true });
+    fireEvent(document.activeElement as Element, escapeEvent);
+    expect(escapeEvent.defaultPrevented).toBe(true);
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+    expect(outsideControl).toHaveFocus();
+  });
+
+  it('keeps immediate Escape from reaching a lower overlay', async () => {
+    await renderSettingsSearch('MacIntel');
+
+    const trigger = screen.getByTitle('Search settings');
+    fireEvent.click(trigger);
+    const lowerOverlayKeyDown = vi.fn();
+    window.addEventListener('keydown', lowerOverlayKeyDown);
+
+    const event = new KeyboardEvent('keydown', { key: 'Escape', bubbles: true, cancelable: true });
+    fireEvent(trigger, event);
+    window.removeEventListener('keydown', lowerOverlayKeyDown);
+
+    expect(lowerOverlayKeyDown).not.toHaveBeenCalled();
+  });
+
+  it('closes from the dialog Escape path and restores the original focus', async () => {
+    await renderSettingsSearch('MacIntel');
+
+    const outsideControl = screen.getByRole('button', { name: 'Outside control' });
+    outsideControl.focus();
+    dispatchShortcut({ key: 'f', metaKey: true });
+    const input = screen.getByPlaceholderText('Search settings');
+    act(() => input.focus());
+    expect(input).toHaveFocus();
+
+    const escapeEvent = new KeyboardEvent('keydown', { key: 'Escape', bubbles: true, cancelable: true });
+    fireEvent(input, escapeEvent);
+
+    expect(escapeEvent.defaultPrevented).toBe(true);
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+    expect(outsideControl).toHaveFocus();
+  });
+
+  it('closes before a downstream capture handler consumes Escape', async () => {
+    await renderSettingsSearch('MacIntel');
+
+    dispatchShortcut({ key: 'f', metaKey: true });
+    const input = screen.getByPlaceholderText('Search settings');
+    act(() => input.focus());
+    const downstreamCapture = vi.fn((event: KeyboardEvent) => {
+      input.blur();
+      event.stopPropagation();
+    });
+    document.addEventListener('keydown', downstreamCapture, true);
+
+    const escapeEvent = new KeyboardEvent('keydown', { key: 'Escape', bubbles: true, cancelable: true });
+    try {
+      fireEvent(input, escapeEvent);
+    } finally {
+      document.removeEventListener('keydown', downstreamCapture, true);
+    }
+
+    expect(escapeEvent.defaultPrevented).toBe(true);
+    expect(downstreamCapture).not.toHaveBeenCalled();
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+  });
+
+  it('closes when the browser consumes Escape by blurring the input', async () => {
+    await renderSettingsSearch('MacIntel');
+
+    const outsideControl = screen.getByRole('button', { name: 'Outside control' });
+    outsideControl.focus();
+    dispatchShortcut({ key: 'f', metaKey: true });
+    const input = screen.getByPlaceholderText('Search settings');
+    act(() => input.focus());
+
+    act(() => input.blur());
+
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+    expect(outsideControl).toHaveFocus();
+  });
+
+  it('keeps the dialog open when a pointer action blurs the input', async () => {
+    await renderSettingsSearch('MacIntel');
+
+    dispatchShortcut({ key: 'f', metaKey: true });
+    const input = screen.getByPlaceholderText('Search settings');
+    act(() => input.focus());
+
+    fireEvent.pointerDown(input);
+    act(() => input.blur());
+    fireEvent.pointerUp(input);
+
+    expect(screen.getByRole('dialog')).toBeInTheDocument();
+  });
+
+  it('keeps focus inside the dialog when the platform shortcut is pressed again', async () => {
+    await renderSettingsSearch('MacIntel');
+
+    dispatchShortcut({ key: 'f', metaKey: true });
+    const input = screen.getByPlaceholderText('Search settings');
+    act(() => input.focus());
+    expect(input).toHaveFocus();
+    fireEvent.change(input, { target: { value: 'portal' } });
+
+    const shortcutEvent = new KeyboardEvent('keydown', {
+      key: 'f',
+      metaKey: true,
+      bubbles: true,
+      cancelable: true,
+    });
+    fireEvent(input, shortcutEvent);
+
+    expect(shortcutEvent.defaultPrevented).toBe(true);
+    expect(input).toHaveValue('');
+    expect(input).toHaveFocus();
+  });
+});

package/src/__tests__/settings-shell.test.tsx

@@ -182,6 +182,41 @@ describe('SettingsShell', () => {
     expect(document.querySelector('#nocobase-embed-container')).not.toBeInTheDocument();
   });
 
+  it('does not display the Settings header on the OAuth device verification route', () => {
+    matchRoutes.mockReturnValue([
+      { route: { id: 'settingsDetails' } },
+      { route: { id: 'settingsDetails.idpOAuth.device' } },
+    ]);
+
+    render(
+      <MemoryRouter initialEntries={['/settings/idpOAuth/device?user_code=TKHX-NNCC']}>
+        <SettingsShell>
+          <div>device verification content</div>
+        </SettingsShell>
+      </MemoryRouter>,
+    );
+
+    expect(screen.getByText('device verification content')).toBeInTheDocument();
+    expect(document.querySelector('header')).toHaveStyle({ display: 'none' });
+  });
+
+  it('continues to display the Settings header on other details routes', () => {
+    matchRoutes.mockReturnValue([
+      { route: { id: 'settingsDetails' } },
+      { route: { id: 'settingsDetails.workflow.workflows.id' } },
+    ]);
+
+    render(
+      <MemoryRouter initialEntries={['/settings/workflow/workflows/1']}>
+        <SettingsShell>
+          <div>workflow details content</div>
+        </SettingsShell>
+      </MemoryRouter>,
+    );
+
+    expect(screen.getByRole('banner')).toBeVisible();
+  });
+
   it('does not render the Settings header before authentication completes', () => {
     setCurrentUserAuthStatus(mockApp, 'unknown');
 

package/src/acl/ACLProvider.tsx

@@ -12,6 +12,7 @@ import React, { useRef } from 'react';
 import { createContext, useCallback, useContext, useEffect, useMemo, useState, type FC } from 'react';
 import { useLocation } from 'react-router-dom';
 import { useApp } from '../hooks/useApp';
+import { getACLCheckReady, setACLCheckReady } from './aclCheckReadiness';
 import { createAclSnippetAllow } from './createAclSnippetAllow';
 
 export type ACLRoleData = {
@@ -84,16 +85,23 @@ export const ACLRolesCheckProvider: FC = ({ children }) => {
   const location = useLocation();
   const aclStore = ensureACLStore(app);
   const [loading, setLoading] = useState(false);
+  const refreshGenerationRef = useRef(0);
+  const lastSuccessfulCheckRef = useRef(getACLCheckReady(app));
   const pathnameRef = useRef(location.pathname);
   pathnameRef.current = location.pathname;
 
   const refresh = useCallback(async () => {
     if (app.router.isSkippedAuthCheckRoute(pathnameRef.current)) {
       // 认证页等免鉴权路由不需要执行 `roles:check`，避免未登录时产生多余的 401 与 loading 闪烁。
+      refreshGenerationRef.current += 1;
+      lastSuccessfulCheckRef.current = false;
+      setACLCheckReady(app, false);
       setLoading(false);
       return;
     }
 
+    const refreshGeneration = ++refreshGenerationRef.current;
+    setACLCheckReady(app, false);
     const shouldShowLoading = !aclStore.data?.role && !aclStore.data?.snippets?.length;
     if (shouldShowLoading) {
       setLoading(true);
@@ -109,6 +117,10 @@ export const ACLRolesCheckProvider: FC = ({ children }) => {
       const nextData = res?.data?.data || {};
       const nextMeta = res?.data?.meta || {};
 
+      if (refreshGeneration !== refreshGenerationRef.current) {
+        return;
+      }
+
       aclStore.setData(nextData);
       aclStore.setMeta(nextMeta);
       app.pluginSettingsManager.setAclSnippets(nextData?.snippets || []);
@@ -117,13 +129,21 @@ export const ACLRolesCheckProvider: FC = ({ children }) => {
         app.apiClient.auth.setRole(nextData?.role);
       }
 
+      lastSuccessfulCheckRef.current = true;
+      setACLCheckReady(app, true);
+
       if (!createAclSnippetAllow(nextData?.snippets || [], !!nextData?.allowAll)('ui.*')) {
         await app.flowEngine.flowSettings.disable();
       }
     } catch (error) {
+      if (refreshGeneration !== refreshGenerationRef.current) {
+        return;
+      }
+
       const status = error?.response?.status || error?.status;
 
       if (status === 401) {
+        lastSuccessfulCheckRef.current = false;
         aclStore.setData({});
         aclStore.setMeta({});
         app.pluginSettingsManager.setAclSnippets([]);
@@ -131,15 +151,24 @@ export const ACLRolesCheckProvider: FC = ({ children }) => {
         return;
       }
 
+      setACLCheckReady(app, lastSuccessfulCheckRef.current);
       console.error(error);
     } finally {
-      setLoading(false);
+      if (refreshGeneration === refreshGenerationRef.current) {
+        setLoading(false);
+      }
     }
   }, [aclStore, app]);
 
   useEffect(() => {
-    void refresh();
-  }, [refresh]);
+    refresh();
+
+    return () => {
+      refreshGenerationRef.current += 1;
+      lastSuccessfulCheckRef.current = false;
+      setACLCheckReady(app, false);
+    };
+  }, [app, refresh]);
 
   const value = useMemo<ACLContextValue>(
     () => ({

package/src/acl/aclCheckReadiness.ts

@@ -0,0 +1,44 @@
+/**
+ * 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 { useEffect, useState } from 'react';
+
+type ReadinessListener = (ready: boolean) => void;
+
+const readinessByApp = new WeakMap<object, boolean>();
+const listenersByApp = new WeakMap<object, Set<ReadinessListener>>();
+
+export function getACLCheckReady(app: object) {
+  return readinessByApp.get(app) ?? false;
+}
+
+export function setACLCheckReady(app: object, ready: boolean) {
+  readinessByApp.set(app, ready);
+  listenersByApp.get(app)?.forEach((listener) => listener(ready));
+}
+
+export function useACLCheckReady(app: object) {
+  const [ready, setReady] = useState(() => getACLCheckReady(app));
+
+  useEffect(() => {
+    const listeners = listenersByApp.get(app) || new Set<ReadinessListener>();
+    listeners.add(setReady);
+    listenersByApp.set(app, listeners);
+    setReady(getACLCheckReady(app));
+
+    return () => {
+      listeners.delete(setReady);
+      if (!listeners.size) {
+        listenersByApp.delete(app);
+      }
+    };
+  }, [app]);
+
+  return ready;
+}

package/src/authRedirect.ts

@@ -328,10 +328,14 @@ export function getCurrentV2RedirectPath(app: AppLike, locationLike: LocationLik
  *
  * @param app 当前 v2 应用实例
  * @param targetPath 登录后回跳地址
+ * @param options 可选的登录路由配置
  * @returns 指向 v2 登录页的 href
  */
-export function buildV2SigninHref(app: AppLike, targetPath: string) {
-  return `${getV2SigninPath(app)}?redirect=${encodeURIComponent(targetPath)}`;
+export function buildV2SigninHref(app: AppLike, targetPath: string, options?: { signInRoutePath?: string }) {
+  const signInPath = options?.signInRoutePath
+    ? normalizeV2RedirectPath(app, options.signInRoutePath, options.signInRoutePath)
+    : getV2SigninPath(app);
+  return `${signInPath}?redirect=${encodeURIComponent(targetPath)}`;
 }
 
 /**
@@ -339,10 +343,14 @@ export function buildV2SigninHref(app: AppLike, targetPath: string) {
  *
  * @param app 当前 v2 应用实例
  * @param targetPath 登录后回跳地址
- * @param options 跳转选项
+ * @param options 跳转和登录路由选项
  */
-export function redirectToV2Signin(app: AppLike, targetPath: string, options?: { replace?: boolean }) {
-  const href = buildV2SigninHref(app, targetPath);
+export function redirectToV2Signin(
+  app: AppLike,
+  targetPath: string,
+  options?: { replace?: boolean; signInRoutePath?: string },
+) {
+  const href = buildV2SigninHref(app, targetPath, options);
   if (options?.replace === false) {
     window.location.href = href;
     return;

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

@@ -82,6 +82,15 @@ export class CollectionBlockModel<T = DefaultStructure> extends DataBlockModel<T
     const engine = this.context.engine as FlowEngine;
     const currentVersion = this.getDirtyTrackingVersion(engine, dataSourceKey, resource, params);
 
+    if (resource instanceof MultiRecordResource && this.getDataLoadingMode() === 'manual' && !this.hasActiveFilters()) {
+      resource.setData([]);
+      resource.setMeta({ count: 0, hasNext: false });
+      resource.setPage(1);
+      resource.loading = false;
+      this.lastSeenDirtyVersion = currentVersion;
+      return;
+    }
+
     if (forceRefresh) {
       if (this.dirtyRefreshing) return;
       this.dirtyRefreshing = true;

package/src/flow/models/base/__tests__/CollectionBlockModel.initialBeforeRenderRefresh.test.ts

@@ -128,4 +128,64 @@ describe('CollectionBlockModel initial beforeRender refresh', () => {
     expect(resource.getData()).toEqual([]);
     expect(resource.getMeta('count')).toBe(0);
   });
+
+  it('skips forced active refresh in manual mode when filters are empty', async () => {
+    const { model, resource } = setupModelWithManualMode();
+    const refreshSpy = vi.spyOn(resource, 'refresh');
+
+    resource.setData([{ id: 2, name: 'Stale' }]);
+    resource.setMeta({ count: 1, hasNext: true });
+    resource.setPage(2);
+    resource.loading = true;
+
+    model.onActive(true);
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(refreshSpy).not.toHaveBeenCalled();
+    expect(resource.getData()).toEqual([]);
+    expect(resource.getMeta('count')).toBe(0);
+    expect(resource.getMeta('hasNext')).toBe(false);
+    expect(resource.getMeta('page')).toBe(1);
+    expect(resource.getRequestParameter('page')).toBe(1);
+    expect(resource.loading).toBe(false);
+  });
+
+  it('keeps forced active refresh in manual mode when filters are active', async () => {
+    const { model, resource } = setupModelWithManualMode();
+    const refreshSpy = vi.spyOn(resource, 'refresh').mockResolvedValue();
+
+    resource.setData([{ id: 2, name: 'Stale' }]);
+    resource.setMeta({ count: 1, hasNext: true, page: 2 });
+    model.setFilterActive('filter-form-item', true);
+
+    model.onActive(true);
+    await Promise.resolve();
+
+    expect(refreshSpy).toHaveBeenCalledTimes(1);
+    expect(resource.getData()).toEqual([{ id: 2, name: 'Stale' }]);
+    expect(resource.getMeta('count')).toBe(1);
+  });
+
+  it('skips forced active refresh in manual mode when only resource filters are active', async () => {
+    const { model, resource } = setupModelWithManualMode();
+    const refreshSpy = vi.spyOn(resource, 'refresh');
+
+    resource.setData([{ id: 2, name: 'Stale' }]);
+    resource.setMeta({ count: 1, hasNext: true });
+    resource.setPage(2);
+    resource.loading = true;
+    resource.addFilterGroup('data-scope', { status: { $eq: 'active' } });
+
+    model.onActive(true);
+    await Promise.resolve();
+
+    expect(refreshSpy).not.toHaveBeenCalled();
+    expect(resource.getData()).toEqual([]);
+    expect(resource.getMeta('count')).toBe(0);
+    expect(resource.getMeta('hasNext')).toBe(false);
+    expect(resource.getMeta('page')).toBe(1);
+    expect(resource.getRequestParameter('page')).toBe(1);
+    expect(resource.loading).toBe(false);
+  });
 });

package/src/index.ts

@@ -33,6 +33,7 @@ export {
   CurrentUserContext,
   NocoBaseBuildInPlugin,
   NocoBaseBuildInPluginV2,
+  resolveUnauthenticatedSignInRoute,
   useCurrentRoles,
   useCurrentUserContext,
 } from './nocobase-buildin-plugin';
@@ -60,6 +61,7 @@ export {
 } from './flow-compat';
 export type { NocoBaseDesktopRoute } from './flow-compat';
 export * from './utils/markdownSanitize';
+export * from './ui-operation';
 export { default as AntdAppProvider } from './theme/AntdAppProvider';
 export { isSettingsApp } from './settings-app/isSettingsApp';
 export { MINIMAL_THEME_UID, useSettingsThemeConfig } from './settings-app/useSettingsThemeConfig';

package/src/layout-manager/LayoutContentRoute.tsx

@@ -38,11 +38,12 @@ export const LayoutContentRoute = (props: LayoutContentRouteProps) => {
       id: lastMatch?.id,
       name: lastMatch?.id,
       pathname: location.pathname,
+      state: location.state,
       params: (lastMatch?.params || {}) as Record<string, string | undefined>,
       layoutRouteName: layout.routeName,
       layoutBasePathname: layoutMatch?.pathname,
     };
-  }, [layout.routeName, location.pathname, matches]);
+  }, [layout.routeName, location.pathname, location.state, matches]);
   if (!model) {
     throw new Error(`[NocoBase] Layout '${layout.routeName}' model '${layout.uid}' is not mounted.`);
   }

package/src/layout-manager/LayoutRoute.tsx

@@ -71,11 +71,12 @@ export const LayoutRoute = (props: LayoutRouteProps) => {
       id: lastMatch?.id,
       name: lastMatch?.id,
       pathname: location.pathname,
+      state: location.state,
       params: lastMatchParams,
       layoutRouteName: layout.routeName,
       layoutBasePathname: layoutMatch?.pathname,
     };
-  }, [lastMatch?.id, lastMatchParams, layout.routeName, layoutMatch?.pathname, location.pathname]);
+  }, [lastMatch?.id, lastMatchParams, layout.routeName, layoutMatch?.pathname, location.pathname, location.state]);
   const { loading, data, error } = useRequest(
     async () => {
       const existingModel = flowEngine.getModel<BaseLayoutModel>(layout.uid);