@nocobase/flow-engine 2.0.0-alpha.4 → 2.0.0-alpha.40

package/lib/runjs-context/snippets/scene/table/export-selected-json.snippet.js

@@ -0,0 +1,64 @@
+/**
+ * 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.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var export_selected_json_snippet_exports = {};
+__export(export_selected_json_snippet_exports, {
+  default: () => export_selected_json_snippet_default
+});
+module.exports = __toCommonJS(export_selected_json_snippet_exports);
+var import_JSCollectionActionRunJSContext = require("../../../contexts/JSCollectionActionRunJSContext");
+const snippet = {
+  contexts: [import_JSCollectionActionRunJSContext.JSCollectionActionRunJSContext],
+  prefix: "sn-act-export",
+  label: "Export selected rows as JSON",
+  description: "Download selected rows as a JSON file",
+  locales: {
+    "zh-CN": {
+      label: "\u5BFC\u51FA\u9009\u4E2D\u884C\u4E3A JSON",
+      description: "\u5C06\u9009\u4E2D\u7684\u884C\u5BFC\u51FA\u4E3A JSON \u6587\u4EF6\u4E0B\u8F7D"
+    }
+  },
+  content: `
+const rows = ctx.resource?.getSelectedRows?.() || [];
+if (!rows.length) {
+  ctx.message.warning(ctx.t('Please select at least one row'));
+  return;
+}
+
+// Create JSON file and download
+const jsonStr = JSON.stringify(rows, null, 2);
+const blob = new Blob([jsonStr], { type: 'application/json' });
+const url = URL.createObjectURL(blob);
+const link = document.createElement('a');
+link.href = url;
+link.download = \`export-\${new Date().toISOString().split('T')[0]}.json\`;
+link.click();
+URL.revokeObjectURL(url);
+
+ctx.message.success(ctx.t('Exported {{count}} records', { count: rows.length }));
+`
+};
+var export_selected_json_snippet_default = snippet;

package/lib/runjs-context/snippets/scene/table/iterate-selected-rows.snippet.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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';
+declare const snippet: SnippetModule;
+export default snippet;

package/lib/runjs-context/snippets/scene/{actions → table}/iterate-selected-rows.snippet.js

@@ -29,10 +29,18 @@ __export(iterate_selected_rows_snippet_exports, {
   default: () => iterate_selected_rows_snippet_default
 });
 module.exports = __toCommonJS(iterate_selected_rows_snippet_exports);
-var iterate_selected_rows_snippet_default = {
-  contexts: ["JSCollectionActionRunJSContext"],
+var import_JSCollectionActionRunJSContext = require("../../../contexts/JSCollectionActionRunJSContext");
+const snippet = {
+  contexts: [import_JSCollectionActionRunJSContext.JSCollectionActionRunJSContext],
   prefix: "sn-act-iterate",
   label: "Iterate selected rows",
+  description: "Loop through selected rows and process each record",
+  locales: {
+    "zh-CN": {
+      label: "\u904D\u5386\u9009\u4E2D\u884C",
+      description: "\u904D\u5386\u9009\u4E2D\u884C\u5E76\u5904\u7406\u6BCF\u6761\u8BB0\u5F55"
+    }
+  },
   content: `
 const rows = ctx.resource?.getSelectedRows?.() || [];
 for (const row of rows) {
@@ -41,3 +49,4 @@ for (const row of rows) {
 ctx.message.success(ctx.t('Processed {{count}} rows', { count: rows.length }));
 `
 };
+var iterate_selected_rows_snippet_default = snippet;

package/lib/runjs-context/snippets/types.d.ts

@@ -6,11 +6,19 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
+export type SnippetContextSpecifier = string | {
+    name: string;
+} | (new (...args: any[]) => any);
 export type SnippetModule = {
     content: string;
-    contexts?: string[];
+    contexts?: SnippetContextSpecifier[];
     versions?: string[];
+    scenes?: string[];
     prefix?: string;
     label?: string;
     description?: string;
+    locales?: Record<string, {
+        label?: string;
+        description?: string;
+    }>;
 };

package/lib/scheduler/ModelOperationScheduler.d.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 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;
+}
+export declare class ModelOperationScheduler {
+    private engine;
+    private itemsByTargetUid;
+    private itemIdsByFromUid;
+    private itemsById;
+    private unbindHandlers;
+    private subscribedEventNames;
+    constructor(engine: FlowEngine);
+    /** 外部调用入口 */
+    schedule(fromModelOrUid: FlowModel | string, toUid: string, fn: (model: FlowModel) => Promise<void> | void, options?: ScheduleOptions): ScheduledCancel;
+    cancel(filter: {
+        fromUid?: string;
+        toUid?: string;
+    }): void;
+    /** 引擎关闭时释放 */
+    dispose(): void;
+    private bindEngineLifecycle;
+    private ensureEventSubscriptionIfNeeded;
+    private parseEventWhen;
+    private processLifecycleEvent;
+    private shouldTrigger;
+    private tryExecuteOnce;
+    private internalCancel;
+    private takeItem;
+}
+export default ModelOperationScheduler;

