@nocobase/client-v2 2.1.0-beta.26 → 2.1.0-beta.29

package/src/flow/actions/dateRangeLimit.tsx

@@ -0,0 +1,66 @@
+/**
+ * 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 { defineAction, tExpr } from '@nocobase/flow-engine';
+import { FieldAssignValueInput } from '../components/FieldAssignValueInput';
+
+function normalizeDateRangeValue(value: any) {
+  if (value === '' || value === null || typeof value === 'undefined') {
+    return undefined;
+  }
+  return value;
+}
+
+export const dateRangeLimit = defineAction({
+  name: 'dateRangeLimit',
+  title: tExpr('Date range limit'),
+  uiMode: {
+    type: 'dialog',
+    props: {
+      width: 720,
+    },
+  },
+  uiSchema(ctx: any) {
+    const targetPath = ctx.model.context?.collectionField?.name || '';
+    const dateLimitInputProps = {
+      targetPath,
+      enableDateVariableAsConstant: true,
+    };
+
+    return {
+      _minDate: {
+        type: 'string',
+        title: tExpr('MinDate'),
+        'x-decorator': 'FormItem',
+        'x-component': FieldAssignValueInput,
+        'x-component-props': dateLimitInputProps,
+      },
+      _maxDate: {
+        type: 'string',
+        title: tExpr('MaxDate'),
+        'x-decorator': 'FormItem',
+        'x-component': FieldAssignValueInput,
+        'x-component-props': dateLimitInputProps,
+      },
+    };
+  },
+  defaultParams(ctx: any) {
+    return {
+      _minDate: normalizeDateRangeValue(ctx.model.props?._minDate),
+      _maxDate: normalizeDateRangeValue(ctx.model.props?._maxDate),
+    };
+  },
+  useRawParams: true,
+  async handler(ctx: any, params) {
+    ctx.model.setProps({
+      _minDate: normalizeDateRangeValue(params?._minDate),
+      _maxDate: normalizeDateRangeValue(params?._maxDate),
+    });
+  },
+});

package/src/flow/actions/index.ts

@@ -20,6 +20,7 @@ export * from './refreshTargetBlocks';
 export * from './setTargetDataScope';
 export { titleField } from './titleField';
 export * from './dateTimeFormat';
+export * from './dateRangeLimit';
 export * from './sortingRules';
 export * from './dataLoadingMode';
 export * from './renderMode';

package/src/flow/actions/linkageRules.tsx

@@ -51,11 +51,7 @@ import {
   getCollectionFromModel,
   isToManyAssociationField,
 } from '../internal/utils/modelUtils';
-import {
-  namePathToPathKey,
-  parsePathString,
-  resolveDynamicNamePath,
-} from '../models/blocks/form/value-runtime/path';
+import { namePathToPathKey, parsePathString, resolveDynamicNamePath } from '../models/blocks/form/value-runtime/path';
 import { ensureFormValueDrivenLinkageRefresh } from './linkageRulesFormValueRefresh';
 
 interface LinkageRule {
@@ -1759,7 +1755,7 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
 
   const linkageRules: LinkageRule[] = params.value as LinkageRule[];
   const allModels: FlowModel[] = ctx.model.__allModels || (ctx.model.__allModels = []);
-  const directValuePatches: Array<{ path: any; value: any }> = [];
+  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 => {
     if (!Array.isArray(namePath) || !namePath.length) return true;
@@ -1800,6 +1796,24 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
     const fieldIndex = (ctx.model as any)?.context?.fieldIndex;
     return resolveDynamicNamePath(path, fieldIndex);
   };
+  const getDefaultPatchRuntime = () => {
+    const blockModel = (ctx.model as any)?.context?.blockModel ?? ctx.model;
+    return blockModel?.formValueRuntime ?? (ctx as any)?.formValueRuntime;
+  };
+  const rememberAppliedDefaultPatches = (patches: typeof directValuePatches) => {
+    const runtime = getDefaultPatchRuntime();
+    if (typeof runtime?.recordDefaultValuePatch !== 'function') return;
+
+    const lastPatchByPathKey = new Map<string, (typeof directValuePatches)[number]>();
+    for (const patch of patches) {
+      lastPatchByPathKey.set(namePathToPathKey(patch.path), patch);
+    }
+
+    for (const patch of lastPatchByPathKey.values()) {
+      if (!patch.whenEmpty) continue;
+      runtime.recordDefaultValuePatch(patch.path, patch.value);
+    }
+  };
   const addFormValuePatch = (patch: { path: any; value: any; whenEmpty?: boolean }) => {
     if (!patch) return;
     const path = (patch as any)?.path;
@@ -1823,20 +1837,33 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
       return;
     }
     const whenEmpty = !!(patch as any)?.whenEmpty;
+    const value = (patch as any)?.value;
     try {
       const form = ctx.model?.context?.form;
       const current = form?.getFieldValue?.(resolvedPath);
-      if (whenEmpty && typeof current !== 'undefined' && current !== null && current !== '') {
-        return;
+      if (whenEmpty) {
+        const runtime = getDefaultPatchRuntime();
+        if (typeof runtime?.canApplyDefaultValuePatch === 'function') {
+          const canApply = runtime.canApplyDefaultValuePatch(resolvedPath, value);
+          if (!canApply) {
+            return;
+          }
+        } else if (typeof current !== 'undefined' && current !== null && current !== '') {
+          return;
+        }
       }
-      if (_.isEqual(current, (patch as any)?.value)) {
+      if (_.isEqual(current, value)) {
         return;
       }
     } catch {
       // ignore
     }
 
-    directValuePatches.push({ path: resolvedPath, value: (patch as any)?.value });
+    directValuePatches.push({
+      path: resolvedPath,
+      value,
+      ...(whenEmpty ? { whenEmpty: true } : {}),
+    });
   };
 
   const getModelTargetPathForPatch = (model: any): string | null => {
@@ -2018,6 +2045,7 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
   if (typeof directSetter === 'function') {
     try {
       await trySetFormValues(directSetter, directCtx, 'linkage');
+      rememberAppliedDefaultPatches(allPatches);
       return;
     } catch (error) {
       console.warn('[linkageRules] Failed to set form values via setFormValues', {
@@ -2034,6 +2062,7 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
   if (typeof blockSetter === 'function') {
     try {
       await trySetFormValues(blockSetter, blockCtx, 'linkage');
+      rememberAppliedDefaultPatches(allPatches);
       return;
     } catch (error) {
       console.warn('[linkageRules] Failed to set form values via setFormValues', {
@@ -2063,6 +2092,7 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
       console.warn('[linkageRules] Failed to set form field value (fallback setFieldValue)', { path }, error);
     }
   });
+  rememberAppliedDefaultPatches(allPatches);
 };
 
 export const blockLinkageRules = defineAction({
@@ -2348,33 +2378,95 @@ export const fieldLinkageRules = defineAction({
       return;
     }
 
-    const getRowScopeKeyFromModel = (model: any): string | null => {
+    const getRowFieldIndexInfoFromModel = (model: any) => {
       const fieldIndex = model?.context?.fieldIndex;
       const arr = Array.isArray(fieldIndex) ? fieldIndex : [];
-      if (!arr.length) return null;
+      const normalized = arr.filter((it): it is string => typeof it === 'string');
       const entries: Array<{ name: string; index: number }> = [];
-      for (const it of arr) {
-        if (typeof it !== 'string') continue;
+      const path: Array<string | number> = [];
+      for (const it of normalized) {
         const [name, indexStr] = it.split(':');
         const index = Number(indexStr);
         if (!name || Number.isNaN(index)) continue;
         entries.push({ name, index });
+        path.push(name, index);
       }
+      return { normalized, entries, path };
+    };
+
+    const getRowScopeKeyFromModel = (model: any): string | null => {
+      const { entries } = getRowFieldIndexInfoFromModel(model);
       if (!entries.length) return null;
       const deepest = entries[entries.length - 1].name;
       const occurrence = entries.reduce((count, e) => (e.name === deepest ? count + 1 : count), 0);
       return `${deepest}#${occurrence}`;
     };
 
+    const getRowFieldIndexKeyFromModel = (model: any): string | null => {
+      const { normalized } = getRowFieldIndexInfoFromModel(model);
+      if (!normalized.length) return null;
+      return JSON.stringify(normalized);
+    };
+
+    const getRowPathFromModel = (model: any): Array<string | number> | null => {
+      const { path } = getRowFieldIndexInfoFromModel(model);
+      return path.length ? path : null;
+    };
+
+    const getFormForRowFork = (model: any) => {
+      return (
+        model?.context?.form ??
+        model?.context?.blockModel?.context?.form ??
+        ctx.model?.context?.form ??
+        ctx.model?.context?.blockModel?.context?.form
+      );
+    };
+
+    const isRowForkMountedInCurrentValue = (model: any): boolean => {
+      const rowPath = getRowPathFromModel(model);
+      if (!rowPath) return true;
+      const form = getFormForRowFork(model);
+      if (!form || typeof form.getFieldValue !== 'function') return true;
+      return typeof form.getFieldValue(rowPath as any) !== 'undefined';
+    };
+
+    const hasRowItemContext = (model: any): boolean => {
+      const itemOptions = model?.context?.getPropertyOptions?.('item');
+      if (itemOptions) return true;
+      return typeof model?.context?.item !== 'undefined';
+    };
+
+    const hasSubTableRowMarker = (model: any): boolean => {
+      const markerOptions = model?.context?.getPropertyOptions?.('subTableRowFork');
+      if (markerOptions) return true;
+      return (
+        typeof model?.context?.subTableRowFork !== 'undefined' ||
+        typeof model?.subTableRowFork !== 'undefined' ||
+        model?.subTableRowFork === true
+      );
+    };
+
     const isRowGridForkModel = (model: any): boolean => {
       if (!model || typeof model !== 'object') return false;
       if ((model as any)?.subModels?.field) return false;
       if (!(model as any)?.subModels?.items) return false;
-      return !!getRowScopeKeyFromModel(model);
+      return !!getRowScopeKeyFromModel(model) && !!getRowFieldIndexKeyFromModel(model);
+    };
+
+    const isSubTableRowForkModel = (model: any): boolean => {
+      if (!model || typeof model !== 'object') return false;
+      if (!hasSubTableRowMarker(model)) return false;
+      if (!getRowScopeKeyFromModel(model) || !getRowFieldIndexKeyFromModel(model)) return false;
+      return hasRowItemContext(model);
+    };
+
+    const isRowScopedForkModel = (model: any): boolean => {
+      return isRowGridForkModel(model) || isSubTableRowForkModel(model);
     };
 
-    const collectRowGridForksByKey = (): Map<string, FlowModel[]> => {
+    const collectRowScopedForksByKey = (): Map<string, FlowModel[]> => {
       const out = new Map<string, FlowModel[]>();
+      const seenByKey = new Map<string, Set<string>>();
       const engine = ctx.engine;
       if (!engine?.forEachModel) return out;
 
@@ -2383,9 +2475,15 @@ export const fieldLinkageRules = defineAction({
         if (!forks || typeof forks.forEach !== 'function') return;
         forks.forEach((fork: any) => {
           if (!fork || fork.disposed) return;
-          if (!isRowGridForkModel(fork)) return;
+          if (!isRowScopedForkModel(fork)) return;
+          if (!isRowForkMountedInCurrentValue(fork)) return;
           const rowScopeKey = getRowScopeKeyFromModel(fork);
-          if (!rowScopeKey) return;
+          const fieldIndexKey = getRowFieldIndexKeyFromModel(fork);
+          if (!rowScopeKey || !fieldIndexKey) return;
+          const seen = seenByKey.get(rowScopeKey) || new Set<string>();
+          if (seen.has(fieldIndexKey)) return;
+          seen.add(fieldIndexKey);
+          seenByKey.set(rowScopeKey, seen);
           const arr = out.get(rowScopeKey) || [];
           arr.push(fork as FlowModel);
           out.set(rowScopeKey, arr);
@@ -2396,7 +2494,7 @@ export const fieldLinkageRules = defineAction({
     };
 
     const runRowScoped = async (): Promise<boolean> => {
-      const forksByKey = collectRowGridForksByKey();
+      const forksByKey = collectRowScopedForksByKey();
       let hasAnyRowFork = false;
       for (const [rowScopeKey, rowParams] of rowParamsByKey.entries()) {
         const forks = forksByKey.get(rowScopeKey) || [];

package/src/flow/actions/openView.tsx

@@ -345,7 +345,8 @@ export const openView = defineAction({
         target: ctx.inputArgs.target || ctx.layoutContentElement,
         dataSourceKey: runtimeDataSourceKey ?? actionDefaults.dataSourceKey,
         collectionName: runtimeCollectionName ?? actionDefaults.collectionName,
-        associationName: runtimeAssociationName ?? actionDefaults.associationName,
+        associationName:
+          typeof runtimeAssociationName !== 'undefined' ? runtimeAssociationName : actionDefaults.associationName,
         filterByTk: mergedFilterByTk,
         sourceId: mergedSourceId,
         tabUid: mergedTabUid,

package/src/flow/actions/pattern.tsx

@@ -7,9 +7,25 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { BindingOptions, defineAction, tExpr, DisplayItemModel } from '@nocobase/flow-engine';
+import { defineAction, tExpr } from '@nocobase/flow-engine';
 import { DetailsItemModel } from '../models/blocks/details/DetailsItemModel';
-import { rebuildFieldSubModel } from '../internal/utils/rebuildFieldSubModel';
+import { getFieldBindingUse, rebuildFieldSubModel } from '../internal/utils/rebuildFieldSubModel';
+
+type PatternAwareFieldModelMeta = {
+  preserveOnPatternChange?: boolean;
+};
+
+type PatternAwareFieldModel = {
+  scheduleApplyJsSettings?: () => void;
+};
+
+function shouldPreserveFieldModelOnPatternChange(ctx: any) {
+  const fieldModel = ctx.model.subModels.field;
+  const fieldUse = getFieldBindingUse(fieldModel) ?? fieldModel?.use;
+  const ModelClass = typeof fieldUse === 'string' ? ctx.engine.getModelClass(fieldUse) : fieldUse;
+
+  return ((ModelClass?.meta as PatternAwareFieldModelMeta | undefined)?.preserveOnPatternChange ?? false) === true;
+}
 
 export const pattern = defineAction({
   name: 'pattern',
@@ -56,6 +72,13 @@ export const pattern = defineAction({
     };
   },
   afterParamsSave: async (ctx: any, params, previousParams) => {
+    if (shouldPreserveFieldModelOnPatternChange(ctx)) {
+      if (params.pattern !== previousParams.pattern) {
+        (ctx.model.subModels.field as PatternAwareFieldModel | undefined)?.scheduleApplyJsSettings?.();
+      }
+      return;
+    }
+
     const targetCollection = ctx.collectionField.targetCollection;
     const targetCollectionTitleField = targetCollection?.getField(
       ctx.model.subModels.field.props?.fieldNames?.label || ctx.model.props.titleField,

package/src/flow/actions/titleField.tsx

@@ -8,7 +8,7 @@
  */
 
 import { defineAction, DisplayItemModel, FlowModelContext, tExpr } from '@nocobase/flow-engine';
