@variojs/core 0.1.0

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@variojs/core",
+  "version": "0.1.0",
+  "description": "Vario Core Runtime - Instruction VM, Expression System, Runtime Context",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "postbuild": "tsc-alias",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.23.6",
+    "@babel/types": "^7.23.6"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/errors.ts

@@ -0,0 +1,194 @@
+/**
+ * Vario 错误处理体系
+ * 
+ * 统一的错误基类和错误码系统
+ */
+
+import type { Action } from './types.js'
+
+/**
+ * 错误上下文信息
+ */
+export interface ErrorContext {
+  /** Schema 路径（如 "events.click[0]"） */
+  schemaPath?: string
+  /** 表达式字符串 */
+  expression?: string
+  /** 动作对象 */
+  action?: Action
+  /** 调用栈（简化版） */
+  stack?: string[]
+  /** 额外上下文信息 */
+  metadata?: Record<string, unknown>
+}
+
+/**
+ * Vario 错误基类
+ * 
+ * 所有 Vario 相关错误都应继承此类
+ */
+export class VarioError extends Error {
+  /** 错误码 */
+  public readonly code: string
+  /** 错误上下文 */
+  public readonly context: ErrorContext
+
+  constructor(
+    message: string,
+    code: string,
+    context: ErrorContext = {}
+  ) {
+    super(message)
+    this.name = 'VarioError'
+    this.code = code
+    this.context = context
+    
+    // 确保 stack 属性存在
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, VarioError)
+    }
+  }
+
+  /**
+   * 获取友好的错误消息
+   */
+  getFriendlyMessage(): string {
+    const parts: string[] = [this.message]
+    
+    if (this.context.schemaPath) {
+      parts.push(`\n  Schema 路径: ${this.context.schemaPath}`)
+    }
+    
+    if (this.context.expression) {
+      parts.push(`\n  表达式: ${this.context.expression}`)
+    }
+    
+    if (this.context.action) {
+      parts.push(`\n  动作类型: ${this.context.action.type}`)
+    }
+    
+    return parts.join('')
+  }
+
+  /**
+   * 转换为 JSON（用于序列化）
+   */
+  toJSON(): Record<string, unknown> {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      context: this.context,
+      stack: this.stack
+    }
+  }
+}
+
+/**
+ * 动作执行错误
+ */
+export class ActionError extends VarioError {
+  constructor(
+    action: Action,
+    message: string,
+    code: string = 'ACTION_ERROR',
+    context: Omit<ErrorContext, 'action'> = {}
+  ) {
+    super(message, code, {
+      ...context,
+      action
+    })
+    this.name = 'ActionError'
+  }
+}
+
+/**
+ * 表达式求值错误
+ */
+export class ExpressionError extends VarioError {
+  constructor(
+    expression: string,
+    message: string,
+    code: string = 'EXPRESSION_ERROR',
+    context: Omit<ErrorContext, 'expression'> = {}
+  ) {
+    super(message, code, {
+      ...context,
+      expression
+    })
+    this.name = 'ExpressionError'
+  }
+}
+
+/**
+ * 服务调用错误
+ */
+export class ServiceError extends VarioError {
+  public readonly service: string
+  public readonly originalError?: Error
+
+  constructor(
+    service: string,
+    message: string,
+    originalError?: Error,
+    context: ErrorContext = {}
+  ) {
+    super(message, 'SERVICE_ERROR', context)
+    this.name = 'ServiceError'
+    this.service = service
+    this.originalError = originalError
+  }
+}
+
+/**
+ * 批量执行错误
+ */
+export class BatchError extends VarioError {
+  public readonly failedActions: Array<{ action: Action; error: Error }>
+
+  constructor(
+    failedActions: Array<{ action: Action; error: Error }>,
+    message: string,
+    context: ErrorContext = {}
+  ) {
+    super(message, 'BATCH_ERROR', context)
+    this.name = 'BatchError'
+    this.failedActions = failedActions
+  }
+}
+
+/**
+ * 错误码定义
+ */
+export const ErrorCodes = {
+  // 动作相关错误
+  ACTION_UNKNOWN_TYPE: 'ACTION_UNKNOWN_TYPE',
+  ACTION_EXECUTION_ERROR: 'ACTION_EXECUTION_ERROR',
+  ACTION_ABORTED: 'ACTION_ABORTED',
+  ACTION_TIMEOUT: 'ACTION_TIMEOUT',
+  ACTION_MAX_STEPS_EXCEEDED: 'ACTION_MAX_STEPS_EXCEEDED',
+  ACTION_MISSING_PARAM: 'ACTION_MISSING_PARAM',
+  ACTION_INVALID_PARAM: 'ACTION_INVALID_PARAM',
+  
+  // 表达式相关错误
+  EXPRESSION_PARSE_ERROR: 'EXPRESSION_PARSE_ERROR',
+  EXPRESSION_VALIDATION_ERROR: 'EXPRESSION_VALIDATION_ERROR',
+  EXPRESSION_EVALUATION_ERROR: 'EXPRESSION_EVALUATION_ERROR',
+  EXPRESSION_TIMEOUT: 'EXPRESSION_TIMEOUT',
+  EXPRESSION_MAX_STEPS_EXCEEDED: 'EXPRESSION_MAX_STEPS_EXCEEDED',
+  EXPRESSION_UNSAFE_ACCESS: 'EXPRESSION_UNSAFE_ACCESS',
+  EXPRESSION_FUNCTION_NOT_WHITELISTED: 'EXPRESSION_FUNCTION_NOT_WHITELISTED',
+  
+  // 服务相关错误
+  SERVICE_NOT_FOUND: 'SERVICE_NOT_FOUND',
+  SERVICE_CALL_ERROR: 'SERVICE_CALL_ERROR',
+  
+  // 批量执行错误
+  BATCH_ERROR: 'BATCH_ERROR',
+  
+  // Schema 相关错误
+  SCHEMA_VALIDATION_ERROR: 'SCHEMA_VALIDATION_ERROR',
+  SCHEMA_INVALID_ACTION: 'SCHEMA_INVALID_ACTION',
+} as const
+
+export type ErrorCode = typeof ErrorCodes[keyof typeof ErrorCodes]

