@nocobase/client-v2 2.1.0-alpha.25 → 2.1.0-alpha.27

package/src/flow/components/code-editor/runjsDiagnostics.ts

@@ -27,6 +27,50 @@ import {
   shouldPreprocessRunJSTemplates,
 } from '@nocobase/flow-engine';
 
+const acornWalkBase = {
+  ...(acornWalk as any).base,
+  JSXElement(node: any, state: any, callback: any) {
+    callback(node.openingElement, state);
+    for (const child of node.children || []) callback(child, state);
+    if (node.closingElement) callback(node.closingElement, state);
+  },
+  JSXFragment(node: any, state: any, callback: any) {
+    callback(node.openingFragment, state);
+    for (const child of node.children || []) callback(child, state);
+    callback(node.closingFragment, state);
+  },
+  JSXOpeningElement(node: any, state: any, callback: any) {
+    callback(node.name, state);
+    for (const attribute of node.attributes || []) callback(attribute, state);
+  },
+  JSXClosingElement(node: any, state: any, callback: any) {
+    callback(node.name, state);
+  },
+  JSXAttribute(node: any, state: any, callback: any) {
+    callback(node.name, state);
+    if (node.value) callback(node.value, state);
+  },
+  JSXExpressionContainer(node: any, state: any, callback: any) {
+    callback(node.expression, state);
+  },
+  JSXSpreadAttribute(node: any, state: any, callback: any) {
+    callback(node.argument, state);
+  },
+  JSXMemberExpression(node: any, state: any, callback: any) {
+    callback(node.object, state);
+    callback(node.property, state);
+  },
+  JSXNamespacedName(node: any, state: any, callback: any) {
+    callback(node.namespace, state);
+    callback(node.name, state);
+  },
+  JSXIdentifier() {},
+  JSXText() {},
+  JSXEmptyExpression() {},
+  JSXOpeningFragment() {},
+  JSXClosingFragment() {},
+};
+
 export type RunJSIssue = {
   type: 'lint' | 'runtime';
   message: string;
@@ -615,55 +659,63 @@ function collectHeuristicIssues(code: string): RunJSIssue[] {
 
   // Collect declared identifiers (very coarse, best-effort).
   try {
-    acornWalk.full(ast, (node: any) => {
-      switch (node?.type) {
-        case 'VariableDeclarator':
-          addPatternIds(node.id);
-          break;
-        case 'FunctionDeclaration':
-          addId(node.id);
-          (node.params || []).forEach(addPatternIds);
-          break;
-        case 'FunctionExpression':
-          addId(node.id);
-          (node.params || []).forEach(addPatternIds);
-          break;
-        case 'ArrowFunctionExpression':
-          (node.params || []).forEach(addPatternIds);
-          break;
-        case 'CatchClause':
-          addPatternIds((node as any).param);
-          break;
-        case 'ClassDeclaration':
-          addId(node.id);
-          break;
-        default:
-          break;
-      }
-    });
+    acornWalk.full(
+      ast,
+      (node: any) => {
+        switch (node?.type) {
+          case 'VariableDeclarator':
+            addPatternIds(node.id);
+            break;
+          case 'FunctionDeclaration':
+            addId(node.id);
+            (node.params || []).forEach(addPatternIds);
+            break;
+          case 'FunctionExpression':
+            addId(node.id);
+            (node.params || []).forEach(addPatternIds);
+            break;
+          case 'ArrowFunctionExpression':
+            (node.params || []).forEach(addPatternIds);
+            break;
+          case 'CatchClause':
+            addPatternIds((node as any).param);
+            break;
+          case 'ClassDeclaration':
+            addId(node.id);
+            break;
+          default:
+            break;
+        }
+      },
+      acornWalkBase,
+    );
   } catch (_) {
     // ignore
   }
 
   // 1) Non-callable call: 123(), 'x'(), (1+2)(), ({})()
   try {
-    acornWalk.full(ast, (node: any) => {
-      if (!node || typeof node.type !== 'string') return;
-      if (node.type !== 'CallExpression') return;
-      const callee = node.callee;
-      const isCallableLike =
-        callee &&
-        (callee.type === 'Identifier' ||
-          callee.type === 'MemberExpression' ||
-          callee.type === 'FunctionExpression' ||
-          callee.type === 'ArrowFunctionExpression' ||
-          callee.type === 'CallExpression' ||
-          callee.type === 'ChainExpression');
-      if (!isCallableLike) {
-        const pos = (callee as any)?.start ?? node.start ?? 0;
-        pushAtPos(pos, 'no-noncallable-call', 'This expression is not callable.');
-      }
-    });
+    acornWalk.full(
+      ast,
+      (node: any) => {
+        if (!node || typeof node.type !== 'string') return;
+        if (node.type !== 'CallExpression') return;
+        const callee = node.callee;
+        const isCallableLike =
+          callee &&
+          (callee.type === 'Identifier' ||
+            callee.type === 'MemberExpression' ||
+            callee.type === 'FunctionExpression' ||
+            callee.type === 'ArrowFunctionExpression' ||
+            callee.type === 'CallExpression' ||
+            callee.type === 'ChainExpression');
+        if (!isCallableLike) {
+          const pos = (callee as any)?.start ?? node.start ?? 0;
+          pushAtPos(pos, 'no-noncallable-call', 'This expression is not callable.');
+        }
+      },
+      acornWalkBase,
+    );
   } catch (_) {
     // ignore
   }
@@ -673,37 +725,45 @@ function collectHeuristicIssues(code: string): RunJSIssue[] {
   try {
     const reported = new Set<string>();
     const allowedShort = new Set<string>(['t']);
-    acornWalk.full(ast, (node: any) => {
-      if (!node || typeof node.type !== 'string') return;
-      if (node.type !== 'CallExpression') return;
-      let callee = node.callee;
-      if (callee?.type === 'ChainExpression') callee = callee.expression;
-      if (!callee || callee.type !== 'MemberExpression') return;
-      const obj = callee.object;
-      if (!obj || obj.type !== 'Identifier' || obj.name !== 'ctx') return;
-
-      let name: string | null = null;
-      if (!callee.computed && callee.property?.type === 'Identifier') {
-        name = callee.property.name;
-      } else if (callee.computed && callee.property?.type === 'Literal' && typeof callee.property.value === 'string') {
-        name = callee.property.value;
-      }
+    acornWalk.full(
+      ast,
+      (node: any) => {
+        if (!node || typeof node.type !== 'string') return;
+        if (node.type !== 'CallExpression') return;
+        let callee = node.callee;
+        if (callee?.type === 'ChainExpression') callee = callee.expression;
+        if (!callee || callee.type !== 'MemberExpression') return;
+        const obj = callee.object;
+        if (!obj || obj.type !== 'Identifier' || obj.name !== 'ctx') return;
+
+        let name: string | null = null;
+        if (!callee.computed && callee.property?.type === 'Identifier') {
+          name = callee.property.name;
+        } else if (
+          callee.computed &&
+          callee.property?.type === 'Literal' &&
+          typeof callee.property.value === 'string'
+        ) {
+          name = callee.property.value;
+        }
 
-      if (!name || typeof name !== 'string') return;
-      const normalized = name.trim();
-      if (!normalized || normalized.startsWith('_')) return;
-      if (normalized.length > 2) return;
-      if (allowedShort.has(normalized)) return;
-      if (reported.has(normalized)) return;
-
-      const pos = (callee.property as any)?.start ?? callee.start ?? node.start ?? 0;
-      pushAtPos(
-        pos,
-        'possible-undefined-ctx-member-call',
-        `Possible undefined ctx method call: ctx.${normalized}(). This may be a typo or not available in the current ctx API.`,
-      );
-      reported.add(normalized);
-    });
+        if (!name || typeof name !== 'string') return;
+        const normalized = name.trim();
+        if (!normalized || normalized.startsWith('_')) return;
+        if (normalized.length > 2) return;
+        if (allowedShort.has(normalized)) return;
+        if (reported.has(normalized)) return;
+
+        const pos = (callee.property as any)?.start ?? callee.start ?? node.start ?? 0;
+        pushAtPos(
+          pos,
+          'possible-undefined-ctx-member-call',
+          `Possible undefined ctx method call: ctx.${normalized}(). This may be a typo or not available in the current ctx API.`,
+        );
+        reported.add(normalized);
+      },
+      acornWalkBase,
+    );
   } catch (_) {
     // ignore
   }
@@ -711,31 +771,35 @@ function collectHeuristicIssues(code: string): RunJSIssue[] {
   // 2) Possible undefined variable (exclude declarations and property keys)
   try {
     const reported = new Set<string>();
-    acornWalk.ancestor(ast, {
-      Identifier(node: any, ancestors: any[]) {
-        const name = node?.name;
-        if (!name || declared.has(name) || reported.has(name)) return;
-        const parent = ancestors[ancestors.length - 2];
-        if (!parent) return;
-        if (
-          (parent.type === 'VariableDeclarator' && parent.id === node) ||
-          (parent.type === 'FunctionDeclaration' && parent.id === node) ||
-          (parent.type === 'FunctionExpression' && parent.id === node) ||
-          (parent.type === 'ClassDeclaration' && parent.id === node) ||
-          (parent.type === 'ClassExpression' && parent.id === node) ||
-          (parent.type === 'Property' && parent.key === node && parent.computed !== true) ||
-          (parent.type === 'MemberExpression' && parent.property === node && parent.computed !== true) ||
-          (parent.type === 'LabeledStatement' && parent.label === node) ||
-          (parent.type === 'BreakStatement' && parent.label === node) ||
-          (parent.type === 'ContinueStatement' && parent.label === node)
-        ) {
-          return;
-        }
-        const pos = (node as any).start ?? 0;
-        pushAtPos(pos, 'possible-undefined-variable', `Possible undefined variable: ${name}`);
-        reported.add(name);
+    acornWalk.ancestor(
+      ast,
+      {
+        Identifier(node: any, ancestors: any[]) {
+          const name = node?.name;
+          if (!name || declared.has(name) || reported.has(name)) return;
+          const parent = ancestors[ancestors.length - 2];
+          if (!parent) return;
+          if (
+            (parent.type === 'VariableDeclarator' && parent.id === node) ||
+            (parent.type === 'FunctionDeclaration' && parent.id === node) ||
+            (parent.type === 'FunctionExpression' && parent.id === node) ||
+            (parent.type === 'ClassDeclaration' && parent.id === node) ||
+            (parent.type === 'ClassExpression' && parent.id === node) ||
+            (parent.type === 'Property' && parent.key === node && parent.computed !== true) ||
+            (parent.type === 'MemberExpression' && parent.property === node && parent.computed !== true) ||
+            (parent.type === 'LabeledStatement' && parent.label === node) ||
+            (parent.type === 'BreakStatement' && parent.label === node) ||
+            (parent.type === 'ContinueStatement' && parent.label === node)
+          ) {
+            return;
+          }
+          const pos = (node as any).start ?? 0;
+          pushAtPos(pos, 'possible-undefined-variable', `Possible undefined variable: ${name}`);
+          reported.add(name);
+        },
       },
-    });
+      acornWalkBase,
+    );
   } catch (_) {
     // ignore
   }

package/src/flow/components/code-editor/types.ts

@@ -17,6 +17,7 @@ import { RunLog } from './hooks/useCodeRunner';
 export interface EditorRef {
   write(document: string): void;
   read(): string;
+  run?(): Promise<unknown>;
   buttonGroupHeight?: number;
   snippetEntries: SnippetEntry[];
   logs: RunLog[];

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' },
+      },
+    });
+  });
 });

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

