@variojs/core 0.1.0

package/src/vm/handlers/array/utils.ts

@@ -0,0 +1,41 @@
+/**
+ * 数组指令工具函数
+ */
+
+import type { RuntimeContext } from '@/types.js'
+import { evaluate } from '@/expression/evaluate.js'
+
+/**
+ * 递归求值对象/数组中的表达式
+ * 支持在对象属性和数组元素中使用 {{ expression }} 格式
+ */
+export function evaluateExpressionsRecursively(
+  value: any,
+  ctx: RuntimeContext
+): any {
+  // 字符串：检查是否为表达式
+  if (typeof value === 'string') {
+    if (value.startsWith('{{') && value.endsWith('}}')) {
+      const expr = value.slice(2, -2).trim()
+      return evaluate(expr, ctx)
+    }
+    return value
+  }
+  
+  // 数组：递归处理每个元素
+  if (Array.isArray(value)) {
+    return value.map(item => evaluateExpressionsRecursively(item, ctx))
+  }
+  
+  // 对象：递归处理每个属性值
+  if (value && typeof value === 'object') {
+    const result: Record<string, any> = {}
+    for (const [key, val] of Object.entries(value)) {
+      result[key] = evaluateExpressionsRecursively(val, ctx)
+    }
+    return result
+  }
+  
+  // 其他类型：直接返回
+  return value
+}

package/src/vm/handlers/batch.ts

@@ -0,0 +1,57 @@
+/**
+ * batch 动作处理器
+ * 
+ * 功能：批量执行动作（保证原子性）
+ * 示例：{ "type": "batch", "actions": [...] }
+ */
+
+import type { RuntimeContext, Action } from '@/types.js'
+import { ActionError, BatchError, ErrorCodes } from '@/errors.js'
+import { execute } from '../executor.js'
+
+/**
+ * 处理 batch 动作
+ */
+export async function handleBatch(
+  ctx: RuntimeContext,
+  action: Action
+): Promise<void> {
+  const { actions } = action
+  
+  if (!actions || !Array.isArray(actions)) {
+    throw new ActionError(
+      action,
+      'batch action requires "actions" parameter (array)',
+      ErrorCodes.ACTION_MISSING_PARAM,
+      { metadata: { param: 'actions' } }
+    )
+  }
+  
+  const errors: Array<{ action: Action; error: Error }> = []
+  
+  // 批量执行，收集错误
+  for (const act of actions) {
+    try {
+      await execute([act], ctx)
+    } catch (error: unknown) {
+      errors.push({
+        action: act,
+        error: error instanceof Error ? error : new Error(String(error))
+      })
+    }
+  }
+  
+  // 如果有错误，抛出 BatchError
+  if (errors.length > 0) {
+    throw new BatchError(
+      errors,
+      `${errors.length} actions failed in batch`,
+      {
+        metadata: {
+          failedCount: errors.length,
+          totalCount: actions.length
+        }
+      }
+    )
+  }
+}

package/src/vm/handlers/call.ts