package/src/expression/README.md

@@ -0,0 +1,192 @@
+# Vario 表达式系统
+
+## 概述
+
+Vario 表达式系统是一个安全、强大的表达式求值引擎，支持复杂的条件判断、数据访问和计算。
+
+## 支持的语法
+
+### 1. 基础表达式
+
+```javascript
+// 变量访问
+showContent
+userRole
+count
+
+// 字面量
+123
+"hello"
+true
+false
+null
+```
+
+### 2. 成员访问
+
+```javascript
+// 对象属性
+user.name
+user.profile.email
+
+// 数组访问
+todos[0]
+items[index]
+
+// 可选链（安全访问）
+user?.profile?.name
+```
+
+### 3. 二元运算
+
+```javascript
+// 算术运算
+count + 1
+price * quantity
+total / items.length
+
+// 比较运算
+count > 10
+userRole === "admin"
+age >= 18
+name !== ""
+
+// 逻辑运算
+showContent && userRole === "admin"
+count > 0 || isActive
+```
+
+### 4. 逻辑表达式
+
+```javascript
+// AND
+userRole === "admin" && showContent
+count > 10 && items.length > 0
+
+// OR
+userRole === "admin" || userRole === "user"
+isActive || isEnabled
+
+// 空值合并
+name ?? "Guest"
+value ?? defaultValue
+```
+
+### 5. 三元表达式
+
+```javascript
+// 条件表达式
+count > 10 ? "high" : "low"
+userRole === "admin" ? "Admin" : "User"
+showContent ? "visible" : "hidden"
+```
+
+### 6. 函数调用（白名单）
+
+```javascript
+// 数组方法
+Array.isArray(items)
+todos.length
+items.filter(item => item.active).length
+
+// 数学函数
+Math.max(a, b)
+Math.min(x, y)
+Math.round(value)
+
+// 字符串方法（通过属性访问）
+name.length
+message.toUpperCase()
+```
+
+### 7. 复杂条件示例
+
+```javascript
+// 多条件组合
+userRole === "admin" && showContent && count > 10
+
+// 嵌套条件
+(userRole === "admin" || userRole === "user") && isActive
+
+// 数组操作
+todos.length > 0 && todos.filter(t => t.completed).length > 0
+
+// 对象属性检查
+user && user.profile && user.profile.email
+user?.profile?.email  // 使用可选链更简洁
+```
+
+## 在 Schema 中使用
+
+### cond 条件渲染
+
+```json
+{
+  "type": "ElAlert",
+  "cond": "{{ userRole === 'admin' && showContent }}",
+  "props": { "type": "success" },
+  "children": "Admin content"
+}
+```
+
+### show 可见性控制
+
+```json
+{
+  "type": "ElCard",
+  "show": "{{ showContent && items.length > 0 }}",
+  "children": "Content"
+}
+```
+
+### props 中的表达式
+
+```json
+{
+  "type": "ElInput",
+  "props": {
+    "placeholder": "{{ userRole === 'admin' ? 'Admin input' : 'User input' }}",
+    "disabled": "{{ !isActive }}"
+  }
+}
+```
+
+### 循环中的表达式
+
+```json
+{
+  "type": "div",
+  "loop": {
+    "items": "{{ todos.filter(t => !t.completed) }}"
+  },
+  "children": "{{ $record.text }}"
+}
+```
+
+## 安全特性
+
+1. **白名单验证**：只允许安全的 AST 节点类型
+2. **禁止危险操作**：不允许赋值、函数定义、this 访问等
+3. **执行限制**：最大步数和超时限制，防止无限循环
+4. **沙箱隔离**：禁止访问全局对象和危险属性
+
+## 性能优化
+
+1. **表达式缓存**：相同表达式的求值结果会被缓存
+2. **依赖追踪**：自动追踪表达式依赖的状态路径
+3. **缓存失效**：状态更新时自动失效相关缓存
+
+## 限制
+
+1. **不支持赋值**：`a = b` 不允许
+2. **不支持函数定义**：`() => {}` 不允许
+3. **不支持 this**：`this.value` 不允许
+4. **不支持 new**：`new Date()` 不允许（但可以使用 Date.now()）
+5. **函数调用受限**：只能调用白名单中的函数
+
+## 最佳实践
+
+1. **使用可选链**：`user?.profile?.name` 比 `user && user.profile && user.profile.name` 更简洁
+2. **简化条件**：将复杂条件拆分为多个简单条件
+3. **利用缓存**：相同表达式会自动缓存，无需担心性能
+4. **类型安全**：表达式结果类型在运行时确定，使用时注意类型检查