package/lib/scheduler/ModelOperationScheduler.js

@@ -0,0 +1,262 @@
+/**
+ * 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.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ModelOperationScheduler_exports = {};
+__export(ModelOperationScheduler_exports, {
+  ModelOperationScheduler: () => ModelOperationScheduler,
+  default: () => ModelOperationScheduler_default
+});
+module.exports = __toCommonJS(ModelOperationScheduler_exports);
+var import_secure = require("uid/secure");
+const _ModelOperationScheduler = class _ModelOperationScheduler {
+  constructor(engine) {
+    this.engine = engine;
+    this.bindEngineLifecycle();
+  }
+  itemsByTargetUid = /* @__PURE__ */ new Map();
+  itemIdsByFromUid = /* @__PURE__ */ new Map();
+  itemsById = /* @__PURE__ */ new Map();
+  unbindHandlers = [];
+  subscribedEventNames = /* @__PURE__ */ new Set();
+  /** 外部调用入口 */
+  schedule(fromModelOrUid, toUid, fn, options) {
+    const fromUid = typeof fromModelOrUid === "string" ? fromModelOrUid : fromModelOrUid == null ? void 0 : 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 = {
+      id: (0, import_secure.uid)(),
+      fromUid,
+      toUid,
+      fn,
+      options: {
+        // 默认语义：仅当 when === 'created' 时，对“已存在的目标”进行一次立即执行；
+        // 其它 when 不做立即执行，需等待后续真实生命周期事件。
+        when: (options == null ? void 0 : options.when) ?? "created"
+      }
+    };
+    let targetMap = this.itemsByTargetUid.get(toUid);
+    if (!targetMap) {
+      targetMap = /* @__PURE__ */ new Map();
+      this.itemsByTargetUid.set(toUid, targetMap);
+    }
+    targetMap.set(item.id, item);
+    let fromSet = this.itemIdsByFromUid.get(fromUid);
+    if (!fromSet) {
+      fromSet = /* @__PURE__ */ new Set();
+      this.itemIdsByFromUid.set(fromUid, fromSet);
+    }
+    fromSet.add(item.id);
+    this.itemsById.set(item.id, item);
+    this.ensureEventSubscriptionIfNeeded(item.options.when);
+    const modelNow = this.engine.getModel(toUid);
+    if (modelNow && item.options.when === "created") {
+      void this.tryExecuteOnce(item.id, { type: "created", uid: toUid, model: modelNow });
+    }
+    return () => this.internalCancel(item.id);
+  }
+  cancel(filter) {
+    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) {
+        }
+      }
+    } finally {
+      this.unbindHandlers = [];
+    }
+    for (const map of this.itemsByTargetUid.values()) {
+      for (const item of map.values()) this.internalCancel(item.id);
+    }
+    this.itemsByTargetUid.clear();
+    this.itemIdsByFromUid.clear();
+  }
+  bindEngineLifecycle() {
+    const emitter = this.engine.emitter;
+    if (!emitter || typeof emitter.on !== "function") return;
+    const onCreated = /* @__PURE__ */ __name((e) => {
+      this.processLifecycleEvent(e.uid, { ...e, type: "created" });
+    }, "onCreated");
+    emitter.on("model:created", onCreated);
+    this.unbindHandlers.push(() => emitter.off("model:created", onCreated));
+    const onMounted = /* @__PURE__ */ __name((e) => {
+      this.processLifecycleEvent(e.uid, { ...e, type: "mounted" });
+    }, "onMounted");
+    emitter.on("model:mounted", onMounted);
+    this.unbindHandlers.push(() => emitter.off("model:mounted", onMounted));
+    const onGenericBeforeStart = /* @__PURE__ */ __name((e) => {
+      this.processLifecycleEvent(e.uid, { ...e, type: "event:beforeRender:start" });
+    }, "onGenericBeforeStart");
+    emitter.on("model:event:beforeRender:start", onGenericBeforeStart);
+    this.unbindHandlers.push(() => emitter.off("model:event:beforeRender:start", onGenericBeforeStart));
+    const onGenericBeforeEnd = /* @__PURE__ */ __name((e) => {
+      this.processLifecycleEvent(e.uid, { ...e, type: "event:beforeRender:end" });
+    }, "onGenericBeforeEnd");
+    emitter.on("model:event:beforeRender:end", onGenericBeforeEnd);
+    this.unbindHandlers.push(() => emitter.off("model:event:beforeRender:end", onGenericBeforeEnd));
+    const onUnmounted = /* @__PURE__ */ __name((e) => {
+      this.processLifecycleEvent(e.uid, { ...e, type: "unmounted" });
+    }, "onUnmounted");
+    emitter.on("model:unmounted", onUnmounted);
+    this.unbindHandlers.push(() => emitter.off("model:unmounted", onUnmounted));
+    const onDestroyed = /* @__PURE__ */ __name((e) => {
+      const targetBucket = this.itemsByTargetUid.get(e.uid);
+      const event = { ...e, type: "destroyed" };
+      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)) {
+            void this.tryExecuteOnce(id, event);
+          } else {
+            this.internalCancel(id);
+          }
+        }
+      }
+    }, "onDestroyed");
+    emitter.on("model:destroyed", onDestroyed);
+    this.unbindHandlers.push(() => emitter.off("model:destroyed", onDestroyed));
+  }
+  ensureEventSubscriptionIfNeeded(when) {
+    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 = /* @__PURE__ */ __name((e) => {
+      this.processLifecycleEvent(e.uid, { ...e, type: `event:${name}:start` });
+    }, "onStart");
+    const onEnd = /* @__PURE__ */ __name((e) => {
+      this.processLifecycleEvent(e.uid, { ...e, type: `event:${name}:end` });
+    }, "onEnd");
+    const onError = /* @__PURE__ */ __name((e) => {
+      this.processLifecycleEvent(e.uid, { ...e, type: `event:${name}:error` });
+    }, "onError");
+    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));
+  }
+  parseEventWhen(when) {
+    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] };
+  }
+  processLifecycleEvent(targetUid, event) {
+    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;
+      void this.tryExecuteOnce(id, event);
+    }
+  }
+  shouldTrigger(when, event) {
+    if (!when) return false;
+    if (typeof when === "function") return !!when(event);
+    return when === event.type;
+  }
+  async tryExecuteOnce(id, event) {
+    var _a, _b;
+    const item = this.takeItem(id);
+    if (!item) return;
+    try {
+      const model = event.model || this.engine.getModel(item.toUid);
+      if (!model) return;
+      await Promise.resolve(item.fn(model));
+    } catch (err) {
+      (_b = (_a = this.engine.logger) == null ? void 0 : _a.error) == null ? void 0 : _b.call(
+        _a,
+        { err, id, fromUid: item.fromUid, toUid: item.toUid, when: item.options.when },
+        "ModelOperationScheduler: operation execution failed"
+      );
+    }
+  }
+  internalCancel(id) {
+    return !!this.takeItem(id);
+  }
+  takeItem(id) {
+    const it = this.itemsById.get(id);
+    if (!it) return void 0;
+    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;
+  }
+};
+__name(_ModelOperationScheduler, "ModelOperationScheduler");
+let ModelOperationScheduler = _ModelOperationScheduler;
+var ModelOperationScheduler_default = ModelOperationScheduler;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ModelOperationScheduler
+});