@@ -0,0 +1,92 @@
+/**
+ * call 动作处理器
+ * 
+ * 功能：调用 method（通过 $methods）
+ * 示例：{ "type": "call", "method": "services.fetchUser", "params": {...}, "resultTo": "user" }
+ * 
+ * 参考文档：action-reference.md - call 动作
+ */
+
+import type { RuntimeContext, Action } from '@/types.js'
+import { ActionError, ServiceError, ErrorCodes } from '@/errors.js'
+import { evaluate } from '@/expression/evaluate.js'
+import { invalidateCache } from '@/expression/cache.js'
+
+/**
+ * 处理 call 动作
+ */
+export async function handleCall(
+  ctx: RuntimeContext,
+  action: Action
+): Promise<unknown> {
+  const method = action.method as string | undefined
+  const params = (action.params || {}) as Record<string, unknown>
+  const resultTo = action.resultTo as string | undefined
+  
+  if (!method || typeof method !== 'string') {
+    throw new ActionError(
+      action,
+      'call action requires "method" parameter',
+      ErrorCodes.ACTION_MISSING_PARAM,
+      { metadata: { param: 'method' } }
+    )
+  }
+  
+  // 查找方法（通过 $methods）
+  const handler = ctx.$methods[method]
+  if (!handler) {
+    throw new ServiceError(
+      method,
+      `Method "${method}" not found in $methods`,
+      undefined,
+      {
+        metadata: { method }
+      }
+    )
+  }
+  
+  // 求值参数（支持表达式）
+  const finalParams: Record<string, unknown> = {}
+  
+  try {
+    for (const [key, value] of Object.entries(params)) {
+      if (typeof value === 'string' && value.startsWith('{{') && value.endsWith('}}')) {
+        const expr = value.slice(2, -2).trim()
+        finalParams[key] = evaluate(expr, ctx)
+      } else {
+        finalParams[key] = value
+      }
+    }
+    
+    // 调用 method
+    const result = await handler(ctx, finalParams)
+    
+    // 如果指定了 resultTo，保存结果到状态
+    if (resultTo) {
+      ctx._set(resultTo, result)
+      invalidateCache(resultTo, ctx)
+    }
+    
+    return result
+  } catch (error: unknown) {
+    // 如果错误已经是 ServiceError，直接抛出
+    if (error instanceof ServiceError) {
+      throw error
+    }
+    
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    const originalError = error instanceof Error ? error : undefined
+    
+    throw new ServiceError(
+      method,
+      `Service call failed: ${errorMessage}`,
+      originalError,
+      {
+        metadata: {
+          method,
+          params: finalParams
+        }
+      }
+    )
+  }
+}

package/src/vm/handlers/emit.ts

@@ -0,0 +1,39 @@
+/**
+ * emit 动作处理器
+ * 
+ * 功能：触发事件
+ * 示例：{ "type": "emit", "event": "submit", "data": { "userId": 123 } }
+ */
+
+import type { RuntimeContext, Action } from '@/types.js'
+import { ActionError, ErrorCodes } from '@/errors.js'
+import { evaluate } from '@/expression/evaluate.js'
+
+/**
+ * 处理 emit 动作
+ */
+export async function handleEmit(
+  ctx: RuntimeContext,
+  action: Action
+): Promise<void> {
+  const { event, data } = action
+  
+  if (!event || typeof event !== 'string') {
+    throw new ActionError(
+      action,
+      'emit action requires "event" parameter',
+      ErrorCodes.ACTION_MISSING_PARAM,
+      { metadata: { param: 'event' } }
+    )
+  }
+  
+  // 求值 data（支持表达式）
+  let finalData = data
+  if (typeof data === 'string' && data.startsWith('{{') && data.endsWith('}}')) {
+    const expr = data.slice(2, -2).trim()
+    finalData = evaluate(expr, ctx)
+  }
+  
+  // 触发事件
+  ctx.$emit(event, finalData)
+}

package/src/vm/handlers/if.ts

@@ -0,0 +1,48 @@
+/**
+ * if 动作处理器
+ * 
+ * 功能：条件分支
+ * 示例：{ "type": "if", "cond": "user.age > 18", "then": [...], "else": [...] }
+ * 示例：{ "type": "if", "cond": "{{ counter < 10 }}", "then": [...], "else": [...] }
+ */
+
+import type { RuntimeContext, Action } from '@/types.js'
+import { ActionError, ErrorCodes } from '@/errors.js'
+import { evaluate, extractExpression } from '@/expression/index.js'
+import { execute } from '../executor.js'
+
+/**
+ * 处理 if 动作
+ */
+export async function handleIf(
+  ctx: RuntimeContext,
+  action: Action
+): Promise<void> {
+  const { cond, then, else: elseBranch } = action
+  
+  if (!cond || typeof cond !== 'string') {
+    throw new ActionError(
+      action,
+      'if action requires "cond" parameter',
+      ErrorCodes.ACTION_MISSING_PARAM,
+      { metadata: { param: 'cond' } }
+    )
+  }
+  
+  // 提取表达式（支持 {{ }} 格式）
+  const condExpr = extractExpression(cond)
+  
+  // 求值条件表达式
+  const condition = evaluate(condExpr, ctx)
+  
+  // 执行对应的分支
+  if (condition) {
+    if (then && Array.isArray(then)) {
+      await execute(then, ctx)
+    }
+  } else {
+    if (elseBranch && Array.isArray(elseBranch)) {
+      await execute(elseBranch, ctx)
+    }
+  }
+}

