@nocobase/client-v2 2.1.0-alpha.40 → 2.1.0-alpha.45

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,102 @@
+/**
+ * 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 {
+  /**
+   * **Preferred way to restrict fields**, alongside `nonfilterableFieldNames`.
+   *
+   * 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[];
+  /**
+   * **Preferred way to restrict fields**, alongside `filterableFieldNames`.
+   *
+   * Blacklist of root-level field names to drop. Mirrors v1's `nonfilterable: [...]` schema prop on `Filter.Action`. Applies at depth 1 only, same as the whitelist. When both `filterableFieldNames` and `nonfilterableFieldNames` are provided, both apply: the final field set is `(whitelist or all) minus blacklist`.
+   */
+  nonfilterableFieldNames?: string[];
+  /**
+   * Bypass the `filterableFieldNames` whitelist (mirrors v1 `noIgnore`).
+   *
+   * Legacy escape hatch from v1 schemas — prefer adjusting `filterableFieldNames` / `nonfilterableFieldNames` instead. Kept only for parity with existing v1 schemas that already set `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, nonfilterableFieldNames, noIgnore = false, t = identity } = args;
+
+  const fields = useMemo(() => collection?.getFields() || [], [collection]);
+
+  const ignoreFieldsNames = useMemo(() => {
+    // Whitelist contribution: every field not in `filterableFieldNames`.
+    // Skipped when `noIgnore` is set, or when no whitelist was provided.
+    const whitelistIgnored =
+      noIgnore || !filterableFieldNames?.length
+        ? []
+        : fields.map((f) => f.name).filter((n) => !filterableFieldNames.includes(n));
+    // Blacklist contribution: explicit names. Always applied, even with
+    // `noIgnore` (the blacklist's whole job is to subtract specific fields).
+    const blacklistIgnored = nonfilterableFieldNames ?? [];
+    if (!blacklistIgnored.length) return whitelistIgnored;
+    // Union the two so the final ignore set is `whitelist-derived ∪ blacklist`.
+    return Array.from(new Set([...whitelistIgnored, ...blacklistIgnored]));
+  }, [fields, filterableFieldNames, nonfilterableFieldNames, 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/actions/UpdateRecordActionModel.tsx

@@ -7,75 +7,22 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { tExpr, FlowModelRenderer, useFlowEngine, useFlowSettingsContext } from '@nocobase/flow-engine';
+import { tExpr, useFlowSettingsContext } from '@nocobase/flow-engine';
 import { Alert, ButtonProps } from 'antd';
-import React, { useEffect, useRef } from 'react';
+import React from 'react';
 import { AxiosRequestConfig } from 'axios';
 import { ActionModel, ActionSceneEnum } from '../base/ActionModel';
-import { CollectionActionModel } from '../base/CollectionActionModel';
-import { RecordActionModel } from '../base/RecordActionModel';
 import { AssignFormModel } from '../blocks/assign-form/AssignFormModel';
+import {
+  createAssignFieldValuesStep,
+  createAssignFormSubModelOptions,
+  getAssignFieldValuesDefaultParams,
+} from '../blocks/assign-form/assignFieldValuesFlow';
 import { applyUpdateRecordAction } from './UpdateRecordActionUtils';
 // import { RemoteFlowModelRenderer } from '../../FlowPage';
 
 const SETTINGS_FLOW_KEY = 'assignSettings';
 
-// 配置态编辑器：渲染 assignForm 子模型
-function AssignFieldsEditor() {
-  const { model, blockModel } = useFlowSettingsContext();
-  const action: any = model;
-  const engine = useFlowEngine();
-  const initializedRef = useRef(false);
-  const [formModel, setFormModel] = React.useState<AssignFormModel | null>(null);
-
-  // 初始化回填
-  useEffect(() => {
-    let cancelled = false;
-    (async () => {
-      const loaded = (await engine.loadOrCreateModel(
-        {
-          parentId: action.uid,
-          subKey: 'assignForm',
-          use: 'AssignFormModel',
-        },
-        { skipSave: !model.context.flowSettingsEnabled },
-      )) as AssignFormModel;
-      if (cancelled) return;
-      setFormModel(loaded);
-      action.assignFormUid = (loaded as any)?.uid || action.assignFormUid;
-    })();
-    return () => {
-      cancelled = true;
-    };
-  }, [action, engine]);
-
-  // 初始化回填（在子模型加载完成后）
-  useEffect(() => {
-    if (initializedRef.current) return;
-    if (!formModel) return;
-    const prev = action.getStepParams?.(SETTINGS_FLOW_KEY, 'assignFieldValues') || {};
-    // 注入资源上下文：与所在表格区块一致
-    const coll = blockModel?.collection || action?.context?.collection;
-    const dsKey = coll?.dataSourceKey;
-    const collName = coll?.name;
-    if (dsKey && collName) {
-      formModel.setStepParams('resourceSettings', 'init', {
-        dataSourceKey: dsKey,
-        collectionName: collName,
-      });
-    }
-    formModel.setInitialAssignedValues(prev?.assignedValues || {});
-    // 批量配置态：移除 ctx.record（Action 为区块级，不具备单条记录上下文）
-    const isBulk = action instanceof CollectionActionModel && !(action instanceof RecordActionModel);
-    if (isBulk && (formModel as any)?.context?.defineProperty) {
-      formModel.context.defineProperty('record', { get: () => undefined, cache: false });
-    }
-    initializedRef.current = true;
-  }, [action, blockModel?.collection, formModel]);
-
-  return formModel ? <FlowModelRenderer model={formModel} showFlowSettings={false} /> : null;
-}
-
 function Info() {
   const ctx = useFlowSettingsContext();
   return (
@@ -124,16 +71,9 @@ UpdateRecordActionModel.define({
   sort: 50,
   // 使用函数型 createModelOptions，从父级上下文提取资源信息，直接注入到子模型的 resourceSettings.init
   createModelOptions: (ctx) => {
-    const dsKey = ctx.collection.dataSourceKey;
-    const collName = ctx.collection.name;
-    const init = dsKey && collName ? { dataSourceKey: dsKey, collectionName: collName } : undefined;
     return {
       subModels: {
-        assignForm: {
-          async: true,
-          use: 'AssignFormModel',
-          stepParams: { resourceSettings: { init } },
-        },
+        assignForm: createAssignFormSubModelOptions(ctx),
       },
     };
   },
@@ -155,32 +95,12 @@ UpdateRecordActionModel.registerFlow({
         content: tExpr('Are you sure you want to perform the Update record action?'),
       },
     },
-    assignFieldValues: {
+    assignFieldValues: createAssignFieldValuesStep({
+      settingsFlowKey: SETTINGS_FLOW_KEY,
       title: tExpr('Field values'),
-      uiSchema() {
-        return {
-          tip: {
-            'x-decorator': 'FormItem',
-            'x-component': () => <Info />,
-          },
-          editor: {
-            'x-decorator': 'FormItem',
-            'x-component': () => <AssignFieldsEditor />,
-          },
-        };
-      },
-      async beforeParamsSave(ctx) {
-        const m = ctx.model as UpdateRecordActionModel;
-        // 跨视图栈按 uid 定位到设置面板中的真实 AssignForm 实例
-        const form: AssignFormModel = m?.assignFormUid && ctx.engine.getModel?.(m.assignFormUid, true);
-        if (!form) return;
-        await form?.form?.validateFields?.();
-        const assignedValues = form?.getAssignedValues?.() || {};
-        const grid = form?.subModels?.grid;
-        const items = grid?.subModels?.items || [];
-        ctx.model.setStepParams(SETTINGS_FLOW_KEY, 'assignFieldValues', { assignedValues });
-      },
-    },
+      tipComponent: Info,
+      validateBeforeSave: true,
+    }),
   },
 });
 
@@ -190,8 +110,7 @@ UpdateRecordActionModel.registerFlow({
   steps: {
     apply: {
       async defaultParams(ctx) {
-        const step = ctx.model.getStepParams(SETTINGS_FLOW_KEY, 'assignFieldValues') || {};
-        return { assignedValues: step?.assignedValues || {} };
+        return getAssignFieldValuesDefaultParams(ctx, SETTINGS_FLOW_KEY);
       },
       async handler(ctx, params) {
         await applyUpdateRecordAction(ctx, params, { settingsFlowKey: SETTINGS_FLOW_KEY });

package/src/flow/models/actions/UpdateRecordActionUtils.ts

@@ -7,8 +7,9 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { MultiRecordResource, SingleRecordResource, resolveRunJSObjectValues } from '@nocobase/flow-engine';
+import { MultiRecordResource, SingleRecordResource } from '@nocobase/flow-engine';
 import { dispatchEventDeep } from '../../utils';
+import { resolveAssignFieldValues } from '../blocks/assign-form/assignFieldValuesFlow';
 
 export async function refreshLinkageRulesAfterUpdate(ctx: any) {
   const blockModel = ctx?.blockModel || ctx?.model?.context?.blockModel || ctx?.model;
@@ -59,12 +60,8 @@ export async function applyUpdateRecordAction(
   const confirmParams = savedConfirm && typeof savedConfirm === 'object' ? savedConfirm : { enable: false };
   await ctx.runAction('confirm', confirmParams);
 
-  let assignedValues: Record<string, any> = {};
-  try {
-    assignedValues = await resolveRunJSObjectValues(ctx, params?.assignedValues);
-  } catch (error) {
-    console.error('[UpdateRecordAction] RunJS execution failed', error);
-    ctx.message.error(ctx.t('RunJS execution failed'));
+  const assignedValues = await resolveAssignFieldValues(ctx, params?.assignedValues, 'UpdateRecordAction');
+  if (!assignedValues) {
     return;
   }
 

package/src/flow/models/actions/__tests__/AssignFormRefill.test.ts

@@ -9,7 +9,7 @@
 
 import { describe, it, expect } from 'vitest';
 import { FlowEngine, FlowModel } from '@nocobase/flow-engine';
-import { UpdateRecordActionModel } from '../../..'; // 这样可以解决循环依赖问题
+import { FormSubmitActionModel, UpdateRecordActionModel } from '../../..'; // 这样可以解决循环依赖问题
 
 /**
  * 精简版 AssignFormModel（仅用于单测）：
@@ -52,4 +52,29 @@ describe('AssignForm value refill and save (beforeParamsSave)', () => {
     const saved = action.getStepParams('assignSettings', 'assignFieldValues');
     expect(saved?.assignedValues).toEqual({ nickname: 'Alice', score: 99 });
   });
+
+  it('FormSubmitActionModel: reuses assignFieldValues step and saves assignedValues from AssignForm', async () => {
+    const root = new FlowEngine();
+
+    root.registerModels({ FormSubmitActionModel, AssignFormModel: TestAssignFormModel });
+
+    const action = root.createModel<FormSubmitActionModel>({ use: 'FormSubmitActionModel', uid: 'submit-u' });
+    const form = root.createModel<TestAssignFormModel>({
+      use: 'AssignFormModel',
+      uid: 'submit-form-u',
+      parentId: action.uid,
+      subKey: 'assignForm',
+    });
+    form.setAssignedValues({ status: 'published' });
+    action.assignFormUid = form.uid;
+
+    const flow = action.getFlow('submitSettings') as any;
+    const step = flow?.steps?.assignFieldValues;
+    expect(step?.beforeParamsSave).toBeTypeOf('function');
+
+    await step.beforeParamsSave({ engine: root, model: action });
+
+    const saved = action.getStepParams('submitSettings', 'assignFieldValues');
+    expect(saved?.assignedValues).toEqual({ status: 'published' });
+  });
 });

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;
       }