@variojs/core 0.0.1 → 0.0.2

package/dist/vm/handlers/array/splice.js

@@ -1,59 +1 @@
-/**
- * splice 动作处理器
- *
- * 功能：删除或替换数组元素
- * 示例：{ "type": "splice", "path": "items", "start": 0, "deleteCount": 1, "items": "{{ newItem }}" }
- */
-import { ActionError, ErrorCodes } from '../../../errors.js';
-import { evaluate } from '../../../expression/evaluate.js';
-import { invalidateCache } from '../../../expression/cache.js';
-import { evaluateExpressionsRecursively } from './utils.js';
-/**
- * 处理 splice 动作
- */
-export async function handleSplice(ctx, action) {
-    const { path, start, deleteCount = 0, items } = action;
-    if (!path || typeof path !== 'string') {
-        throw new ActionError(action, 'splice action requires "path" parameter', ErrorCodes.ACTION_MISSING_PARAM, { metadata: { param: 'path' } });
-    }
-    // 获取数组
-    const array = ctx._get(path);
-    if (!Array.isArray(array)) {
-        throw new ActionError(action, `Path "${path}" does not point to an array`, ErrorCodes.ACTION_INVALID_PARAM, { metadata: { param: 'path', path, actualType: typeof array } });
-    }
-    // 求值 start（支持表达式）
-    let finalStart;
-    if (typeof start === 'string' && start.startsWith('{{') && start.endsWith('}}')) {
-        const expr = start.slice(2, -2).trim();
-        finalStart = Number(evaluate(expr, ctx));
-    }
-    else {
-        finalStart = Number(start);
-    }
-    // 求值 deleteCount（支持表达式）
-    let finalDeleteCount;
-    if (typeof deleteCount === 'string' && deleteCount.startsWith('{{') && deleteCount.endsWith('}}')) {
-        const expr = deleteCount.slice(2, -2).trim();
-        finalDeleteCount = Number(evaluate(expr, ctx));
-    }
-    else {
-        finalDeleteCount = Number(deleteCount);
-    }
-    // 求值 items（支持递归表达式）
-    let finalItems = [];
-    if (items != null) {
-        const evaluated = evaluateExpressionsRecursively(items, ctx);
-        if (Array.isArray(evaluated)) {
-            finalItems = evaluated;
-        }
-        else {
-            finalItems = [evaluated];
-        }
-    }
-    // 执行 splice
-    array.splice(finalStart, finalDeleteCount, ...finalItems);
-    // 使相关缓存失效
-    invalidateCache(path, ctx);
-    invalidateCache(`${path}.*`, ctx);
-}
-//# sourceMappingURL=splice.js.map
+import{ActionError as f,ErrorCodes as u}from"../../../errors.js";import{evaluate as h}from"../../../expression/evaluate.js";import{invalidateCache as y}from"../../../expression/cache.js";import{evaluateExpressionsRecursively as A}from"./utils.js";async function C(r,s){const{path:e,start:a,deleteCount:i=0,items:m}=s;if(!e||typeof e!="string")throw new f(s,'splice action requires "path" parameter',u.ACTION_MISSING_PARAM,{metadata:{param:"path"}});const o=r._get(e);if(!Array.isArray(o))throw new f(s,`Path "${e}" does not point to an array`,u.ACTION_INVALID_PARAM,{metadata:{param:"path",path:e,actualType:typeof o}});let n;if(typeof a=="string"&&a.startsWith("{{")&&a.endsWith("}}")){const t=a.slice(2,-2).trim();n=Number(h(t,r))}else n=Number(a);let l;if(typeof i=="string"&&i.startsWith("{{")&&i.endsWith("}}")){const t=i.slice(2,-2).trim();l=Number(h(t,r))}else l=Number(i);let p=[];if(m!=null){const t=A(m,r);Array.isArray(t)?p=t:p=[t]}o.splice(n,l,...p),y(e,r),y(`${e}.*`,r)}export{C as handleSplice};

package/dist/vm/handlers/array/unshift.js

