@nocobase/client-v2 2.1.8 → 2.1.10

package/src/flow/components/__tests__/FieldAssignRulesEditor.test.tsx

@@ -795,15 +795,23 @@ describe('FieldAssignRulesEditor', () => {
     );
 
     expect(screen.getByLabelText('Default value')).toBeInTheDocument();
+    expect(screen.getByLabelText('Override value')).toBeInTheDocument();
     expect(screen.getByLabelText('Fixed value')).toBeInTheDocument();
     expect(screen.getByLabelText('Fixed value')).toBeChecked();
     await userEvent.click(screen.getByLabelText('Default value'));
     await waitFor(() => {
       expect(onChange).toHaveBeenCalled();
     });
-
-    const lastCall = onChange.mock.calls[onChange.mock.calls.length - 1]?.[0] as FieldAssignRuleItem[];
+    let lastCall = onChange.mock.calls[onChange.mock.calls.length - 1]?.[0] as FieldAssignRuleItem[];
     expect(lastCall?.[0]?.mode).toBe('default');
+
+    onChange.mockClear();
+    await userEvent.click(screen.getByLabelText('Override value'));
+    await waitFor(() => {
+      expect(onChange).toHaveBeenCalled();
+    });
+    lastCall = onChange.mock.calls[onChange.mock.calls.length - 1]?.[0] as FieldAssignRuleItem[];
+    expect(lastCall?.[0]?.mode).toBe('override');
   });
 
   it('shows assignment mode tooltips for each option', async () => {
@@ -821,7 +829,7 @@ describe('FieldAssignRulesEditor', () => {
     );
 
     const questionIcons = Array.from(container.querySelectorAll('.anticon-question-circle'));
-    expect(questionIcons).toHaveLength(2);
+    expect(questionIcons).toHaveLength(3);
 
     await userEvent.hover(questionIcons[0] as Element);
     await waitFor(() => {
@@ -835,11 +843,80 @@ describe('FieldAssignRulesEditor', () => {
     await userEvent.unhover(questionIcons[0] as Element);
 
     await userEvent.hover(questionIcons[1] as Element);
+    await waitFor(() => {
+      expect(screen.getByText('Overrides existing values until the user edits it.')).toBeInTheDocument();
+    });
+
+    await userEvent.unhover(questionIcons[1] as Element);
+
+    await userEvent.hover(questionIcons[2] as Element);
     await waitFor(() => {
       expect(screen.getByText('A system-set value. Read-only.')).toBeInTheDocument();
     });
   });
 
+  it('honors allowed assignment modes', () => {
+    const value: FieldAssignRuleItem[] = [
+      {
+        key: '1',
+        enable: true,
+        targetPath: 'title',
+        mode: 'override',
+      },
+    ];
+
+    render(
+      wrap(
+        <FieldAssignRulesEditor
+          t={t}
+          fieldOptions={[]}
+          value={value}
+          allowedModes={['default', 'assign']}
+          showCondition={false}
+          showEnable={false}
+        />,
+      ),
+    );
+
+    expect(screen.getByLabelText('Default value')).toBeInTheDocument();
+    expect(screen.getByLabelText('Fixed value')).toBeInTheDocument();
+    expect(screen.queryByLabelText('Override value')).toBeNull();
+    expect(screen.getByLabelText('Fixed value')).toBeChecked();
+  });
+
+  it('normalizes disallowed assignment mode before emitting changes', async () => {
+    const onChange = vi.fn();
+    const value: FieldAssignRuleItem[] = [
+      {
+        key: '1',
+        enable: true,
+        targetPath: 'title',
+        mode: 'override',
+      },
+    ];
+
+    render(
+      wrap(
+        <FieldAssignRulesEditor
+          t={t}
+          fieldOptions={[]}
+          value={value}
+          onChange={onChange}
+          allowedModes={['default', 'assign']}
+          showCondition={false}
+        />,
+      ),
+    );
+
+    await userEvent.click(screen.getByRole('switch'));
+
+    await waitFor(() => {
+      expect(onChange).toHaveBeenCalled();
+    });
+    const lastCall = onChange.mock.calls[onChange.mock.calls.length - 1]?.[0] as FieldAssignRuleItem[];
+    expect(lastCall?.[0]?.mode).toBe('assign');
+  });
+
   it('merges extra item tree into base item while keeping order', () => {
     const base: MetaTreeNode[] = [
       { name: 'formValues', title: 'Current form', type: 'object', paths: ['formValues'] },
@@ -897,7 +974,7 @@ describe('FieldAssignRulesEditor', () => {
 
     const itemNode = merged.find((node) => node.name === 'item');
     expect(itemNode).toBeTruthy();
-    const parent = (itemNode.children as MetaTreeNode[]).find((node) => node.name === 'parentItem');
+    const parent = ((itemNode?.children as MetaTreeNode[]) || []).find((node) => node.name === 'parentItem');
     expect(parent).toBeTruthy();
 
     const nestedParent = ((parent?.children as MetaTreeNode[]) || []).find((node) => node.name === 'parentItem');

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

@@ -375,12 +375,15 @@ export class PageModel extends FlowModel<PageModelStructure> {
           tabBarStyle={this.props.tabBarStyle}
           items={this.mapTabs()}
           onChange={(activeKey) => {
+            const previousActiveKey = this.props.tabActiveKey || this.getActiveTabKey();
             this.context.view.navigation?.changeTo?.({
               tabUid: activeKey,
             });
 
             this.invokeTabModelLifecycleMethod(activeKey, 'onActive');
-            this.invokeTabModelLifecycleMethod(this.props.tabActiveKey, 'onInactive');
+            if (previousActiveKey && previousActiveKey !== activeKey) {
+              this.invokeTabModelLifecycleMethod(previousActiveKey, 'onInactive');
+            }
             this.setProps('tabActiveKey', activeKey);
           }}
           // destroyInactiveTabPane

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

@@ -452,6 +452,34 @@ describe('PageModel', () => {
         marginInlineEnd: 24,
       });
     });
+
+    it('should deactivate the previous tab when navigation updates active tab synchronously', () => {
+      pageModel.props = { tabActiveKey: 'tab-old' } as any;
+      const invokeSpy = vi.spyOn(pageModel as any, 'invokeTabModelLifecycleMethod').mockImplementation(() => undefined);
+      const changeTo = vi.fn((params: { tabUid: string }) => {
+        pageModel.props.tabActiveKey = params.tabUid;
+      });
+
+      pageModel.context.view = {
+        navigation: {
+          viewParams: {
+            tabUid: 'tab-old',
+          },
+          changeTo,
+        },
+      } as any;
+
+      const result = pageModel.renderTabs() as any;
+      const tabsElement = result.props.children;
+
+      tabsElement.props.onChange('tab-new');
+
+      expect(changeTo).toHaveBeenCalledWith({ tabUid: 'tab-new' });
+      expect(invokeSpy).toHaveBeenNthCalledWith(1, 'tab-new', 'onActive');
+      expect(invokeSpy).toHaveBeenNthCalledWith(2, 'tab-old', 'onInactive');
+      expect(invokeSpy).not.toHaveBeenCalledWith('tab-new', 'onInactive');
+      expect(pageModel.props.tabActiveKey).toBe('tab-new');
+    });
   });
 
   describe('render header spacing with tabs', () => {

package/src/flow/models/blocks/filter-form/FilterFormBlockModel.tsx

@@ -231,6 +231,7 @@ export class FilterFormBlockModel extends FilterBlockModel<{
   private initialDefaultsPromise?: Promise<void>;
   private initialRefreshHandledTargetIds = new Set<string>();
   private lastDefaultValueByFieldName = new Map<string, any>();
+  private userEditedFieldNames = new Set<string>();
   private defaultValuesRefreshSeq = 0;
 
   get form() {
@@ -436,6 +437,28 @@ export class FilterFormBlockModel extends FilterBlockModel<{
     return isEqual(current, this.lastDefaultValueByFieldName.get(name));
   }
 
+  private canApplyFormOverrideValue(name: string, force?: boolean) {
+    if (force) return true;
+    return !this.userEditedFieldNames.has(name);
+  }
+
+  private normalizeFieldValueMode(mode: unknown): 'default' | 'assign' | 'override' {
+    if (mode === 'assign') return 'assign';
+    if (mode === 'override') return 'override';
+    return 'default';
+  }
+
+  private markFilterFormUserEditedFields(changedValues: any) {
+    if (!changedValues || typeof changedValues !== 'object' || Array.isArray(changedValues)) return;
+    for (const name of Object.keys(changedValues)) {
+      this.userEditedFieldNames.add(String(name));
+    }
+  }
+
+  private resetFilterFormUserEditedFields() {
+    this.userEditedFieldNames.clear();
+  }
+
   private async matchDefaultValueCondition(condition: any) {
     if (!condition) return true;
 
@@ -458,6 +481,10 @@ export class FilterFormBlockModel extends FilterBlockModel<{
     if (!form) return appliedValues;
 
     const force = options?.force === true;
+    if (force) {
+      this.resetFilterFormUserEditedFields();
+    }
+
     const params = this.getStepParams?.('formFilterBlockModelSettings', 'defaultValues');
     const rules = (params?.value || []) as any[];
     if (!Array.isArray(rules) || rules.length === 0) return appliedValues;
@@ -499,8 +526,9 @@ export class FilterFormBlockModel extends FilterBlockModel<{
 
       const operator = getDefaultOperator(itemModel as any);
       const normalized = normalizeFilterValueByOperator(operator, resolved);
-      const mode = String(rule.mode || 'default') === 'assign' ? 'assign' : 'default';
+      const mode = this.normalizeFieldValueMode(rule.mode);
       if (mode === 'default' && !this.canApplyFormDefaultValue(String(name), current, force)) continue;
+      if (mode === 'override' && !this.canApplyFormOverrideValue(String(name), force)) continue;
       if (isEqual(current, normalized)) {
         if (mode === 'default') {
           this.lastDefaultValueByFieldName.set(String(name), normalized);
@@ -527,6 +555,7 @@ export class FilterFormBlockModel extends FilterBlockModel<{
   }
 
   private handleFilterFormValuesChange(changedValues: any, allValues: any) {
+    this.markFilterFormUserEditedFields(changedValues);
     const refreshSeq = ++this.defaultValuesRefreshSeq;
     void (async () => {
       const appliedValues = await this.applyFormDefaultValues({ refreshSeq });

package/src/flow/models/blocks/filter-form/__tests__/defaultValues.wiring.test.ts

@@ -50,6 +50,7 @@ function createFilterFormDefaultValuesModel(rules: any[], initialValues: Record<
   const model = {
     defaultValuesRefreshSeq: 0,
     lastDefaultValueByFieldName: new Map<string, any>(),
+    userEditedFieldNames: new Set<string>(),
     form: {
       getFieldsValue: () => ({ ...values }),
       getFieldValue: (name: string) => values[name],
@@ -86,6 +87,10 @@ function createFilterFormDefaultValuesModel(rules: any[], initialValues: Record<
       return undefined;
     }),
     canApplyFormDefaultValue: (FilterFormBlockModel.prototype as any).canApplyFormDefaultValue,
+    canApplyFormOverrideValue: (FilterFormBlockModel.prototype as any).canApplyFormOverrideValue,
+    normalizeFieldValueMode: (FilterFormBlockModel.prototype as any).normalizeFieldValueMode,
+    markFilterFormUserEditedFields: (FilterFormBlockModel.prototype as any).markFilterFormUserEditedFields,
+    resetFilterFormUserEditedFields: (FilterFormBlockModel.prototype as any).resetFilterFormUserEditedFields,
     matchDefaultValueCondition: (FilterFormBlockModel.prototype as any).matchDefaultValueCondition,
     applyFormDefaultValues: FilterFormBlockModel.prototype.applyFormDefaultValues,
     handleFilterFormValuesChange: (FilterFormBlockModel.prototype as any).handleFilterFormValuesChange,
@@ -315,6 +320,78 @@ describe('filter-form defaultValues wiring', () => {
     expect(values.username_user).toBe('Bob');
   });
 
+  it('applies override values until the target filter field is changed by user', async () => {
+    const { model, values } = createFilterFormDefaultValuesModel(
+      [
+        {
+          key: 'username-override',
+          enable: true,
+          targetPath: 'username',
+          mode: 'override',
+          value: '{{ ctx.formValues.nickname_nick }}',
+        },
+      ],
+      { nickname_nick: 'Bob', username_user: 'Manual' },
+    );
+
+    await FilterFormBlockModel.prototype.applyFormDefaultValues.call(model as any);
+    expect(values.username_user).toBe('Bob');
+
+    values.nickname_nick = 'Carol';
+    model.defaultValuesRefreshSeq += 1;
+    await FilterFormBlockModel.prototype.applyFormDefaultValues.call(model as any, {
+      refreshSeq: model.defaultValuesRefreshSeq,
+    });
+    expect(values.username_user).toBe('Carol');
+
+    values.username_user = 'User value';
+    (model as any).handleFilterFormValuesChange(
+      { username_user: 'User value' },
+      { nickname_nick: 'Carol', username_user: 'User value' },
+    );
+
+    await waitFor(() => {
+      expect(values.username_user).toBe('User value');
+    });
+
+    values.nickname_nick = 'Dora';
+    model.defaultValuesRefreshSeq += 1;
+    await FilterFormBlockModel.prototype.applyFormDefaultValues.call(model as any, {
+      refreshSeq: model.defaultValuesRefreshSeq,
+    });
+    expect(values.username_user).toBe('User value');
+  });
+
+  it('clears filter form user-edited override state on forced apply', async () => {
+    const { model, values } = createFilterFormDefaultValuesModel(
+      [
+        {
+          key: 'username-override',
+          enable: true,
+          targetPath: 'username',
+          mode: 'override',
+          condition: {
+            logic: '$and',
+            items: [{ path: '{{ ctx.formValues.nickname_nick }}', operator: '$eq', value: 'allow' }],
+          },
+          value: '{{ ctx.formValues.nickname_nick }}',
+        },
+      ],
+      { nickname_nick: 'deny', username_user: 'User value' },
+    );
+
+    model.userEditedFieldNames.add('username_user');
+
+    await FilterFormBlockModel.prototype.applyFormDefaultValues.call(model as any, { force: true });
+    expect(values.username_user).toBe('User value');
+    expect(model.userEditedFieldNames.has('username_user')).toBe(false);
+
+    values.nickname_nick = 'allow';
+    await FilterFormBlockModel.prototype.applyFormDefaultValues.call(model as any);
+
+    expect(values.username_user).toBe('allow');
+  });
+
   it('skips filter form field values when the rule condition does not match', async () => {
     const { model, values } = createFilterFormDefaultValuesModel(
       [

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

@@ -239,6 +239,7 @@ EditFormModel.registerFlow({
           // 切换记录（翻页等）时，清理“用户改动标记”，避免把上一条记录的编辑状态带到下一条
           if (recordChanged) {
             ctx.model.resetUserModifiedFields?.();
+            ctx.model.resetRuntimeUserEditedState?.();
           }
 
           ctx.form.setFieldsValue(currentRecord);

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

@@ -166,6 +166,13 @@ export class FormBlockModel<
     this.userModifiedTopLevelFields.clear();
   }
 
+  /**
+   * @internal
+   */
+  resetRuntimeUserEditedState(): void {
+    this.formValueRuntime?.resetUserEditedState?.();
+  }
+
   public async onDispatchEventStart(eventName: string, options?: any, inputArgs?: Record<string, any>): Promise<void> {
     if (eventName === 'beforeRender') {
       const grid = this.subModels.grid;

package/src/flow/models/blocks/form/__tests__/FormBlockModel.test.tsx

@@ -420,6 +420,23 @@ describe('FormBlockModel (form/formValues injection & server resolve anchors)',
     expect(savedUids).toContain('grid-1');
   });
 
+  it('keeps dirty reset separate from runtime user-edited reset', async () => {
+    const model = await setupFormModel();
+    const resetUserEditedState = vi.fn();
+    model.formValueRuntime = { resetUserEditedState } as any;
+
+    model.markUserModifiedFields({ status: 'draft' });
+    expect(model.getUserModifiedFields().has('status')).toBe(true);
+
+    model.resetUserModifiedFields();
+
+    expect(model.getUserModifiedFields().size).toBe(0);
+    expect(resetUserEditedState).not.toHaveBeenCalled();
+
+    model.resetRuntimeUserEditedState();
+    expect(resetUserEditedState).toHaveBeenCalledTimes(1);
+  });
+
   it('re-syncs delegated assignRules when grid submodel is added after block init', async () => {
     const model = await setupFormModel();
     const syncAssignRules = vi.fn();