@nocobase/flow-engine 2.0.0-alpha.7 → 2.0.0-alpha.71

package/src/scheduler/ModelOperationScheduler.ts

@@ -0,0 +1,306 @@
+/**
+ * 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 { uid as genUid } from 'uid/secure';
+import type { FlowEngine } from '../flowEngine';
+import type { FlowModel } from '../models/flowModel';
+
+type LifecycleType =
+  | 'created'
+  | 'mounted'
+  | 'unmounted'
+  | 'destroyed'
+  | `event:${string}:start`
+  | `event:${string}:end`
+  | `event:${string}:error`;
+
+export type ScheduleWhen = LifecycleType | ((e: LifecycleEvent) => boolean);
+
+export interface ScheduleOptions {
+  when?: ScheduleWhen;
+}
+
+export type ScheduledCancel = () => boolean;
+
+export interface LifecycleEvent {
+  type: LifecycleType;
+  uid: string;
+  model?: FlowModel;
+  runId?: string;
+  error?: any;
+  inputArgs?: Record<string, any>;
+  result?: any;
+  flowKey?: string;
+  stepKey?: string;
+}
+
+type ScheduledItem = {
+  id: string;
+  fromUid: string;
+  toUid: string;
+  fn: (model: FlowModel) => Promise<void> | void;
+  options: ScheduleOptions;
+};
+
+export class ModelOperationScheduler {
+  private itemsByTargetUid = new Map<string, Map<string, ScheduledItem>>();
+  private itemIdsByFromUid = new Map<string, Set<string>>();
+  private itemsById = new Map<string, ScheduledItem>();
+
+  private unbindHandlers: Array<() => void> = [];
+  private subscribedEventNames = new Set<string>();
+
+  constructor(private engine: FlowEngine) {
+    this.bindEngineLifecycle();
+  }
+
+  /** 外部调用入口 */
+  schedule(
+    fromModelOrUid: FlowModel | string,
+    toUid: string,
+    fn: (model: FlowModel) => Promise<void> | void,
+    options?: ScheduleOptions,
+  ): ScheduledCancel {
+    const fromUid = typeof fromModelOrUid === 'string' ? fromModelOrUid : fromModelOrUid?.uid;
+    if (!fromUid) {
+      throw new Error('scheduleModelOperation: invalid from model or uid');
+    }
+    if (!toUid || typeof toUid !== 'string') {
+      throw new Error('scheduleModelOperation: invalid target uid');
+    }
+
+    const item: ScheduledItem = {
+      id: genUid(),
+      fromUid,
+      toUid,
+      fn,
+      options: {
+        // 默认语义：仅当 when === 'created' 时，对“已存在的目标”进行一次立即执行；
+        // 其它 when 不做立即执行，需等待后续真实生命周期事件。
+        when: options?.when ?? 'created',
+      },
+    };
+
+    // 注册结构
+    let targetMap = this.itemsByTargetUid.get(toUid);
+    if (!targetMap) {
+      targetMap = new Map();
+      this.itemsByTargetUid.set(toUid, targetMap);
+    }
+    targetMap.set(item.id, item);
+    let fromSet = this.itemIdsByFromUid.get(fromUid);
+    if (!fromSet) {
+      fromSet = new Set();
+      this.itemIdsByFromUid.set(fromUid, fromSet);
+    }
+    fromSet.add(item.id);
+    this.itemsById.set(item.id, item);
+
+    // 若是 event:xxx:start/end 语义，确保已订阅对应的 model:event 通道
+    this.ensureEventSubscriptionIfNeeded(item.options.when);
+
+    const modelNow = this.engine.getModel<FlowModel>(toUid);
+    if (modelNow && item.options.when === 'created') {
+      // 仅 when === 'created' 时，对“已存在的目标”立即执行一次
+      void this.tryExecuteOnce(item.id, { type: 'created', uid: toUid, model: modelNow });
+    }
+
+    return () => this.internalCancel(item.id);
+  }
+
+  cancel(filter: { fromUid?: string; toUid?: string }) {
+    const { fromUid, toUid } = filter || {};
+    if (toUid && this.itemsByTargetUid.has(toUid)) {
+      const map = this.itemsByTargetUid.get(toUid);
+      if (map)
+        for (const item of map.values()) {
+          if (fromUid && item.fromUid !== fromUid) continue;
+          this.internalCancel(item.id);
+        }
+      return;
+    }
+    if (fromUid && this.itemIdsByFromUid.has(fromUid)) {
+      const set = this.itemIdsByFromUid.get(fromUid);
+      if (set)
+        for (const id of Array.from(set)) {
+          const it = this.itemsById.get(id);
+          if (!it) continue;
+          if (toUid && it.toUid !== toUid) continue;
+          this.internalCancel(id);
+        }
+    }
+  }
+
+  /** 引擎关闭时释放 */
+  dispose() {
+    try {
+      for (const unbind of this.unbindHandlers) {
+        try {
+          unbind();
+        } catch (err) {
+          // 忽略解绑异常
+          void err;
+        }
+      }
+    } finally {
+      this.unbindHandlers = [];
+    }
+
+    // 统一取消剩余任务（将触发 cleanupItem，从而移除 abort 监听与计时器）
+    for (const map of this.itemsByTargetUid.values()) {
+      for (const item of map.values()) this.internalCancel(item.id);
+    }
+    this.itemsByTargetUid.clear();
+    this.itemIdsByFromUid.clear();
+  }
+
+  private bindEngineLifecycle() {
+    const emitter = this.engine.emitter;
+    if (!emitter || typeof emitter.on !== 'function') return;
+
+    const onCreated = async (e: LifecycleEvent) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: 'created' });
+    };
+    emitter.on('model:created', onCreated);
+    this.unbindHandlers.push(() => emitter.off('model:created', onCreated));
+
+    const onMounted = async (e: LifecycleEvent) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: 'mounted' });
+    };
+    emitter.on('model:mounted', onMounted);
+    this.unbindHandlers.push(() => emitter.off('model:mounted', onMounted));
+
+    const onGenericBeforeStart = async (e: LifecycleEvent) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: 'event:beforeRender:start' });
+    };
+    emitter.on('model:event:beforeRender:start', onGenericBeforeStart);
+    this.unbindHandlers.push(() => emitter.off('model:event:beforeRender:start', onGenericBeforeStart));
+
+    const onGenericBeforeEnd = async (e: LifecycleEvent) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: 'event:beforeRender:end' });
+    };
+    emitter.on('model:event:beforeRender:end', onGenericBeforeEnd);
+    this.unbindHandlers.push(() => emitter.off('model:event:beforeRender:end', onGenericBeforeEnd));
+
+    const onUnmounted = async (e: LifecycleEvent) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: 'unmounted' });
+    };
+    emitter.on('model:unmounted', onUnmounted);
+    this.unbindHandlers.push(() => emitter.off('model:unmounted', onUnmounted));
+
+    const onDestroyed = async (e: LifecycleEvent) => {
+      const targetBucket = this.itemsByTargetUid.get(e.uid);
+      const event = { ...e, type: 'destroyed' as const };
+      if (targetBucket && targetBucket.size) {
+        const ids = Array.from(targetBucket.keys());
+        for (const id of ids) {
+          const it = this.itemsById.get(id);
+          if (!it) continue;
+          if (this.shouldTrigger(it.options.when, event)) {
+            await this.tryExecuteOnce(id, event);
+          } else {
+            this.internalCancel(id);
+          }
+        }
+      }
+    };
+    emitter.on('model:destroyed', onDestroyed);
+    this.unbindHandlers.push(() => emitter.off('model:destroyed', onDestroyed));
+  }
+
+  private ensureEventSubscriptionIfNeeded(when?: ScheduleWhen) {
+    if (!when || typeof when !== 'string') return;
+    const parsed = this.parseEventWhen(when);
+    if (!parsed) return;
+    const { name } = parsed;
+    if (this.subscribedEventNames.has(name)) return;
+    this.subscribedEventNames.add(name);
+    const emitter = this.engine.emitter;
+    const onStart = async (e: LifecycleEvent) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: `event:${name}:start` as LifecycleType });
+    };
+    const onEnd = async (e: LifecycleEvent) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: `event:${name}:end` as LifecycleType });
+    };
+    const onError = async (e: LifecycleEvent) => {
+      await this.processLifecycleEvent(e.uid, { ...e, type: `event:${name}:error` as LifecycleType });
+    };
+    emitter.on(`model:event:${name}:start`, onStart);
+    emitter.on(`model:event:${name}:end`, onEnd);
+    emitter.on(`model:event:${name}:error`, onError);
+    this.unbindHandlers.push(() => emitter.off(`model:event:${name}:start`, onStart));
+    this.unbindHandlers.push(() => emitter.off(`model:event:${name}:end`, onEnd));
+    this.unbindHandlers.push(() => emitter.off(`model:event:${name}:error`, onError));
+  }
+
+  private parseEventWhen(when?: ScheduleWhen): { name: string; phase: 'start' | 'end' | 'error' } | null {
+    if (!when || typeof when !== 'string') return null;
+    const m = /^event:(.+):(start|end|error)$/.exec(when);
+    if (!m) return null;
+    return { name: m[1], phase: m[2] as 'start' | 'end' | 'error' };
+  }
+
+  private async processLifecycleEvent(targetUid: string, event: LifecycleEvent) {
+    const targetBucket = this.itemsByTargetUid.get(targetUid);
+    if (!targetBucket || targetBucket.size === 0) return;
+    const ids = Array.from(targetBucket.keys());
+    for (const id of ids) {
+      const item = this.itemsById.get(id);
+      if (!item) continue;
+      const should = this.shouldTrigger(item.options.when, event);
+      if (!should) continue;
+      await this.tryExecuteOnce(id, event);
+    }
+  }
+
+  private shouldTrigger(when: ScheduleWhen | undefined, event: LifecycleEvent): boolean {
+    if (!when) return false;
+    if (typeof when === 'function') return !!when(event);
+    return when === event.type;
+  }
+
+  private async tryExecuteOnce(id: string, event: LifecycleEvent) {
+    const item = this.takeItem(id);
+    if (!item) return;
+    try {
+      const model = event.model || this.engine.getModel<FlowModel>(item.toUid);
+      if (!model) return;
+      await Promise.resolve(item.fn(model));
+    } catch (err) {
+      this.engine.logger?.error?.(
+        { err, id, fromUid: item.fromUid, toUid: item.toUid, when: item.options.when },
+        'ModelOperationScheduler: operation execution failed',
+      );
+    }
+  }
+
+  private internalCancel(id: string) {
+    return !!this.takeItem(id);
+  }
+
+  private takeItem(id: string): ScheduledItem | undefined {
+    const it = this.itemsById.get(id);
+    if (!it) return undefined;
+    const { toUid, fromUid } = it;
+    const map = this.itemsByTargetUid.get(toUid);
+    if (map) {
+      map.delete(id);
+      if (map.size === 0) this.itemsByTargetUid.delete(toUid);
+    }
+    const set = this.itemIdsByFromUid.get(fromUid);
+    if (set) {
+      set.delete(id);
+      if (set.size === 0) this.itemIdsByFromUid.delete(fromUid);
+    }
+    this.itemsById.delete(id);
+    return it;
+  }
+}
+
+export default ModelOperationScheduler;