@@ -1,42 +1 @@
-/**
- * unshift 动作处理器
- *
- * 功能：添加元素到数组开头
- * 示例：{ "type": "unshift", "path": "items", "value": "{{ firstItem }}" }
- * 示例：{ "type": "unshift", "path": "todos", "items": [{ text: "{{ newTodo }}", done: false }] }
- */
-import { ActionError, ErrorCodes } from '../../../errors.js';
-import { invalidateCache } from '../../../expression/cache.js';
-import { evaluateExpressionsRecursively } from './utils.js';
-/**
- * 处理 unshift 动作
- */
-export async function handleUnshift(ctx, action) {
-    const { path, value, items } = action;
-    if (!path || typeof path !== 'string') {
-        throw new ActionError(action, 'unshift action requires "path" parameter', ErrorCodes.ACTION_MISSING_PARAM, { metadata: { param: 'path' } });
-    }
-    // 获取数组
-    const array = ctx._get(path);
-    if (!Array.isArray(array)) {
-        throw new ActionError(action, `Path "${path}" does not point to an array`, ErrorCodes.ACTION_INVALID_PARAM, { metadata: { param: 'path', path, actualType: typeof array } });
-    }
-    // 支持 items 作为 value 的别名
-    const inputValue = items !== undefined ? items : value;
-    if (inputValue === undefined) {
-        throw new ActionError(action, 'unshift action requires "value" or "items" parameter', ErrorCodes.ACTION_MISSING_PARAM, { metadata: { param: 'value|items' } });
-    }
-    // 递归求值表达式（支持对象/数组中的表达式）
-    const finalValue = evaluateExpressionsRecursively(inputValue, ctx);
-    // 如果是数组，展开添加
-    if (Array.isArray(finalValue)) {
-        array.unshift(...finalValue);
-    }
-    else {
-        array.unshift(finalValue);
-    }
-    // 使相关缓存失效
-    invalidateCache(path, ctx);
-    invalidateCache(`${path}.*`, ctx);
-}
-//# sourceMappingURL=unshift.js.map
+import{ActionError as n,ErrorCodes as o}from"../../../errors.js";import{invalidateCache as f}from"../../../expression/cache.js";import{evaluateExpressionsRecursively as m}from"./utils.js";async function d(e,r){const{path:a,value:u,items:s}=r;if(!a||typeof a!="string")throw new n(r,'unshift action requires "path" parameter',o.ACTION_MISSING_PARAM,{metadata:{param:"path"}});const t=e._get(a);if(!Array.isArray(t))throw new n(r,`Path "${a}" does not point to an array`,o.ACTION_INVALID_PARAM,{metadata:{param:"path",path:a,actualType:typeof t}});const p=s!==void 0?s:u;if(p===void 0)throw new n(r,'unshift action requires "value" or "items" parameter',o.ACTION_MISSING_PARAM,{metadata:{param:"value|items"}});const i=m(p,e);Array.isArray(i)?t.unshift(...i):t.unshift(i),f(a,e),f(`${a}.*`,e)}export{d as handleUnshift};

package/dist/vm/handlers/array/utils.js

@@ -1,33 +1 @@
-/**
- * 数组指令工具函数
- */
-import { evaluate } from '../../../expression/evaluate.js';
-/**
- * 递归求值对象/数组中的表达式
- * 支持在对象属性和数组元素中使用 {{ expression }} 格式
- */
-export function evaluateExpressionsRecursively(value, ctx) {
-    // 字符串：检查是否为表达式
-    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 = {};
-        for (const [key, val] of Object.entries(value)) {
-            result[key] = evaluateExpressionsRecursively(val, ctx);
-        }
-        return result;
-    }
-    // 其他类型：直接返回
-    return value;
-}
-//# sourceMappingURL=utils.js.map
+import{evaluate as o}from"../../../expression/evaluate.js";function s(r,i){if(typeof r=="string"){if(r.startsWith("{{")&&r.endsWith("}}")){const t=r.slice(2,-2).trim();return o(t,i)}return r}if(Array.isArray(r))return r.map(t=>s(t,i));if(r&&typeof r=="object"){const t={};for(const[e,n]of Object.entries(r))t[e]=s(n,i);return t}return r}export{s as evaluateExpressionsRecursively};

package/dist/vm/handlers/batch.js

@@ -1,40 +1 @@
-/**
- * batch 动作处理器
- *
- * 功能：批量执行动作（保证原子性）
- * 示例：{ "type": "batch", "actions": [...] }
- */
-import { ActionError, BatchError, ErrorCodes } from '../../errors.js';
-import { execute } from '../executor.js';
-/**
- * 处理 batch 动作
- */
-export async function handleBatch(ctx, action) {
-    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 = [];
-    // 批量执行，收集错误
-    for (const act of actions) {
-        try {
-            await execute([act], ctx);
-        }
-        catch (error) {
-            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
-            }
-        });
-    }
-}
-//# sourceMappingURL=batch.js.map
+import{ActionError as c,BatchError as i,ErrorCodes as s}from"../../errors.js";import{execute as h}from"../executor.js";async function m(e,o){const{actions:t}=o;if(!t||!Array.isArray(t))throw new c(o,'batch action requires "actions" parameter (array)',s.ACTION_MISSING_PARAM,{metadata:{param:"actions"}});const r=[];for(const n of t)try{await h([n],e)}catch(a){r.push({action:n,error:a instanceof Error?a:new Error(String(a))})}if(r.length>0)throw new i(r,`${r.length} actions failed in batch`,{metadata:{failedCount:r.length,totalCount:t.length}})}export{m as handleBatch};

