@nocobase/client-v2 2.1.0-beta.36 → 2.1.0-beta.38

package/src/flow/components/FlowRoute.tsx

@@ -7,15 +7,18 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { useFlowEngine } from '@nocobase/flow-engine';
+import { type FlowEngine, useFlowContext, useFlowEngine } from '@nocobase/flow-engine';
 import React, { useEffect, useMemo, useRef, useState } from 'react';
 import { deviceType } from 'react-device-detect';
-import { useAdminLayoutRoutePage } from '../admin-shell/useAdminLayoutRoutePage';
 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 { getAdminLayoutModel, type AdminLayoutModel } from '../admin-shell/admin-layout/AdminLayoutModel';
+import { getLayoutModel, type BaseLayoutModel } from '../admin-shell/BaseLayoutModel';
+import { useLayoutRoutePage } from '../admin-shell/useLayoutRoutePage';
 import { AppNotFound } from '../../components';
+import { useKeepAlive } from '../../components/KeepAlive';
 
 type FlowRouteGuardState = {
   pending: boolean;
@@ -23,8 +26,66 @@ type FlowRouteGuardState = {
   notFound: boolean;
 };
 
-const BridgeFlowRoute = ({ pageUid }: { pageUid: string }) => {
+export type LegacyPageBehavior = 'redirect' | 'notFound' | 'bridge';
+
+export type FlowRouteProps = {
+  pageUid?: string;
+  active?: boolean;
+  getLayoutModel?: (flowEngine: FlowEngine) => BaseLayoutModel | undefined;
+  legacyPageBehavior?: LegacyPageBehavior;
+};
+
+const getDefaultAdminLayoutModel = (flowEngine: FlowEngine) =>
+  getAdminLayoutModel<AdminLayoutModel>(flowEngine, { required: true });
+
+const getDefaultLayoutModel = (flowEngine: FlowEngine, contextLayout?: any) => {
+  const layout = contextLayout || flowEngine.context.layout;
+
+  if (layout?.uid) {
+    return getLayoutModel<BaseLayoutModel>(flowEngine, layout.uid, { required: true });
+  }
+
+  return getDefaultAdminLayoutModel(flowEngine);
+};
+
+const getDefaultLegacyPageBehavior = (flowEngine: FlowEngine, contextLayout?: any): LegacyPageBehavior => {
+  const layout = contextLayout || flowEngine.context.layout;
+
+  if (layout?.routeName && layout.routeName !== 'admin') {
+    return 'notFound';
+  }
+
+  return 'redirect';
+};
+
+const hasFlowModel = async (flowEngine: FlowEngine, pageUid: string) => {
+  if (flowEngine.getModel(pageUid)) {
+    return true;
+  }
+
+  const modelData = await flowEngine.modelRepository?.findOne({ uid: pageUid }).catch(() => null);
+  if (modelData?.uid) {
+    return true;
+  }
+
+  const model = await flowEngine.loadModel({ uid: pageUid }).catch(() => null);
+  if (model && flowEngine.getModel(pageUid) === model) {
+    flowEngine.removeModelWithSubModels(pageUid);
+  }
+  return !!model;
+};
+
+const BridgeFlowRoute = ({
+  pageUid,
+  active,
+  getLayoutModel,
+}: {
+  pageUid: string;
+  active?: boolean;
+  getLayoutModel: (flowEngine: FlowEngine) => BaseLayoutModel | undefined;
+}) => {
   const flowEngine = useFlowEngine();
+  const { active: keepAliveActive } = useKeepAlive();
   const routeRepository = flowEngine.context.routeRepository;
   const refreshDesktopRoutes = React.useMemo(
     () => routeRepository?.refreshAccessible.bind(routeRepository),
@@ -60,11 +121,13 @@ const BridgeFlowRoute = ({ pageUid }: { pageUid: string }) => {
     });
   }, [flowEngine]);
 
-  useAdminLayoutRoutePage({
+  useLayoutRoutePage({
     flowEngine,
     pageUid,
+    active: active ?? keepAliveActive,
     refreshDesktopRoutes,
     layoutContentRef,
+    getLayoutModel,
   });
 
   return <div ref={layoutContentRef} />;
@@ -84,12 +147,20 @@ const BridgeFlowRoute = ({ pageUid }: { pageUid: string }) => {
  * @returns {JSX.Element} 当前动态页面的布局挂载节点
  * @throws {Error} 当缺少 `route.params.name` 时抛出异常
  */
-const FlowRoute = () => {
+const FlowRoute = (props: FlowRouteProps = {}) => {
   const flowEngine = useFlowEngine();
+  const flowContext = useFlowContext<any>();
+  const contextLayout = flowContext?.layout;
+  const getLayoutModel = useMemo(
+    () => props.getLayoutModel || ((engine: FlowEngine) => getDefaultLayoutModel(engine, contextLayout)),
+    [contextLayout, props.getLayoutModel],
+  );
+  const legacyPageBehavior = props.legacyPageBehavior || getDefaultLegacyPageBehavior(flowEngine, contextLayout);
   const app = useApp();
   const routeRepository = flowEngine.context.routeRepository;
   const params = useParams();
-  const pageUid = params?.name;
+  const pageUid = props.pageUid || params?.name;
+  const skipRouteRepositoryCheck = !routeRepository;
   const [guardState, setGuardState] = useState<FlowRouteGuardState>({
     pending: true,
     allowBridge: false,
@@ -99,7 +170,7 @@ const FlowRoute = () => {
   const requestIdRef = useRef(0);
 
   if (!pageUid) {
-    throw new Error('[NocoBase] FlowRoute requires route.params.name.');
+    throw new Error('[NocoBase] FlowRoute requires pageUid or route.params.name.');
   }
 
   useEffect(() => {
@@ -109,7 +180,7 @@ const FlowRoute = () => {
     const run = async () => {
       setGuardState({ pending: true, allowBridge: false, notFound: false });
 
-      if (!routeRepository?.isAccessibleLoaded?.()) {
+      if (!skipRouteRepositoryCheck && !routeRepository?.isAccessibleLoaded?.()) {
         try {
           await routeRepository?.ensureAccessibleLoaded?.();
         } catch (_error) {
@@ -124,8 +195,26 @@ const FlowRoute = () => {
         return;
       }
 
-      const route = routeRepository?.getRouteBySchemaUid?.(pageUid);
+      const route = skipRouteRepositoryCheck ? undefined : routeRepository?.getRouteBySchemaUid?.(pageUid);
+      if (!route && legacyPageBehavior === 'notFound') {
+        const flowModelExists = await hasFlowModel(flowEngine, pageUid);
+        if (active && requestId === requestIdRef.current) {
+          setGuardState({ pending: false, allowBridge: flowModelExists, notFound: !flowModelExists });
+        }
+        return;
+      }
+
       if (route?.type === NocoBaseDesktopRouteType.page) {
+        if (legacyPageBehavior === 'notFound') {
+          setGuardState({ pending: false, allowBridge: false, notFound: true });
+          return;
+        }
+
+        if (legacyPageBehavior === 'bridge') {
+          setGuardState({ pending: false, allowBridge: true, notFound: false });
+          return;
+        }
+
         const target = resolveAdminRouteRuntimeTarget({
           app,
           route,
@@ -161,22 +250,23 @@ const FlowRoute = () => {
     return () => {
       active = false;
     };
-  }, [app, pageUid, routeRepository]);
+  }, [app, flowEngine, legacyPageBehavior, pageUid, routeRepository, skipRouteRepositoryCheck]);
 
   const content = useMemo(() => {
     if (guardState.pending) {
       return null;
     }
 
+    if (guardState.notFound) {
+      return <AppNotFound />;
+    }
+
     if (!guardState.allowBridge) {
-      if (guardState.notFound) {
-        return <AppNotFound />;
-      }
       return null;
     }
 
-    return <BridgeFlowRoute pageUid={pageUid} />;
-  }, [guardState.allowBridge, guardState.notFound, guardState.pending, pageUid]);
+    return <BridgeFlowRoute pageUid={pageUid} active={props.active} getLayoutModel={getLayoutModel} />;
+  }, [getLayoutModel, guardState.allowBridge, guardState.notFound, guardState.pending, pageUid, props.active]);
 
   return content;
 };

package/src/flow/components/filter/index.ts

@@ -15,3 +15,6 @@ export { VariableFilterItem } from './VariableFilterItem';
 export type { VariableFilterItemProps, VariableFilterItemValue } from './VariableFilterItem';
 export { LinkageFilterItem } from './LinkageFilterItem';
 export type { LinkageFilterItemProps, LinkageFilterItemValue } from './LinkageFilterItem';
+export { useFilterOptions } from './useFilterOptions';
+export type { FilterOption, UseFilterOptionsArgs } from './useFilterOptions';
+// Higher-level filter compositions (`CollectionFilterItem`, `useFilterActionProps`, `createCollectionFilterItem`) live under `src/components/form/filter/`. They compose these flow primitives on top of a `Collection` binding — the dependency direction is form/filter → flow/components/filter, never the reverse.

package/src/flow/components/filter/useFilterOptions.ts

@@ -0,0 +1,80 @@
+/**
+ * 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 type { Collection } from '@nocobase/flow-engine';
+import { useMemo } from 'react';
+import { fieldsToOptions } from './fieldsToOptions';
+
+/**
+ * One operator entry on a `FilterOption`. Mirrors v1's interface-defined operator shape so the v2 filter value renderer can pick up the same per-operator value-side schema (e.g. datetime operators wanting the smart date picker, array/enum operators wanting a tag-mode Select).
+ */
+export type FilterOperator = {
+  value: string;
+  label: string;
+  /**
+   * Per-operator override for the value-side renderer. Wins over the field's own `uiSchema` when set. The `x-component` string is looked up against the v2 filter component registry.
+   */
+  schema?: { 'x-component'?: string; 'x-component-props'?: Record<string, any> } & Record<string, any>;
+  /** Operator takes no right-hand value (e.g. `$empty`, `$notEmpty`). */
+  noValue?: boolean;
+  [key: string]: any;
+};
+
+/** Single field-tree node returned by `useFilterOptions`. */
+export type FilterOption = {
+  name: string;
+  type?: string;
+  target?: string;
+  title: string;
+  schema?: Record<string, any>;
+  operators?: FilterOperator[];
+  children?: FilterOption[];
+};
+
+export interface UseFilterOptionsArgs {
+  /**
+   * Whitelist of root-level field names to expose. Empty/undefined means "all filterable fields". The whitelist applies only at depth 1 — nested fields under an allowed association field are always included, matching the legacy v1 `Filter.Action` behaviour.
+   */
+  filterableFieldNames?: string[];
+  /** Bypass the `filterableFieldNames` whitelist (mirrors v1 `noIgnore`). */
+  noIgnore?: boolean;
+  /** Translator used for field/operator labels. Defaults to identity. */
+  t?: (key: string) => string;
+}
+
+const identity = (s: string) => s;
+
+/**
+ * v2 equivalent of v1's `useFilterOptions`/`useFilterFieldOptions`. Walks a `Collection`'s fields and returns the nested option tree consumed by antd `Cascader` in `CollectionFilterItem` (and any other v2 filter surface that wants the same field picker).
+ *
+ * Mirrors v1 in two ways that matter:
+ * - association fields (belongsTo / hasMany / m2m / etc.) are kept and recursed into via `fieldsToOptions`'s `nested` branch — so picking `user.username` is a first-class action, just like the legacy cascader.
+ * - the whitelist applies at depth 1 only, so capping the root field list (e.g. to `['lockedTs', 'unlockTs', 'user']`) doesn't accidentally hide the nested `user.username` / `user.nickname` leaves.
+ */
+export function useFilterOptions(collection: Collection | undefined, args: UseFilterOptionsArgs = {}): FilterOption[] {
+  const { filterableFieldNames, noIgnore = false, t = identity } = args;
+
+  const fields = useMemo(() => collection?.getFields() || [], [collection]);
+
+  const ignoreFieldsNames = useMemo(() => {
+    if (noIgnore || !filterableFieldNames?.length) return [];
+    return fields.map((f) => f.name).filter((n) => !filterableFieldNames.includes(n));
+  }, [fields, filterableFieldNames, noIgnore]);
+
+  return useMemo(
+    () =>
+      fieldsToOptions(
+        fields.filter((field) => field.target !== 'attachments' && field.interface !== 'formula'),
+        1,
+        ignoreFieldsNames,
+        t,
+      ).filter(Boolean) as FilterOption[],
+    [fields, ignoreFieldsNames, t],
+  );
+}

package/src/flow/index.ts

@@ -100,7 +100,11 @@ export * from './utils';
 export * from './actions';
 export * from './system-settings';
 export * from './admin-shell/admin-layout';
+export * from './admin-shell/BaseLayoutModel';
+export * from './admin-shell/BaseLayoutRouteCoordinator';
 export * from './admin-shell/AdminLayoutRouteCoordinator';
+export * from './admin-shell/useLayoutRoutePage';
+export * from './admin-shell/useAdminLayoutRoutePage';
 export * from '../settings-center';
 export { openViewFlow } from './flows/openViewFlow';
 export { editMarkdownFlow } from './flows/editMarkdownFlow';

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

@@ -80,7 +80,14 @@ ActionModel.registerFlow({
         };
       },
       defaultParams(ctx) {
-        return ctx.model.defaultProps;
+        const defaultProps = ctx.model.defaultProps || {};
+        if (!ctx.model.enableEditColor) {
+          return defaultProps;
+        }
+        return {
+          ...defaultProps,
+          color: ctx.model.props?.color ?? defaultProps.color ?? ctx.themeToken?.colorPrimary,
+        };
       },
       handler(ctx, params) {
         const { title, tooltip, ...rest } = params;

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

@@ -40,6 +40,15 @@ type PageModelStructure = {
   };
 };
 
+type CurrentRouteWithTabs = {
+  id?: string | number | null;
+  enableTabs?: boolean;
+};
+
+type PageModelContextWithRoute = {
+  currentRoute?: CurrentRouteWithTabs | null;
+};
+
 export class PageModel extends FlowModel<PageModelStructure> {
   tabBarExtraContent: { left?: ReactNode; right?: ReactNode } = {};
   private viewActivatedListener?: (_payload?: unknown) => void;
@@ -53,9 +62,15 @@ export class PageModel extends FlowModel<PageModelStructure> {
    * 根页面标签页开关以路由表为准，避免 flow model 里的旧配置覆盖路由管理设置。
    */
   private getEnableTabs(): boolean {
-    const routeEnableTabs = (this.context as any)?.currentRoute?.enableTabs;
-    if (this.props.routeId != null && typeof routeEnableTabs === 'boolean') {
-      return routeEnableTabs;
+    const currentRoute = (this.context as PageModelContextWithRoute).currentRoute;
+    const routeId = this.props.routeId;
+    if (
+      routeId != null &&
+      currentRoute?.id != null &&
+      String(currentRoute.id) === String(routeId) &&
+      typeof currentRoute.enableTabs === 'boolean'
+    ) {
+      return currentRoute.enableTabs;
     }
     return !!this.props.enableTabs;
   }
@@ -77,16 +92,27 @@ export class PageModel extends FlowModel<PageModelStructure> {
         if (this.unmounted) return;
         // Only skip when explicitly inactive; treat "unknown" (undefined) as active for backward compatibility.
         if (getPageActive(this.context) === false) return;
-        const activeKey = this.getActiveTabKey();
-        if (activeKey) {
-          this.invokeTabModelLifecycleMethod(activeKey, 'onActive', forceRefresh);
-        }
+        this.activateCurrentTab(forceRefresh);
       })
       .catch(() => {
         // ignore
       });
   }
 
+  activateCurrentTab(forceRefresh = false) {
+    const activeKey = this.getActiveTabKey();
+    if (activeKey) {
+      this.invokeTabModelLifecycleMethod(activeKey, 'onActive', forceRefresh);
+    }
+  }
+
+  deactivateCurrentTab() {
+    const activeKey = this.props.tabActiveKey || this.getFirstTab()?.uid;
+    if (activeKey) {
+      this.invokeTabModelLifecycleMethod(activeKey, 'onInactive');
+    }
+  }
+
   onMount(): void {
     super.onMount();
     this.unmounted = false;
@@ -98,10 +124,7 @@ export class PageModel extends FlowModel<PageModelStructure> {
     // We align this with the existing tab lifecycle by invoking `onActive` for the current tab blocks.
     if (!this.viewActivatedListener) {
       this.viewActivatedListener = (_payload?: unknown) => {
-        const activeKey = this.getActiveTabKey();
-        if (activeKey) {
-          this.invokeTabModelLifecycleMethod(activeKey, 'onActive');
-        }
+        this.activateCurrentTab();
       };
       this.flowEngine?.emitter?.on?.(VIEW_ACTIVATED_EVENT, this.viewActivatedListener);
     }
@@ -113,10 +136,7 @@ export class PageModel extends FlowModel<PageModelStructure> {
       emitterActivatedVersion > 0 && emitterActivatedVersion !== this.lastSeenEmitterViewActivatedVersion;
     this.lastSeenEmitterViewActivatedVersion = emitterActivatedVersion;
     if (shouldCatchUp && getPageActive(this.context) !== false) {
-      const activeKey = this.getActiveTabKey();
-      if (activeKey) {
-        this.invokeTabModelLifecycleMethod(activeKey, 'onActive');
-      }
+      this.activateCurrentTab();
     }
 
     // When data is written within the same view, trigger an "active" lifecycle pass so blocks can refresh based on dirty.
@@ -141,11 +161,21 @@ export class PageModel extends FlowModel<PageModelStructure> {
     super.onUnmount();
   }
 
-  invokeTabModelLifecycleMethod(tabActiveKey: string, method: 'onActive' | 'onInactive', forceRefresh = false) {
+  invokeTabModelLifecycleMethod(
+    tabActiveKey: string | undefined,
+    method: 'onActive' | 'onInactive',
+    forceRefresh = false,
+  ) {
+    if (!tabActiveKey) {
+      return;
+    }
+
     if (method === 'onActive' && this.context?.pageInfo) {
       this.context.pageInfo.version = 'v2';
     }
-    const tabModel = this.flowEngine.getModel(tabActiveKey) as BasePageTabModel | undefined;
+    const tabModel =
+      this.findSubModel('tabs', (model) => model.uid === tabActiveKey) ||
+      (this.flowEngine.getModel(tabActiveKey) as BasePageTabModel | undefined);
 
     if (tabModel) {
       if (tabModel.context.tabActive) {
@@ -183,7 +213,10 @@ export class PageModel extends FlowModel<PageModelStructure> {
     const routePathname = this.flowEngine?.context?.route?.pathname;
     // In route-managed multi-view mode, only the top view in URL should mutate document.title.
     if (hasRouteNavigation && currentViewUid && typeof routePathname === 'string') {
-      const topViewUid = parsePathnameToViewParams(routePathname).at(-1)?.viewUid;
+      const layoutRoutePath = this.context?.layout?.routePath;
+      const topViewUid = parsePathnameToViewParams(routePathname, {
+        basePath: this.context?.layoutRoute?.basePathname || (layoutRoutePath?.startsWith('/') ? layoutRoutePath : ''),
+      }).at(-1)?.viewUid;
       if (topViewUid && topViewUid !== currentViewUid) {
         return;
       }

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

@@ -68,22 +68,15 @@ export class RootPageModel extends PageModel {
     reaction(
       () => this.context.pageActive.value,
       () => {
+        if (this.context.view?.inputArgs?.activationControlledByLayout) {
+          this.mounted = true;
+          return;
+        }
         if (this.context.pageActive.value && this.mounted) {
-          const firstTab = this.subModels.tabs?.[0];
-          if (firstTab) {
-            this.setProps('tabActiveKey', firstTab.uid);
-            this.invokeTabModelLifecycleMethod(firstTab.uid, 'onActive', true);
-          }
+          this.activateCurrentTab(true);
         }
         if (this.context.pageActive.value === false) {
-          if (this.props.tabActiveKey) {
-            this.invokeTabModelLifecycleMethod(this.props.tabActiveKey, 'onInactive');
-          } else {
-            const firstTab = this.subModels.tabs?.[0];
-            if (firstTab) {
-              this.invokeTabModelLifecycleMethod(firstTab.uid, 'onInactive');
-            }
-          }
+          this.deactivateCurrentTab();
         }
         this.mounted = true;
       },

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

@@ -47,6 +47,13 @@ vi.mock('@nocobase/flow-engine', () => {
       return [];
     }
 
+    findSubModel(key: string, callback: any) {
+      if (this.subModels[key]) {
+        return this.subModels[key].find(callback) || null;
+      }
+      return null;
+    }
+
     addSubModel() {}
     setSubModel() {}
 
@@ -260,6 +267,44 @@ describe('PageModel', () => {
     });
   });
 
+  describe('tab lifecycle', () => {
+    it('should invoke tab lifecycle on PageModel subModels before engine lookup', () => {
+      const blockOnActive = vi.fn();
+      const blockOnInactive = vi.fn();
+      const tabModel = {
+        uid: 'tab1',
+        context: {
+          tabActive: { value: false },
+        },
+        subModels: {
+          grid: {
+            mapSubModels: vi.fn((_key, callback) => {
+              callback({ onActive: blockOnActive, onInactive: blockOnInactive });
+            }),
+          },
+        },
+      };
+      (pageModel as any).subModels = { tabs: [tabModel] };
+      (pageModel as any).flowEngine = {
+        getModel: vi.fn(() => undefined),
+      };
+      (pageModel as any).context = {
+        pageInfo: {},
+        view: {
+          inputArgs: { pageActive: true },
+        },
+      };
+
+      pageModel.invokeTabModelLifecycleMethod('tab1', 'onActive', true);
+      pageModel.invokeTabModelLifecycleMethod('tab1', 'onInactive');
+
+      expect((pageModel as any).flowEngine.getModel).not.toHaveBeenCalled();
+      expect(tabModel.context.tabActive.value).toBe(false);
+      expect(blockOnActive).toHaveBeenCalledWith(true);
+      expect(blockOnInactive).toHaveBeenCalledWith(false);
+    });
+  });
+
   describe('renderTabs activeKey logic', () => {
     beforeEach(() => {
       // Mock mapTabs to avoid complex rendering logic inside it
@@ -455,6 +500,7 @@ describe('PageModel', () => {
       } as any;
       (pageModel as any).context = {
         currentRoute: {
+          id: 'route-1',
           enableTabs: false,
         },
       };
@@ -479,6 +525,7 @@ describe('PageModel', () => {
       } as any;
       (pageModel as any).context = {
         currentRoute: {
+          id: 'route-1',
           enableTabs: true,
         },
       };
@@ -495,6 +542,59 @@ describe('PageModel', () => {
         paddingBottom: 0,
       });
     });
+
+    it('should ignore stale desktop route enableTabs=false from another route', () => {
+      pageModel.props = {
+        routeId: 'route-1',
+        displayTitle: true,
+        enableTabs: true,
+        title: 'Title',
+        headerStyle: { backgroundColor: 'var(--colorBgLayout)' },
+      } as any;
+      (pageModel as any).context = {
+        currentRoute: {
+          id: 'route-2',
+          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).toHaveBeenCalled();
+      expect(pageModel.renderFirstTab).not.toHaveBeenCalled();
+      expect(header.props.style).toMatchObject({
+        backgroundColor: 'var(--colorBgLayout)',
+        paddingBottom: 0,
+      });
+    });
+
+    it('should ignore stale desktop route enableTabs=true from another route', () => {
+      pageModel.props = {
+        routeId: 'route-1',
+        displayTitle: true,
+        enableTabs: false,
+        title: 'Title',
+        headerStyle: { backgroundColor: 'var(--colorBgLayout)' },
+      } as any;
+      (pageModel as any).context = {
+        currentRoute: {
+          id: 'route-2',
+          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).not.toHaveBeenCalled();
+      expect(pageModel.renderFirstTab).toHaveBeenCalled();
+      expect(header.props.style).toEqual({ backgroundColor: 'var(--colorBgLayout)' });
+    });
   });
 
   describe('dirty refresh signal', () => {
@@ -554,7 +654,7 @@ describe('PageModel', () => {
       pageModel.onMount();
 
       expect(typeof listeners['view:activated']).toBe('function');
-      expect(invokeSpy).toHaveBeenCalledWith('tab1', 'onActive');
+      expect(invokeSpy).toHaveBeenCalledWith('tab1', 'onActive', false);
     });
   });
 
@@ -630,6 +730,7 @@ describe('PageModel', () => {
     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 = {
+        id: 'route-1',
         enableTabs: false,
       };
       (pageModel as any).stepParams = {

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

@@ -21,7 +21,7 @@ RouteModel.registerFlow({
         return {
           mode: 'embed',
           preventClose: true,
-          pageModelClass: 'RootPageModel',
+          pageModelClass: ctx.layout?.rootPageModelClass || 'RootPageModel',
         };
       },
     },

package/src/flow/models/blocks/form/FormActionGroupModel.tsx

@@ -12,4 +12,18 @@ import { FormActionModel } from './FormActionModel';
 
 export class FormActionGroupModel extends ActionGroupModel {
   static baseClass = FormActionModel;
+
+  static async defineChildren(ctx) {
+    const allowedModelNames = ctx.allowedFormActionModelNames;
+
+    if (!Array.isArray(allowedModelNames) || allowedModelNames.length === 0) {
+      return super.defineChildren(ctx);
+    }
+
+    await Promise.all(allowedModelNames.map((name) => ctx.engine?.getModelClassAsync?.(name)));
+
+    const items = await super.defineChildren(ctx);
+    const allowedSet = new Set(allowedModelNames);
+    return items.filter((item) => allowedSet.has(item.useModel || item.key));
+  }
 }

package/src/flow/models/blocks/form/FormItemModel.tsx

@@ -138,6 +138,10 @@ export class FormItemModel<T extends DefaultStructure = DefaultStructure> extend
                 });
               }
             }
+            fork.context.defineProperty('fieldPathArray', {
+              get: () => this.context.fieldPathArray,
+              cache: false,
+            });
             if (isHiddenReservedValuePreview) {
               fork.setProps({ hidden: false });
             }
@@ -151,7 +155,10 @@ export class FormItemModel<T extends DefaultStructure = DefaultStructure> extend
       : { hidden, ...mergedPropsWithoutInitial };
     const fieldPath = buildDynamicNamePath(this.props.name, idx);
     this.context.defineProperty('fieldPathArray', {
-      value: [...parentFieldPathArray, ..._.castArray(fieldPath)],
+      get: () => {
+        return [...parentFieldPathArray, ..._.castArray(fieldPath)];
+      },
+      cache: false,
     });
     const record = this.context.item?.value || this.context.record;
     const content = (