package/src/types.ts

@@ -9,6 +9,7 @@
 
 import { ISchema } from '@formily/json-schema';
 import { SubModelItem } from './components';
+import type { PropertyOptions } from './flowContext';
 import { FlowContext, FlowModelContext, FlowRuntimeContext, FlowSettingsContext } from './flowContext';
 import type { FlowEngine } from './flowEngine';
 import type { FlowModel } from './models';
@@ -109,6 +110,8 @@ export interface FlowDefinitionOptions<TModel extends FlowModel = FlowModel> {
    * 仅填补缺失，不覆盖已有。固定返回形状：{ [stepKey]: params }
    */
   defaultParams?: Record<string, any> | ((ctx: FlowModelContext) => StepParam | Promise<StepParam>);
+  enableTitle?: boolean;
+  divider?: 'top' | 'bottom';
 }
 
 export interface IModelComponentProps {
@@ -134,6 +137,8 @@ export enum ActionScene {
   BLOCK_LINKAGE_RULES = 1,
   /** 表单字段级联动规则可用 */
   FIELD_LINKAGE_RULES,
+  /** 子表单字段级联动规则可用 */
+  SUB_FORM_FIELD_LINKAGE_RULES,
   /** 详情字段级联动规则可用 */
   DETAILS_FIELD_LINKAGE_RULES,
   /** 按钮级联动规则可用 */
@@ -157,6 +162,36 @@ export interface ActionDefinition<TModel extends FlowModel = FlowModel, TCtx ext
   uiMode?: StepUIMode | ((ctx: FlowRuntimeContext<TModel>) => StepUIMode | Promise<StepUIMode>);
   scene?: ActionScene | ActionScene[];
   sort?: number;
+  /**
+   * Whether the step/action requires params to be configured before use.
+   */
+  paramsRequired?: boolean;
+  /**
+   * Whether to hide this step/action from settings menus.
+   * - Supports static boolean and dynamic decision based on runtime context.
+   * - StepDefinition.hideInSettings can override the ActionDefinition value.
+   */
+  hideInSettings?: boolean | ((ctx: TCtx) => boolean | Promise<boolean>);
+  /**
+   * 在执行 Action 前为 ctx 定义临时属性。
+   * - 仅支持 PropertyOptions 形态（例如：{ foo: { value: 5 } }）；
+   * - 或函数形式（接收 ctx，返回 PropertyOptions 对象；支持 Promise）。
+   */
+  defineProperties?:
+    | Record<string, PropertyOptions>
+    | ((ctx: TCtx) => Record<string, PropertyOptions> | Promise<Record<string, PropertyOptions>>);
+  /**
+   * 在执行 Action 前为 ctx 定义临时方法。
+   * - 支持 JSON 形式（对象的值应为函数）
+   * - 或函数形式（接收 ctx，返回方法对象；支持 Promise）
+   */
+  defineMethods?:
+    | Record<string, (this: TCtx, ...args: any[]) => any>
+    | ((
+        ctx: TCtx,
+      ) =>
+        | Record<string, (this: TCtx, ...args: any[]) => any>
+        | Promise<Record<string, (this: TCtx, ...args: any[]) => any>>);
 }
 
 /**
@@ -178,12 +213,47 @@ export type FlowEventName =
   // fallback to any string for extensibility
   | (string & {});
 
+/**
+ * 事件流的执行时机（phase）。
+ *
+ * 说明：
+ * - 缺省（phase 未配置）表示保持现有行为；
+ * - 当配置了 phase 时，运行时会将其映射为 `scheduleModelOperation` 的 `when` 锚点；
+ * - phase 同时适用于动态事件流（实例级）与静态流（内置）。
+ */
+export type FlowEventPhase =
+  | 'beforeAllFlows'
+  | 'afterAllFlows'
+  | 'beforeFlow'
+  | 'afterFlow'
+  | 'beforeStep'
+  | 'afterStep';
+
 /**
  * Flow 事件类型（供 FlowDefinitionOptions.on 使用）。
  */
 export type FlowEvent<TModel extends FlowModel = FlowModel> =
   | FlowEventName
-  | { eventName: FlowEventName; defaultParams?: Record<string, any> };
+  | {
+      eventName: FlowEventName;
+      defaultParams?: Record<string, any>;
+      /** 动态事件流的执行时机（默认 beforeAllFlows） */
+      phase?: FlowEventPhase;
+      /** phase 为 beforeFlow/afterFlow/beforeStep/afterStep 时使用 */
+      flowKey?: string;
+      /** phase 为 beforeStep/afterStep 时使用 */
+      stepKey?: string;
+    };
+
+/**
+ * 事件分发选项。
+ */
+export interface DispatchEventOptions {
+  /** 是否顺序执行（默认并行） */
+  sequential?: boolean;
+  /** 是否使用缓存（默认 false；beforeRender 的默认值为 true，可覆盖） */
+  useCache?: boolean;
+}
 
 /**
  * 事件定义：用于事件注册表（全局/模型类级）。
@@ -199,7 +269,7 @@ export type StepUIMode =
   | 'embed'
   // | 'switch'
   // | 'select'
-  | { type?: 'dialog' | 'drawer' | 'embed'; props?: Record<string, any> };
+  | { type?: 'dialog' | 'drawer' | 'embed' | 'select' | 'switch'; props?: Record<string, any>; key?: string };
 // | { type: 'switch'; props?: Record<string, any> }
 // | { type: 'select'; props?: Record<string, any> }
 
@@ -218,8 +288,6 @@ export interface StepDefinition<TModel extends FlowModel = FlowModel>
   // Step configuration
   // `preset: true` 的 step params 需要在创建时填写，没有标记的可以创建模型后再填写。
   preset?: boolean;
-  paramsRequired?: boolean; // Optional: whether the step params are required, will open the config dialog before adding the model
-  hideInSettings?: boolean; // Optional: whether to hide the step in the settings menu
   uiMode?: StepUIMode | ((ctx: FlowRuntimeContext<TModel>) => StepUIMode | Promise<StepUIMode>);
 }
 
@@ -278,6 +346,18 @@ export type ParamObject = {
  */
 export type RegisteredModelClassName = string;
 
+/**
+ * resolveUse 返回类型：可返回目标 use，或 { use, stop } 包含中断标志。
+ */
+export type ResolveUseResult =
+  | RegisteredModelClassName
+  | ModelConstructor
+  | {
+      use: RegisteredModelClassName | ModelConstructor;
+      /** 标记是否终止后续 resolveUse 链；默认 false（继续解析） */
+      stop?: boolean;
+    };
+
 /**
  * Options for creating a model instance
  */
@@ -300,6 +380,7 @@ export interface IFlowModelRepository<T extends FlowModel = FlowModel> {
   save(model: T, options?: { onlyStepParams?: boolean }): Promise<Record<string, any>>;
   destroy(uid: string): Promise<boolean>;
   move(sourceId: string, targetId: string, position: 'before' | 'after'): Promise<void>;
+  duplicate(uid: string): Promise<Record<string, any> | null>;
 }
 
 /**
@@ -419,7 +500,7 @@ export type FlowModelMeta =
      * 是否在菜单中隐藏该模型类
      * @default false
      */
-    hide?: boolean;
+    hide?: boolean | ((context: FlowModelContext) => boolean);
     eventList?: { label: string; value: string }[]; // 支持的事件列表
   };
 

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

