@nocobase/flow-engine 2.0.0-beta.22 → 2.0.0-beta.23

package/src/utils/safeGlobals.ts

@@ -352,3 +352,55 @@ export function createSafeNavigator(extra?: Record<string, any>) {
     },
   );
 }
+
+/**
+ * Create a safe globals object for RunJS execution.
+ *
+ * - Always tries to provide `navigator`
+ * - Best-effort provides `window` and `document` in browser environments
+ * - Never throws (so callers can decide how to handle missing globals)
+ */
+export function createSafeRunJSGlobals(extraGlobals?: Record<string, any>): Record<string, any> {
+  const globals: Record<string, any> = {};
+
+  try {
+    const navigator = createSafeNavigator();
+    globals.navigator = navigator;
+    try {
+      globals.window = createSafeWindow({ navigator });
+    } catch {
+      // ignore when window is not available (e.g. SSR/tests)
+    }
+  } catch {
+    // ignore
+  }
+
+  try {
+    globals.document = createSafeDocument();
+  } catch {
+    // ignore when document is not available (e.g. SSR/tests)
+  }
+
+  return extraGlobals ? { ...globals, ...extraGlobals } : globals;
+}
+
+/**
+ * Execute RunJS with safe globals (window/document/navigator).
+ *
+ * Keeps `this` binding by calling `ctx.runjs(...)` instead of passing bare function references.
+ */
+export async function runjsWithSafeGlobals(
+  ctx: unknown,
+  code: string,
+  options?: any,
+  extraGlobals?: Record<string, any>,
+): Promise<any> {
+  if (!ctx || (typeof ctx !== 'object' && typeof ctx !== 'function')) return undefined;
+  const runjs = (ctx as { runjs?: unknown }).runjs;
+  if (typeof runjs !== 'function') return undefined;
+  return (ctx as { runjs: (code: string, variables?: Record<string, any>, options?: any) => Promise<any> }).runjs(
+    code,
+    createSafeRunJSGlobals(extraGlobals),
+    options,
+  );
+}

package/src/utils/schema-utils.ts

@@ -277,3 +277,82 @@ export async function shouldHideStepInSettings<TModel extends FlowModel = FlowMo
 
   return !!hideInSettings;
 }
+
+/**
+ * 解析步骤在设置菜单中的禁用状态与提示文案。
+ * - 支持 StepDefinition.disabledInSettings 与 ActionDefinition.disabledInSettings（step 优先）。
+ * - 支持 StepDefinition.disabledReasonInSettings 与 ActionDefinition.disabledReasonInSettings（step 优先）。
+ * - 以上属性均支持静态值与函数（接收 FlowRuntimeContext）。
+ */
+export async function resolveStepDisabledInSettings<TModel extends FlowModel = FlowModel>(
+  model: TModel,
+  flow: any,
+  step: StepDefinition,
+): Promise<{ disabled: boolean; reason?: string }> {
+  if (!step) return { disabled: false };
+
+  let disabledInSettings = step.disabledInSettings;
+  let disabledReasonInSettings = step.disabledReasonInSettings;
+
+  if ((typeof disabledInSettings === 'undefined' || typeof disabledReasonInSettings === 'undefined') && step.use) {
+    try {
+      const action = model.getAction?.(step.use);
+      if (typeof disabledInSettings === 'undefined') {
+        disabledInSettings = action?.disabledInSettings;
+      }
+      if (typeof disabledReasonInSettings === 'undefined') {
+        disabledReasonInSettings = action?.disabledReasonInSettings;
+      }
+    } catch (error) {
+      console.warn(`Failed to get action ${step.use}:`, error);
+    }
+  }
+
+  let ctx: FlowRuntimeContext<TModel> | null = null;
+  const getContext = () => {
+    if (ctx) return ctx;
+    ctx = new FlowRuntimeContext(model, flow.key, 'settings');
+    setupRuntimeContextSteps(ctx, flow.steps, model, flow.key);
+    ctx.defineProperty('currentStep', { value: step });
+    return ctx;
+  };
+
+  let disabled = false;
+  if (typeof disabledInSettings === 'function') {
+    try {
+      disabled = !!(await disabledInSettings(getContext() as any));
+    } catch (error) {
+      console.warn(`Error evaluating disabledInSettings for step '${step.key || ''}' in flow '${flow.key}':`, error);
+      return { disabled: false };
+    }
+  } else {
+    disabled = !!disabledInSettings;
+  }
+
+  if (!disabled) {
+    return { disabled: false };
+  }
+
+  let reason: string | undefined;
+  if (typeof disabledReasonInSettings === 'function') {
+    try {
+      const resolved = await disabledReasonInSettings(getContext() as any);
+      if (typeof resolved !== 'undefined' && resolved !== null && resolved !== '') {
+        reason = String(resolved);
+      }
+    } catch (error) {
+      console.warn(
+        `Error evaluating disabledReasonInSettings for step '${step.key || ''}' in flow '${flow.key}':`,
+        error,
+      );
+    }
+  } else if (
+    typeof disabledReasonInSettings !== 'undefined' &&
+    disabledReasonInSettings !== null &&
+    disabledReasonInSettings !== ''
+  ) {
+    reason = String(disabledReasonInSettings);
+  }
+
+  return { disabled: true, reason };
+}