@unmagic/vms 0.0.2 → 0.0.3

package/dist/{cli-BbBKrAPm.js → cli-R8YB9UUi.js}

@@ -939,22 +939,22 @@ function checkSlotsUsage(templateContent) {
     return templateContent.includes('slot') || templateContent.includes('Slot');
 }
 /**
- * 确保 @vue-mini/core 中导入了指定的 specifierName。
- * 如果已存在则跳过，否则追加到已有的 @vue-mini/core import 或新建一个。
+ * 确保 @unmagic/vue-mini 中导入了指定的 specifierName。
+ * 如果已存在则跳过，否则追加到已有的 @unmagic/vue-mini import 或新建一个。
  */
 function ensureCoreImport(sfcContext, specifierName) {
-    const hasImport = sfcContext.importAST.some((importNode) => importNode.source.value === '@vue-mini/core' &&
+    const hasImport = sfcContext.importAST.some((importNode) => importNode.source.value === '@unmagic/vue-mini' &&
         importNode.specifiers.some((spec) => t.isImportSpecifier(spec) &&
             t.isIdentifier(spec.imported) &&
             spec.imported.name === specifierName));
     if (hasImport)
         return;
-    const vueImport = sfcContext.importAST.find((importNode) => t.isImportDeclaration(importNode) && importNode.source.value === '@vue-mini/core');
+    const vueImport = sfcContext.importAST.find((importNode) => t.isImportDeclaration(importNode) && importNode.source.value === '@unmagic/vue-mini');
     if (vueImport && t.isImportDeclaration(vueImport)) {
         vueImport.specifiers.push(t.importSpecifier(t.identifier(specifierName), t.identifier(specifierName)));
     }
     else {
-        sfcContext.importAST.push(t.importDeclaration([t.importSpecifier(t.identifier(specifierName), t.identifier(specifierName))], t.stringLiteral('@vue-mini/core')));
+        sfcContext.importAST.push(t.importDeclaration([t.importSpecifier(t.identifier(specifierName), t.identifier(specifierName))], t.stringLiteral('@unmagic/vue-mini')));
     }
 }
 async function extractSetupBodyUsingAST(scriptContent, returnValue, bridgedFunctions, internalVars, renderVars, needsProxyRefs, isPage, scriptScope) {
@@ -1273,7 +1273,7 @@ async function parseScript(descriptor, returnValue, bridgedFunctions = new Set()
     const { sfcContext, setupFunAst } = await extractSetupBodyUsingAST(script, returnValue, bridgedFunctions, internalVars, renderVars, needsProxyRefs, isPage, scriptScope);
     // 生成import抽象语法
     const programBody = [
-        t.importDeclaration([t.importSpecifier(t.identifier('defineComponent'), t.identifier('defineComponent'))], t.stringLiteral('@vue-mini/core')),
+        t.importDeclaration([t.importSpecifier(t.identifier('defineComponent'), t.identifier('defineComponent'))], t.stringLiteral('@unmagic/vue-mini')),
         ...sfcContext.importAST,
     ];
     // 生成defineComponent参数
@@ -1343,37 +1343,38 @@ async function parseScript(descriptor, returnValue, bridgedFunctions = new Set()
 /**
  * 替换函数中的 props 变量访问
  * 将 __vmsProxyRefs.propName 替换为 __vmsProps.propName
+ * 使用 Babel VISITOR_KEYS 进行正确的 AST 遍历，
+ * 只访问有意义的子节点，避免遍历 Babel 内部属性。
  */
 function replacePropsAccessInFunction(func, propsVarNames, propsVarName) {
-    // 递归遍历函数体中的所有 MemberExpression
+    // 使用 Babel VISITOR_KEYS 遍历，只处理有意义的子节点
     function traverseNode(node) {
-        if (!node)
+        if (!node || typeof node !== 'object')
             return;
-        // 检查当前节点是否是 MemberExpression
+        // 处理 MemberExpression：检查并替换 __vmsProxyRefs.propName
         if (t.isMemberExpression(node)) {
-            // 检查是否是 __vmsProxyRefs.propName 形式
             if (t.isIdentifier(node.object, { name: '__vmsProxyRefs' }) &&
                 t.isIdentifier(node.property) &&
                 propsVarNames.has(node.property.name)) {
-                // 替换为 __vmsProps.propName
                 node.object = t.identifier(propsVarName);
             }
         }
-        // 递归遍历子节点
-        if (typeof node === 'object') {
-            for (const key in node) {
-                const value = node[key];
-                if (Array.isArray(value)) {
-                    value.forEach((item) => {
-                        if (typeof item === 'object' && item !== null) {
-                            traverseNode(item);
-                        }
-                    });
-                }
-                else if (typeof value === 'object' && value !== null && value.type) {
-                    traverseNode(value);
+        // 使用 VISITOR_KEYS 获取该节点类型的有效子节点属性名
+        const visitorKeys = t.VISITOR_KEYS[node.type];
+        if (!visitorKeys)
+            return;
+        for (const key of visitorKeys) {
+            const value = node[key];
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    if (child && typeof child === 'object' && Object.hasOwn(child, 'type')) {
+                        traverseNode(child);
+                    }
                 }
             }
+            else if (value && typeof value === 'object' && Object.hasOwn(value, 'type')) {
+                traverseNode(value);
+            }
         }
     }
     traverseNode(func);
@@ -3442,262 +3443,161 @@ function processArrowFunctionExpression(ast, counter, callExpressionWithArgs, ex
         const wrappedBody = t__default.blockStatement([t__default.expressionStatement(body)]);
         return processInlineArrowFunction(wrappedBody, arrowFunctionArguments, counter, callExpressionWithArgs, excludeBindingVars, node, returnValue, ctx, isAsync);
     }
-    else if (t__default.isConditionalExpression(body)) {
+    else if (t__default.isConditionalExpression(body) || t__default.isLogicalExpression(body)) {
         // 处理三元表达式：(e) => flag ? a() : b()
-        // 收集条件表达式中使用的外部变量
+        // 处理逻辑表达式：(e) => flag && onClick(e)
         const vForInfoList = getVForInfoList(ctx, node);
         const vForVars = getVForVariables(ctx, node);
-        const arrowFunctionArgumentNames = arrowFunctionArguments.length > 0
-            ? new Set(arrowFunctionArguments
-                .map((p) => (t__default.isIdentifier(p) ? p.name : ''))
-                .filter(Boolean))
-            : undefined;
-        // 收集 test、consequent、alternate 中的外部变量
-        const varsToCollect = new Set();
-        const collectVarsFromNode = (node) => {
-            if (t__default.isIdentifier(node)) {
-                const name = node.name;
-                if (name !== EVENT_PARAM_NAME &&
-                    name !== '$event' &&
-                    !GLOBAL_WHITELIST.has(name) &&
-                    !(arrowFunctionArgumentNames && arrowFunctionArgumentNames.has(name)) &&
-                    !vForVars.has(name)) {
-                    varsToCollect.add(name);
-                }
-            }
-            else if (t__default.isMemberExpression(node)) {
-                collectVarsFromNode(node.object);
-            }
-            else if (t__default.isCallExpression(node)) {
-                collectVarsFromNode(node.callee);
-                node.arguments.forEach((arg) => collectVarsFromNode(arg));
-            }
-            else if (t__default.isConditionalExpression(node)) {
-                collectVarsFromNode(node.test);
-                collectVarsFromNode(node.consequent);
-                collectVarsFromNode(node.alternate);
-            }
-            else if (t__default.isLogicalExpression(node) || t__default.isBinaryExpression(node)) {
-                collectVarsFromNode(node.left);
-                collectVarsFromNode(node.right);
-            }
-            else if (t__default.isUnaryExpression(node)) {
-                collectVarsFromNode(node.argument);
+        return createShortExprHandler(body, arrowFunctionArguments, callExpressionWithArgs, vForInfoList, vForVars, ctx, counter, returnValue, isAsync);
+    }
+    return '';
+}
+function collectExternalVarsFromExpression(body, arrowFunctionArgumentNames, vForVars) {
+    const varsToCollect = new Set();
+    const collectVarsFromNode = (node) => {
+        if (t__default.isIdentifier(node)) {
+            const name = node.name;
+            if (name !== EVENT_PARAM_NAME &&
+                name !== '$event' &&
+                !GLOBAL_WHITELIST.has(name) &&
+                !(arrowFunctionArgumentNames && arrowFunctionArgumentNames.has(name)) &&
+                !vForVars.has(name)) {
+                varsToCollect.add(name);
             }
-        };
+        }
+        else if (t__default.isMemberExpression(node)) {
+            collectVarsFromNode(node.object);
+        }
+        else if (t__default.isCallExpression(node)) {
+            collectVarsFromNode(node.callee);
+            node.arguments.forEach((arg) => collectVarsFromNode(arg));
+        }
+        else if (t__default.isConditionalExpression(node)) {
+            collectVarsFromNode(node.test);
+            collectVarsFromNode(node.consequent);
+            collectVarsFromNode(node.alternate);
+        }
+        else if (t__default.isLogicalExpression(node) || t__default.isBinaryExpression(node)) {
+            collectVarsFromNode(node.left);
+            collectVarsFromNode(node.right);
+        }
+        else if (t__default.isUnaryExpression(node)) {
+            collectVarsFromNode(node.argument);
+        }
+    };
+    // 收集对应表达式类型的节点
+    if (t__default.isConditionalExpression(body)) {
         collectVarsFromNode(body.test);
         collectVarsFromNode(body.consequent);
         collectVarsFromNode(body.alternate);
-        // 将收集的变量添加到 returnValue
-        varsToCollect.forEach((varName) => {
-            if (!shouldSkipVariable(varName, ctx.scriptScope)) {
-                addProperty(returnValue, varName);
-                ctx.internalVars.add(varName);
-            }
-        });
-        // 标记需要 __vmsProxyRefs
-        if (varsToCollect.size > 0) {
-            ctx.needsProxyRefs = true;
-        }
-        // 生成桥接函数
-        const functionName = counter.generateFunctionPropertyName();
-        const dataKey = vForInfoList && vForInfoList.length > 0
-            ? getFunctionIndexChar(counter.nodeDataKeyIndex++)
-            : '';
-        // 处理参数
-        const statements = [];
-        if (arrowFunctionArguments.length > 0) {
-            const param = arrowFunctionArguments[0];
-            if (t__default.isIdentifier(param) && param.name !== '$event' && param.name !== EVENT_PARAM_NAME) {
-                statements.push(t__default.variableDeclaration('const', [
-                    t__default.variableDeclarator(param, t__default.memberExpression(t__default.identifier(EVENT_PARAM_NAME), t__default.identifier('detail'))),
-                ]));
-            }
-        }
-        // 处理 v-for dataset 获取
-        if (vForInfoList && vForInfoList.length > 0) {
-            const indices = vForInfoList.map((info) => getVForIndexName(info) || 'index');
-            const indexVars = indices.map((idx) => t__default.identifier(idx));
-            statements.push(t__default.variableDeclaration('const', [
-                t__default.variableDeclarator(t__default.objectPattern([
-                    t__default.objectProperty(t__default.identifier(dataKey), t__default.arrayPattern(indexVars), false, false),
-                ]), t__default.memberExpression(t__default.memberExpression(t__default.identifier(EVENT_PARAM_NAME), t__default.identifier('currentTarget')), t__default.identifier('dataset'))),
-            ]));
-        }
-        // 构建处理后的条件表达式
-        const processConditionalExpr = (expr) => {
-            if (t__default.isIdentifier(expr)) {
-                const name = expr.name;
-                if (arrowFunctionArgumentNames && arrowFunctionArgumentNames.has(name)) {
-                    return t__default.memberExpression(t__default.identifier(EVENT_PARAM_NAME), t__default.identifier('detail'));
-                }
-                if (ctx.scriptScope?.props.has(name)) {
-                    const propsVarName = ctx.scriptScope.propsVarName || '__vmsProps';
-                    return t__default.memberExpression(t__default.identifier(propsVarName), t__default.identifier(name));
-                }
-                if (varsToCollect.has(name)) {
-                    return t__default.memberExpression(t__default.identifier('__vmsProxyRefs'), t__default.identifier(name));
-                }
-                return expr;
-            }
-            else if (t__default.isMemberExpression(expr)) {
-                return t__default.memberExpression(processConditionalExpr(expr.object), expr.property, expr.computed);
-            }
-            else if (t__default.isCallExpression(expr)) {
-                return t__default.callExpression(processConditionalExpr(expr.callee), expr.arguments.map((arg) => processConditionalExpr(arg)));
-            }
-            else if (t__default.isConditionalExpression(expr)) {
-                return t__default.conditionalExpression(processConditionalExpr(expr.test), processConditionalExpr(expr.consequent), processConditionalExpr(expr.alternate));
-            }
-            else if (t__default.isLogicalExpression(expr)) {
-                return t__default.logicalExpression(expr.operator, processConditionalExpr(expr.left), processConditionalExpr(expr.right));
-            }
-            else if (t__default.isBinaryExpression(expr)) {
-                return t__default.binaryExpression(expr.operator, processConditionalExpr(expr.left), processConditionalExpr(expr.right));
-            }
-            else if (t__default.isUnaryExpression(expr)) {
-                return t__default.unaryExpression(expr.operator, processConditionalExpr(expr.argument));
-            }
-            return expr;
-        };
-        const processedBody = processConditionalExpr(body);
-        statements.push(t__default.returnStatement(processedBody));
-        const functionBody = t__default.blockStatement(statements);
-        const dataArgsAst = vForInfoList && vForInfoList.length > 0
-            ? vForInfoList.map((info) => t__default.identifier(getVForIndexName(info) || 'index'))
-            : null;
-        callExpressionWithArgs.set(functionName, {
-            dataKey,
-            dataArgsAst,
-            returnValueBodyAst: functionBody,
-            isAsync,
-        });
-        return functionName;
     }
-    else if (t__default.isLogicalExpression(body)) {
-        // 处理逻辑表达式：(e) => flag && onClick(e)
-        // 复用条件表达式的处理逻辑，将逻辑表达式包装为类似条件表达式的处理
-        const vForInfoList = getVForInfoList(ctx, node);
-        const vForVars = getVForVariables(ctx, node);
-        const arrowFunctionArgumentNames = arrowFunctionArguments.length > 0
-            ? new Set(arrowFunctionArguments
-                .map((p) => (t__default.isIdentifier(p) ? p.name : ''))
-                .filter(Boolean))
-            : undefined;
-        // 收集逻辑表达式中使用的外部变量
-        const varsToCollect = new Set();
-        const collectVarsFromNode = (node) => {
-            if (t__default.isIdentifier(node)) {
-                const name = node.name;
-                if (name !== EVENT_PARAM_NAME &&
-                    name !== '$event' &&
-                    !GLOBAL_WHITELIST.has(name) &&
-                    !(arrowFunctionArgumentNames && arrowFunctionArgumentNames.has(name)) &&
-                    !vForVars.has(name)) {
-                    varsToCollect.add(name);
-                }
-            }
-            else if (t__default.isMemberExpression(node)) {
-                collectVarsFromNode(node.object);
-            }
-            else if (t__default.isCallExpression(node)) {
-                collectVarsFromNode(node.callee);
-                node.arguments.forEach((arg) => collectVarsFromNode(arg));
-            }
-            else if (t__default.isLogicalExpression(node) || t__default.isBinaryExpression(node)) {
-                collectVarsFromNode(node.left);
-                collectVarsFromNode(node.right);
-            }
-            else if (t__default.isUnaryExpression(node)) {
-                collectVarsFromNode(node.argument);
-            }
-        };
+    else {
+        // LogicalExpression
         collectVarsFromNode(body.left);
         collectVarsFromNode(body.right);
-        // 将收集的变量添加到 returnValue
-        varsToCollect.forEach((varName) => {
-            if (!shouldSkipVariable(varName, ctx.scriptScope)) {
-                addProperty(returnValue, varName);
-                ctx.internalVars.add(varName);
+    }
+    return varsToCollect;
+}
+/**
+ * 重写表达式中的变量引用
+ * 将外部变量、props、箭头函数参数替换为正确的访问路径
+ */
+function rewriteExpressionVars(expr, varsToCollect, arrowFunctionArgumentNames, ctx) {
+    const processExpr = (node) => {
+        if (t__default.isIdentifier(node)) {
+            const name = node.name;
+            if (arrowFunctionArgumentNames && arrowFunctionArgumentNames.has(name)) {
+                return t__default.memberExpression(t__default.identifier(EVENT_PARAM_NAME), t__default.identifier('detail'));
             }
-        });
-        // 标记需要 __vmsProxyRefs
-        if (varsToCollect.size > 0) {
-            ctx.needsProxyRefs = true;
-        }
-        // 生成桥接函数
-        const functionName = counter.generateFunctionPropertyName();
-        const dataKey = vForInfoList && vForInfoList.length > 0
-            ? getFunctionIndexChar(counter.nodeDataKeyIndex++)
-            : '';
-        // 处理参数
-        const statements = [];
-        if (arrowFunctionArguments.length > 0) {
-            const param = arrowFunctionArguments[0];
-            if (t__default.isIdentifier(param) && param.name !== '$event' && param.name !== EVENT_PARAM_NAME) {
-                statements.push(t__default.variableDeclaration('const', [
-                    t__default.variableDeclarator(param, t__default.memberExpression(t__default.identifier(EVENT_PARAM_NAME), t__default.identifier('detail'))),
-                ]));
+            if (ctx.scriptScope?.props.has(name)) {
+                const propsVarName = ctx.scriptScope.propsVarName || '__vmsProps';
+                return t__default.memberExpression(t__default.identifier(propsVarName), t__default.identifier(name));
+            }
+            if (varsToCollect.has(name)) {
+                return t__default.memberExpression(t__default.identifier('__vmsProxyRefs'), t__default.identifier(name));
             }
+            return node;
         }
-        // 处理 v-for dataset 获取
-        if (vForInfoList && vForInfoList.length > 0) {
-            const indices = vForInfoList.map((info) => getVForIndexName(info) || 'index');
-            const indexVars = indices.map((idx) => t__default.identifier(idx));
+        else if (t__default.isMemberExpression(node)) {
+            return t__default.memberExpression(processExpr(node.object), node.property, node.computed);
+        }
+        else if (t__default.isCallExpression(node)) {
+            return t__default.callExpression(processExpr(node.callee), node.arguments.map((arg) => processExpr(arg)));
+        }
+        else if (t__default.isConditionalExpression(node)) {
+            return t__default.conditionalExpression(processExpr(node.test), processExpr(node.consequent), processExpr(node.alternate));
+        }
+        else if (t__default.isLogicalExpression(node)) {
+            return t__default.logicalExpression(node.operator, processExpr(node.left), processExpr(node.right));
+        }
+        else if (t__default.isBinaryExpression(node)) {
+            return t__default.binaryExpression(node.operator, processExpr(node.left), processExpr(node.right));
+        }
+        else if (t__default.isUnaryExpression(node)) {
+            return t__default.unaryExpression(node.operator, processExpr(node.argument));
+        }
+        return node;
+    };
+    return processExpr(expr);
+}
+/**
+ * 创建简短表达式（条件/逻辑表达式）的箭头函数处理器
+ * 供 processArrowFunctionExpression 中条件表达式和逻辑表达式分支复用
+ */
+function createShortExprHandler(body, arrowFunctionArguments, callExpressionWithArgs, vForInfoList, vForVars, ctx, counter, returnValue, isAsync) {
+    const arrowFunctionArgumentNames = arrowFunctionArguments.length > 0
+        ? new Set(arrowFunctionArguments.map((p) => (t__default.isIdentifier(p) ? p.name : '')).filter(Boolean))
+        : undefined;
+    // 收集外部变量
+    const varsToCollect = collectExternalVarsFromExpression(body, arrowFunctionArgumentNames, vForVars);
+    // 将收集的变量添加到 returnValue
+    varsToCollect.forEach((varName) => {
+        if (!shouldSkipVariable(varName, ctx.scriptScope)) {
+            addProperty(returnValue, varName);
+            ctx.internalVars.add(varName);
+        }
+    });
+    // 标记需要 __vmsProxyRefs
+    if (varsToCollect.size > 0) {
+        ctx.needsProxyRefs = true;
+    }
+    // 生成桥接函数
+    const functionName = counter.generateFunctionPropertyName();
+    const dataKey = vForInfoList && vForInfoList.length > 0 ? getFunctionIndexChar(counter.nodeDataKeyIndex++) : '';
+    // 处理参数
+    const statements = [];
+    if (arrowFunctionArguments.length > 0) {
+        const param = arrowFunctionArguments[0];
+        if (t__default.isIdentifier(param) && param.name !== '$event' && param.name !== EVENT_PARAM_NAME) {
             statements.push(t__default.variableDeclaration('const', [
-                t__default.variableDeclarator(t__default.objectPattern([
-                    t__default.objectProperty(t__default.identifier(dataKey), t__default.arrayPattern(indexVars), false, false),
-                ]), t__default.memberExpression(t__default.memberExpression(t__default.identifier(EVENT_PARAM_NAME), t__default.identifier('currentTarget')), t__default.identifier('dataset'))),
+                t__default.variableDeclarator(param, t__default.memberExpression(t__default.identifier(EVENT_PARAM_NAME), t__default.identifier('detail'))),
             ]));
         }
-        // 构建处理后的逻辑表达式
-        const processLogicalExpr = (expr) => {
-            if (t__default.isIdentifier(expr)) {
-                const name = expr.name;
-                if (arrowFunctionArgumentNames && arrowFunctionArgumentNames.has(name)) {
-                    return t__default.memberExpression(t__default.identifier(EVENT_PARAM_NAME), t__default.identifier('detail'));
-                }
-                if (ctx.scriptScope?.props.has(name)) {
-                    const propsVarName = ctx.scriptScope.propsVarName || '__vmsProps';
-                    return t__default.memberExpression(t__default.identifier(propsVarName), t__default.identifier(name));
-                }
-                if (varsToCollect.has(name)) {
-                    return t__default.memberExpression(t__default.identifier('__vmsProxyRefs'), t__default.identifier(name));
-                }
-                return expr;
-            }
-            else if (t__default.isMemberExpression(expr)) {
-                return t__default.memberExpression(processLogicalExpr(expr.object), expr.property, expr.computed);
-            }
-            else if (t__default.isCallExpression(expr)) {
-                return t__default.callExpression(processLogicalExpr(expr.callee), expr.arguments.map((arg) => processLogicalExpr(arg)));
-            }
-            else if (t__default.isLogicalExpression(expr)) {
-                return t__default.logicalExpression(expr.operator, processLogicalExpr(expr.left), processLogicalExpr(expr.right));
-            }
-            else if (t__default.isBinaryExpression(expr)) {
-                return t__default.binaryExpression(expr.operator, processLogicalExpr(expr.left), processLogicalExpr(expr.right));
-            }
-            else if (t__default.isUnaryExpression(expr)) {
-                return t__default.unaryExpression(expr.operator, processLogicalExpr(expr.argument));
-            }
-            return expr;
-        };
-        const processedBody = processLogicalExpr(body);
-        statements.push(t__default.returnStatement(processedBody));
-        const functionBody = t__default.blockStatement(statements);
-        const dataArgsAst = vForInfoList && vForInfoList.length > 0
-            ? vForInfoList.map((info) => t__default.identifier(getVForIndexName(info) || 'index'))
-            : null;
-        callExpressionWithArgs.set(functionName, {
-            dataKey,
-            dataArgsAst,
-            returnValueBodyAst: functionBody,
-            isAsync,
-        });
-        return functionName;
     }
-    return '';
+    // 处理 v-for dataset 获取
+    if (vForInfoList && vForInfoList.length > 0) {
+        const indices = vForInfoList.map((info) => getVForIndexName(info) || 'index');
+        const indexVars = indices.map((idx) => t__default.identifier(idx));
+        statements.push(t__default.variableDeclaration('const', [
+            t__default.variableDeclarator(t__default.objectPattern([
+                t__default.objectProperty(t__default.identifier(dataKey), t__default.arrayPattern(indexVars), false, false),
+            ]), t__default.memberExpression(t__default.memberExpression(t__default.identifier(EVENT_PARAM_NAME), t__default.identifier('currentTarget')), t__default.identifier('dataset'))),
+        ]));
+    }
+    // 重写表达式中的变量引用
+    const processedBody = rewriteExpressionVars(body, varsToCollect, arrowFunctionArgumentNames, ctx);
+    statements.push(t__default.returnStatement(processedBody));
+    const functionBody = t__default.blockStatement(statements);
+    const dataArgsAst = vForInfoList && vForInfoList.length > 0
+        ? vForInfoList.map((info) => t__default.identifier(getVForIndexName(info) || 'index'))
+        : null;
+    callExpressionWithArgs.set(functionName, {
+        dataKey,
+        dataArgsAst,
+        returnValueBodyAst: functionBody,
+        isAsync,
+    });
+    return functionName;
 }
 /**
  * 处理事件名转换
@@ -4599,7 +4499,7 @@ function createResult(key, content, priority) {
  * 从 v-for 指令中提取 forItem 和 forIndex
  * 公共逻辑，供 transformVForProp 共用
  */
-function parseForVariables(prop) {
+function parseForVariables(prop, counter) {
     const directive = prop;
     if (!directive.forParseResult) {
         return undefined;
@@ -4608,15 +4508,9 @@ function parseForVariables(prop) {
         ? directive.forParseResult.value.content
         : 'item';
     const hasExplicitIndex = directive.forParseResult.key?.type === NodeTypes.SIMPLE_EXPRESSION;
-    const sourceContent = directive.forParseResult.source?.type === NodeTypes.SIMPLE_EXPRESSION
-        ? directive.forParseResult.source.content
-        : 'item';
     const forIndex = hasExplicitIndex
         ? directive.forParseResult.key.content
-        : `_${sourceContent
-            .split('.')
-            .pop()
-            ?.replace(/[^a-zA-Z0-9_]/g, '_') || 'item'}_index`;
+        : counter.generateVForIndexName(forItem);
     return { forItem, forIndex };
 }
 /**
@@ -4633,7 +4527,7 @@ function transformVForProp(prop, context) {
     }
     // 获取数组表达式
     const { content: arrayName } = getTemplateNodeProp(context.node, { loc: directive.loc, exp: directive.forParseResult.source }, context.returnValue, context.counter, context.wxsExpressionStatements, context.ctx);
-    const forVars = parseForVariables(prop);
+    const forVars = parseForVariables(prop, context.counter);
     if (!forVars)
         return undefined;
     // 写回 forParseResult 供后续使用
@@ -4803,12 +4697,16 @@ function parseTemplate(templateAST, filePath, isPage = false, scriptScope) {
         wxsFunctionCounter: 0,
         functionPropertyCounter: 0,
         nodeDataKeyIndex: 0,
+        vForIndexCounter: 0,
         generateWxsFunctionName() {
             return `__wxs_${this.wxsFunctionCounter++}`;
         },
         generateFunctionPropertyName() {
             return `__fun_${this.functionPropertyCounter++}`;
         },
+        generateVForIndexName(forItem) {
+            return `_${forItem}_${this.vForIndexCounter++}_index`;
+        },
     };
     const wxsExpressionStatements = [];
     const returnValue = t.objectExpression([]);
@@ -5220,6 +5118,14 @@ const NODE_ENV = process$1.env.NODE_ENV || 'production';
 let pagePaths = null;
 // 缓存文件路径到是否为页面组件的映射
 const pageComponentCache = new Map();
+/**
+ * 清空所有缓存（在 app.json 变更时调用）
+ */
+function clearAllCaches() {
+    pagePaths = null;
+    pageComponentCache.clear();
+    pathCache.clear();
+}
 /**
  * 读取 app.json 并生成页面路径列表
  * 页面路径格式: pages/index/Index 或 subHome/pages/home/HomeIndex
@@ -5720,6 +5626,12 @@ async function dev() {
             }
         })
             .on('change', async (filePath) => {
+            // 如果 app.json 变更，清空所有缓存并重新加载页面路径
+            if (filePath.endsWith('app.json')) {
+                console.log(bold(green('检测到 app.json 变更，清空缓存并重新加载页面路径...')));
+                clearAllCaches();
+                await loadPagePaths();
+            }
             // 如果文件正在处理中，标记需要重新处理（排队一次），不直接丢弃
             if (processingFiles.has(filePath)) {
                 pendingFiles.add(filePath);

package/dist/index.js

@@ -2,7 +2,7 @@ import dotenv from 'dotenv-flow';
 
 async function runVMS(options) {
     dotenv.config({ node_env: options.mode });
-    const { dev, prod } = await import('./cli-BbBKrAPm.js');
+    const { dev, prod } = await import('./cli-R8YB9UUi.js');
     if (options.mode === 'production') {
         return prod(options);
     }

package/dist/macro.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentContext, ShallowRef } from '@vue-mini/core'
+import type { ComponentContext, ShallowRef } from '@unmagic/vue-mini'
 
 type TemplateRef<T = unknown> = Readonly<ShallowRef<T | null>>
 
@@ -12,7 +12,7 @@ declare global {
   function defineContext(): ComponentContext
 
   /**
-   * 定义@vue-mini/core缺少的组件上下文
+   * 定义@unmagic/vue-mini缺少的组件上下文
    * @param key
    */
   function useTemplateRef<T = unknown, Keys extends string = string>(key: Keys): TemplateRef<T>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unmagic/vms",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "基于 @unmagic/vue-mini 的Vue3 单文件组件构建工具",
   "type": "module",
   "main": "dist/index.js",
@@ -38,15 +38,17 @@
     "@types/babel__traverse": "^7.28.0",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^25.5.0",
+    "@vue/reactivity": "3.5.32",
+    "execa": "^9.6.1",
     "fast-check": "^4.7.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.4.0",
+    "miniprogram-api-typings": "4.0.8",
     "oxfmt": "^0.46.0",
     "oxlint": "^1.61.0",
     "oxlint-tsgolint": "^0.21.1",
-    "typescript": "~6.0.3",
-    "lint-staged": "^16.4.0",
     "tsx": "^4.21.0",
-    "husky": "^9.1.7",
-    "execa": "^9.6.1",
+    "typescript": "~6.0.3",
     "vitest": "^4.1.5"
   },
   "dependencies": {