package/src/vm/handlers/index.ts

@@ -0,0 +1,52 @@
+/**
+ * 内置动作处理器
+ * 
+ * 所有内置动作统一注册到 ctx.$methods
+ */
+
+import type { RuntimeContext, MethodHandler } from '@/types.js'
+import { handleSet } from './set.js'
+import { handleEmit } from './emit.js'
+import { handleIf } from './if.js'
+import { handleLoop } from './loop.js'
+import { handleCall } from './call.js'
+import { handleBatch } from './batch.js'
+import { handleNavigate } from './navigate.js'
+import { handleLog } from './log.js'
+import { handlePush } from './array/push.js'
+import { handlePop } from './array/pop.js'
+import { handleShift } from './array/shift.js'
+import { handleUnshift } from './array/unshift.js'
+import { handleSplice } from './array/splice.js'
+
+/**
+ * 注册所有内置动作到 $methods
+ */
+export function registerBuiltinMethods(ctx: RuntimeContext): void {
+  // 动作处理器作为特殊的方法注册，参数是 Action
+  ctx.$methods = {
+    // 原子动作
+    'set': handleSet as MethodHandler,
+    'emit': handleEmit as MethodHandler,
+    'navigate': handleNavigate as MethodHandler,
+    'log': handleLog as MethodHandler,
+    
+    // 控制流动作
+    'if': handleIf as MethodHandler,
+    'loop': handleLoop as MethodHandler,
+    
+    // 复合动作
+    'call': handleCall as MethodHandler,
+    'batch': handleBatch as MethodHandler,
+    
+    // 数组操作动作
+    'push': handlePush as MethodHandler,
+    'pop': handlePop as MethodHandler,
+    'shift': handleShift as MethodHandler,
+    'unshift': handleUnshift as MethodHandler,
+    'splice': handleSplice as MethodHandler,
+    
+    // 保留已有的方法（允许覆盖或扩展）
+    ...ctx.$methods
+  }
+}

package/src/vm/handlers/log.ts

@@ -0,0 +1,54 @@
+/**
+ * log 动作处理器
+ * 
+ * 功能：调试输出
+ * 示例：{ "type": "log", "level": "info", "message": "User logged in" }
+ */
+
+import type { RuntimeContext, Action } from '@/types.js'
+import { ActionError, ErrorCodes } from '@/errors.js'
+import { evaluate } from '@/expression/evaluate.js'
+
+/**
+ * 处理 log 动作
+ */
+export async function handleLog(
+  ctx: RuntimeContext,
+  action: Action
+): Promise<void> {
+  const { level = 'info', message } = action
+  
+  if (!message) {
+    throw new ActionError(
+      action,
+      'log action requires "message" parameter',
+      ErrorCodes.ACTION_MISSING_PARAM,
+      { metadata: { param: 'message' } }
+    )
+  }
+  
+  // 求值 message（支持表达式）
+  let finalMessage: unknown = message
+  if (typeof message === 'string' && message.startsWith('{{') && message.endsWith('}}')) {
+    const expr = message.slice(2, -2).trim()
+    finalMessage = evaluate(expr, ctx)
+  }
+  
+  // 输出日志（将 finalMessage 转换为字符串）
+  const logLevel = String(level).toLowerCase()
+  const messageStr = String(finalMessage)
+  if (typeof console !== 'undefined') {
+    switch (logLevel) {
+      case 'error':
+        console.error('[Vario]', messageStr)
+        break
+      case 'warn':
+        console.warn('[Vario]', messageStr)
+        break
+      case 'info':
+      default:
+        console.log('[Vario]', messageStr)
+        break
+    }
+  }
+}

package/src/vm/handlers/loop.ts