@@ -10,8 +10,9 @@
 /**
  * 通用的字段子模型重建工具：
  * - 保留原有 uid
- * - 通过 FieldModel 入口 + fieldBinding.use 动态选择目标字段类
+ * - 直接重建为目标字段类，保持与 defineChildren 初始创建逻辑一致
  * - 支持同步父项模式（pattern）
+ * - 同一字段模型类型下保留已有字段设置；切换到其他字段模型类型时丢弃不兼容设置
  * - 重建后触发 beforeRender（useCache: false）
  */
 import { FieldModel } from '../../models/base/FieldModel';
@@ -39,6 +40,16 @@ type RebuildOptions = {
   fieldSettingsInit?: unknown;
 };
 
+function normalizeModelUse(value: unknown): string | undefined {
+  if (typeof value === 'string') {
+    return value;
+  }
+  if (typeof value === 'function' && value.name) {
+    return value.name;
+  }
+  return undefined;
+}
+
 export function getFieldBindingUse(fieldModel?: FieldModel): string | undefined {
   const bindingUse = (fieldModel?.stepParams as FieldStepParams | undefined)?.fieldBinding?.use;
   return typeof bindingUse === 'string' ? bindingUse : undefined;
@@ -61,13 +72,18 @@ export async function rebuildFieldSubModel({
       delete prevSubModels[key];
     }
   }
-  const prevStepParams: FieldStepParams = (fieldModel?.stepParams as FieldStepParams) || {};
+  const currentUse = normalizeModelUse(getFieldBindingUse(fieldModel) || fieldModel?.use);
+  const shouldPreserveStepParams = currentUse === targetUse;
+  const prevStepParams: FieldStepParams = shouldPreserveStepParams
+    ? (fieldModel?.stepParams as FieldStepParams) || {}
+    : {};
   const nextFieldSettingsInit = fieldSettingsInit ?? parentModel.getFieldSettingsInitParams?.();
+  const { fieldBinding: _fieldBinding, ...restStepParams } = prevStepParams;
 
   const nextStepParams: FieldStepParams = {
-    ...prevStepParams,
-    fieldBinding: { ...prevStepParams.fieldBinding, use: targetUse },
+    ...restStepParams,
     fieldSettings: {
+      ...(restStepParams.fieldSettings || {}),
       init: nextFieldSettingsInit,
     },
   };
@@ -81,7 +97,7 @@ export async function rebuildFieldSubModel({
 
   const subModel = parentModel.setSubModel('field', {
     uid: fieldUid,
-    use: FieldModel,
+    use: targetUse,
     props: { ...(defaultProps || {}), ...(pattern ? { pattern } : {}) },
     stepParams: nextStepParams as StepParams,
     // Preserve existing subModels (e.g. SubTable columns) so switching field component back and forth

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

@@ -27,8 +27,8 @@ export class BlockGridModel extends GridModel {
   dragOverlayConfig: DragOverlayConfig = {
     // 列内插入
     columnInsert: {
-      before: { offsetTop: -24 },
-      after: { offsetTop: 24 },
+      before: { offsetTop: -12 },
+      after: { offsetTop: 12 },
     },
     // 列边缘
     columnEdge: {