package/dist/vm/handlers/call.js

@@ -1,65 +1 @@
-/**
- * call 动作处理器
- *
- * 功能：调用 method（通过 $methods）
- * 示例：{ "type": "call", "method": "services.fetchUser", "params": {...}, "resultTo": "user" }
- *
- * 参考文档：action-reference.md - call 动作
- */
-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, action) {
-    const method = action.method;
-    const params = (action.params || {});
-    const resultTo = action.resultTo;
-    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 = {};
-    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) {
-        // 如果错误已经是 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
-            }
-        });
-    }
-}
-//# sourceMappingURL=call.js.map
+import{ActionError as l,ServiceError as m,ErrorCodes as h}from"../../errors.js";import{evaluate as p}from"../../expression/evaluate.js";import{invalidateCache as u}from"../../expression/cache.js";async function v(o,a){const e=a.method,f=a.params||{},i=a.resultTo;if(!e||typeof e!="string")throw new l(a,'call action requires "method" parameter',h.ACTION_MISSING_PARAM,{metadata:{param:"method"}});const d=o.$methods[e];if(!d)throw new m(e,`Method "${e}" not found in $methods`,void 0,{metadata:{method:e}});const n={};try{for(const[s,t]of Object.entries(f))if(typeof t=="string"&&t.startsWith("{{")&&t.endsWith("}}")){const c=t.slice(2,-2).trim();n[s]=p(c,o)}else n[s]=t;const r=await d(o,n);return i&&(o._set(i,r),u(i,o)),r}catch(r){if(r instanceof m)throw r;const s=r instanceof Error?r.message:String(r),t=r instanceof Error?r:void 0;throw new m(e,`Service call failed: ${s}`,t,{metadata:{method:e,params:n}})}}export{v as handleCall};

package/dist/vm/handlers/emit.js

@@ -1,26 +1 @@
-/**
- * emit 动作处理器
- *
- * 功能：触发事件
- * 示例：{ "type": "emit", "event": "submit", "data": { "userId": 123 } }
- */
-import { ActionError, ErrorCodes } from '../../errors.js';
-import { evaluate } from '../../expression/evaluate.js';
-/**
- * 处理 emit 动作
- */
-export async function handleEmit(ctx, action) {
-    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);
-}
-//# sourceMappingURL=emit.js.map
+import{ActionError as o,ErrorCodes as m}from"../../errors.js";import{evaluate as s}from"../../expression/evaluate.js";async function c(r,a){const{event:e,data:t}=a;if(!e||typeof e!="string")throw new o(a,'emit action requires "event" parameter',m.ACTION_MISSING_PARAM,{metadata:{param:"event"}});let i=t;if(typeof t=="string"&&t.startsWith("{{")&&t.endsWith("}}")){const n=t.slice(2,-2).trim();i=s(n,r)}r.$emit(e,i)}export{c as handleEmit};

package/dist/vm/handlers/if.js

@@ -1,35 +1 @@
-/**
- * if 动作处理器
- *
- * 功能：条件分支
- * 示例：{ "type": "if", "cond": "user.age > 18", "then": [...], "else": [...] }
- * 示例：{ "type": "if", "cond": "{{ counter < 10 }}", "then": [...], "else": [...] }
- */
-import { ActionError, ErrorCodes } from '../../errors.js';
-import { evaluate, extractExpression } from '../../expression/index.js';
-import { execute } from '../executor.js';
-/**
- * 处理 if 动作
- */
-export async function handleIf(ctx, action) {
-    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);
-        }
-    }
-}
-//# sourceMappingURL=if.js.map
+import{ActionError as s,ErrorCodes as c}from"../../errors.js";import{evaluate as f,extractExpression as d}from"../../expression/index.js";import{execute as i}from"../executor.js";async function l(r,a){const{cond:o,then:e,else:t}=a;if(!o||typeof o!="string")throw new s(a,'if action requires "cond" parameter',c.ACTION_MISSING_PARAM,{metadata:{param:"cond"}});const n=d(o);f(n,r)?e&&Array.isArray(e)&&await i(e,r):t&&Array.isArray(t)&&await i(t,r)}export{l as handleIf};

package/dist/vm/handlers/index.js

