@nocobase/flow-engine 2.0.0-beta.9 → 2.0.1

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

@@ -13,6 +13,7 @@ import {
   isInheritedFrom,
   resolveDefaultParams,
   resolveStepUiSchema,
+  resolveStepDisabledInSettings,
   shouldHideStepInSettings,
   FlowExitException,
   defineAction,
@@ -1117,4 +1118,98 @@ describe('Utils', () => {
       consoleSpy.mockRestore();
     });
   });
+
+  // ==================== resolveStepDisabledInSettings() FUNCTION ====================
+  describe('resolveStepDisabledInSettings()', () => {
+    let mockFlow: any;
+    let mockStep: StepDefinition;
+
+    beforeEach(() => {
+      mockFlow = {
+        key: 'testFlow',
+        title: 'Test Flow',
+        steps: {},
+      };
+
+      mockStep = {
+        key: 'testStep',
+        handler: vi.fn(),
+      };
+    });
+
+    test('returns disabled=false when step is falsy', async () => {
+      const result = await resolveStepDisabledInSettings(mockModel, mockFlow, null as any);
+      expect(result).toEqual({ disabled: false });
+    });
+
+    test('respects static step.disabledInSettings and disabledReasonInSettings', async () => {
+      mockStep.disabledInSettings = true;
+      mockStep.disabledReasonInSettings = 'legacy reason';
+
+      const result = await resolveStepDisabledInSettings(mockModel, mockFlow, mockStep);
+      expect(result).toEqual({ disabled: true, reason: 'legacy reason' });
+    });
+
+    test('falls back to action disabled settings when step value is undefined', async () => {
+      const action: ActionDefinition = {
+        name: 'testAction',
+        handler: vi.fn(),
+        disabledInSettings: true,
+        disabledReasonInSettings: 'from action',
+      } as any;
+
+      mockStep.use = 'testAction';
+      mockModel.flowEngine.getAction = vi.fn().mockReturnValue(action);
+
+      const result = await resolveStepDisabledInSettings(mockModel, mockFlow, mockStep);
+      expect(result).toEqual({ disabled: true, reason: 'from action' });
+    });
+
+    test('prefers step disabled settings over action values', async () => {
+      const action: ActionDefinition = {
+        name: 'testAction',
+        handler: vi.fn(),
+        disabledInSettings: false,
+        disabledReasonInSettings: 'from action',
+      } as any;
+
+      mockStep.use = 'testAction';
+      mockStep.disabledInSettings = true;
+      mockStep.disabledReasonInSettings = 'from step';
+      mockModel.flowEngine.getAction = vi.fn().mockReturnValue(action);
+
+      const result = await resolveStepDisabledInSettings(mockModel, mockFlow, mockStep);
+      expect(result).toEqual({ disabled: true, reason: 'from step' });
+    });
+
+    test('evaluates function disabled settings with FlowRuntimeContext', async () => {
+      const disabledFn = vi.fn().mockResolvedValue(true);
+      const reasonFn = vi.fn().mockResolvedValue('computed reason');
+      mockStep.disabledInSettings = disabledFn as any;
+      mockStep.disabledReasonInSettings = reasonFn as any;
+
+      const result = await resolveStepDisabledInSettings(mockModel, mockFlow, mockStep);
+
+      expect(disabledFn).toHaveBeenCalledTimes(1);
+      expect(reasonFn).toHaveBeenCalledTimes(1);
+      const disabledCtx = disabledFn.mock.calls[0][0] as FlowRuntimeContext;
+      const reasonCtx = reasonFn.mock.calls[0][0] as FlowRuntimeContext;
+      expect(disabledCtx).toBeInstanceOf(FlowRuntimeContext);
+      expect(reasonCtx).toBeInstanceOf(FlowRuntimeContext);
+      expect((disabledCtx as any).currentStep).toBeInstanceOf(ContextPathProxy);
+      expect(String((disabledCtx as any).currentStep)).toBe('{{ctx.currentStep}}');
+      expect(result).toEqual({ disabled: true, reason: 'computed reason' });
+    });
+
+    test('returns disabled=false when function disabledInSettings throws', async () => {
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      mockStep.disabledInSettings = vi.fn().mockRejectedValue(new Error('boom')) as any;
+
+      const result = await resolveStepDisabledInSettings(mockModel, mockFlow, mockStep);
+
+      expect(consoleSpy).toHaveBeenCalled();
+      expect(result).toEqual({ disabled: false });
+      consoleSpy.mockRestore();
+    });
+  });
 });

