@nocobase/client-v2 2.1.0-beta.23 → 2.1.0-beta.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/client-v2",
-  "version": "2.1.0-beta.23",
+  "version": "2.1.0-beta.25",
   "license": "Apache-2.0",
   "main": "lib/index.js",
   "module": "es/index.mjs",
@@ -24,9 +24,10 @@
     "@formily/antd-v5": "1.2.3",
     "@formily/react": "^2.2.27",
     "@formily/shared": "^2.2.27",
-    "@nocobase/flow-engine": "2.1.0-beta.23",
-    "@nocobase/sdk": "2.1.0-beta.23",
-    "@nocobase/shared": "2.1.0-beta.23",
+    "@nocobase/flow-engine": "2.1.0-beta.25",
+    "@nocobase/sdk": "2.1.0-beta.25",
+    "@nocobase/shared": "2.1.0-beta.25",
+    "ahooks": "^3.7.2",
     "antd": "5.24.2",
     "classnames": "^2.3.1",
     "dayjs": "^1.11.10",
@@ -35,5 +36,5 @@
     "react-i18next": "^11.15.1",
     "react-router-dom": "^6.30.1"
   },
-  "gitHead": "bb4c0d3551bf9eff505b63756dd24a0813231f16"
+  "gitHead": "824f8b8200e9fe086135768934d3ef427b212446"
 }

package/src/BaseApplication.tsx

@@ -189,6 +189,7 @@ export abstract class BaseApplication<
     this.configureContext();
     this.addBaseProviders();
     this.addCustomProviders();
+    this.addFinalProviders();
     this.addReactRouterComponents();
     this.addProviders(options.providers || []);
     this.ws = this.createWebSocketClient(options);
@@ -338,6 +339,9 @@ export abstract class BaseApplication<
     this.use(FlowEngineProvider, { engine: this.flowEngine });
     this.use(GlobalThemeProvider);
     this.use(AntdAppProvider);
+  }
+
+  protected addFinalProviders() {
     this.use(FlowEngineGlobalsContextProvider);
   }
 

package/src/__tests__/globalDeps.test.ts

@@ -23,5 +23,6 @@ describe('client-v2 defineGlobalDeps', () => {
     expect(define).toHaveBeenCalledWith('@nocobase/utils/client', expect.any(Function));
     expect(define).toHaveBeenCalledWith('@nocobase/client-v2', expect.any(Function));
     expect(define).toHaveBeenCalledWith('@nocobase/flow-engine', expect.any(Function));
+    expect(define).toHaveBeenCalledWith('ahooks', expect.any(Function));
   });
 });

package/src/__tests__/remotePlugins.test.ts

@@ -8,6 +8,7 @@
  */
 
 import { Plugin } from '../Plugin';
+import { getRequireJs } from '../utils/requirejs';
 import { defineDevPlugins, definePluginClient, getPlugins } from '../utils/remotePlugins';
 
 describe('client-v2 remotePlugins', () => {
@@ -69,4 +70,30 @@ describe('client-v2 remotePlugins', () => {
     expect(mockDefine).toHaveBeenCalledWith('@nocobase/demo/client-v2', expect.any(Function));
     expect(mockDefine).not.toHaveBeenCalledWith('@nocobase/demo/client', expect.any(Function));
   });
+
+  it('should not append duplicate .js for plugin URLs without query strings', () => {
+    const requirejs = getRequireJs();
+
+    requirejs.requirejs.config({
+      paths: {
+        '@nocobase/demo': '/static/plugins/@nocobase/demo/dist/client-v2/index.js',
+      },
+    });
+
+    expect(requirejs.requirejs.toUrl('@nocobase/demo')).toBe('/static/plugins/@nocobase/demo/dist/client-v2/index.js');
+  });
+
+  it('should keep hashed plugin URLs unchanged', () => {
+    const requirejs = getRequireJs();
+
+    requirejs.requirejs.config({
+      paths: {
+        '@nocobase/demo': '/static/plugins/@nocobase/demo/dist/client-v2/index.js?hash=12345678',
+      },
+    });
+
+    expect(requirejs.requirejs.toUrl('@nocobase/demo')).toBe(
+      '/static/plugins/@nocobase/demo/dist/client-v2/index.js?hash=12345678',
+    );
+  });
 });