@@ -1,55 +1 @@
-/**
- * 内置动作处理器
- *
- * 所有内置动作统一注册到 ctx.$methods
- */
-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';
-/**
- * 内置动作处理器映射
- */
-const BUILTIN_METHODS = {
-    // 原子动作
-    'set': handleSet,
-    'emit': handleEmit,
-    'navigate': handleNavigate,
-    'log': handleLog,
-    // 控制流动作
-    'if': handleIf,
-    'loop': handleLoop,
-    // 复合动作
-    'call': handleCall,
-    'batch': handleBatch,
-    // 数组操作动作
-    'push': handlePush,
-    'pop': handlePop,
-    'shift': handleShift,
-    'unshift': handleUnshift,
-    'splice': handleSplice,
-};
-/**
- * 注册所有内置动作到 $methods
- *
- * 注意：此函数通过向现有 $methods 对象添加属性来注册方法，
- * 而不是整体覆盖 $methods，以确保在 Proxy 保护下也能正常工作。
- */
-export function registerBuiltinMethods(ctx) {
-    // 向现有 $methods 对象添加内置方法，不覆盖已有的同名方法
-    for (const [name, handler] of Object.entries(BUILTIN_METHODS)) {
-        if (!(name in ctx.$methods)) {
-            ctx.$methods[name] = handler;
-        }
-    }
-}
-//# sourceMappingURL=index.js.map
+import{handleSet as e}from"./set.js";import{handleEmit as i}from"./emit.js";import{handleIf as m}from"./if.js";import{handleLoop as h}from"./loop.js";import{handleCall as n}from"./call.js";import{handleBatch as a}from"./batch.js";import{handleNavigate as f}from"./navigate.js";import{handleLog as l}from"./log.js";import{handlePush as p}from"./array/push.js";import{handlePop as d}from"./array/pop.js";import{handleShift as s}from"./array/shift.js";import{handleUnshift as c}from"./array/unshift.js";import{handleSplice as g}from"./array/splice.js";const u={set:e,emit:i,navigate:f,log:l,if:m,loop:h,call:n,batch:a,push:p,pop:d,shift:s,unshift:c,splice:g};function $(o){for(const[t,r]of Object.entries(u))t in o.$methods||(o.$methods[t]=r)}export{$ as registerBuiltinMethods};

package/dist/vm/handlers/log.js

@@ -1,41 +1 @@
-/**
- * log 动作处理器
- *
- * 功能：调试输出
- * 示例：{ "type": "log", "level": "info", "message": "User logged in" }
- */
-import { ActionError, ErrorCodes } from '../../errors.js';
-import { evaluate } from '../../expression/evaluate.js';
-/**
- * 处理 log 动作
- */
-export async function handleLog(ctx, action) {
-    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 = 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;
-        }
-    }
-}
-//# sourceMappingURL=log.js.map
+import{ActionError as c,ErrorCodes as l}from"../../errors.js";import{evaluate as f}from"../../expression/evaluate.js";async function p(s,o){const{level:t="info",message:e}=o;if(!e)throw new c(o,'log action requires "message" parameter',l.ACTION_MISSING_PARAM,{metadata:{param:"message"}});let a=e;if(typeof e=="string"&&e.startsWith("{{")&&e.endsWith("}}")){const i=e.slice(2,-2).trim();a=f(i,s)}const n=String(t).toLowerCase(),r=String(a);if(typeof console<"u")switch(n){case"error":console.error("[Vario]",r);break;case"warn":console.warn("[Vario]",r);break;case"info":default:console.log("[Vario]",r);break}}export{p as handleLog};

package/dist/vm/handlers/loop.js

@@ -1,71 +1 @@
-/**
- * loop 动作处理器
- *
- * 功能：循环执行
- * 示例：{ "type": "loop", "var": "item", "in": "items", "body": [...] }
- */
-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, action) {
-    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 } });
-    }
-}
-//# sourceMappingURL=loop.js.map
+import{ActionError as p,ErrorCodes as l}from"../../errors.js";import{evaluate as I}from"../../expression/evaluate.js";import{invalidateCache as y}from"../../expression/cache.js";import{execute as A}from"../executor.js";import{createLoopContext as c,releaseLoopContext as u}from"../../runtime/loop-context-pool.js";async function v(s,a){const{var:o,in:m,body:i}=a;if(!o||typeof o!="string")throw new p(a,'loop action requires "var" parameter',l.ACTION_MISSING_PARAM,{metadata:{param:"var"}});if(!m||typeof m!="string")throw new p(a,'loop action requires "in" parameter',l.ACTION_MISSING_PARAM,{metadata:{param:"in"}});if(!i||!Array.isArray(i))throw new p(a,'loop action requires "body" parameter (array of actions)',l.ACTION_MISSING_PARAM,{metadata:{param:"body"}});const r=I(m,s);if(r!=null)if(Array.isArray(r))for(let t=0;t<r.length;t++){const e=c(s,r[t],t);e[o]=r[t];try{y(o,e),await A(i,e)}finally{u(e)}}else if(typeof r=="object"&&r!==null){const t=Object.entries(r);for(let e=0;e<t.length;e++){const[,f]=t[e],n=c(s,f,e);n[o]=f;try{y(o,n),await A(i,n)}finally{u(n)}}}else throw new p(a,`loop "in" expression must evaluate to an array or object, got ${typeof r}`,l.ACTION_INVALID_PARAM,{metadata:{param:"in",actualType:typeof r}})}export{v as handleLoop};

