@nocobase/flow-engine 2.0.0-alpha.9 → 2.0.0-beta.2

package/lib/types.d.ts

@@ -9,6 +9,7 @@
 /// <reference types="react" />
 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';
@@ -93,6 +94,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 {
     [key: string]: any;
@@ -110,12 +113,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 +137,28 @@ 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>>);
 }
 /**
  * Flow 事件名称集合。
@@ -160,8 +187,9 @@ export interface DispatchEventOptions {
  */
 export type EventDefinition<TModel extends FlowModel = FlowModel, TCtx extends FlowContext = FlowContext> = ActionDefinition<TModel, TCtx>;
 export type StepUIMode = 'dialog' | 'drawer' | 'embed' | {
-    type?: 'dialog' | 'drawer' | 'embed';
+    type?: 'dialog' | 'drawer' | 'embed' | 'select' | 'switch';
     props?: Record<string, any>;
+    key?: string;
 };
 /**
  * Step definition with unified support for both registered actions and inline handlers
@@ -173,8 +201,6 @@ export interface StepDefinition<TModel extends FlowModel = FlowModel> extends Pa
     use?: string;
     sort?: number;
     preset?: boolean;
-    paramsRequired?: boolean;
-    hideInSettings?: boolean;
     uiMode?: StepUIMode | ((ctx: FlowRuntimeContext<TModel>) => StepUIMode | Promise<StepUIMode>);
 }
 /**
@@ -225,6 +251,14 @@ 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
  */
@@ -249,6 +283,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>;
 }
 /**
  * 步骤设置对话框的属性接口
@@ -350,7 +385,7 @@ export type FlowModelMeta = Pick<SubModelItem, 'key' | 'label' | 'icon' | 'child
      * 是否在菜单中隐藏该模型类
      * @default false
      */
-    hide?: boolean;
+    hide?: boolean | ((context: FlowModelContext) => boolean);
     eventList?: {
         label: string;
         value: string;

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;

package/lib/utils/associationObjectVariable.js

@@ -0,0 +1,157 @@
+/**
+ * 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 __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var associationObjectVariable_exports = {};
+__export(associationObjectVariable_exports, {
+  createAssociationAwareObjectMetaFactory: () => createAssociationAwareObjectMetaFactory,
+  createAssociationSubpathResolver: () => createAssociationSubpathResolver
+});
+module.exports = __toCommonJS(associationObjectVariable_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_createCollectionContextMeta = require("./createCollectionContextMeta");
+function baseFieldNameOf(subPath) {
+  if (!subPath) return void 0;
+  const m = subPath.match(/^([^.[]+)/);
+  return m == null ? void 0 : m[1];
+}
+__name(baseFieldNameOf, "baseFieldNameOf");
+function findFieldByName(collection, name) {
+  var _a;
+  if (!collection || !name) return void 0;
+  const direct = collection.getField(name);
+  if (direct) return direct;
+  const fields = ((_a = collection.getFields) == null ? void 0 : _a.call(collection)) || [];
+  return fields.find((f) => f.name === name);
+}
+__name(findFieldByName, "findFieldByName");
+function toFilterByTk(value, primaryKey) {
+  if (value == null) return void 0;
+  if (Array.isArray(primaryKey)) {
+    if (typeof value !== "object" || !value) return void 0;
+    const out = {};
+    for (const k of primaryKey) {
+      const v = value[k];
+      if (typeof v === "undefined" || v === null) return void 0;
+      out[k] = v;
+    }
+    return out;
+  }
+  if (typeof value === "string" || typeof value === "number") return value;
+  if (typeof value === "object") {
+    return value[primaryKey];
+  }
+  return void 0;
+}
+__name(toFilterByTk, "toFilterByTk");
+function createAssociationSubpathResolver(collectionAccessor, valueAccessor) {
+  return (p) => {
+    if (!p || !p.includes(".")) return false;
+    const base = baseFieldNameOf(p);
+    if (!base) return false;
+    const collection = collectionAccessor();
+    const field = findFieldByName(collection, base);
+    const isAssoc = !!(field == null ? void 0 : field.isAssociationField());
+    if (!isAssoc) return false;
+    if (typeof valueAccessor === "function") {
+      const local = valueAccessor();
+      if (local && typeof local === "object") {
+        const v = import_lodash.default.get(local, p);
+        if (typeof v !== "undefined") return false;
+      }
+    }
+    return true;
+  };
+}
+__name(createAssociationSubpathResolver, "createAssociationSubpathResolver");
+function createAssociationAwareObjectMetaFactory(collectionAccessor, title, valueAccessor) {
+  const baseFactory = (0, import_createCollectionContextMeta.createCollectionContextMeta)(collectionAccessor, title, true);
+  const factory = /* @__PURE__ */ __name(async () => {
+    const base = await baseFactory();
+    if (!base) return null;
+    const meta = {
+      ...base,
+      buildVariablesParams: /* @__PURE__ */ __name((ctx) => {
+        var _a;
+        const collection = collectionAccessor();
+        const obj = valueAccessor(ctx);
+        if (!collection || !obj || typeof obj !== "object") return {};
+        const params = {};
+        const fields = ((_a = collection.getFields) == null ? void 0 : _a.call(collection)) || [];
+        for (const field of fields) {
+          const name = field.name;
+          if (!name) continue;
+          if (!field.isAssociationField()) continue;
+          const target = field.target;
+          const targetCollection = field.targetCollection;
+          if (!target || !targetCollection) continue;
+          const primaryKey = targetCollection.filterTargetKey;
+          const associationValue = obj[name];
+          if (associationValue == null) continue;
+          if (Array.isArray(associationValue)) {
+            const ids = associationValue.map((item) => toFilterByTk(item, primaryKey)).filter((v) => v != null);
+            if (ids.length) {
+              params[name] = {
+                collection: target,
+                dataSourceKey: targetCollection.dataSourceKey,
+                filterByTk: ids
+              };
+            }
+          } else {
+            const id = toFilterByTk(associationValue, primaryKey);
+            if (id != null) {
+              params[name] = {
+                collection: target,
+                dataSourceKey: targetCollection.dataSourceKey,
+                filterByTk: id
+              };
+            }
+          }
+        }
+        return params;
+      }, "buildVariablesParams")
+    };
+    return meta;
+  }, "factory");
+  factory.title = title;
+  return factory;
+}
+__name(createAssociationAwareObjectMetaFactory, "createAssociationAwareObjectMetaFactory");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAssociationAwareObjectMetaFactory,
+  createAssociationSubpathResolver
+});

