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

package/src/flow/actions/linkageRules.tsx

@@ -1606,7 +1606,9 @@ const LinkageRulesUI = observer(
             <div style={{ paddingLeft: 12 }}>
               <FilterGroup
                 value={rule.condition}
-                FilterItem={(props) => <LinkageFilterItem model={ctx.model} value={props.value} />}
+                FilterItem={(props) => (
+                  <LinkageFilterItem model={ctx.model} value={props.value} maxAssociationFieldDepth={2} />
+                )}
               />
             </div>
           </div>
@@ -1766,6 +1768,7 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
   const allModels: FlowModel[] = ctx.model.__allModels || (ctx.model.__allModels = []);
   const modelsToApply = new Set<FlowModel>(allModels);
   const patchPropsByModel = new Map<FlowModel, any>();
+  const clearValueOnHiddenModelUids = new Set<string>();
   const directValuePatches: Array<{ path: Array<string | number>; value: any; whenEmpty?: boolean }> = [];
   const rootCollection = getCollectionFromModel((ctx.model as any)?.context?.blockModel ?? ctx.model);
   const isSafeToWriteAssociationSubpath = (namePath: any): boolean => {
@@ -1876,6 +1879,16 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
       ...(whenEmpty ? { whenEmpty: true } : {}),
     });
   };
+  const removePendingFormValuePatches = (path: any) => {
+    const resolvedPath = resolveNamePathForPatch(path);
+    if (!resolvedPath) return;
+    const resolvedPathKey = namePathToPathKey(resolvedPath);
+    for (let i = directValuePatches.length - 1; i >= 0; i--) {
+      if (namePathToPathKey(directValuePatches[i].path) === resolvedPathKey) {
+        directValuePatches.splice(i, 1);
+      }
+    }
+  };
 
   const getModelTargetPathForPatch = (model: any): string | null => {
     if (!model || typeof model !== 'object') return null;
@@ -1971,6 +1984,23 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
 
     return out;
   };
+  const getModelTargetPathForHiddenClear = (model: any): string | Array<string | number> | null => {
+    const fieldPathArray = normalizeNamePathForKey(model?.context?.fieldPathArray);
+    const targetPath = getModelTargetPathForPatch(model);
+    if (fieldPathArray) {
+      const targetPathLastString = targetPath
+        ? ([...parsePathString(targetPath)].reverse().find((seg) => typeof seg === 'string') as string | undefined)
+        : undefined;
+      const fieldPathArrayLastString = [...fieldPathArray].reverse().find((seg) => typeof seg === 'string');
+      if (!targetPathLastString || targetPathLastString === fieldPathArrayLastString) {
+        return fieldPathArray;
+      }
+    }
+
+    if (!targetPath) return null;
+
+    return resolveIndexedRelativePath(targetPath, model?.context?.fieldIndex) || targetPath;
+  };
   const getModelTargetPathKeys = (model: any): Set<string> => {
     const keys = new Set<string>();
     const fieldPathArray = normalizeNamePathForKey(model?.context?.fieldPathArray);
@@ -2058,6 +2088,13 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
           ...props,
         });
 
+        if (
+          (action.name === 'linkageSetFieldProps' || action.name === 'subFormLinkageSetFieldProps') &&
+          props?.hiddenModel === true
+        ) {
+          clearValueOnHiddenModelUids.add(model?.uid || String(model));
+        }
+
         if (allModels.indexOf(model) === -1) {
           allModels.push(model);
         }