package/dist/vm/handlers/navigate.js

@@ -1,43 +1 @@
-/**
- * navigate 动作处理器
- *
- * 功能：路由导航
- * 示例：{ "type": "navigate", "to": "/users/123" }
- */
-import { ActionError, ErrorCodes } from '../../errors.js';
-import { evaluate } from '../../expression/evaluate.js';
-/**
- * 处理 navigate 动作
- */
-export async function handleNavigate(ctx, action) {
-    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 = 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.location) {
-            window.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' } });
-        }
-    }
-}
-//# sourceMappingURL=navigate.js.map
+import{ActionError as n,ErrorCodes as r}from"../../errors.js";import{evaluate as l}from"../../expression/evaluate.js";async function w(e,a){const{to:t}=a;if(!t||typeof t!="string")throw new n(a,'navigate action requires "to" parameter',r.ACTION_MISSING_PARAM,{metadata:{param:"to"}});let i=t;if(t.startsWith("{{")&&t.endsWith("}}")){const d=t.slice(2,-2).trim(),o=l(d,e);if(typeof o!="string")throw new n(a,`navigate "to" expression must evaluate to a string, got ${typeof o}`,r.ACTION_INVALID_PARAM,{metadata:{param:"to",actualType:typeof o}});i=o}const s=e.$methods.navigate||e.$methods.$navigate;if(s)await s(e,{to:i});else if(typeof window<"u"&&window.location)window.location.href=i;else throw new n(a,"navigate method not registered and window.location is not available",r.ACTION_EXECUTION_ERROR,{metadata:{reason:"navigate_not_available"}})}export{w as handleNavigate};

package/dist/vm/handlers/set.js

@@ -1,30 +1 @@
-/**
- * set 动作处理器
- *
- * 功能：修改状态
- * 示例：{ "type": "set", "path": "user.name", "value": "张三" }
- *
- * 注意：缓存失效通过 RuntimeContext 的 onStateChange 钩子处理
- * 框架集成层应在创建上下文时注册该钩子
- */
-import { ActionError, ErrorCodes } from '../../errors.js';
-import { evaluate } from '../../expression/evaluate.js';
-/**
- * 处理 set 动作
- */
-export async function handleSet(ctx, action) {
-    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);
-}
-//# sourceMappingURL=set.js.map
+import{ActionError as s,ErrorCodes as n}from"../../errors.js";import{evaluate as p}from"../../expression/evaluate.js";async function h(r,a){const{path:e,value:t}=a;if(!e||typeof e!="string")throw new s(a,'set action requires "path" parameter',n.ACTION_MISSING_PARAM,{metadata:{param:"path"}});let o=t;if(typeof t=="string"&&t.startsWith("{{")&&t.endsWith("}}")){const i=t.slice(2,-2).trim();o=p(i,r)}r._set(e,o)}export{h as handleSet};

package/dist/vm/index.js

@@ -1,7 +1 @@
-/**
- * VM 模块导出
- */
-export { execute } from './executor.js';
-export { registerBuiltinMethods } from './handlers/index.js';
-export * from './errors.js';
-//# sourceMappingURL=index.js.map
+import{execute as o}from"./executor.js";import{registerBuiltinMethods as x}from"./handlers/index.js";export*from"./errors.js";export{o as execute,x as registerBuiltinMethods};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@variojs/core",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Vario Core Runtime - Instruction VM, Expression System, Runtime Context",
   "type": "module",
   "main": "./dist/index.js",
@@ -14,7 +14,7 @@
   },
   "scripts": {
     "build": "tsc",
-    "postbuild": "tsc-alias",
+    "postbuild": "tsc-alias && node ../../scripts/minify.js",
     "dev": "tsc --watch",
     "test": "vitest run",
     "test:watch": "vitest",