-import { isTitleField } from '../../flow-compat';
+import { getFlowFieldInterfaceOptions, isTitleFieldInterface } from '../../flow-compat';
 
 const normalizeFilterTargetKey = (filterTargetKey: any) => {
   if (typeof filterTargetKey === 'string') {
@@ -37,10 +37,15 @@ export const titleField = defineAction({
   title: tExpr('Title field'),
   uiMode: (ctx) => {
     const targetCollection = ctx.collectionField.targetCollection;
-    const dataSourceManager = ctx.app.dataSourceManager;
+    const dataSourceManager =
+      ctx.dataSourceManager || ctx.model?.context?.dataSourceManager || ctx.app?.dataSourceManager;
     const targetFields = targetCollection?.getFields?.() ?? [];
     const options = targetFields
-      .filter((field) => isTitleField(dataSourceManager, field.options))
+      .filter((field) =>
+        isTitleFieldInterface(
+          getFlowFieldInterfaceOptions(field.options?.interface || field.interface, dataSourceManager),
+        ),
+      )
       .map((field) => ({
         value: field.name,
         label: field?.title,

package/src/flow/admin-shell/AdminLayoutRouteCoordinator.ts

@@ -47,6 +47,8 @@ interface RouteLike {
   pathname?: string;
 }
 
+const hasUsableSourceId = (sourceId: unknown) => sourceId !== undefined && sourceId !== null && String(sourceId) !== '';
+
 /**
  * 管理 admin 场景下每个 page 的 v2 视图栈编排。
  * 该协调器只负责状态机和开关视图，不直接绑定 React 生命周期。
@@ -264,6 +266,10 @@ export class AdminLayoutRouteCoordinator {
     const destroyRef = React.createRef<(result?: any, force?: boolean) => void>();
     const updateRef = React.createRef<(value: any) => void>();
     const openViewParams = getOpenViewStepParams(viewItem.model);
+    const associationName =
+      openViewParams?.associationName && !hasUsableSourceId(viewItem.params.sourceId)
+        ? null
+        : openViewParams?.associationName;
     const openerUids = viewList.slice(0, viewItem.index).map((item) => item.params.viewUid);
     const navigation = new ViewNavigation(
       this.flowEngine.context,
@@ -273,7 +279,7 @@ export class AdminLayoutRouteCoordinator {
     viewItem.model.dispatchEvent('click', {
       target: runtime.meta.layoutContentElement || this.layoutContentElement,
       collectionName: openViewParams?.collectionName,
-      associationName: openViewParams?.associationName,
+      associationName,
       dataSourceKey: openViewParams?.dataSourceKey,
       destroyRef,
       updateRef,

package/src/flow/admin-shell/__tests__/AdminLayoutRouteCoordinator.test.ts

@@ -0,0 +1,117 @@
+/**
+ * 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 { FlowEngine } from '@nocobase/flow-engine';
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { getViewDiffAndUpdateHidden } from '../../getViewDiffAndUpdateHidden';
+import { getOpenViewStepParams } from '../../flows/openViewFlow';
+import { resolveViewParamsToViewList } from '../../resolveViewParamsToViewList';
+import { AdminLayoutRouteCoordinator } from '../AdminLayoutRouteCoordinator';
+import { RouteModel } from '../../models/base/RouteModel';
+
+vi.mock('../../resolveViewParamsToViewList', () => ({
+  resolveViewParamsToViewList: vi.fn(),
+  updateViewListHidden: vi.fn(),
+}));
+
+vi.mock('../../getViewDiffAndUpdateHidden', () => ({
+  getViewDiffAndUpdateHidden: vi.fn(),
+  getKey: vi.fn((viewItem) => viewItem.params.viewUid),
+}));
+
+vi.mock('../../flows/openViewFlow', async (importOriginal) => {
+  const actual = await importOriginal();
+  return {
+    ...(actual as any),
+    getOpenViewStepParams: vi.fn(),
+  };
+});
+
+const mockResolveViewParamsToViewList = vi.mocked(resolveViewParamsToViewList);
+const mockGetViewDiffAndUpdateHidden = vi.mocked(getViewDiffAndUpdateHidden);
+const mockGetOpenViewStepParams = vi.mocked(getOpenViewStepParams);
+
+function setupRouteReplay(viewParams: Record<string, any>) {
+  const engine = new FlowEngine();
+  engine.registerModels({ RouteModel });
+  engine.context.defineProperty('route', {
+    value: {
+      params: { name: 'test-route' },
+      pathname: '/admin/popup/filterbytk/member',
+    },
+  });
+  engine.context.defineProperty('routeRepository', {
+    value: {
+      getRouteBySchemaUid: vi.fn(() => ({})),
+    },
+  });
+
+  const dispatchEvent = vi.fn(() => Promise.resolve());
+  const viewItem = {
+    params: {
+      viewUid: 'popup',
+      filterByTk: 'member',
+      ...viewParams,
+    },
+    modelUid: 'popup',
+    model: { uid: 'popup', dispatchEvent } as any,
+    hidden: { value: false },
+    index: 0,
+  };
+
+  mockResolveViewParamsToViewList.mockReturnValue([viewItem]);
+  mockGetViewDiffAndUpdateHidden.mockReturnValue({
+    viewsToClose: [],
+    viewsToOpen: [viewItem],
+  });
+  mockGetOpenViewStepParams.mockReturnValue({
+    collectionName: 'roles',
+    associationName: 'users.roles',
+    dataSourceKey: 'main',
+  } as any);
+
+  const coordinator = new AdminLayoutRouteCoordinator(engine);
+  coordinator.registerPage('test-route', {
+    active: true,
+    layoutContentElement: document.createElement('div'),
+  });
+
+  return { dispatchEvent };
+}
+
+describe('AdminLayoutRouteCoordinator', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('drops configured associationName during route replay when sourceId is absent', () => {
+    const { dispatchEvent } = setupRouteReplay({});
+
+    expect(dispatchEvent.mock.calls[0][1]).toMatchObject({
+      collectionName: 'roles',
+      associationName: null,
+      dataSourceKey: 'main',
+      filterByTk: 'member',
+      triggerByRouter: true,
+    });
+  });
+
+  it('keeps configured associationName during route replay when sourceId is present', () => {
+    const { dispatchEvent } = setupRouteReplay({ sourceId: '1' });
+
+    expect(dispatchEvent.mock.calls[0][1]).toMatchObject({
+      collectionName: 'roles',
+      associationName: 'users.roles',
+      dataSourceKey: 'main',
+      filterByTk: 'member',
+      sourceId: '1',
+      triggerByRouter: true,
+    });
+  });
+});

package/src/flow/components/FieldAssignValueInput.tsx

@@ -485,6 +485,7 @@ type AssignValueFieldSource = {
 const ASSIGN_VALUE_IGNORED_PROP_KEYS = new Set([
   'value',
   'defaultValue',
+  'hidden',
   'onChange',
   'onClick',
   'open',

package/src/flow/components/code-editor/__tests__/linter.test.ts

@@ -39,6 +39,24 @@ describe('code-editor linter', () => {
     );
   });
 
+  it('does not warn for callback parameters used inside JSX', () => {
+    const code = `
+const columns = [
+  {
+    render: (roles, record) => (
+      <div>
+        {roles.map((role) => <Tag key={role.name}>{record.nickname || role.title}</Tag>)}
+      </div>
+    ),
+  },
+];
+`;
+    const diags = computeDiagnosticsFromText(code);
+    expect(diags.some((d) => d.message.includes('Possible undefined variable: roles'))).toBe(false);
+    expect(diags.some((d) => d.message.includes('Possible undefined variable: record'))).toBe(false);
+    expect(diags.some((d) => d.message.includes('Possible undefined variable: role'))).toBe(false);
+  });
+
   it('reports non-callable expression warning', () => {
     const code = `(1+2)()`;
     const diags = computeDiagnosticsFromText(code);

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

@@ -38,6 +38,29 @@ describe('runjsDiagnostics', () => {
     expect(res.issues.some((i) => i.type === 'lint' && i.ruleId === 'no-noncallable-call')).toBe(true);
   });
 
+  it('does not report JSX callback parameters as undefined variables', async () => {
+    const ctx = createTestCtx();
+    const code = `
+const { Tag } = ctx.libs.antd;
+const columns = [
+  {
+    render: (roles, record) => (
+      <div>
+        {roles.map((role) => <Tag key={role.name}>{record.nickname || role.title}</Tag>)}
+      </div>
+    ),
+  },
+];
+ctx.render(<div />);
+`;
+    const res = await diagnoseRunJS(code, ctx);
+    expect(
+      res.issues.some(
+        (i) => i.type === 'lint' && i.ruleId === 'possible-undefined-variable' && /roles|record|role/.test(i.message),
+      ),
+    ).toBe(false);
+  });
+
   it('reports suspicious short ctx member call as a lint issue', async () => {
     const ctx = createTestCtx();
     const res = await diagnoseRunJS('ctx.fw();', ctx);

package/src/flow/components/code-editor/index.tsx

@@ -133,6 +133,19 @@ export const CodeEditor: React.FC<CodeEditorProps> = ({
     return createRunJSCompletionSource({ hostCtx, staticOptions: finalExtra });
   }, [hostCtx, finalExtra]);
 
+  const runCurrentCode = useCallback(async () => {
+    const code = viewRef.current?.state.doc.toString() || '';
+    clearDiagnostics(viewRef.current);
+    const res = await run(code);
+    if (!res?.success) {
+      const rawErr = res?.error;
+      const errText = res?.timeout ? tr('Execution timed out') : String(rawErr || tr('Unknown error'));
+      const pos = parseErrorLineColumn(rawErr);
+      if (pos && viewRef.current) markErrorAt(viewRef.current, pos.line, pos.column, errText);
+    }
+    return res;
+  }, [run, tr]);
+
   // JSX 转换支持暂时移除：直接按原样运行代码
 
   // 错误标注相关工具已提取至 errorHelpers.ts
@@ -153,6 +166,9 @@ export const CodeEditor: React.FC<CodeEditorProps> = ({
       const v = viewRef.current;
       return v ? v.state.doc.toString() : '';
     },
+    run() {
+      return Promise.resolve(undefined);
+    },
 
     buttonGroupHeight: 0,
     snippetEntries: [],
@@ -160,6 +176,7 @@ export const CodeEditor: React.FC<CodeEditorProps> = ({
   });
   extraEditorRef.current.snippetEntries = snippetEntries;
   extraEditorRef.current.logs = logs;
+  extraEditorRef.current.run = runCurrentCode;
 
   // snippet group display handled in SnippetsDrawer
 
@@ -210,23 +227,7 @@ export const CodeEditor: React.FC<CodeEditorProps> = ({
                   {tr('Snippets')}
                 </Button>
                 <>
-                  <Button
-                    size="small"
-                    loading={running}
-                    onClick={async () => {
-                      const code = viewRef.current?.state.doc.toString() || '';
-                      clearDiagnostics(viewRef.current);
-                      const res = await run(code);
-                      if (!res?.success) {
-                        const rawErr = res?.error;
-                        const errText = res?.timeout
-                          ? tr('Execution timed out')
-                          : String(rawErr || tr('Unknown error'));
-                        const pos = parseErrorLineColumn(rawErr);
-                        if (pos && viewRef.current) markErrorAt(viewRef.current, pos.line, pos.column, errText);
-                      }
-                    }}
-                  >
+                  <Button size="small" loading={running} onClick={runCurrentCode}>
                     {tr('Run')}
                   </Button>
                 </>