@@ -0,0 +1,51 @@
+/**
+ * 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 } from 'vitest';
+import { createCollectionContextMeta } from '../createCollectionContextMeta';
+import { FlowEngine } from '../../flowEngine';
+import { CollectionFieldInterfaceManager } from '../../../../client/src/data-source/collection-field-interface/CollectionFieldInterfaceManager';
+
+describe('createCollectionContextMeta', () => {
+  it('filters association sub fields when includeNonFilterable is false', 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' }, // 未声明 filterable
+      ],
+    });
+
+    ds.addCollection({
+      name: 'posts',
+      fields: [
+        { name: 'title', type: 'string', interface: 'text', filterable: true },
+        { name: 'author', type: 'belongsTo', target: 'users', interface: 'm2o', filterable: true },
+      ],
+    });
+
+    const posts = ds.getCollection('posts')!;
+    const metaFactory = createCollectionContextMeta(posts, 'Posts', false);
+    const meta = await metaFactory();
+    const props = await (meta?.properties as any)?.();
+    const authorMeta: any = props?.author;
+    const authorFields = await authorMeta?.properties?.();
+
+    expect(authorFields).toBeTruthy();
+    expect(authorFields).toHaveProperty('email');
+    expect(authorFields).not.toHaveProperty('nickname');
+  });
+});

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

@@ -0,0 +1,65 @@
+/**
+ * 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, test, expect } from 'vitest';
+import { FlowEngine } from '../../flowEngine';
+import { FlowModel } from '../../models/flowModel';
+import { isBeforeRenderFlow } from '../index';
+
+describe('utils/isBeforeRenderFlow', () => {
+  test('identifies beforeRender by on string', () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+    const m = engine.createModel({ use: 'M' });
+    m.registerFlow('A', { on: 'beforeRender', steps: {} });
+    const flow = m.flowRegistry.getFlow('A')!;
+    expect(isBeforeRenderFlow(flow)).toBe(true);
+  });
+
+  test('identifies beforeRender by on object', () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+    const m = engine.createModel({ use: 'M' });
+    m.registerFlow('B', { on: { eventName: 'beforeRender' }, steps: {} });
+    const flow = m.flowRegistry.getFlow('B')!;
+    expect(isBeforeRenderFlow(flow)).toBe(true);
+  });
+
+  test('treats missing on and non-manual as beforeRender', () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+    const m = engine.createModel({ use: 'M' });
+    m.registerFlow('C', { steps: {} });
+    const flow = m.flowRegistry.getFlow('C')!;
+    expect(isBeforeRenderFlow(flow)).toBe(true);
+  });
+
+  test('manual flow is not beforeRender when on is missing', () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+    const m = engine.createModel({ use: 'M' });
+    m.registerFlow('D', { manual: true, steps: {} });
+    const flow = m.flowRegistry.getFlow('D')!;
+    expect(isBeforeRenderFlow(flow)).toBe(false);
+  });
+
+  test('non-beforeRender event is not beforeRender', () => {
+    const engine = new FlowEngine();
+    class M extends FlowModel {}
+    engine.registerModels({ M });
+    const m = engine.createModel({ use: 'M' });
+    m.registerFlow('E', { on: { eventName: 'click' }, steps: {} });
+    const flow = m.flowRegistry.getFlow('E')!;
+    expect(isBeforeRenderFlow(flow)).toBe(false);
+  });
+});

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

@@ -0,0 +1,38 @@
+/**
+ * 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, it, expect } from 'vitest';
+import { compileRunJs } from '../../utils/jsxTransform';
+
+describe('compileRunJs', () => {
+  it('returns original code when no JSX is present', async () => {
+    const src = `const a = 1; const b = a + 1;`;
+    const out = await compileRunJs(src);
+    expect(out).toBe(src);
+  });
+
+  it('transforms JSX when sucrase is available (skip if missing)', async () => {
+    const src = `ctx.render(<div className="x">hi</div>);`;
+
+    // Try to import sucrase to decide if this environment has it installed
+    const hasSucrase = await import('sucrase').then(() => true).catch(() => false);
+
+    const out = await compileRunJs(src);
+
+    if (!hasSucrase) {
+      // Environment without sucrase: current implementation falls back to original code
+      expect(out).toBe(src);
+      return;
+    }
+
+    // sucrase available: output should contain React.createElement mapping
+    expect(out).not.toBe(src);
+    expect(out).toMatch(/ctx\.React\.createElement/);
+  });
+});

package/src/utils/__tests__/params-resolvers.test.ts

@@ -491,6 +491,46 @@ describe('resolveExpressions', () => {
         ],
       });
     });
+
+    test('should resolve dot-only path with dashed keys', async () => {
+      ctx.defineProperty('formValues', {
+        value: {
+          'oho-test': {
+            'o2m-users': [1, 2],
+          },
+        },
+      });
+
+      const params = '{{ctx.formValues.oho-test.o2m-users}}';
+
+      const result = await resolveExpressions(params, ctx);
+
+      expect(result).toEqual([1, 2]);
+    });
+
+    test('should resolve dashed keys inside template strings', async () => {
+      ctx.defineProperty('formValues', {
+        value: {
+          'oho-test': {
+            'o2m-users': 'X',
+          },
+        },
+      });
+
+      const params = 'prefix {{ctx.formValues.oho-test.o2m-users}} suffix';
+
+      const result = await resolveExpressions(params, ctx);
+
+      expect(result).toEqual('prefix X suffix');
+    });
+
+    test('should not treat subtraction as dashed key path', async () => {
+      const params = '{{ctx.aa.bb-ctx.cc}}';
+
+      const result = await resolveExpressions(params, ctx);
+
+      expect(result).toEqual(5);
+    });
   });
 
   // 测试高级功能：多表达式模板字符串