package/src/utils/associationObjectVariable.ts

@@ -71,7 +71,7 @@ function toFilterByTk(value: unknown, primaryKey: string | string[]) {
 }
 
 /**
- * 创建一个用于“对象类变量”（如 formValues / currentObject）的 `resolveOnServer` 判定函数。
+ * 创建一个用于“对象类变量”（如 formValues / item）的 `resolveOnServer` 判定函数。
  * 仅当访问路径以“关联字段名”开头（且继续访问其子属性）时，返回 true 交由服务端解析；
  * 否则在前端解析即可。
  *
@@ -114,7 +114,7 @@ export function createAssociationSubpathResolver(
  *
  * @param collectionAccessor 获取集合对象，用于字段/元信息来源
  * @param title 变量组标题（用于 UI 展示）
- * @param valueAccessor 获取当前对象值（如 ctx.form.getFieldsValue() / ctx.currentObject）
+ * @param valueAccessor 获取当前对象值（如 ctx.form.getFieldsValue() / ctx.item）
  * @returns PropertyMetaFactory
  */
 export function createAssociationAwareObjectMetaFactory(

package/src/utils/createCollectionContextMeta.ts

@@ -88,6 +88,7 @@ function createMetaBaseProperties(field: CollectionField) {
   return {
     title: field.title || field.name,
     interface: field.interface,
+    options: field.options,
     uiSchema: field.uiSchema || {},
   };
 }

package/src/utils/createEphemeralContext.ts

@@ -7,9 +7,8 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { FlowContext } from '../flowContext';
+import { FlowContext, type FlowContextMethodInfoInput, type PropertyOptions } from '../flowContext';
 import type { ActionDefinition } from '../types';
-import type { PropertyOptions } from '../flowContext';
 
 // 临时上下文：
 // - 读：优先从 scoped（临时定义）读取，兜底 parent；
@@ -51,7 +50,8 @@ export async function createEphemeralContext<TCtx extends FlowContext>(
           return (propKey: string, options: any) => (scoped as FlowContext).defineProperty(propKey, options);
         }
         if (key === 'defineMethod') {
-          return (name: string, fn: any, des?: string) => (scoped as FlowContext).defineMethod(name, fn, des);
+          return (name: string, fn: any, info?: string | FlowContextMethodInfoInput) =>
+            (scoped as FlowContext).defineMethod(name, fn, info);
         }
         if (Reflect.has(scopedObj, key)) {
           return Reflect.get(scopedObj, key, receiver);
@@ -118,7 +118,8 @@ export async function createEphemeralContext<TCtx extends FlowContext>(
           return (propKey: string, options: any) => (parent as FlowContext).defineProperty(propKey, options);
         }
         if (key === 'defineMethod') {
-          return (name: string, fn: any, des?: string) => (parent as FlowContext).defineMethod(name, fn, des);
+          return (name: string, fn: any, info?: string | FlowContextMethodInfoInput) =>
+            (parent as FlowContext).defineMethod(name, fn, info);
         }
         if (Reflect.has(scopedObj, key)) {
           return Reflect.get(scopedObj, key, receiver);

package/src/utils/dateVariable.ts

@@ -0,0 +1,397 @@
+/**
+ * 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 dayjs from 'dayjs';
+
+const CTX_DATE_REGEX = /^\{\{\s*ctx\.date(?:\.(.+?))?\s*\}\}$/;
+
+const PRESET_KEYS = new Set([
+  'today',
+  'now',
+  'yesterday',
+  'tomorrow',
+  'thisWeek',
+  'lastWeek',
+  'nextWeek',
+  'thisMonth',
+  'lastMonth',
+  'nextMonth',
+  'thisQuarter',
+  'lastQuarter',
+  'nextQuarter',
+  'thisYear',
+  'lastYear',
+  'nextYear',
+]);
+
+const RELATIVE_DIRECTIONS = new Set(['next', 'past']);
+const RELATIVE_UNITS = new Set(['day', 'week', 'month', 'year']);
+
+function parseCtxDateSegments(value: string): string[] | null {
+  if (typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  const match = trimmed.match(CTX_DATE_REGEX);
+  if (!match) return null;
+  const rawPath = String(match[1] || '');
+  if (!rawPath) return [];
+  return rawPath
+    .split('.')
+    .map((seg) => seg.trim())
+    .filter(Boolean);
+}
+
+export function isCtxDatePathPrefix(pathSegments: string[]): boolean {
+  const segments = withDatePrefix((pathSegments || []).map((seg) => String(seg)));
+  if (segments[0] !== 'date') return false;
+  if (segments.length === 1) return true;
+
+  if (segments[1] === 'preset') {
+    if (segments.length === 2) return true;
+    return segments.length === 3 && PRESET_KEYS.has(segments[2]);
+  }
+
+  if (segments[1] === 'relative') {
+    if (segments.length === 2) return true;
+    if (segments.length === 3) return RELATIVE_DIRECTIONS.has(segments[2]);
+    if (segments.length === 4) {
+      return RELATIVE_DIRECTIONS.has(segments[2]) && RELATIVE_UNITS.has(segments[3]);
+    }
+    if (segments.length === 5) {
+      return (
+        RELATIVE_DIRECTIONS.has(segments[2]) &&
+        RELATIVE_UNITS.has(segments[3]) &&
+        typeof parseNumberToken(segments[4]) === 'number'
+      );
+    }
+    return false;
+  }
+
+  if (segments[1] === 'exact') {
+    if (segments.length === 2) return true;
+
+    if (segments[2] === 'single') {
+      if (segments.length === 3) return true;
+      if (segments.length === 4) return segments[3] === 'date';
+      if (segments.length === 5) return segments[3] === 'date' && /^v.+/.test(segments[4]);
+      return false;
+    }
+
+    if (segments[2] === 'range') {
+      if (segments.length === 3) return true;
+      if (segments.length === 4) return segments[3] === 'date';
+      if (segments.length === 5) return segments[3] === 'date' && /^v.+/.test(segments[4]);
+      if (segments.length === 6) return segments[3] === 'date' && /^v.+/.test(segments[4]) && /^v.+/.test(segments[5]);
+      return false;
+    }
+
+    return false;
+  }
+
+  return false;
+}
+
+function withDatePrefix(pathSegments: string[]): string[] {
+  if (pathSegments[0] === 'date') {
+    return pathSegments;
+  }
+  return ['date', ...pathSegments];
+}
+
+function toCtxDateExpression(pathSegments: string[]): string {
+  const segs = withDatePrefix(pathSegments);
+  return `{{ ctx.${segs.join('.')} }}`;
+}
+
+function utf8ToBase64(input: string): string {
+  const globalBuffer = (globalThis as any)?.Buffer;
+  if (globalBuffer && typeof globalBuffer.from === 'function') {
+    return globalBuffer.from(input, 'utf8').toString('base64');
+  }
+
+  if (typeof btoa === 'function') {
+    const encoded = encodeURIComponent(input).replace(/%([0-9A-F]{2})/g, (_m, p1) =>
+      String.fromCharCode(parseInt(p1, 16)),
+    );
+    return btoa(encoded);
+  }
+
+  throw new Error('No base64 encoder available');
+}
+
+function base64ToUtf8(input: string): string {
+  const globalBuffer = (globalThis as any)?.Buffer;
+  if (globalBuffer && typeof globalBuffer.from === 'function') {
+    return globalBuffer.from(input, 'base64').toString('utf8');
+  }
+
+  if (typeof atob === 'function') {
+    const binary = atob(input);
+    const encoded = Array.from(binary)
+      .map((char) => `%${char.charCodeAt(0).toString(16).padStart(2, '0')}`)
+      .join('');
+    return decodeURIComponent(encoded);
+  }
+
+  throw new Error('No base64 decoder available');
+}
+
+function normalizeToString(value: any): string | undefined {
+  if (value == null) return undefined;
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : undefined;
+  }
+  if (dayjs.isDayjs(value)) {
+    return value.toISOString();
+  }
+  if (value instanceof Date) {
+    return dayjs(value).toISOString();
+  }
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return String(value);
+  }
+  return undefined;
+}
+
+function parseNumberToken(token: string): number | undefined {
+  const match = String(token || '').match(/^n(\d+)$/);
+  if (!match) return undefined;
+  const parsed = Number(match[1]);
+  if (!Number.isFinite(parsed) || parsed <= 0) return undefined;
+  return parsed;
+}
+
+function startOfIsoWeek(date: dayjs.Dayjs): dayjs.Dayjs {
+  const day = date.day();
+  const offset = day === 0 ? -6 : 1 - day;
+  return date.add(offset, 'day').startOf('day');
+}
+
+function startOfQuarter(date: dayjs.Dayjs): dayjs.Dayjs {
+  const month = date.month();
+  const quarterStartMonth = Math.floor(month / 3) * 3;
+  return date.month(quarterStartMonth).startOf('month');
+}
+
+export function encodeBase64Url(input: string): string {
+  const base64 = utf8ToBase64(String(input || ''));
+  return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+}
+
+export function decodeBase64Url(input: string): string | undefined {
+  try {
+    const raw = String(input || '').replace(/=+$/g, '');
+    if (!raw) return undefined;
+    if (!/^[A-Za-z0-9_-]+$/.test(raw)) return undefined;
+
+    const normalized = raw.replace(/-/g, '+').replace(/_/g, '/');
+    const padLength = normalized.length % 4 === 0 ? 0 : 4 - (normalized.length % 4);
+    const padded = `${normalized}${'='.repeat(padLength)}`;
+    const decoded = base64ToUtf8(padded);
+
+    if (encodeBase64Url(decoded) !== raw) return undefined;
+    return decoded;
+  } catch (_error) {
+    return undefined;
+  }
+}
+
+export function isCtxDateExpression(value: unknown): value is string {
+  if (typeof value !== 'string') return false;
+  return CTX_DATE_REGEX.test(value.trim());
+}
+
+export function isCompleteCtxDatePath(pathSegments: string[]): boolean {
+  if (!isCtxDatePathPrefix(pathSegments)) return false;
+  const segments = withDatePrefix((pathSegments || []).map((seg) => String(seg)));
+  if (segments[0] !== 'date') return false;
+
+  if (segments[1] === 'preset') {
+    return segments.length === 3 && PRESET_KEYS.has(segments[2]);
+  }
+
+  if (segments[1] === 'relative') {
+    if (segments.length !== 5) return false;
+    return (
+      RELATIVE_DIRECTIONS.has(segments[2]) &&
+      RELATIVE_UNITS.has(segments[3]) &&
+      typeof parseNumberToken(segments[4]) === 'number'
+    );
+  }
+
+  if (segments[1] === 'exact' && segments[2] === 'single' && segments[3] === 'date') {
+    return segments.length === 5 && /^v.+/.test(segments[4]);
+  }
+
+  if (segments[1] === 'exact' && segments[2] === 'range' && segments[3] === 'date') {
+    return segments.length === 6 && /^v.+/.test(segments[4]) && /^v.+/.test(segments[5]);
+  }
+
+  return false;
+}
+
+export function parseCtxDateExpression(value: unknown): any {
+  if (!isCtxDateExpression(value)) return undefined;
+  const segments = withDatePrefix(parseCtxDateSegments(value as string) || []);
+
+  if (segments[1] === 'preset' && segments.length === 3 && PRESET_KEYS.has(segments[2])) {
+    return { type: segments[2] };
+  }
+
+  if (
+    segments[1] === 'relative' &&
+    segments.length === 5 &&
+    RELATIVE_DIRECTIONS.has(segments[2]) &&
+    RELATIVE_UNITS.has(segments[3])
+  ) {
+    const amount = parseNumberToken(segments[4]);
+    if (typeof amount === 'number') {
+      return { type: segments[2], unit: segments[3], number: amount };
+    }
+    return undefined;
+  }
+
+  if (segments[1] === 'exact' && segments[2] === 'single' && segments[3] === 'date' && segments.length === 5) {
+    const raw = String(segments[4] || '');
+    if (!raw.startsWith('v')) return undefined;
+    return decodeBase64Url(raw.slice(1));
+  }
+
+  if (segments[1] === 'exact' && segments[2] === 'range' && segments[3] === 'date' && segments.length === 6) {
+    const leftRaw = String(segments[4] || '');
+    const rightRaw = String(segments[5] || '');
+    if (!leftRaw.startsWith('v') || !rightRaw.startsWith('v')) return undefined;
+    const left = decodeBase64Url(leftRaw.slice(1));
+    const right = decodeBase64Url(rightRaw.slice(1));
+    if (typeof left === 'undefined' || typeof right === 'undefined') return undefined;
+    return [left, right];
+  }
+
+  return undefined;
+}
+
+export function serializeCtxDateValue(value: unknown): string | undefined {
+  if (isCtxDateExpression(value)) {
+    return String(value).trim();
+  }
+
+  if (value == null || value === '') {
+    return undefined;
+  }
+
+  if (Array.isArray(value)) {
+    const start = normalizeToString(value[0]);
+    const end = normalizeToString(value[1]);
+    if (start && end) {
+      return toCtxDateExpression([
+        'date',
+        'exact',
+        'range',
+        'date',
+        `v${encodeBase64Url(start)}`,
+        `v${encodeBase64Url(end)}`,
+      ]);
+    }
+    if (start) {
+      return toCtxDateExpression(['date', 'exact', 'single', 'date', `v${encodeBase64Url(start)}`]);
+    }
+    return undefined;
+  }
+
+  if (typeof value === 'object' && value) {
+    const typed = value as { type?: unknown; unit?: unknown; number?: unknown };
+    const type = typeof typed.type === 'string' ? typed.type : '';
+
+    if (type === 'past' || type === 'next') {
+      const unit = typeof typed.unit === 'string' && RELATIVE_UNITS.has(typed.unit) ? typed.unit : 'day';
+      const rawNumber = Number(typed.number);
+      const number = Number.isFinite(rawNumber) && rawNumber > 0 ? Math.floor(rawNumber) : 1;
+      return toCtxDateExpression(['date', 'relative', type, unit, `n${number}`]);
+    }
+
+    if (PRESET_KEYS.has(type)) {
+      return toCtxDateExpression(['date', 'preset', type]);
+    }
+  }
+
+  const single = normalizeToString(value);
+  if (single) {
+    return toCtxDateExpression(['date', 'exact', 'single', 'date', `v${encodeBase64Url(single)}`]);
+  }
+  return undefined;
+}
+
+export function resolveCtxDatePath(pathSegments: string[]): any {
+  const segments = withDatePrefix((pathSegments || []).map((seg) => String(seg)));
+  if (segments[0] !== 'date') return undefined;
+
+  if (segments[1] === 'preset' && segments.length === 3) {
+    const key = segments[2];
+    if (key === 'now') {
+      return dayjs().toISOString();
+    }
+
+    const now = dayjs();
+
+    if (key === 'today') return now.format('YYYY-MM-DD');
+    if (key === 'yesterday') return now.add(-1, 'day').format('YYYY-MM-DD');
+    if (key === 'tomorrow') return now.add(1, 'day').format('YYYY-MM-DD');
+
+    if (key === 'thisWeek') return startOfIsoWeek(now).format('YYYY-MM-DD');
+    if (key === 'lastWeek') return startOfIsoWeek(now.add(-1, 'week')).format('YYYY-MM-DD');
+    if (key === 'nextWeek') return startOfIsoWeek(now.add(1, 'week')).format('YYYY-MM-DD');
+
+    if (key === 'thisMonth') return now.startOf('month').format('YYYY-MM-DD');
+    if (key === 'lastMonth') return now.add(-1, 'month').startOf('month').format('YYYY-MM-DD');
+    if (key === 'nextMonth') return now.add(1, 'month').startOf('month').format('YYYY-MM-DD');
+
+    if (key === 'thisQuarter') return startOfQuarter(now).format('YYYY-MM-DD');
+    if (key === 'lastQuarter') return startOfQuarter(now.add(-3, 'month')).format('YYYY-MM-DD');
+    if (key === 'nextQuarter') return startOfQuarter(now.add(3, 'month')).format('YYYY-MM-DD');
+
+    if (key === 'thisYear') return now.startOf('year').format('YYYY-MM-DD');
+    if (key === 'lastYear') return now.add(-1, 'year').startOf('year').format('YYYY-MM-DD');
+    if (key === 'nextYear') return now.add(1, 'year').startOf('year').format('YYYY-MM-DD');
+
+    return undefined;
+  }
+
+  if (
+    segments[1] === 'relative' &&
+    segments.length === 5 &&
+    RELATIVE_DIRECTIONS.has(segments[2]) &&
+    RELATIVE_UNITS.has(segments[3])
+  ) {
+    const amount = parseNumberToken(segments[4]);
+    if (typeof amount !== 'number') return undefined;
+    const direction = segments[2] === 'past' ? -1 : 1;
+    const unit = segments[3] as dayjs.ManipulateType;
+    return dayjs()
+      .add(direction * amount, unit)
+      .format('YYYY-MM-DD');
+  }
+
+  if (segments[1] === 'exact' && segments[2] === 'single' && segments[3] === 'date' && segments.length === 5) {
+    const token = String(segments[4] || '');
+    if (!token.startsWith('v')) return undefined;
+    return decodeBase64Url(token.slice(1));
+  }
+
+  if (segments[1] === 'exact' && segments[2] === 'range' && segments[3] === 'date' && segments.length === 6) {
+    const leftToken = String(segments[4] || '');
+    const rightToken = String(segments[5] || '');
+    if (!leftToken.startsWith('v') || !rightToken.startsWith('v')) return undefined;
+    const left = decodeBase64Url(leftToken.slice(1));
+    const right = decodeBase64Url(rightToken.slice(1));
+    if (typeof left === 'undefined' || typeof right === 'undefined') return undefined;
+    return [left, right];
+  }
+
+  return undefined;
+}

package/src/utils/exceptions.ts

@@ -34,3 +34,14 @@ export class FlowExitAllException extends Error {
     this.modelUid = modelUid;
   }
 }
+
+/**
+ * 取消当前保存但保持设置弹窗打开
+ * 用于“保存前确认”场景，用户取消时不应关闭弹窗也不应提示错误
+ */
+export class FlowCancelSaveException extends Error {
+  constructor(message = 'Flow settings save cancelled.') {
+    super(message);
+    this.name = 'FlowCancelSaveException';
+  }
+}

package/src/utils/index.ts

@@ -22,7 +22,7 @@ export {
 export { escapeT, getT, tExpr } from './translation';
 
 // 异常类
-export { FlowExitException } from './exceptions';
+export { FlowCancelSaveException, FlowExitException } from './exceptions';
 
 // 流程定义相关
 export { defineAction } from './flow-definitions';
@@ -34,7 +34,13 @@ export { isInheritedFrom } from './inheritance';
 export { resolveCreateModelOptions, resolveDefaultParams, resolveExpressions } from './params-resolvers';
 
 // Schema 工具
-export { compileUiSchema, resolveStepUiSchema, resolveUiMode, shouldHideStepInSettings } from './schema-utils';
+export {
+  compileUiSchema,
+  resolveStepUiSchema,
+  resolveStepDisabledInSettings,
+  resolveUiMode,
+  shouldHideStepInSettings,
+} from './schema-utils';
 
 // Runtime Context Steps 设置
 export { setupRuntimeContextSteps } from './setupRuntimeContextSteps';
@@ -59,9 +65,34 @@ export { extractPropertyPath, formatPathToVariable, isVariableExpression } from
 
 export { clearAutoFlowError, getAutoFlowError, setAutoFlowError, type AutoFlowError } from './autoFlowError';
 export { parsePathnameToViewParams, type ViewParam } from './parsePathnameToViewParams';
+export {
+  decodeBase64Url,
+  encodeBase64Url,
+  isCompleteCtxDatePath,
+  isCtxDatePathPrefix,
+  isCtxDateExpression,
+  parseCtxDateExpression,
+  resolveCtxDatePath,
+  serializeCtxDateValue,
+} from './dateVariable';
 
 // 安全全局对象（window/document）
-export { createSafeDocument, createSafeWindow, createSafeNavigator } from './safeGlobals';
+export {
+  createSafeDocument,
+  createSafeWindow,
+  createSafeNavigator,
+  createSafeRunJSGlobals,
+  runjsWithSafeGlobals,
+} from './safeGlobals';
+
+// RunJS value helpers
+export { isRunJSValue, normalizeRunJSValue, extractUsedVariablePathsFromRunJS, type RunJSValue } from './runjsValue';
+
+// RunJS helpers
+export { resolveRunJSObjectValues } from './resolveRunJSObjectValues';
+
+// RunJS 代码兼容预处理（{{ }}）与 JSX 编译
+export { prepareRunJsCode, preprocessRunJsTemplates } from './runjsTemplateCompat';
 
 // Ephemeral context helper（用于临时注入属性/方法，避免污染父级 ctx）
 export { createEphemeralContext } from './createEphemeralContext';
@@ -69,3 +100,6 @@ export { createEphemeralContext } from './createEphemeralContext';
 // Filter helpers
 export { pruneFilter } from './pruneFilter';
 export { isBeforeRenderFlow } from './flows';
+
+// Module URL resolver
+export { resolveModuleUrl, isCssFile } from './resolveModuleUrl';