@@ -0,0 +1,102 @@
+/**
+ * loop 动作处理器
+ * 
+ * 功能：循环执行
+ * 示例：{ "type": "loop", "var": "item", "in": "items", "body": [...] }
+ */
+
+import type { RuntimeContext, Action } from '@/types.js'
+import { ActionError, ErrorCodes } from '@/errors.js'
+import { evaluate } from '@/expression/evaluate.js'
+import { invalidateCache } from '@/expression/cache.js'
+import { execute } from '../executor.js'
+import { createLoopContext, releaseLoopContext } from '@/runtime/loop-context-pool.js'
+
+/**
+ * 处理 loop 动作
+ */
+export async function handleLoop(
+  ctx: RuntimeContext,
+  action: Action
+): Promise<void> {
+  const { var: varName, in: inExpr, body } = action
+  
+  if (!varName || typeof varName !== 'string') {
+    throw new ActionError(
+      action,
+      'loop action requires "var" parameter',
+      ErrorCodes.ACTION_MISSING_PARAM,
+      { metadata: { param: 'var' } }
+    )
+  }
+  
+  if (!inExpr || typeof inExpr !== 'string') {
+    throw new ActionError(
+      action,
+      'loop action requires "in" parameter',
+      ErrorCodes.ACTION_MISSING_PARAM,
+      { metadata: { param: 'in' } }
+    )
+  }
+  
+  if (!body || !Array.isArray(body)) {
+    throw new ActionError(
+      action,
+      'loop action requires "body" parameter (array of actions)',
+      ErrorCodes.ACTION_MISSING_PARAM,
+      { metadata: { param: 'body' } }
+    )
+  }
+  
+  // 求值 in 表达式，获取要遍历的数组或对象
+  const iterable = evaluate(inExpr, ctx)
+  
+  if (iterable == null) {
+    return
+  }
+  
+  // 遍历数组
+  if (Array.isArray(iterable)) {
+    for (let i = 0; i < iterable.length; i++) {
+      // 使用对象池创建循环上下文
+      const loopCtx = createLoopContext(ctx, iterable[i], i)
+      loopCtx[varName] = iterable[i]
+      
+      try {
+        // 触发缓存失效，确保表达式重新求值
+        invalidateCache(varName, loopCtx)
+        await execute(body, loopCtx)
+      } finally {
+        // 释放循环上下文回对象池
+        releaseLoopContext(loopCtx)
+      }
+    }
+  }
+  // 遍历对象
+  else if (typeof iterable === 'object' && iterable !== null) {
+    const entries = Object.entries(iterable)
+    for (let i = 0; i < entries.length; i++) {
+      const [, value] = entries[i]
+      // 使用对象池创建循环上下文
+      const loopCtx = createLoopContext(ctx, value, i)
+      loopCtx[varName] = value
+      
+      try {
+        // 触发缓存失效，确保表达式重新求值
+        invalidateCache(varName, loopCtx)
+        await execute(body, loopCtx)
+      } finally {
+        // 释放循环上下文回对象池
+        releaseLoopContext(loopCtx)
+      }
+    }
+  }
+  else {
+    throw new ActionError(
+      action,
+      `loop "in" expression must evaluate to an array or object, got ${typeof iterable}`,
+      ErrorCodes.ACTION_INVALID_PARAM,
+      { metadata: { param: 'in', actualType: typeof iterable } }
+    )
+  }
+}

package/src/vm/handlers/navigate.ts

