@nocobase/flow-engine 2.1.0-alpha.3 → 2.1.0-alpha.30

package/src/runjs-context/snippets/index.ts

@@ -49,6 +49,7 @@ const snippets: Record<string, RunJSSnippetLoader | undefined> = {
   'scene/detail/status-tag': () => import('./scene/detail/status-tag.snippet'),
   'scene/detail/relative-time': () => import('./scene/detail/relative-time.snippet'),
   'scene/detail/percentage-bar': () => import('./scene/detail/percentage-bar.snippet'),
+  'scene/detail/set-field-style': () => import('./scene/detail/set-field-style.snippet'),
   // scene/form
   'scene/form/render-basic': () => import('./scene/form/render-basic.snippet'),
   'scene/form/set-field-value': () => import('./scene/form/set-field-value.snippet'),
@@ -67,6 +68,7 @@ const snippets: Record<string, RunJSSnippetLoader | undefined> = {
   'scene/table/iterate-selected-rows': () => import('./scene/table/iterate-selected-rows.snippet'),
   'scene/table/destroy-selected': () => import('./scene/table/destroy-selected.snippet'),
   'scene/table/export-selected-json': () => import('./scene/table/export-selected-json.snippet'),
+  'scene/table/set-cell-style': () => import('./scene/table/set-cell-style.snippet'),
 };
 
 export default snippets;
@@ -125,10 +127,19 @@ function normalizeScenes(def: any, key: string): string[] {
   return [];
 }
 
+function normalizeSceneGroup(scene: string): string {
+  const mapping: Record<string, string> = {
+    detailFieldEvent: 'detail',
+    tableFieldEvent: 'table',
+    formFieldEvent: 'form',
+  };
+  return mapping[scene] || scene;
+}
+
 function computeGroups(def: any, key: string): string[] {
   const scenes = normalizeScenes(def, key);
   if (scenes.length) {
-    return scenes.map((scene) => `scene/${scene}`);
+    return Array.from(new Set(scenes.map((scene) => `scene/${normalizeSceneGroup(scene)}`)));
   }
   const parts = key.split('/');
   if (!parts.length) return [];

package/src/runjs-context/snippets/scene/detail/set-field-style.snippet.ts

@@ -0,0 +1,30 @@
+/**
+ * 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 type { SnippetModule } from '../../types';
+const snippet: SnippetModule = {
+  contexts: ['*'],
+  scenes: ['detailFieldEvent', 'formFieldEvent'],
+  prefix: 'sn-item-style',
+  label: 'Set form item/details item style',
+  description: 'Customize form item and details item container styles',
+  locales: {
+    'zh-CN': {
+      label: '设置表单项/详情项样式',
+      description: '自定义表单项和详情项容器样式',
+    },
+  },
+  content: `
+ctx.model.props.style = {
+  background: 'red',
+};
+`,
+};
+
+export default snippet;

package/src/runjs-context/snippets/scene/table/set-cell-style.snippet.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 type { SnippetModule } from '../../types';
+const snippet: SnippetModule = {
+  contexts: ['*'],
+  scenes: ['tableFieldEvent'],
+  prefix: 'sn-table-cell-style',
+  label: 'Set table cell style',
+  description: 'Customize table field cell styles with onCell',
+  locales: {
+    'zh-CN': {
+      label: '表格字段样式设置',
+      description: '通过 onCell 自定义表格字段单元格样式',
+    },
+  },
+  content: `
+ctx.model.props.onCell = (record, rowIndex) => {
+  return {
+    style: {
+      background: 'red',
+    },
+  };
+};
+`,
+};
+
+export default snippet;

package/src/scheduler/ModelOperationScheduler.ts

@@ -21,7 +21,11 @@ type LifecycleType =
   | `event:${string}:end`
   | `event:${string}:error`;
 
-export type ScheduleWhen = LifecycleType | ((e: LifecycleEvent) => boolean);
+type EventPredicateWhen = ((e: LifecycleEvent) => boolean) & {
+  __eventType?: string;
+};
+
+export type ScheduleWhen = LifecycleType | EventPredicateWhen;
 
 export interface ScheduleOptions {
   when?: ScheduleWhen;
@@ -37,6 +41,7 @@ export interface LifecycleEvent {
   error?: any;
   inputArgs?: Record<string, any>;
   result?: any;
+  aborted?: boolean;
   flowKey?: string;
   stepKey?: string;
 }
@@ -216,8 +221,14 @@ export class ModelOperationScheduler {
   }
 
   private ensureEventSubscriptionIfNeeded(when?: ScheduleWhen) {
-    if (!when || typeof when !== 'string') return;
-    const parsed = this.parseEventWhen(when);
+    const eventType =
+      typeof when === 'string'
+        ? when
+        : typeof when === 'function'
+          ? (when as EventPredicateWhen).__eventType
+          : undefined;
+    if (!eventType) return;
+    const parsed = this.parseEventWhen(eventType as ScheduleWhen);
     if (!parsed) return;
     const { name } = parsed;
     if (this.subscribedEventNames.has(name)) return;

package/src/types.ts

@@ -213,6 +213,7 @@ export interface ActionDefinition<TModel extends FlowModel = FlowModel, TCtx ext
  */
 export type FlowEventName =
   | 'click'
+  | 'close'
   | 'submit'
   | 'reset'
   | 'remove'
@@ -387,6 +388,65 @@ export interface CreateModelOptions {
   delegateToParent?: boolean;
   [key: string]: any; // 允许额外的自定义选项
 }
+
+/**
+ * FlowModel loader result.
+ * Supports returning the model constructor directly, a default export, or a module object containing the named export.
+ */
+export type FlowModelLoaderResult =
+  | ModelConstructor
+  | {
+      default?: ModelConstructor;
+      [key: string]: unknown;
+    }
+  | Record<string, unknown>;
+
+/**
+ * FlowModel loader function.
+ */
+export type FlowModelLoader = () => Promise<FlowModelLoaderResult>;
+
+/**
+ * FlowModel loader entry (normalized internal form).
+ */
+export interface FlowModelLoaderEntry {
+  loader: FlowModelLoader;
+  extends?: string[];
+  // meta?: Partial<FlowModelMeta>;
+  // scenes?: string[];
+}
+
+/**
+ * FlowModel loader input (user-facing form for registerModelLoaders).
+ * The `extends` field accepts flexible formats that will be normalized to `string[]` at registration time.
+ */
+export interface FlowModelLoaderInput {
+  loader: FlowModelLoader;
+  extends?: string | ModelConstructor | (string | ModelConstructor)[];
+}
+
+/**
+ * FlowModel loader entry map (normalized internal form).
+ */
+export type FlowModelLoaderMap = Record<string, FlowModelLoaderEntry>;
+
+/**
+ * FlowModel loader input map (user-facing form for registerModelLoaders).
+ */
+export type FlowModelLoaderInputMap = Record<string, FlowModelLoaderInput>;
+
+/**
+ * Batch ensure result.
+ */
+export interface EnsureBatchResult {
+  requested: string[];
+  loaded: string[];
+  failed: Array<{
+    name: string;
+    error?: unknown;
+  }>;
+}
+
 export interface IFlowModelRepository<T extends FlowModel = FlowModel> {
   findOne(query: Record<string, any>): Promise<Record<string, any> | null>;
   save(model: T, options?: { onlyStepParams?: boolean }): Promise<Record<string, any>>;

package/src/utils/__tests__/createCollectionContextMeta.test.ts

@@ -26,6 +26,7 @@ describe('createCollectionContextMeta', () => {
         { name: 'id', type: 'integer', interface: 'number', filterable: true },
         { name: 'email', type: 'string', interface: 'text', filterable: true },
         { name: 'nickname', type: 'string', interface: 'text' }, // 未声明 filterable
+        { name: 'rawUserPayload', type: 'json', filterable: true },
       ],
     });
 
@@ -34,6 +35,7 @@ describe('createCollectionContextMeta', () => {
       fields: [
         { name: 'title', type: 'string', interface: 'text', filterable: true },
         { name: 'author', type: 'belongsTo', target: 'users', interface: 'm2o', filterable: true },
+        { name: 'rawPostPayload', type: 'json', filterable: true },
       ],
     });
 
@@ -44,8 +46,54 @@ describe('createCollectionContextMeta', () => {
     const authorMeta: any = props?.author;
     const authorFields = await authorMeta?.properties?.();
 
+    expect(props).toHaveProperty('title');
+    expect(props).toHaveProperty('author');
+    expect(props).not.toHaveProperty('rawPostPayload');
     expect(authorFields).toBeTruthy();
     expect(authorFields).toHaveProperty('email');
     expect(authorFields).not.toHaveProperty('nickname');
+    expect(authorFields).not.toHaveProperty('rawUserPayload');
+  });
+
+  it('keeps interfaced non-filterable fields but hides fields without interface when includeNonFilterable is true', async () => {
+    const engine = new FlowEngine();
+    const dm = engine.dataSourceManager as any;
+    dm.collectionFieldInterfaceManager = new CollectionFieldInterfaceManager([], {}, dm);
+    engine.context.defineProperty('app', { value: { dataSourceManager: dm } });
+    const ds = dm.getDataSource('main')!;
+
+    ds.addCollection({
+      name: 'users',
+      fields: [
+        { name: 'id', type: 'integer', interface: 'number', filterable: true },
+        { name: 'email', type: 'string', interface: 'text', filterable: true },
+        { name: 'nickname', type: 'string', interface: 'text' },
+        { name: 'rawUserPayload', type: 'json', filterable: true },
+      ],
+    });
+
+    ds.addCollection({
+      name: 'posts',
+      fields: [
+        { name: 'title', type: 'string', interface: 'text', filterable: true },
+        { name: 'internalName', type: 'string', interface: 'text' },
+        { name: 'rawPostPayload', type: 'json', filterable: true },
+        { name: 'author', type: 'belongsTo', target: 'users', interface: 'm2o', filterable: true },
+      ],
+    });
+
+    const posts = ds.getCollection('posts')!;
+    const metaFactory = createCollectionContextMeta(posts, 'Posts', true);
+    const meta = await metaFactory();
+    const props = await (meta?.properties as any)?.();
+    const authorFields = await props?.author?.properties?.();
+
+    expect(props).toHaveProperty('title');
+    expect(props).toHaveProperty('internalName');
+    expect(props).toHaveProperty('author');
+    expect(props).not.toHaveProperty('rawPostPayload');
+    expect(authorFields).toHaveProperty('email');
+    expect(authorFields).toHaveProperty('nickname');
+    expect(authorFields).not.toHaveProperty('rawUserPayload');
   });
 });