package/lib/utils/createCollectionContextMeta.d.ts

@@ -8,4 +8,4 @@
  */
 import type { Collection } from '../data-source';
 import type { PropertyMetaFactory } from '../flowContext';
-export declare function createCollectionContextMeta(collectionOrFactory: Collection | (() => Collection | null), title?: string): PropertyMetaFactory;
+export declare function createCollectionContextMeta(collectionOrFactory: Collection | (() => Collection | null), title?: string, includeNonFilterable?: boolean): PropertyMetaFactory;

package/lib/utils/createCollectionContextMeta.js

@@ -32,7 +32,7 @@ __export(createCollectionContextMeta_exports, {
 module.exports = __toCommonJS(createCollectionContextMeta_exports);
 const RELATION_FIELD_TYPES = ["belongsTo", "hasOne", "hasMany", "belongsToMany", "belongsToArray"];
 const NUMERIC_FIELD_TYPES = ["integer", "float", "double", "decimal"];
-function createFieldMetadata(field) {
+function createFieldMetadata(field, includeNonFilterable) {
   const baseProperties = createMetaBaseProperties(field);
   if (field.isAssociationField()) {
     const targetCollection = field.targetCollection;
@@ -49,7 +49,9 @@ function createFieldMetadata(field) {
       properties: /* @__PURE__ */ __name(async () => {
         const subProperties = {};
         targetCollection.fields.forEach((subField) => {
-          subProperties[subField.name] = createFieldMetadata(subField);
+          if (includeNonFilterable || subField.filterable) {
+            subProperties[subField.name] = createFieldMetadata(subField, includeNonFilterable);
+          }
         });
         return subProperties;
       }, "properties")
@@ -89,7 +91,7 @@ function createMetaBaseProperties(field) {
   };
 }
 __name(createMetaBaseProperties, "createMetaBaseProperties");
-function createCollectionContextMeta(collectionOrFactory, title) {
+function createCollectionContextMeta(collectionOrFactory, title, includeNonFilterable) {
   const metaFn = /* @__PURE__ */ __name(async () => {
     const collection = typeof collectionOrFactory === "function" ? collectionOrFactory() : collectionOrFactory;
     if (!collection) {
@@ -101,7 +103,9 @@ function createCollectionContextMeta(collectionOrFactory, title) {
       properties: /* @__PURE__ */ __name(async () => {
         const properties = {};
         collection.fields.forEach((field) => {
-          properties[field.name] = createFieldMetadata(field);
+          if (includeNonFilterable || field.filterable) {
+            properties[field.name] = createFieldMetadata(field, includeNonFilterable);
+          }
         });
         return properties;
       }, "properties")

package/lib/utils/createEphemeralContext.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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 { FlowContext } from '../flowContext';
+import type { ActionDefinition } from '../types';
+type ContextDefsLike<TCtx extends FlowContext> = Partial<Pick<ActionDefinition<any, TCtx>, 'defineProperties' | 'defineMethods'>> | null | undefined;
+export declare function createEphemeralContext<TCtx extends FlowContext>(parent: TCtx, contextDefs?: ContextDefsLike<TCtx>): Promise<TCtx>;
+export {};

package/lib/utils/createEphemeralContext.js

@@ -0,0 +1,140 @@
+/**
+ * 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 createEphemeralContext_exports = {};
+__export(createEphemeralContext_exports, {
+  createEphemeralContext: () => createEphemeralContext
+});
+module.exports = __toCommonJS(createEphemeralContext_exports);
+var import_flowContext = require("../flowContext");
+async function createEphemeralContext(parent, contextDefs) {
+  if (contextDefs == null || !contextDefs.defineProperties && !contextDefs.defineMethods) {
+    return parent;
+  }
+  const scoped = new import_flowContext.FlowContext();
+  scoped.addDelegate(parent);
+  const scopedProxy = scoped.createProxy();
+  const scopedObj = scopedProxy;
+  const parentObj = parent;
+  const getFromParent = /* @__PURE__ */ __name((key) => {
+    const val = Reflect.get(parentObj, key, parentObj);
+    return typeof val === "function" ? val.bind(parent) : val;
+  }, "getFromParent");
+  const hasInScopedOrParent = /* @__PURE__ */ __name((key) => key === "defineProperty" || key === "defineMethod" || Reflect.has(scopedObj, key) || Reflect.has(parentObj, key), "hasInScopedOrParent");
+  const injectionProxy = new Proxy(scopedProxy, {
+    get(_t, key, receiver) {
+      if (typeof key === "string") {
+        if (key === "defineProperty") {
+          return (propKey, options) => scoped.defineProperty(propKey, options);
+        }
+        if (key === "defineMethod") {
+          return (name, fn, des) => scoped.defineMethod(name, fn, des);
+        }
+        if (Reflect.has(scopedObj, key)) {
+          return Reflect.get(scopedObj, key, receiver);
+        }
+        return getFromParent(key);
+      }
+      return Reflect.get(scopedObj, key, receiver);
+    },
+    set(_t, key, value) {
+      return Reflect.set(parentObj, key, value);
+    },
+    has(_t, key) {
+      return hasInScopedOrParent(key);
+    },
+    getOwnPropertyDescriptor(_t, key) {
+      return Object.getOwnPropertyDescriptor(scopedObj, key) || Object.getOwnPropertyDescriptor(parentObj, key);
+    }
+  });
+  if (contextDefs) {
+    const defs = Array.isArray(contextDefs) ? contextDefs : [contextDefs];
+    for (const defLike of defs) {
+      if (!defLike) continue;
+      const dp = defLike.defineProperties;
+      if (dp) {
+        const raw = typeof dp === "function" ? await dp(injectionProxy) : dp;
+        if (!raw || typeof raw !== "object") {
+          throw new TypeError("defineProperties must return an object of PropertyOptions");
+        }
+        const propsDef = raw;
+        for (const [key, options] of Object.entries(propsDef)) {
+          if (!options || typeof options !== "object") {
+            throw new TypeError(`defineProperties['${key}'] must be a PropertyOptions object`);
+          }
+          scoped.defineProperty(key, options);
+        }
+      }
+      const dm = defLike.defineMethods;
+      if (dm) {
+        const raw = typeof dm === "function" ? await dm(injectionProxy) : dm;
+        if (!raw || typeof raw !== "object") {
+          throw new TypeError("defineMethods must return an object of functions");
+        }
+        const methodsDef = raw;
+        for (const [key, fn] of Object.entries(methodsDef)) {
+          if (typeof fn !== "function") {
+            throw new TypeError(`defineMethods['${key}'] must be a function`);
+          }
+          scoped.defineMethod(key, fn);
+        }
+      }
+    }
+  }
+  const outerProxy = new Proxy(scopedProxy, {
+    get(_t, key, receiver) {
+      if (typeof key === "string") {
+        if (key === "defineProperty") {
+          return (propKey, options) => parent.defineProperty(propKey, options);
+        }
+        if (key === "defineMethod") {
+          return (name, fn, des) => parent.defineMethod(name, fn, des);
+        }
+        if (Reflect.has(scopedObj, key)) {
+          return Reflect.get(scopedObj, key, receiver);
+        }
+        return getFromParent(key);
+      }
+      return Reflect.get(scopedObj, key, receiver);
+    },
+    set(_t, key, value) {
+      return Reflect.set(parentObj, key, value);
+    },
+    has(_t, key) {
+      return hasInScopedOrParent(key);
+    },
+    getOwnPropertyDescriptor(_t, key) {
+      return Object.getOwnPropertyDescriptor(scopedObj, key) || Object.getOwnPropertyDescriptor(parentObj, key);
+    }
+  });
+  return outerProxy;
+}
+__name(createEphemeralContext, "createEphemeralContext");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createEphemeralContext
+});

package/lib/utils/flows.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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 { FlowDefinition } from '../FlowDefinition';
+export declare const isBeforeRenderFlow: (flow: FlowDefinition) => boolean;

package/lib/utils/flows.js

@@ -0,0 +1,48 @@
+/**
+ * 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 flows_exports = {};
+__export(flows_exports, {
+  isBeforeRenderFlow: () => isBeforeRenderFlow
+});
+module.exports = __toCommonJS(flows_exports);
+const isBeforeRenderFlow = /* @__PURE__ */ __name((flow) => {
+  if (typeof flow.on === "string") {
+    return flow.on === "beforeRender";
+  }
+  if (typeof flow.on === "object") {
+    return flow.on.eventName === "beforeRender";
+  }
+  if (!flow.on && flow.manual !== true) {
+    return true;
+  }
+  return false;
+}, "isBeforeRenderFlow");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isBeforeRenderFlow
+});

package/lib/utils/index.d.ts

@@ -12,11 +12,15 @@ export { FlowExitException } from './exceptions';
 export { defineAction } from './flow-definitions';
 export { isInheritedFrom } from './inheritance';
 export { resolveCreateModelOptions, resolveDefaultParams, resolveExpressions } from './params-resolvers';
-export { compileUiSchema, resolveStepUiSchema, resolveUiMode } from './schema-utils';
+export { compileUiSchema, resolveStepUiSchema, resolveUiMode, shouldHideStepInSettings } from './schema-utils';
 export { setupRuntimeContextSteps } from './setupRuntimeContextSteps';
 export { createCollectionContextMeta } from './createCollectionContextMeta';
-export { buildRecordMeta, collectContextParamsForTemplate, createCurrentRecordMetaFactory, createRecordMetaFactory, extractUsedVariableNames, extractUsedVariablePaths, inferRecordRef, type RecordParamsBuilder, } from './variablesParams';
+export { createAssociationAwareObjectMetaFactory, createAssociationSubpathResolver } from './associationObjectVariable';
+export { buildRecordMeta, collectContextParamsForTemplate, createCurrentRecordMetaFactory, createRecordResolveOnServerWithLocal, createRecordMetaFactory, extractUsedVariableNames, extractUsedVariablePaths, inferRecordRef, type RecordParamsBuilder, } from './variablesParams';
 export { extractPropertyPath, formatPathToVariable, isVariableExpression } from './context';
 export { clearAutoFlowError, getAutoFlowError, setAutoFlowError, type AutoFlowError } from './autoFlowError';
 export { parsePathnameToViewParams, type ViewParam } from './parsePathnameToViewParams';
-export { createSafeDocument, createSafeWindow } from './safeGlobals';
+export { createSafeDocument, createSafeWindow, createSafeNavigator } from './safeGlobals';
+export { createEphemeralContext } from './createEphemeralContext';
+export { pruneFilter } from './pruneFilter';
+export { isBeforeRenderFlow } from './flows';