package/lib/types.d.ts

@@ -10,6 +10,7 @@
 import { ISchema } from '@formily/json-schema';
 import { SubModelItem } from './components';
 import { FlowContext, FlowModelContext, FlowRuntimeContext, FlowSettingsContext } from './flowContext';
+import type { PropertyOptions } from './flowContext';
 import type { FlowEngine } from './flowEngine';
 import type { FlowModel } from './models';
 /**
@@ -110,12 +111,14 @@ export declare enum ActionScene {
     BLOCK_LINKAGE_RULES = 1,
     /** 表单字段级联动规则可用 */
     FIELD_LINKAGE_RULES = 2,
+    /** 子表单字段级联动规则可用 */
+    SUB_FORM_FIELD_LINKAGE_RULES = 3,
     /** 详情字段级联动规则可用 */
-    DETAILS_FIELD_LINKAGE_RULES = 3,
+    DETAILS_FIELD_LINKAGE_RULES = 4,
     /** 按钮级联动规则可用 */
-    ACTION_LINKAGE_RULES = 4,
+    ACTION_LINKAGE_RULES = 5,
     /** 动态事件流可用 */
-    DYNAMIC_EVENT_FLOW = 5
+    DYNAMIC_EVENT_FLOW = 6
 }
 /**
  * Defines a reusable action with generic model type support.
@@ -132,6 +135,18 @@ export interface ActionDefinition<TModel extends FlowModel = FlowModel, TCtx ext
     uiMode?: StepUIMode | ((ctx: FlowRuntimeContext<TModel>) => StepUIMode | Promise<StepUIMode>);
     scene?: ActionScene | ActionScene[];
     sort?: number;
+    /**
+     * 在执行 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>>);
 }
 /**
  * Flow 事件名称集合。
@@ -146,6 +161,15 @@ export type FlowEvent<TModel extends FlowModel = FlowModel> = FlowEventName | {
     eventName: FlowEventName;
     defaultParams?: Record<string, any>;
 };
+/**
+ * 事件分发选项。
+ */
+export interface DispatchEventOptions {
+    /** 是否顺序执行（默认并行） */
+    sequential?: boolean;
+    /** 是否使用缓存（默认 false；beforeRender 的默认值为 true，可覆盖） */
+    useCache?: boolean;
+}
 /**
  * 事件定义：用于事件注册表（全局/模型类级）。
  */