package/src/utils/__tests__/parsePathnameToViewParams.test.ts

@@ -109,6 +109,13 @@ describe('parsePathnameToViewParams', () => {
     expect(result).toEqual([{ viewUid: 'xxx', filterByTk: { id: '1', tenant: 'ac' } }]);
   });
 
+  test('should parse filterByTk from single key-value encoded segment into object', () => {
+    const kv = encodeURIComponent('id=1');
+    const path = `/admin/xxx/filterbytk/${kv}`;
+    const result = parsePathnameToViewParams(path);
+    expect(result).toEqual([{ viewUid: 'xxx', filterByTk: { id: '1' } }]);
+  });
+
   test('should parse filterByTk from JSON object segment', () => {
     const json = encodeURIComponent('{"id":"1","tenant":"ac"}');
     const path = `/admin/xxx/filterbytk/${json}`;

package/src/utils/__tests__/runjsValue.test.ts

@@ -41,4 +41,15 @@ describe('runjsValue utils', () => {
     expect(out.someVar).toContain('');
     expect(out.user).toContain('name');
   });
+
+  it('extractUsedVariablePathsFromRunJS: extracts ctx.getVar string paths', () => {
+    const code = `
+      const phone = await ctx.getVar('ctx.item.value.phone');
+      const assignee = await ctx.getVar("ctx.user.profile.name");
+      return [phone, assignee];
+    `;
+    const out = extractUsedVariablePathsFromRunJS(code);
+    expect(out.item).toContain('value.phone');
+    expect(out.user).toContain('profile.name');
+  });
 });

