@nocobase/client-v2 2.1.0-beta.43 → 2.1.0-beta.45

package/src/flow/actions/__tests__/linkageRules.subFormSetFieldProps.test.ts

@@ -9,9 +9,15 @@
 
 import React from 'react';
 import { fireEvent, render, screen } from '@testing-library/react';
-import { FlowSettingsContextProvider } from '@nocobase/flow-engine';
+import { FlowEngine, FlowModel, FlowSettingsContextProvider } from '@nocobase/flow-engine';
 import { describe, expect, it, vi } from 'vitest';
-import { fieldLinkageRules, linkageSetFieldProps, subFormLinkageSetFieldProps } from '../linkageRules';
+import {
+  fieldLinkageRules,
+  linkageAssignField,
+  linkageSetFieldProps,
+  subFormFieldLinkageRules,
+  subFormLinkageSetFieldProps,
+} from '../linkageRules';
 
 const createSubFormFieldModel = ({
   uid,
@@ -335,6 +341,110 @@ describe('subFormLinkageSetFieldProps action', () => {
     expect(row0CollectedModel.hidden).toBe(false);
     expect(row1CollectedModel.hidden).toBe(true);
   });
+
+  it('should clear the current row value when a subform list field is hidden without reserving value', async () => {
+    const setFormValues = vi.fn(async () => undefined);
+    const form = {
+      getFieldValue: vi.fn((path: Array<string | number>) => {
+        if (JSON.stringify(path) === JSON.stringify(['items', 0, 'a'])) {
+          return 'row value';
+        }
+        return undefined;
+      }),
+      setFieldValue: vi.fn(),
+    };
+    const engine = new FlowEngine();
+
+    const rowGridFork = new FlowModel({ uid: 'row-grid-fork', flowEngine: engine }) as any;
+    rowGridFork.hidden = false;
+    rowGridFork.context.defineProperty('fieldKey', { value: ['items:0'] });
+    rowGridFork.context.defineProperty('fieldIndex', { value: ['items:0'] });
+    rowGridFork.context.defineProperty('form', { value: form });
+    rowGridFork.context.defineProperty('setFormValues', { value: setFormValues });
+    rowGridFork.context.defineProperty('app', {
+      value: {
+        jsonLogic: {
+          apply: () => true,
+        },
+      },
+    });
+    rowGridFork.getAction = vi.fn((name: string) => {
+      if (name === 'subFormLinkageSetFieldProps') {
+        return subFormLinkageSetFieldProps;
+      }
+    });
+
+    const targetFieldFork: any = {
+      uid: 'field-a',
+      isFork: true,
+      hidden: false,
+      props: {},
+      context: {
+        fieldIndex: ['items:0'],
+      },
+      getStepParams: vi.fn((flowKey: string, stepKey: string) => {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') {
+          return { fieldPath: 'a' };
+        }
+      }),
+      setProps(key: any, value?: any) {
+        if (typeof key === 'string') {
+          this.props[key] = value;
+        } else {
+          this.props = { ...this.props, ...key };
+        }
+      },
+    };
+
+    const formItemModel: any = {
+      uid: 'field-a',
+      getFork: vi.fn((key: string) => (key === 'items:0:field-a' ? targetFieldFork : undefined)),
+    };
+
+    engine.getModel = vi.fn((uid: string) => (uid === 'field-a' ? formItemModel : undefined)) as any;
+
+    await subFormFieldLinkageRules.handler(
+      {
+        model: {
+          hidden: false,
+          subModels: {
+            grid: {
+              forks: [rowGridFork],
+            },
+          },
+        },
+        flowKey: 'eventSettings',
+      } as any,
+      {
+        value: [
+          {
+            key: 'rule-1',
+            enable: true,
+            condition: { logic: '$and', items: [] },
+            actions: [
+              {
+                name: 'subFormLinkageSetFieldProps',
+                params: {
+                  value: {
+                    fields: ['field-a'],
+                    state: 'hidden',
+                  },
+                },
+              },
+            ],
+          },
+        ],
+      },
+    );
+
+    expect(form.getFieldValue).toHaveBeenCalledWith(['items', 0, 'a']);
+    expect(targetFieldFork.hidden).toBe(true);
+    expect(setFormValues).toHaveBeenCalledWith(
+      [{ path: ['items', 0, 'a'], value: undefined }],
+      expect.objectContaining({ source: 'linkage' }),
+    );
+    expect(form.setFieldValue).not.toHaveBeenCalled();
+  });
 });
 
 describe('linkageSetFieldProps action', () => {
@@ -541,6 +651,263 @@ describe('linkageSetFieldProps action', () => {
     expect(form.setFieldValue).not.toHaveBeenCalled();
   });
 
+  it('should clear form value when a field is hidden without reserving value', async () => {
+    const setFormValues = vi.fn(async () => undefined);
+    const form = {
+      getFieldValue: vi.fn(() => '123'),
+      setFieldValue: vi.fn(),
+    };
+    const fieldModel: any = {
+      uid: 'name-field',
+      hidden: false,
+      context: { form },
+      props: {
+        label: 'Name',
+      },
+      getStepParams: vi.fn((flowKey: string, stepKey: string) => {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') {
+          return { fieldPath: 'name' };
+        }
+      }),
+      setProps(key: any, value?: any) {
+        if (typeof key === 'string') {
+          this.props[key] = value;
+        } else {
+          this.props = { ...this.props, ...key };
+        }
+      },
+    };
+    const ctx: any = {
+      app: {
+        jsonLogic: {
+          apply: vi.fn(() => true),
+        },
+      },
+      model: {
+        context: { form },
+        subModels: {
+          grid: {
+            subModels: {
+              items: [fieldModel],
+            },
+          },
+        },
+      },
+      setFormValues,
+      getAction: (name: string) => (name === 'linkageSetFieldProps' ? linkageSetFieldProps : null),
+      resolveJsonTemplate: vi.fn(async (value) => value),
+    };
+
+    await fieldLinkageRules.handler(ctx, {
+      value: [
+        {
+          key: 'rule-1',
+          enable: true,
+          condition: { logic: '$and', items: [] },
+          actions: [
+            {
+              key: 'action-1',
+              name: 'linkageSetFieldProps',
+              params: {
+                value: {
+                  fields: ['name-field'],
+                  state: 'hidden',
+                },
+              },
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(fieldModel.hidden).toBe(true);
+    expect(setFormValues).toHaveBeenCalledWith(
+      [{ path: ['name'], value: undefined }],
+      expect.objectContaining({ source: 'linkage' }),
+    );
+    expect(form.setFieldValue).not.toHaveBeenCalled();
+  });
+
+  it('should keep hidden clear after same-round assignment for the same field', async () => {
+    const formValues: { name?: string } = {};
+    const setFormValues = vi.fn(async (patches: Array<{ path: Array<string | number>; value: string | undefined }>) => {
+      for (const patch of patches) {
+        if (patch.path.length === 1 && patch.path[0] === 'name') {
+          formValues.name = patch.value;
+        }
+      }
+    });
+    const form = {
+      getFieldValue: vi.fn((path: Array<string | number>) => {
+        if (path.length === 1 && path[0] === 'name') {
+          return formValues.name;
+        }
+        return undefined;
+      }),
+      setFieldValue: vi.fn(),
+    };
+    const fieldModel: any = {
+      uid: 'name-field',
+      hidden: false,
+      context: { form },
+      props: {
+        label: 'Name',
+      },
+      getStepParams: vi.fn((flowKey: string, stepKey: string) => {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') {
+          return { fieldPath: 'name' };
+        }
+      }),
+      setProps(key: any, value?: any) {
+        if (typeof key === 'string') {
+          this.props[key] = value;
+        } else {
+          this.props = { ...this.props, ...key };
+        }
+      },
+    };
+    const ctx: any = {
+      app: {
+        jsonLogic: {
+          apply: vi.fn(() => true),
+        },
+      },
+      model: {
+        context: { form },
+        subModels: {
+          grid: {
+            subModels: {
+              items: [fieldModel],
+            },
+          },
+        },
+      },
+      setFormValues,
+      getAction: (name: string) => {
+        if (name === 'linkageSetFieldProps') return linkageSetFieldProps;
+        if (name === 'linkageAssignField') return linkageAssignField;
+        return null;
+      },
+      resolveJsonTemplate: vi.fn(async (value) => value),
+    };
+
+    await fieldLinkageRules.handler(ctx, {
+      value: [
+        {
+          key: 'rule-1',
+          enable: true,
+          condition: { logic: '$and', items: [] },
+          actions: [
+            {
+              key: 'action-1',
+              name: 'linkageSetFieldProps',
+              params: {
+                value: {
+                  fields: ['name-field'],
+                  state: 'hidden',
+                },
+              },
+            },
+            {
+              key: 'action-2',
+              name: 'linkageAssignField',
+              params: {
+                value: [
+                  {
+                    key: 'assign-1',
+                    enable: true,
+                    targetPath: 'name',
+                    value: 'assigned',
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(fieldModel.hidden).toBe(true);
+    expect(formValues.name).toBeUndefined();
+    expect(setFormValues).not.toHaveBeenCalled();
+    expect(form.setFieldValue).not.toHaveBeenCalled();
+  });
+
+  it('should not clear form value when a field is hidden with reserved value', async () => {
+    const setFormValues = vi.fn(async () => undefined);
+    const form = {
+      getFieldValue: vi.fn(() => '123'),
+      setFieldValue: vi.fn(),
+    };
+    const fieldModel: any = {
+      uid: 'name-field',
+      hidden: false,
+      context: { form },
+      props: {
+        label: 'Name',
+      },
+      getStepParams: vi.fn((flowKey: string, stepKey: string) => {
+        if (flowKey === 'fieldSettings' && stepKey === 'init') {
+          return { fieldPath: 'name' };
+        }
+      }),
+      setProps(key: any, value?: any) {
+        if (typeof key === 'string') {
+          this.props[key] = value;
+        } else {
+          this.props = { ...this.props, ...key };
+        }
+      },
+    };
+    const ctx: any = {
+      app: {
+        jsonLogic: {
+          apply: vi.fn(() => true),
+        },
+      },
+      model: {
+        context: { form },
+        subModels: {
+          grid: {
+            subModels: {
+              items: [fieldModel],
+            },
+          },
+        },
+      },
+      setFormValues,
+      getAction: (name: string) => (name === 'linkageSetFieldProps' ? linkageSetFieldProps : null),
+      resolveJsonTemplate: vi.fn(async (value) => value),
+    };
+
+    await fieldLinkageRules.handler(ctx, {
+      value: [
+        {
+          key: 'rule-1',
+          enable: true,
+          condition: { logic: '$and', items: [] },
+          actions: [
+            {
+              key: 'action-1',
+              name: 'linkageSetFieldProps',
+              params: {
+                value: {
+                  fields: ['name-field'],
+                  state: 'hiddenReservedValue',
+                },
+              },
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(fieldModel.hidden).toBe(false);
+    expect(fieldModel.props.hidden).toBe(true);
+    expect(setFormValues).not.toHaveBeenCalled();
+    expect(form.setFieldValue).not.toHaveBeenCalled();
+  });
+
   it('should keep all options selectable after options were limited once', async () => {
     const fieldComponentModel: any = {
       uid: 'status-field-component',

package/src/flow/actions/dataScope.tsx

@@ -33,7 +33,14 @@ export const dataScope = defineAction({
         return (
           <FilterGroup
             value={props.value}
-            FilterItem={(p) => <VariableFilterItem {...p} model={flowContext.model} rightAsVariable />}
+            FilterItem={(p) => (
+              <VariableFilterItem
+                {...p}
+                model={flowContext.model}
+                rightAsVariable
+                maxAssociationFieldDepth={flowContext.model instanceof FieldModel ? undefined : 2}
+              />
+            )}
           />
         );
       },

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);
         }
@@ -2145,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/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/AdminLayoutComponent.tsx

@@ -42,6 +42,7 @@ import {
   FLOW_SETTINGS_PREFERENCE_STORAGE_KEY,
   readFlowSettingsPreference,
 } from './flowSettingsPreference';
+import { useAppListRender } from './AppListRender';
 
 const className1 = css`
   height: var(--nb-header-height);
@@ -391,7 +392,8 @@ export const AdminLayoutComponent = observer((props: any) => {
   );
   const designable = !isMobileSider && preferredFlowSettingsEnabled;
   const { styles } = useHeaderStyle();
-  const { Component: AppsComponent } = useApplications();
+  const { appList } = useApplications();
+  const appListRender = useAppListRender();
   const flowSettingsSyncRef = useRef(0);
   const desiredFlowSettingsEnabledRef = useRef(false);
   const handleLayoutContentElementChange = useCallback(
@@ -601,6 +603,31 @@ export const AdminLayoutComponent = observer((props: any) => {
       overflowedIndicatorPopupClassName: styles.headerPopup,
     };
   }, [styles.headerPopup]);
+  const appSwitcherStyle = useMemo(
+    () => css`
+      .ant-layout-header.ant-pro-layout-header,
+      .ant-pro-top-nav-header {
+        z-index: 101 !important;
+      }
+
+      .ant-pro-layout-apps-popover {
+        z-index: 2000 !important;
+      }
+
+      .ant-pro-layout-apps-icon {
+        color: ${customToken.colorTextHeaderMenu || 'rgba(255, 255, 255, 0.85)'};
+      }
+
+      .ant-pro-layout-apps-icon:hover,
+      .ant-pro-layout-apps-icon-active {
+        color: ${customToken.colorTextHeaderMenuHover ||
+        customToken.colorTextHeaderMenu ||
+        'rgba(255, 255, 255, 0.85)'};
+        background: ${customToken.colorBgHeaderMenuHover || 'rgba(255, 255, 255, 0.12)'};
+      }
+    `,
+    [customToken.colorBgHeaderMenuHover, customToken.colorTextHeaderMenu, customToken.colorTextHeaderMenuHover],
+  );
 
   const closeMobileMenu = useCallback(() => {
     if (!isMobileSider) {
@@ -634,16 +661,17 @@ export const AdminLayoutComponent = observer((props: any) => {
               {...props}
               contentStyle={contentStyle}
               siderWidth={customToken.siderWidth || 200}
-              className={resetStyle}
+              className={`${resetStyle} ${appSwitcherStyle}`}
               location={location}
               route={route}
               actionsRender={props.actionsRender || actionsRender}
               logo={
                 <div style={{ display: 'flex', alignItems: 'center' }}>
-                  {AppsComponent && <AppsComponent />}
                   <NocoBaseLogo />
                 </div>
               }
+              appList={appList}
+              appListRender={appListRender}
               title={''}
               layout="mix"
               splitMenus

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',