@@ -2099,16 +2136,17 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
   mergedByUid.forEach((model: any, uid) => {
     const patchProps = mergedPropsByUid.get(uid) || {};
     const newProps = { ...model.__originalProps, ...patchProps };
-    const hasHiddenModelPatch = Object.prototype.hasOwnProperty.call(patchProps, 'hiddenModel');
+    const prevHidden = !!model.hidden;
+    const nextHidden = !!newProps.hiddenModel;
 
     model.setProps(_.omit(newProps, ['hiddenModel', 'value', 'hiddenText']));
     syncFieldOptionsToForks(model, patchProps);
     if (typeof model.setHidden === 'function') {
       model.setHidden(!!newProps.hiddenModel);
     } else {
-      model.hidden = !!newProps.hiddenModel;
-      if (hasHiddenModelPatch) {
-        hiddenStatePatches.push({ model, hidden: model.hidden });
+      model.hidden = nextHidden;
+      if (prevHidden !== nextHidden) {
+        hiddenStatePatches.push({ model, hidden: nextHidden });
       }
     }
 
@@ -2144,6 +2182,24 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
       }
     }
 
+    if (
+      clearValueOnHiddenModelUids.has(uid) &&
+      Object.prototype.hasOwnProperty.call(patchProps, 'hiddenModel') &&
+      patchProps.hiddenModel === true
+    ) {
+      const targetPath = getModelTargetPathForHiddenClear(model);
+      if (!targetPath) {
+        console.warn('[linkageRules] Skip clearing hidden field value due to missing target path', {
+          flowKey: ctx.flowKey,
+          modelUid: ctx.model?.uid,
+          targetUid: model?.uid,
+        });
+      } else {
+        removePendingFormValuePatches(targetPath);
+        addFormValuePatch({ path: targetPath, value: undefined });
+      }
+    }
+
     model.__props = null;
   });
   hiddenStatePatches.forEach(({ model, hidden }) => {

package/src/flow/actions/linkageRulesRefresh.tsx

@@ -41,16 +41,15 @@ export const linkageRulesRefresh = defineAction({
     const flowSettingsEnabled = Boolean(
       (ctx as any)?.flowSettingsEnabled || (model as any)?.context?.flowSettingsEnabled,
     );
-    const hasMountedForkWithFlow =
+    const hasForkWithFlow =
       !model?.isFork &&
       !!model?.forks?.size &&
       Array.from(model?.forks || []).some((fork: any) => {
         if (!fork || fork.disposed) return false;
-        if (!fork?.context?.ref?.current) return false;
         return !!fork?.getFlow?.(flowKey);
       });
     const isMasterMounted = Boolean((model as any)?.context?.ref?.current);
-    if (hasMountedForkWithFlow && !isMasterMounted && !flowSettingsEnabled) {
+    if (hasForkWithFlow && !isMasterMounted && !flowSettingsEnabled) {
       return;
     }
 

package/src/flow/actions/setTargetDataScope.tsx

@@ -135,7 +135,7 @@ function SetTargetDataScope(props) {
   return (
     <FilterGroup
       value={props.value}
-      FilterItem={(p) => <VariableFilterItem {...p} model={targetModel} rightAsVariable />}
+      FilterItem={(p) => <VariableFilterItem {...p} model={targetModel} rightAsVariable maxAssociationFieldDepth={2} />}
     />
   );
 }

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

@@ -55,6 +55,15 @@ const insertPositionToMethod = {
   afterEnd: 'insertAfter',
 } as const;
 
+const omitMenuRuntimeProps = (props: Record<string, unknown> = {}) => {
+  const persistableProps = { ...props };
+  delete persistableProps.item;
+  delete persistableProps.dom;
+  delete persistableProps.options;
+  delete persistableProps.renderType;
+  return persistableProps;
+};
+
 export class AdminLayoutMenuItemModel extends FlowModel<AdminLayoutMenuItemStructure> {
   private creationPersisted = false;
   private persistedStateHydrated = false;
@@ -261,6 +270,12 @@ export class AdminLayoutMenuItemModel extends FlowModel<AdminLayoutMenuItemStruc
     return currentFlowCount > 0 || initialFlowCount > 0;
   }
 
+  serialize(): ReturnType<FlowModel['serialize']> {
+    const data = super.serialize();
+    data.props = omitMenuRuntimeProps(data.props);
+    return data;
+  }
+
   setHidden(value: boolean) {
     const previous = this.hidden;
     super.setHidden(value);
@@ -698,7 +713,6 @@ AdminLayoutMenuItemModel.registerFlow({
 AdminLayoutMenuItemModel.registerFlow({
   key: 'menuSettings',
   title: 'Menu settings',
-  manual: true,
   steps: {
     edit: {
       title: 'Edit',

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

@@ -9,7 +9,7 @@
 
 import React from 'react';
 import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { FlowEngine, FlowEngineProvider } from '@nocobase/flow-engine';
 import { observer } from '@nocobase/flow-engine';
 import { MemoryRouter } from 'react-router-dom';
@@ -45,6 +45,9 @@ describe('AdminLayoutModel menu items', () => {
   let modalConfirmMock: ReturnType<typeof vi.fn>;
 
   beforeEach(() => {
+    // Fixtures mount the modern client under the `v2` segment; tell the
+    // runtime-prefix helper so v2-runtime detection matches.
+    (globalThis.window as any).__nocobase_modern_client_prefix__ = 'v2';
     engine = new FlowEngine();
     modalConfirmMock = vi.fn().mockResolvedValue(true);
     engine.registerModels({
@@ -104,6 +107,10 @@ describe('AdminLayoutModel menu items', () => {
     vi.spyOn(window, 'open').mockImplementation(() => null);
   });
 
+  afterEach(() => {
+    delete (globalThis.window as any).__nocobase_modern_client_prefix__;
+  });
+
   const createRoute = (options?: Partial<import('../../../../flow-compat').NocoBaseDesktopRoute>) => ({
     id: 1,
     title: 'Page 1',
@@ -950,6 +957,73 @@ describe('AdminLayoutModel menu items', () => {
     });
   });
 
+  it('should save menu linkage rules without serializing runtime render props', async () => {
+    type SerializedFlowModel = Record<string, unknown> & {
+      props?: Record<string, unknown>;
+      subModels?: unknown;
+    };
+    const save = vi.fn(
+      async (targetModel: { serialize: () => SerializedFlowModel }, options?: { onlyStepParams?: boolean }) => {
+        const data = targetModel.serialize();
+        if (options?.onlyStepParams) {
+          delete data.subModels;
+        }
+
+        expect(data.props?.item).toBeUndefined();
+        expect(data.props?.dom).toBeUndefined();
+        expect(data.props?.options).toBeUndefined();
+        expect(data.props?.renderType).toBeUndefined();
+        expect(() => JSON.stringify(data)).not.toThrow();
+        return data;
+      },
+    );
+    const updateRoute = vi.fn().mockResolvedValue(undefined);
+    engine.setModelRepository({ save } as Parameters<FlowEngine['setModelRepository']>[0]);
+    engine.context.routeRepository.updateRoute = updateRoute;
+
+    const route = createRoute();
+    const model = engine.createModel<AdminLayoutMenuItemModel>({
+      uid: 'menu-item-linkage-runtime-props',
+      use: AdminLayoutMenuItemModel,
+      props: {
+        route,
+      },
+    });
+    const item = {
+      name: 'Page 1',
+      path: '/admin/page-1',
+      _route: route,
+      _model: model,
+    };
+
+    model.setProps({
+      item,
+      dom: React.createElement('span', null, 'Page 1'),
+      renderType: 'item',
+      options: { collapsed: false },
+    });
+    model.setStepParams('menuSettings', 'linkageRules', {
+      value: [
+        {
+          key: 'r1',
+          title: 'Hide menu item',
+          enable: true,
+          condition: { logic: '$and', items: [] },
+          actions: [{ key: 'a1', name: 'linkageSetMenuItemProps', params: { value: 'hidden' } }],
+        },
+      ],
+    });
+
+    await model.saveStepParams();
+
+    expect(save).toHaveBeenCalledWith(model, { onlyStepParams: true });
+    expect(updateRoute).toHaveBeenCalledWith(1, {
+      options: {
+        hasPersistedMenuInstanceFlow: true,
+      },
+    });
+  });
+
   it('should clear persisted menu linkage rules when no persisted state remains', async () => {
     const saveModel = vi.spyOn(engine, 'saveModel').mockResolvedValue(undefined as any);
     const destroy = vi.fn().mockResolvedValue(true);

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

@@ -23,6 +23,17 @@ const app = {
   },
 } as any;
 
+// These fixtures mount the modern client under the `v2` segment; tell the
+// runtime-prefix helper so `isV2AdminRuntime` detects it (the server injects
+// this in production).
+beforeAll(() => {
+  (window as any).__nocobase_modern_client_prefix__ = 'v2';
+});
+
+afterAll(() => {
+  delete (window as any).__nocobase_modern_client_prefix__;
+});
+
 describe('resolveAdminRouteRuntimeTarget', () => {
   it('should resolve flowPage to v2 spa runtime target', () => {
     expect(

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

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { getV2EffectiveBasePath } from '../../../authRedirect';
+import { getModernClientPrefix, getV2EffectiveBasePath } from '../../../authRedirect';
 import type { BaseApplication } from '../../../BaseApplication';
 import { NocoBaseDesktopRouteType, type NocoBaseDesktopRoute } from '../../../flow-compat';
 
@@ -26,8 +26,6 @@ export type AdminRouteRuntimeTarget = {
   reason: AdminRouteRuntimeTargetReason;
 };
 
-const V2_PUBLIC_PATH_SUFFIX = '/v2/';
-
 type LocationLike = {
   pathname: string;
   search?: string;
@@ -69,7 +67,7 @@ function normalizePublicPath(value = '/') {
 }
 
 export function isV2AdminRuntime(app?: ResolveAdminRouteRuntimeTargetOptions['app']) {
-  return !!app?.getPublicPath && normalizePublicPath(app.getPublicPath()).endsWith(V2_PUBLIC_PATH_SUFFIX);
+  return !!app?.getPublicPath && normalizePublicPath(app.getPublicPath()).endsWith(`/${getModernClientPrefix()}/`);
 }
 
 export function toRouterNavigationPath(pathname: string, basename?: string) {

package/src/flow/common/Markdown/Edit.tsx

@@ -34,13 +34,41 @@ const defaultToolbar = [
   'code',
   'inline-code',
   'upload',
-  'fullscreen',
 ];
 
 const NAMESPACE = 'block-markdown';
 
 const locales = ['en_US', 'fr_FR', 'pt_BR', 'ja_JP', 'ko_KR', 'ru_RU', 'sv_SE', 'zh_CN', 'zh_TW'];
 
+type MarkdownToolbarItem =
+  | string
+  | {
+      name: string;
+      tipPosition?: string;
+      toolbar?: MarkdownToolbarItem[];
+      [key: string]: unknown;
+    };
+
+function placeToolbarTooltipsBelow(toolbar: MarkdownToolbarItem[]) {
+  return toolbar.map((item) => {
+    if (typeof item === 'string') {
+      if (item === '|' || item === 'br') {
+        return item;
+      }
+      return {
+        name: item,
+        tipPosition: 's',
+      };
+    }
+
+    return {
+      ...item,
+      tipPosition: 's',
+      toolbar: item.toolbar ? placeToolbarTooltipsBelow(item.toolbar) : item.toolbar,
+    };
+  });
+}
+
 const Edit = (props) => {
   const { disabled, onChange, value, fileCollection, toolbar, vditorRef } = props;
   const flowCtx = useFlowContext();
@@ -73,7 +101,7 @@ const Edit = (props) => {
   useEffect(() => {
     if (!containerRef.current) return;
 
-    const toolbarConfig = toolbar ?? defaultToolbar;
+    const toolbarConfig = placeToolbarTooltipsBelow(toolbar ?? defaultToolbar);
     const vditor = new Vditor(containerRef.current, {
       value: value ?? '',
       lang,
@@ -321,7 +349,7 @@ export const MarkdownWithContextSelector: React.FC<MarkdownWithContextSelectorPr
     if (quoteFlag !== false) {
       setInnerValue(value);
     }
-  }, [value]);
+  }, [quoteFlag, value]);
   const handleTextChange = useCallback(
     (e) => {
       const val = e ?? '';
@@ -375,7 +403,7 @@ export const MarkdownWithContextSelector: React.FC<MarkdownWithContextSelectorPr
         editor.focus();
       });
     },
-    [innerValue, onChange],
+    [onChange],
   );
 
   const handleVariableSelected = useCallback(

package/src/flow/components/ConditionBuilder.tsx

@@ -13,14 +13,24 @@ import { FilterGroup, LinkageFilterItem } from './filter';
 import { evaluateConditions, FilterGroupType, removeInvalidFilterItems } from '@nocobase/utils/client';
 
 export const ConditionBuilder = observer(
-  (props: { value: FilterGroupType; onChange: (value: FilterGroupType) => void; extraMetaTree?: MetaTreeNode[] }) => {
+  (props: {
+    value: FilterGroupType;
+    onChange: (value: FilterGroupType) => void;
+    extraMetaTree?: MetaTreeNode[];
+    maxAssociationFieldDepth?: number;
+  }) => {
     const ctx = useFlowContext();
 
     return (
       <FilterGroup
         value={props.value || { logic: '$and', items: [] }}
         FilterItem={(itemProps) => (
-          <LinkageFilterItem model={ctx.model} value={itemProps.value} extraMetaTree={props.extraMetaTree} />
+          <LinkageFilterItem
+            model={ctx.model}
+            value={itemProps.value}
+            extraMetaTree={props.extraMetaTree}
+            maxAssociationFieldDepth={props.maxAssociationFieldDepth}
+          />
         )}
         onChange={props.onChange}
       />

package/src/flow/components/DefaultValue.tsx

@@ -31,7 +31,7 @@ import { FieldModel } from '../models';
 import { RecordSelectFieldModel } from '../models/fields/AssociationFieldModel';
 import { InputFieldModel } from '../models/fields/InputFieldModel';
 import { ensureOptionsFromUiSchemaEnumIfAbsent } from '../internal/utils/enumOptionsUtils';
-import { resolveOperatorComponent } from '../internal/utils/operatorSchemaHelper';
+import { pickOperatorStyle as pickStyle, resolveOperatorComponent } from '../internal/utils/operatorSchemaHelper';
 import { RunJSValueEditor } from './RunJSValueEditor';
 import { buildDynamicNamePath } from '../models/blocks/form/dynamicNamePath';
 
@@ -592,7 +592,7 @@ export const DefaultValue = connect((props: Props) => {
             }
           }
         }
-      }, [inputProps, value]);
+      }, [inputProps]);
       return (
         <div style={{ flexGrow: 1 }}>
           <FlowModelRenderer model={tempRoot} showFlowSettings={false} />
@@ -600,11 +600,13 @@ export const DefaultValue = connect((props: Props) => {
       );
     };
     return ConstantValueEditor;
-  }, [tempRoot]);
+  }, [tempRoot, value]);
+
+  const modelOperator = (model as { operator?: string })?.operator;
 
   // 文本类多关键词：根据已注册的 operator schema 渲染（用于默认值配置）
   React.useEffect(() => {
-    const operator = (model as any)?.operator;
+    const operator = modelOperator;
     const fieldModel = tempRoot?.subModels?.fields?.[0];
     if (!operator || !fieldModel) return;
     const originalRender = fieldModel['__originalRender'] || fieldModel.render;
@@ -622,17 +624,21 @@ export const DefaultValue = connect((props: Props) => {
         <Comp
           {...fieldModel.props}
           {...xProps}
-          style={{ width: '100%', ...(fieldModel.props as any)?.style, ...xProps?.style }}
+          style={{
+            width: '100%',
+            ...pickStyle((fieldModel.props as Record<string, unknown>)?.style),
+            ...pickStyle(xProps?.style),
+          }}
         />
       );
     } else if (typeof originalRender === 'function') {
       fieldModel.render = originalRender;
     }
-  }, [model, tempRoot, (model as any)?.operator]);
+  }, [model, tempRoot, modelOperator]);
 
   // 根据操作符 schema 的 x-component-props 补全临时字段的输入属性（如多选）
   React.useEffect(() => {
-    const operator = (model as any)?.operator;
+    const operator = modelOperator;
     const fieldModel = tempRoot?.subModels?.fields?.[0];
     if (!fieldModel || !operator) return;
     const ops = model.collectionField?.filterable?.operators || [];
@@ -641,7 +647,7 @@ export const DefaultValue = connect((props: Props) => {
     if (xComponentProps) {
       fieldModel.setProps(xComponentProps);
     }
-  }, [model, tempRoot, (model as any)?.operator]);
+  }, [model, tempRoot, modelOperator]);
 
   const NullComponent = useMemo(() => {
     function NullValuePlaceholder() {