@@ -0,0 +1,64 @@
+/**
+ * navigate 动作处理器
+ * 
+ * 功能：路由导航
+ * 示例：{ "type": "navigate", "to": "/users/123" }
+ */
+
+import type { RuntimeContext, Action } from '@/types.js'
+import { ActionError, ErrorCodes } from '@/errors.js'
+import { evaluate } from '@/expression/evaluate.js'
+
+/**
+ * 处理 navigate 动作
+ */
+export async function handleNavigate(
+  ctx: RuntimeContext,
+  action: Action
+): Promise<void> {
+  const { to } = action
+  
+  if (!to || typeof to !== 'string') {
+    throw new ActionError(
+      action,
+      'navigate action requires "to" parameter',
+      ErrorCodes.ACTION_MISSING_PARAM,
+      { metadata: { param: 'to' } }
+    )
+  }
+  
+  // 求值 to（支持表达式）
+  let finalTo: string = to
+  if (to.startsWith('{{') && to.endsWith('}}')) {
+    const expr = to.slice(2, -2).trim()
+    const result = evaluate(expr, ctx)
+    if (typeof result !== 'string') {
+      throw new ActionError(
+        action,
+        `navigate "to" expression must evaluate to a string, got ${typeof result}`,
+        ErrorCodes.ACTION_INVALID_PARAM,
+        { metadata: { param: 'to', actualType: typeof result } }
+      )
+    }
+    finalTo = result
+  }
+  
+  // 调用路由导航方法（如果已注册）
+  const navigateHandler = ctx.$methods['navigate'] || ctx.$methods['$navigate']
+  if (navigateHandler) {
+    await navigateHandler(ctx, { to: finalTo })
+  } else {
+    // 如果没有注册导航方法，使用默认行为（浏览器导航）
+    // 使用类型安全的 window 访问
+    if (typeof window !== 'undefined' && (window as { location?: { href: string } }).location) {
+      ((window as unknown) as { location: { href: string } }).location.href = finalTo
+    } else {
+      throw new ActionError(
+        action,
+        'navigate method not registered and window.location is not available',
+        ErrorCodes.ACTION_EXECUTION_ERROR,
+        { metadata: { reason: 'navigate_not_available' } }
+      )
+    }
+  }
+}

package/src/vm/handlers/set.ts

@@ -0,0 +1,43 @@
+/**
+ * set 动作处理器
+ * 
+ * 功能：修改状态
+ * 示例：{ "type": "set", "path": "user.name", "value": "张三" }
+ * 
+ * 注意：缓存失效通过 RuntimeContext 的 onStateChange 钩子处理
+ * 框架集成层应在创建上下文时注册该钩子
+ */
+
+import type { RuntimeContext, Action } from '@/types.js'
+import { ActionError, ErrorCodes } from '@/errors.js'
+import { evaluate } from '@/expression/evaluate.js'
+
+/**
+ * 处理 set 动作
+ */
+export async function handleSet(
+  ctx: RuntimeContext,
+  action: Action
+): Promise<void> {
+  const { path, value } = action
+  
+  if (!path || typeof path !== 'string') {
+    throw new ActionError(
+      action,
+      'set action requires "path" parameter',
+      ErrorCodes.ACTION_MISSING_PARAM,
+      { metadata: { param: 'path' } }
+    )
+  }
+  
+  // 求值 value（支持表达式）
+  let finalValue = value
+  if (typeof value === 'string' && value.startsWith('{{') && value.endsWith('}}')) {
+    // 表达式插值：{{ user.age + 1 }}
+    const expr = value.slice(2, -2).trim()
+    finalValue = evaluate(expr, ctx)
+  }
+  
+  // 设置状态（缓存失效通过 onStateChange 钩子自动处理）
+  ctx._set(path, finalValue)
+}

package/src/vm/index.ts

@@ -0,0 +1,8 @@
+/**
+ * VM 模块导出
+ */
+
+export { execute } from './executor.js'
+export type { ExecuteOptions } from './executor.js'
+export { registerBuiltinMethods } from './handlers/index.js'
+export * from './errors.js'

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "baseUrl": "./src",
+    "paths": {
+      "@/*": ["./*"]
+    },
+    "types": ["node"],
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": false,
+    "preserveSymlinks": false
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,30 @@
+import { defineConfig } from 'vitest/config'
+import { resolve } from 'path'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['__tests__/**/*.test.ts'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      exclude: ['**/*.test.ts', '**/__tests__/**', '**/test/**']
+    }
+  },
+  resolve: {
+    alias: {
+      '@': resolve(__dirname, './src')
+    },
+    // 确保相对路径导入能正确解析（支持 .ts 文件）
+    extensions: ['.ts', '.tsx', '.js', '.jsx', '.json']
+  },
+  // 确保 TypeScript 文件正确解析
+  esbuild: {
+    target: 'node18'
+  },
+  // 配置 Vite 的依赖优化
+  optimizeDeps: {
+    include: ['@babel/parser', '@babel/types']
+  }
+})