package/src/expression/cache.ts

@@ -0,0 +1,199 @@
+/**
+ * 表达式缓存系统
+ * 
+ * 功能：
+ * - 每个 RuntimeContext 独立缓存（WeakMap 关联）
+ * - LRU 淘汰策略
+ * - 通配符依赖匹配
+ * - 缓存失效机制
+ * 
+ * 设计原则：
+ * - 惰性求值：只在需要时计算
+ * - 依赖追踪：精确的缓存失效
+ * - 内存友好：WeakMap + LRU 淘汰
+ */
+
+import type { RuntimeContext, ExpressionCache } from '../types.js'
+import { matchPath } from '../runtime/path.js'
+
+/**
+ * 每个上下文独立缓存
+ * 使用 RuntimeContext 作为键（WeakMap 自动回收）
+ */
+const cacheMap = new WeakMap<RuntimeContext<Record<string, unknown>>, Map<string, ExpressionCache>>()
+
+/**
+ * 缓存配置
+ */
+const CACHE_CONFIG = {
+  /** 最大缓存条目数 */
+  maxSize: 100,
+  /** 缓存有效期（毫秒），0 表示不过期 */
+  ttl: 0
+} as const
+
+/**
+ * 获取上下文的缓存 Map
+ */
+function getCache(ctx: RuntimeContext): Map<string, ExpressionCache> {
+  let cache = cacheMap.get(ctx as RuntimeContext<Record<string, unknown>>)
+  if (!cache) {
+    cache = new Map()
+    cacheMap.set(ctx as RuntimeContext<Record<string, unknown>>, cache)
+  }
+  return cache
+}
+
+/**
+ * 检查缓存条目是否有效
+ */
+function isCacheValid(
+  entry: ExpressionCache,
+  ctx: RuntimeContext
+): boolean {
+  // TTL 检查
+  if (CACHE_CONFIG.ttl > 0 && Date.now() - entry.timestamp > CACHE_CONFIG.ttl) {
+    return false
+  }
+  
+  // 依赖检查：所有依赖的值必须存在
+  return entry.dependencies.every(dep => {
+    if (dep.includes('*')) {
+      // 通配符依赖：检查父路径是否存在
+      const parentPath = dep.split('.*')[0]
+      return ctx._get(parentPath) != null
+    }
+    // 具体路径：检查值是否存在
+    return ctx._get(dep) !== undefined
+  })
+}
+
+/**
+ * LRU 淘汰：删除最旧的缓存条目
+ */
+function evictOldest(cache: Map<string, ExpressionCache>): void {
+  let oldestKey: string | null = null
+  let oldestTime = Infinity
+  
+  for (const [key, entry] of cache.entries()) {
+    if (entry.timestamp < oldestTime) {
+      oldestTime = entry.timestamp
+      oldestKey = key
+    }
+  }
+  
+  if (oldestKey) {
+    cache.delete(oldestKey)
+  }
+}
+
+/**
+ * 获取缓存的表达式结果
+ * 
+ * @param expr 表达式字符串
+ * @param ctx 运行时上下文
+ * @returns 缓存的结果，无缓存或已失效返回 null
+ */
+export function getCachedExpression(
+  expr: string,
+  ctx: RuntimeContext
+): unknown | null {
+  const cache = getCache(ctx)
+  const entry = cache.get(expr)
+  
+  if (!entry) {
+    return null
+  }
+  
+  if (!isCacheValid(entry, ctx)) {
+    cache.delete(expr)
+    return null
+  }
+  
+  // 更新时间戳（LRU）
+  entry.timestamp = Date.now()
+  return entry.result
+}
+
+/**
+ * 设置表达式缓存
+ * 
+ * @param expr 表达式字符串
+ * @param result 求值结果
+ * @param dependencies 依赖的状态路径
+ * @param ctx 运行时上下文
+ */
+export function setCachedExpression(
+  expr: string,
+  result: unknown,
+  dependencies: string[],
+  ctx: RuntimeContext
+): void {
+  const cache = getCache(ctx)
+  
+  // LRU 淘汰
+  if (cache.size >= CACHE_CONFIG.maxSize) {
+    evictOldest(cache)
+  }
+  
+  cache.set(expr, {
+    expr,
+    result,
+    dependencies,
+    timestamp: Date.now()
+  })
+}
+
+/**
+ * 使缓存失效
+ * 
+ * 当状态变化时调用，精确删除依赖该状态的缓存
+ * 
+ * @param changedPath 变化的状态路径
+ * @param ctx 运行时上下文
+ */
+export function invalidateCache(
+  changedPath: string,
+  ctx: RuntimeContext
+): void {
+  const cache = getCache(ctx)
+  const toDelete: string[] = []
+  
+  for (const [expr, entry] of cache.entries()) {
+    // 检查是否有依赖被影响
+    const isAffected = entry.dependencies.some(dep => 
+      matchPath(dep, changedPath) || matchPath(changedPath, dep)
+    )
+    
+    if (isAffected) {
+      toDelete.push(expr)
+    }
+  }
+  
+  // 批量删除
+  for (const expr of toDelete) {
+    cache.delete(expr)
+  }
+}
+
+/**
+ * 清除指定上下文的所有缓存
+ */
+export function clearCache(ctx: RuntimeContext): void {
+  const cache = getCache(ctx)
+  cache.clear()
+}
+
+/**
+ * 获取缓存统计信息（调试用）
+ */
+export function getCacheStats(ctx: RuntimeContext): {
+  size: number
+  expressions: string[]
+} {
+  const cache = getCache(ctx)
+  return {
+    size: cache.size,
+    expressions: Array.from(cache.keys())
+  }
+}