package/src/flow/actions/__tests__/dataScopeFilter.test.ts

@@ -0,0 +1,158 @@
+/**
+ * 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 { describe, expect, it, vi } from 'vitest';
+import { dataScope } from '../dataScope';
+import { normalizeDataScopeFilter } from '../dataScopeFilter';
+import { setTargetDataScope } from '../setTargetDataScope';
+
+describe('normalizeDataScopeFilter', () => {
+  it('keeps null when a right-side variable resolves to empty', () => {
+    const rawFilter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.formValues.department.id }}' }],
+    };
+    const resolvedFilter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: undefined }],
+    };
+
+    expect(normalizeDataScopeFilter(rawFilter, resolvedFilter)).toEqual({
+      $and: [{ departmentId: { $eq: null } }],
+    });
+  });
+
+  it('keeps null when a right-side variable resolves to an empty string', () => {
+    const rawFilter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.formValues.department.id }}' }],
+    };
+    const resolvedFilter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: '' }],
+    };
+
+    expect(normalizeDataScopeFilter(rawFilter, resolvedFilter)).toEqual({
+      $and: [{ departmentId: { $eq: null } }],
+    });
+  });
+
+  it('still prunes empty constant values', () => {
+    const filter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: undefined }],
+    };
+
+    expect(normalizeDataScopeFilter(filter, filter)).toBeUndefined();
+  });
+
+  it('handles nested groups and keeps non-empty values unchanged', () => {
+    const rawFilter = {
+      logic: '$and',
+      items: [
+        { path: 'status', operator: '$eq', value: 'active' },
+        {
+          logic: '$or',
+          items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.formValues.department.id }}' }],
+        },
+      ],
+    };
+    const resolvedFilter = {
+      logic: '$and',
+      items: [
+        { path: 'status', operator: '$eq', value: 'active' },
+        {
+          logic: '$or',
+          items: [{ path: 'departmentId', operator: '$eq', value: null }],
+        },
+      ],
+    };
+
+    expect(normalizeDataScopeFilter(rawFilter, resolvedFilter)).toEqual({
+      $and: [{ status: { $eq: 'active' } }, { $or: [{ departmentId: { $eq: null } }] }],
+    });
+  });
+
+  it('does not preserve explicit null constants', () => {
+    const filter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: null }],
+    };
+
+    expect(normalizeDataScopeFilter(filter, filter)).toBeUndefined();
+  });
+
+  it('dataScope handler sends null for empty variable dependencies', async () => {
+    const resource = {
+      addFilterGroup: vi.fn(),
+      removeFilterGroup: vi.fn(),
+    };
+    const ctx = {
+      model: {
+        uid: 'field-1',
+        resource,
+      },
+      resolveJsonTemplate: vi.fn(async (template) => ({
+        ...template,
+        items: [{ ...template.items[0], value: undefined }],
+      })),
+    };
+    const params = {
+      filter: {
+        logic: '$and',
+        items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.formValues.department.id }}' }],
+      },
+    };
+
+    await (dataScope as any).handler(ctx, params);
+
+    expect(resource.addFilterGroup).toHaveBeenCalledWith('field-1', {
+      $and: [{ departmentId: { $eq: null } }],
+    });
+    expect(resource.removeFilterGroup).not.toHaveBeenCalled();
+  });
+
+  it('setTargetDataScope handler sends null for empty variable dependencies', async () => {
+    const resource = {
+      addFilterGroup: vi.fn(),
+      removeFilterGroup: vi.fn(),
+      hasData: vi.fn(() => false),
+      refresh: vi.fn(),
+    };
+    const targetModel = { resource };
+    const ctx = {
+      model: {
+        uid: 'action-1',
+        scheduleModelOperation: vi.fn((_uid, callback) => callback(targetModel)),
+      },
+      resolveJsonTemplate: vi.fn(async (template) => ({
+        ...template,
+        filter: {
+          ...template.filter,
+          items: [{ ...template.filter.items[0], value: undefined }],
+        },
+      })),
+    };
+    const params = {
+      targetBlockUid: 'target-1',
+      filter: {
+        logic: '$and',
+        items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.formValues.department.id }}' }],
+      },
+    };
+
+    await (setTargetDataScope as any).handler(ctx, params);
+
+    expect(ctx.model.scheduleModelOperation).toHaveBeenCalledWith('target-1', expect.any(Function));
+    expect(resource.addFilterGroup).toHaveBeenCalledWith('setTargetDataScope_action-1', {
+      $and: [{ departmentId: { $eq: null } }],
+    });
+    expect(resource.removeFilterGroup).not.toHaveBeenCalled();
+  });
+});

package/src/flow/actions/dataScope.tsx

@@ -7,12 +7,12 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { defineAction, MultiRecordResource, pruneFilter, tExpr, useFlowSettingsContext } from '@nocobase/flow-engine';
-import { isEmptyFilter, transformFilter } from '@nocobase/utils/client';
-import _ from 'lodash';
+import { defineAction, MultiRecordResource, tExpr, useFlowSettingsContext } from '@nocobase/flow-engine';
+import { isEmptyFilter } from '@nocobase/utils/client';
 import React from 'react';
 import { FilterGroup, VariableFilterItem } from '../components/filter';
 import { FieldModel } from '../models/base/FieldModel';
+import { normalizeDataScopeFilter } from './dataScopeFilter';
 
 export const dataScope = defineAction({
   name: 'dataScope',
@@ -43,6 +43,7 @@ export const dataScope = defineAction({
       filter: { logic: '$and', items: [] },
     };
   },
+  useRawParams: true,
   async handler(ctx, params) {
     // @ts-ignore
     const resource = ctx.model?.resource as MultiRecordResource;
@@ -50,7 +51,8 @@ export const dataScope = defineAction({
       return;
     }
 
-    const filter = pruneFilter(transformFilter(params.filter));
+    const resolvedFilter = await ctx.resolveJsonTemplate(params.filter);
+    const filter = normalizeDataScopeFilter(params.filter, resolvedFilter);
 
     if (isEmptyFilter(filter)) {
       resource.removeFilterGroup(ctx.model.uid);

package/src/flow/actions/dataScopeFilter.ts

@@ -0,0 +1,70 @@
+/**
+ * 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 { isVariableExpression, pruneFilter } from '@nocobase/flow-engine';
+import { transformFilter } from '@nocobase/utils/client';
+import _ from 'lodash';
+
+const PRESERVE_NULL = { __nocobaseDataScopeNull__: true };
+
+function isPreserveNull(value: any) {
+  return (
+    value &&
+    typeof value === 'object' &&
+    !Array.isArray(value) &&
+    value.__nocobaseDataScopeNull__ === true &&
+    Object.keys(value).length === 1
+  );
+}
+
+function restorePreservedNull(value: any): any {
+  if (isPreserveNull(value)) {
+    return null;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => restorePreservedNull(item));
+  }
+  if (value && typeof value === 'object') {
+    return Object.keys(value).reduce<Record<string, any>>((result, key) => {
+      result[key] = restorePreservedNull(value[key]);
+      return result;
+    }, {});
+  }
+  return value;
+}
+
+function markEmptyVariableValues(rawNode: any, resolvedNode: any) {
+  if (!rawNode || !resolvedNode || typeof rawNode !== 'object' || typeof resolvedNode !== 'object') {
+    return;
+  }
+
+  if ('path' in rawNode && 'operator' in rawNode) {
+    if (
+      isVariableExpression(rawNode.value) &&
+      (resolvedNode.value === undefined || resolvedNode.value === null || resolvedNode.value === '')
+    ) {
+      resolvedNode.value = PRESERVE_NULL;
+    }
+    return;
+  }
+
+  if (Array.isArray(rawNode.items) && Array.isArray(resolvedNode.items)) {
+    rawNode.items.forEach((rawItem, index) => {
+      markEmptyVariableValues(rawItem, resolvedNode.items[index]);
+    });
+  }
+}
+
+export function normalizeDataScopeFilter(rawFilter: any, resolvedFilter: any) {
+  const filterForTransform = _.cloneDeep(resolvedFilter);
+  markEmptyVariableValues(rawFilter, filterForTransform);
+
+  const filter = pruneFilter(transformFilter(filterForTransform));
+  return restorePreservedNull(filter);
+}

package/src/flow/actions/setTargetDataScope.tsx

@@ -12,14 +12,13 @@ import {
   defineAction,
   FlowModel,
   MultiRecordResource,
-  pruneFilter,
   useFlowContext,
   tExpr,
 } from '@nocobase/flow-engine';
-import { isEmptyFilter, transformFilter } from '@nocobase/utils/client';
-import _ from 'lodash';
+import { isEmptyFilter } from '@nocobase/utils/client';
 import React from 'react';
 import { FilterGroup, VariableFilterItem } from '../components/filter';
+import { normalizeDataScopeFilter } from './dataScopeFilter';
 
 export const setTargetDataScope = defineAction({
   name: 'setTargetDataScope',
@@ -62,8 +61,10 @@ export const setTargetDataScope = defineAction({
       filter: { logic: '$and', items: [] },
     };
   },
+  useRawParams: true,
   async handler(ctx, params) {
-    const targetBlockUid = params.targetBlockUid;
+    const resolvedParams = await ctx.resolveJsonTemplate(params);
+    const targetBlockUid = resolvedParams.targetBlockUid;
     if (!targetBlockUid) {
       return;
     }
@@ -74,7 +75,7 @@ export const setTargetDataScope = defineAction({
         return;
       }
 
-      const filter = pruneFilter(transformFilter(params.filter));
+      const filter = normalizeDataScopeFilter(params.filter, resolvedParams.filter);
 
       if (isEmptyFilter(filter)) {
         resource.removeFilterGroup(`setTargetDataScope_${ctx.model.uid}`);

package/src/flow/components/Grid/index.tsx

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { EMPTY_COLUMN_UID } from '@nocobase/flow-engine';
+import { EMPTY_COLUMN_UID, GridLayoutPath, GridLayoutV2, normalizeGridLayout } from '@nocobase/flow-engine';
 import { Col, Row } from 'antd';
 import React from 'react';
 
@@ -16,37 +16,63 @@ interface DragOverlayRect {
   readonly left: number;
   readonly width: number;
   readonly height: number;
-  readonly type: 'column' | 'column-edge' | 'row-gap' | 'empty-row' | 'empty-column';
+  readonly type: 'column' | 'column-edge' | 'row-gap' | 'empty-row' | 'empty-column' | 'item-edge';
 }
 
 interface GridProps {
-  readonly rows: Record<string, string[][]>;
+  readonly rows?: Record<string, string[][]>;
   readonly sizes?: Record<string, number[]>;
+  readonly layout?: GridLayoutV2;
   readonly renderItem: (uid: string) => React.ReactNode;
   readonly rowGap?: number;
   readonly colGap?: number;
   readonly dragOverlayRect?: DragOverlayRect | null;
 }
 
-export function Grid({ rows, sizes = {}, renderItem, rowGap = 16, colGap = 16, dragOverlayRect }: GridProps) {
-  if (Object.keys(rows || {}).length === 0) {
+export function Grid({
+  rows = {},
+  sizes = {},
+  layout,
+  renderItem,
+  rowGap = 16,
+  colGap = 16,
+  dragOverlayRect,
+}: GridProps) {
+  const normalizedLayout = layout || normalizeGridLayout({ rows, sizes });
+  if (!normalizedLayout.rows.length) {
     return (
-      <div style={{ position: 'relative' }} data-grid-empty-container>
+      <div style={{ position: 'relative' }} data-grid-root data-grid-empty-container>
         {dragOverlayRect && <GridDragOverlay rect={dragOverlayRect} />}
       </div>
     );
   }
 
   return (
-    <div style={{ position: 'relative', display: 'flex', flexDirection: 'column', gap: rowGap }}>
+    <div style={{ position: 'relative', display: 'flex', flexDirection: 'column', gap: rowGap }} data-grid-root>
       {dragOverlayRect && <GridDragOverlay rect={dragOverlayRect} />}
-      {Object.entries(rows).map(([rowKey, cells]) => {
-        const colCount = cells.length;
-        const rowSizes = sizes[rowKey] || [];
+      <GridRows rows={normalizedLayout.rows} renderItem={renderItem} rowGap={rowGap} colGap={colGap} parentPath={[]} />
+    </div>
+  );
+}
+
+interface GridRowsProps {
+  readonly rows: GridLayoutV2['rows'];
+  readonly renderItem: (uid: string) => React.ReactNode;
+  readonly rowGap: number;
+  readonly colGap: number;
+  readonly parentPath: GridLayoutPath;
+}
+
+function GridRows({ rows, renderItem, rowGap, colGap, parentPath }: GridRowsProps) {
+  return (
+    <>
+      {rows.map((row) => {
+        const colCount = row.cells.length;
+        const rowSizes = row.sizes || [];
         const hasAnySize = rowSizes.some((v) => v != null && v !== undefined);
+        const rowPath = [...parentPath, { rowId: row.id }];
 
-        // 计算每个 cell 的 span
-        const spans = cells.map((_, cellIdx) => {
+        const spans = row.cells.map((_, cellIdx) => {
           if (hasAnySize) {
             const assigned = rowSizes.reduce((sum, v) => sum + (v || 0), 0);
             const unassignedCount = colCount - rowSizes.filter(Boolean).length;
@@ -58,22 +84,24 @@ export function Grid({ rows, sizes = {}, renderItem, rowGap = 16, colGap = 16, d
         });
 
         return (
-          <Row key={rowKey} gutter={colGap} data-grid-row-id={rowKey}>
-            {cells.map((cell, cellIdx) => (
+          <Row key={row.id} gutter={colGap} data-grid-row-id={row.id} data-grid-path={JSON.stringify(rowPath)}>
+            {row.cells.map((cell, cellIdx) => (
               <GridColumn
-                key={`${rowKey}:${cell.join('|') || 'empty'}`}
-                rowKey={rowKey}
+                key={cell.id}
+                rowKey={row.id}
                 columnIndex={cellIdx}
                 span={spans[cellIdx]}
                 rowGap={rowGap}
+                colGap={colGap}
                 cell={cell}
+                path={[...rowPath.slice(0, -1), { rowId: row.id, cellId: cell.id }]}
                 renderItem={renderItem}
               />
             ))}
           </Row>
         );
       })}
-    </div>
+    </>
   );
 }
 
@@ -82,7 +110,9 @@ interface GridColumnProps {
   readonly columnIndex: number;
   readonly span: number;
   readonly rowGap: number;
-  readonly cell: readonly string[];
+  readonly colGap: number;
+  readonly cell: GridLayoutV2['rows'][number]['cells'][number];
+  readonly path: GridLayoutPath;
   readonly renderItem: (uid: string) => React.ReactNode;
 }
 
@@ -91,13 +121,21 @@ const GridColumn = React.memo(function GridColumn({
   columnIndex,
   span,
   rowGap,
+  colGap,
   cell,
+  path,
   renderItem,
 }: GridColumnProps) {
+  const items = cell.items || [];
   return (
-    <Col span={span} data-grid-column-row-id={rowKey} data-grid-column-index={columnIndex}>
+    <Col
+      span={span}
+      data-grid-column-row-id={rowKey}
+      data-grid-column-index={columnIndex}
+      data-grid-path={JSON.stringify(path)}
+    >
       <div style={{ display: 'flex', flexDirection: 'column', gap: rowGap }}>
-        {cell.map((uid, itemIdx) => {
+        {items.map((uid, itemIdx) => {
           if (uid === EMPTY_COLUMN_UID) {
             return null;
           }
@@ -108,11 +146,15 @@ const GridColumn = React.memo(function GridColumn({
               data-grid-column-index={columnIndex}
               data-grid-item-index={itemIdx}
               data-grid-item-uid={uid}
+              data-grid-path={JSON.stringify(path)}
             >
               {renderItem(uid)}
             </div>
           );
         })}
+        {cell.rows?.length ? (
+          <GridRows rows={cell.rows} renderItem={renderItem} rowGap={rowGap} colGap={colGap} parentPath={path} />
+        ) : null}
       </div>
     </Col>
   );
@@ -152,6 +194,10 @@ function GridDragOverlay({ rect }: Readonly<{ rect: DragOverlayRect }>) {
       border: '2px dashed var(--colorPrimary)',
       backgroundColor: 'rgba(22, 119, 255, 0.04)',
     },
+    'item-edge': {
+      border: '2px solid var(--colorPrimary)',
+      backgroundColor: 'rgba(22, 119, 255, 0.12)',
+    },
   };
 
   return <div style={{ ...baseStyle, ...typeStyles[rect.type] }} />;

package/src/flow/internal/utils/__tests__/rebuildFieldSubModel.test.ts

@@ -35,7 +35,7 @@ describe('rebuildFieldSubModel', () => {
     });
   });
 
-  test('rebuilds field with same uid and updates binding use', async () => {
+  test('rebuilds field with same uid and direct target field model use', async () => {
     const staleClickHandler = () => null;
     const parent = engine.createModel<DummyParentModel>({
       use: DummyParentModel,
@@ -66,7 +66,8 @@ describe('rebuildFieldSubModel', () => {
 
     expect(rebuilt).toBeInstanceOf(DummyTargetFieldModel);
     expect(rebuilt.uid).toBe('field-1');
-    expect(getFieldBindingUse(rebuilt)).toBe('DummyTargetFieldModel');
+    expect(getFieldBindingUse(rebuilt)).toBeUndefined();
+    expect(rebuilt.use).toBe('DummyTargetFieldModel');
     expect(rebuilt.props).toMatchObject({ added: 'yes', pattern: 'readPretty' });
     expect((rebuilt.props as any).onClick).toBeUndefined();
 
@@ -106,4 +107,78 @@ describe('rebuildFieldSubModel', () => {
     expect(Array.isArray(cols)).toBe(true);
     expect(cols.map((c) => c.uid)).toEqual(['col-1', 'col-2']);
   });
+
+  test('preserves compatible step params when rebuilding with the same field model use', async () => {
+    const parent = engine.createModel<DummyParentModel>({
+      use: DummyParentModel,
+      uid: 'parent-3',
+      subModels: {
+        field: {
+          use: DummyTargetFieldModel,
+          uid: 'field-3',
+          stepParams: {
+            fieldSettings: { init: { initKey: true } },
+            displayFieldSettings: {
+              overflowMode: {
+                overflowMode: true,
+              },
+            },
+          } as any,
+        },
+      },
+    });
+
+    await rebuildFieldSubModel({
+      parentModel: parent,
+      targetUse: 'DummyTargetFieldModel',
+      fieldSettingsInit: { fieldPath: 'title' },
+    });
+
+    const rebuilt = parent.subModels.field as DummyTargetFieldModel;
+    expect(rebuilt.stepParams).toEqual({
+      fieldSettings: {
+        init: { fieldPath: 'title' },
+      },
+      displayFieldSettings: {
+        overflowMode: {
+          overflowMode: true,
+        },
+      },
+    });
+  });
+
+  test('drops incompatible step params when rebuilding to a different field model use', async () => {
+    const parent = engine.createModel<DummyParentModel>({
+      use: DummyParentModel,
+      uid: 'parent-4',
+      subModels: {
+        field: {
+          use: FieldModel,
+          uid: 'field-4',
+          stepParams: {
+            fieldBinding: { use: 'FieldModel' },
+            fieldSettings: { init: { initKey: true } },
+            numberSettings: {
+              format: {
+                separator: '0,0.00',
+              },
+            },
+          } as any,
+        },
+      },
+    });
+
+    await rebuildFieldSubModel({
+      parentModel: parent,
+      targetUse: 'DummyTargetFieldModel',
+      fieldSettingsInit: { fieldPath: 'title' },
+    });
+
+    const rebuilt = parent.subModels.field as DummyTargetFieldModel;
+    expect(rebuilt.stepParams).toEqual({
+      fieldSettings: {
+        init: { fieldPath: 'title' },
+      },
+    });
+  });
 });