@@ -240,6 +264,7 @@ export interface IFlowModelRepository<T extends FlowModel = FlowModel> {
     }): 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>;
 }
 /**
  * 步骤设置对话框的属性接口

package/lib/types.js

@@ -32,9 +32,10 @@ module.exports = __toCommonJS(types_exports);
 var ActionScene = /* @__PURE__ */ ((ActionScene2) => {
   ActionScene2[ActionScene2["BLOCK_LINKAGE_RULES"] = 1] = "BLOCK_LINKAGE_RULES";
   ActionScene2[ActionScene2["FIELD_LINKAGE_RULES"] = 2] = "FIELD_LINKAGE_RULES";
-  ActionScene2[ActionScene2["DETAILS_FIELD_LINKAGE_RULES"] = 3] = "DETAILS_FIELD_LINKAGE_RULES";
-  ActionScene2[ActionScene2["ACTION_LINKAGE_RULES"] = 4] = "ACTION_LINKAGE_RULES";
-  ActionScene2[ActionScene2["DYNAMIC_EVENT_FLOW"] = 5] = "DYNAMIC_EVENT_FLOW";
+  ActionScene2[ActionScene2["SUB_FORM_FIELD_LINKAGE_RULES"] = 3] = "SUB_FORM_FIELD_LINKAGE_RULES";
+  ActionScene2[ActionScene2["DETAILS_FIELD_LINKAGE_RULES"] = 4] = "DETAILS_FIELD_LINKAGE_RULES";
+  ActionScene2[ActionScene2["ACTION_LINKAGE_RULES"] = 5] = "ACTION_LINKAGE_RULES";
+  ActionScene2[ActionScene2["DYNAMIC_EVENT_FLOW"] = 6] = "DYNAMIC_EVENT_FLOW";
   return ActionScene2;
 })(ActionScene || {});
 // Annotate the CommonJS export names for ESM import in node:

package/lib/utils/associationObjectVariable.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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 { Collection } from '../data-source';
+import type { FlowContext, PropertyMetaFactory } from '../flowContext';
+/**
+ * 创建一个用于“对象类变量”（如 formValues / currentObject）的 `resolveOnServer` 判定函数。
+ * 仅当访问路径以“关联字段名”开头（且继续访问其子属性）时，返回 true 交由服务端解析；
+ * 否则在前端解析即可。
+ *
+ * @param collectionAccessor 返回当前对象所在 collection
+ * @param valueAccessor 可选，本地值访问器。若本地已存在目标子路径的值，则认为无需走后端，优先使用本地值。
+ * @returns `(subPath) => boolean` 判断是否需要服务端解析
+ */
+export declare function createAssociationSubpathResolver(collectionAccessor: () => Collection | null, valueAccessor?: () => unknown): (subPath: string) => boolean;
+/**
+ * 构建“对象类变量”的 PropertyMetaFactory：
+ * - 暴露集合字段结构（通过 createCollectionContextMeta）用于变量选择器；
+ * - 提供 buildVariablesParams：基于对象当前值，收集所有“已选择的关联字段”
+ *   以便服务端在 variables:resolve 时按需补全关联数据。
+ *
+ * @param collectionAccessor 获取集合对象，用于字段/元信息来源
+ * @param title 变量组标题（用于 UI 展示）
+ * @param valueAccessor 获取当前对象值（如 ctx.form.getFieldsValue() / ctx.currentObject）
+ * @returns PropertyMetaFactory
+ */
+export declare function createAssociationAwareObjectMetaFactory(collectionAccessor: () => Collection | null, title: string, valueAccessor: (ctx: FlowContext) => any): PropertyMetaFactory;