package/src/utils/__tests__/utils.test.ts

@@ -12,6 +12,7 @@ import {
   getT,
   isInheritedFrom,
   resolveDefaultParams,
+  shouldHideEventInSettings,
   resolveStepUiSchema,
   resolveStepDisabledInSettings,
   shouldHideStepInSettings,
@@ -27,6 +28,7 @@ import type {
   FlowDefinitionOptions,
   ActionDefinition,
   DeepPartial,
+  EventDefinition,
   ModelConstructor,
   StepParams,
   StepDefinition,
@@ -1002,6 +1004,66 @@ describe('Utils', () => {
     });
   });
 
+  // ==================== shouldHideEventInSettings() FUNCTION ====================
+  describe('shouldHideEventInSettings()', () => {
+    let mockFlow: any;
+    let mockEvent: EventDefinition;
+
+    beforeEach(() => {
+      mockFlow = {
+        key: 'testFlow',
+        title: 'Test Flow',
+        steps: {},
+      };
+
+      mockEvent = {
+        name: 'close',
+        title: 'Close',
+        handler: vi.fn(),
+      };
+    });
+
+    test('returns true for static hideInSettings=true', async () => {
+      mockEvent.hideInSettings = true;
+
+      const result = await shouldHideEventInSettings(mockModel, mockFlow, mockEvent);
+
+      expect(result).toBe(true);
+    });
+
+    test('returns false for static hideInSettings=false', async () => {
+      mockEvent.hideInSettings = false;
+
+      const result = await shouldHideEventInSettings(mockModel, mockFlow, mockEvent);
+
+      expect(result).toBe(false);
+    });
+
+    test('evaluates function hideInSettings with FlowRuntimeContext and can read ctx.view.preventClose', async () => {
+      mockModel.context.defineProperty('view', { value: { preventClose: true } });
+      const hideFn = vi.fn().mockImplementation((ctx) => !!ctx.view?.preventClose);
+      mockEvent.hideInSettings = hideFn as any;
+
+      const result = await shouldHideEventInSettings(mockModel, mockFlow, mockEvent);
+
+      expect(hideFn).toHaveBeenCalledTimes(1);
+      const ctx = hideFn.mock.calls[0][0] as FlowRuntimeContext;
+      expect(ctx).toBeInstanceOf(FlowRuntimeContext);
+      expect(result).toBe(true);
+    });
+
+    test('returns false and logs warning when event hideInSettings throws', async () => {
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      mockEvent.hideInSettings = vi.fn().mockRejectedValue(new Error('boom')) as any;
+
+      const result = await shouldHideEventInSettings(mockModel, mockFlow, mockEvent);
+
+      expect(consoleSpy).toHaveBeenCalled();
+      expect(result).toBe(false);
+      consoleSpy.mockRestore();
+    });
+  });
+
   // ==================== shouldHideStepInSettings() FUNCTION ====================
   describe('shouldHideStepInSettings()', () => {
     let mockFlow: any;

package/src/utils/createCollectionContextMeta.ts

@@ -14,6 +14,10 @@ import type { PropertyMetaFactory } from '../flowContext';
 const RELATION_FIELD_TYPES = ['belongsTo', 'hasOne', 'hasMany', 'belongsToMany', 'belongsToArray'] as const;
 const NUMERIC_FIELD_TYPES = ['integer', 'float', 'double', 'decimal'] as const;
 
+function shouldShowFieldInMeta(field: CollectionField, includeNonFilterable?: boolean) {
+  return Boolean(field.interface && (includeNonFilterable || field.filterable));
+}
+
 /**
  * 创建字段的完整元数据（统一处理关联和非关联字段）
  */
@@ -36,7 +40,7 @@ function createFieldMetadata(field: CollectionField, includeNonFilterable?: bool
       properties: async () => {
         const subProperties: Record<string, any> = {};
         targetCollection.fields.forEach((subField) => {
-          if (includeNonFilterable || subField.filterable) {
+          if (shouldShowFieldInMeta(subField, includeNonFilterable)) {
             subProperties[subField.name] = createFieldMetadata(subField, includeNonFilterable);
           }
         });
@@ -114,7 +118,7 @@ export function createCollectionContextMeta(
 
         // 添加所有字段
         collection.fields.forEach((field) => {
-          if (includeNonFilterable || field.filterable) {
+          if (shouldShowFieldInMeta(field, includeNonFilterable)) {
             properties[field.name] = createFieldMetadata(field, includeNonFilterable);
           }
         });

package/src/utils/index.ts

@@ -22,7 +22,7 @@ export {
 export { escapeT, getT, tExpr } from './translation';
 
 // 异常类
-export { FlowCancelSaveException, FlowExitException } from './exceptions';
+export { FlowCancelSaveException, FlowExitAllException, FlowExitException } from './exceptions';
 
 // 流程定义相关
 export { defineAction } from './flow-definitions';
@@ -39,6 +39,7 @@ export {
   resolveStepUiSchema,
   resolveStepDisabledInSettings,
   resolveUiMode,
+  shouldHideEventInSettings,
   shouldHideStepInSettings,
 } from './schema-utils';
 

package/src/utils/parsePathnameToViewParams.ts

@@ -116,8 +116,8 @@ export const parsePathnameToViewParams = (pathname: string): ViewParam[] => {
               // 解析失败，按字符串保留
               parsed = decoded;
             }
-          } else if (decoded && decoded.includes('=') && decoded.includes('&')) {
-            // 形如 a=b&c=d 的整体段
+          } else if (decoded && /^[^=&]+=[^=&]*(?:&[^=&]+=[^=&]*)*$/.test(decoded)) {
+            // 形如 a=b 或 a=b&c=d 的整体段
             parsed = parseKeyValuePairs(decoded);
           }
           currentView.filterByTk = parsed;

package/src/utils/runjsTemplateCompat.ts

@@ -553,8 +553,8 @@ function extractUsedCtxLibKeys(code: string): string[] {
 }
 
 function injectEnsureLibsPreamble(code: string): string {
-  if (!CTX_LIBS_MARKER_RE.test(code)) return code;
   if (ENSURE_LIBS_MARKER_RE.test(code)) return code;
+  if (!CTX_LIBS_MARKER_RE.test(code)) return code;
   const keys = extractUsedCtxLibKeys(code);
   if (!keys.length) return code;
   return `/* __runjs_ensure_libs */\nawait ctx.__ensureLibs(${JSON.stringify(keys)});\n${code}`;

package/src/utils/runjsValue.ts

@@ -236,6 +236,37 @@ function normalizeSubPath(raw: string): { subPath: string; wildcard: boolean } {
   return { subPath: s, wildcard: false };
 }
 
+function extractCtxRootUsage(expr: string): { varName: string; subPath: string; wildcard: boolean } | null {
+  const raw = String(expr || '').trim();
+  if (!raw || raw === 'ctx') return null;
+
+  const dotMatch = raw.match(/^ctx\.([a-zA-Z_$][a-zA-Z0-9_$]*)([\s\S]*)$/);
+  if (dotMatch) {
+    const varName = dotMatch[1] || '';
+    const rest = dotMatch[2] || '';
+    const normalized = normalizeSubPath(rest);
+    return {
+      varName,
+      subPath: normalized.subPath,
+      wildcard: normalized.wildcard,
+    };
+  }
+
+  const bracketMatch = raw.match(/^ctx\s*\[\s*(['"])([a-zA-Z_$][a-zA-Z0-9_$]*)\1\s*\]([\s\S]*)$/);
+  if (bracketMatch) {
+    const varName = bracketMatch[2] || '';
+    const rest = bracketMatch[3] || '';
+    const normalized = normalizeSubPath(rest);
+    return {
+      varName,
+      subPath: normalized.subPath,
+      wildcard: normalized.wildcard,
+    };
+  }
+
+  return null;
+}
+
 /**
  * Heuristic extraction of ctx variable usage from RunJS code.
  *
@@ -256,27 +287,35 @@ export function extractUsedVariablePathsFromRunJS(code: string): Record<string,
     usage.set(varName, set);
   };
 
+  const addCtxUsage = (expr: string) => {
+    const hit = extractCtxRootUsage(expr);
+    if (!hit?.varName) return;
+    add(hit.varName, hit.wildcard ? '' : hit.subPath);
+  };
+
   // dot form: ctx.foo.bar / ctx.foo[0].bar (excluding ctx.method(...))
   const dotRe = /ctx\.([a-zA-Z_$][a-zA-Z0-9_$]*(?:(?:\.[a-zA-Z_$][a-zA-Z0-9_$]*)|(?:\[[^\]]+\]))*)(?!\s*\()/g;
   let match: RegExpExecArray | null;
   while ((match = dotRe.exec(src))) {
-    const pathAfterCtx = match[1] || '';
-    const firstKeyMatch = pathAfterCtx.match(/^([a-zA-Z_$][a-zA-Z0-9_$]*)/);
-    if (!firstKeyMatch) continue;
-    const firstKey = firstKeyMatch[1];
-    const rest = pathAfterCtx.slice(firstKey.length);
-    const { subPath, wildcard } = normalizeSubPath(rest);
-    add(firstKey, wildcard ? '' : subPath);
+    addCtxUsage(`ctx.${match[1] || ''}`);
   }
 
   // bracket root: ctx['foo'].bar / ctx["foo"][0] (excluding ctx['method'](...))
   const bracketRootRe =
     /ctx\s*\[\s*(['"])([a-zA-Z_$][a-zA-Z0-9_$]*)\1\s*\]((?:(?:\.[a-zA-Z_$][a-zA-Z0-9_$]*)|(?:\[[^\]]+\]))*)(?!\s*\()/g;
   while ((match = bracketRootRe.exec(srcWithStrings))) {
-    const varName = match[2] || '';
-    const rest = match[3] || '';
-    const { subPath, wildcard } = normalizeSubPath(rest);
-    add(varName, wildcard ? '' : subPath);
+    addCtxUsage(`ctx['${match[2] || ''}']${match[3] || ''}`);
+  }
+
+  // async-safe helper form: await ctx.getVar('ctx.foo.bar')
+  const getVarRe = /ctx\.getVar\s*\(\s*(['"])((?:\\.|(?!\1)[\s\S])*)\1\s*\)/g;
+  while ((match = getVarRe.exec(srcWithStrings))) {
+    const expr = String(match[2] || '')
+      .replace(/\\'/g, "'")
+      .replace(/\\"/g, '"')
+      .trim();
+    if (!expr.startsWith('ctx')) continue;
+    addCtxUsage(expr);
   }
 
   const out: Record<string, string[]> = {};

package/src/utils/schema-utils.ts

@@ -11,7 +11,7 @@ import type { ISchema } from '@formily/json-schema';
 import { Schema } from '@formily/json-schema';
 import type { FlowModel } from '../models';
 import { FlowRuntimeContext } from '../flowContext';
-import type { StepDefinition, StepUIMode } from '../types';
+import type { EventDefinition, StepDefinition, StepUIMode } from '../types';
 import { setupRuntimeContextSteps } from './setupRuntimeContextSteps';
 
 /**
@@ -242,6 +242,35 @@ export async function resolveStepUiSchema<TModel extends FlowModel = FlowModel>(
   return resolvedStepUiSchema;
 }
 
+/**
+ * 判断事件在设置菜单中是否应被隐藏。
+ * - 支持 EventDefinition.hideInSettings。
+ * - hideInSettings 可为布尔值或函数（接收 FlowRuntimeContext）。
+ */
+export async function shouldHideEventInSettings<TModel extends FlowModel = FlowModel>(
+  model: TModel,
+  flow: any,
+  event: EventDefinition<TModel> | undefined,
+): Promise<boolean> {
+  if (!event) return true;
+
+  const { hideInSettings } = event;
+
+  if (typeof hideInSettings === 'function') {
+    try {
+      const ctx = new FlowRuntimeContext(model, flow.key, 'settings');
+      setupRuntimeContextSteps(ctx, flow.steps || {}, model, flow.key);
+      const result = await hideInSettings(ctx as any);
+      return !!result;
+    } catch (error) {
+      console.warn(`Error evaluating hideInSettings for event '${event.name || ''}' in flow '${flow.key}':`, error);
+      return false;
+    }
+  }
+
+  return !!hideInSettings;
+}
+
 /**
  * 判断步骤在设置菜单中是否应被隐藏。
  * - 支持 StepDefinition.hideInSettings 与 ActionDefinition.hideInSettings（step 优先）。

package/src/views/FlowView.tsx

@@ -11,13 +11,23 @@ import { PopoverProps as AntdPopoverProps } from 'antd';
 import { FlowContext } from '../flowContext';
 import { ViewNavigation } from './ViewNavigation';
 
+export type FlowViewBeforeClosePayload = {
+  result?: any;
+  force?: boolean;
+};
+
+export type FlowViewBeforeCloseHandler = (
+  payload: FlowViewBeforeClosePayload,
+) => Promise<boolean | void> | boolean | void;
+
 export type FlowView = {
   type: 'drawer' | 'popover' | 'dialog' | 'embed';
   inputArgs: any;
   Header: React.FC<{ title?: React.ReactNode; extra?: React.ReactNode }> | null;
   Footer: React.FC<{ children?: React.ReactNode }> | null;
-  close: (result?: any, force?: boolean) => void;
+  close: (result?: any, force?: boolean) => Promise<boolean | void> | boolean | void;
   update: (newConfig: any) => void;
+  beforeClose?: FlowViewBeforeCloseHandler;
   navigation?: ViewNavigation;
   /** 页面的销毁方法 */
   destroy?: () => void;

package/src/views/__tests__/runViewBeforeClose.test.ts

@@ -0,0 +1,30 @@
+/**
+ * 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 { runViewBeforeClose } from '../runViewBeforeClose';
+
+describe('runViewBeforeClose', () => {
+  it('returns true when no beforeClose handler is configured', async () => {
+    await expect(runViewBeforeClose({} as any, { force: false })).resolves.toBe(true);
+  });
+
+  it('skips beforeClose handler for force close', async () => {
+    const beforeClose = vi.fn();
+
+    await expect(runViewBeforeClose({ beforeClose } as any, { force: true })).resolves.toBe(true);
+    expect(beforeClose).not.toHaveBeenCalled();
+  });
+
+  it('returns false when beforeClose handler blocks the close', async () => {
+    const beforeClose = vi.fn().mockResolvedValue(false);
+
+    await expect(runViewBeforeClose({ beforeClose } as any, { force: false })).resolves.toBe(false);
+  });
+});