@unmagic/vms 0.0.3-beta.0 → 0.0.3

package/dist/{transformer-DjOYWuap.js → cli-R8YB9UUi.js}

@@ -9,14 +9,24 @@ import t__default from '@babel/types';
 import { generate } from '@babel/generator';
 import _traverse from '@babel/traverse';
 import { codeFrameColumns } from '@babel/code-frame';
-import { bold, red } from 'kolorist';
+import { bold, red, green } from 'kolorist';
 import { createTransformContext, traverseNode } from '@vue/compiler-dom';
 import { fileURLToPath } from 'node:url';
 import { resolve } from 'path';
 import fs from 'fs-extra';
 import { pathToFileURL } from 'url';
 import { NodeTypes } from '@vue/compiler-core';
-import { transformFromAstSync } from '@babel/core';
+import { transformFromAstSync, transformAsync, transformFileAsync } from '@babel/core';
+import commonjs from '@rollup/plugin-commonjs';
+import resolve$1 from '@rollup/plugin-node-resolve';
+import replace from '@rollup/plugin-replace';
+import terser from '@rollup/plugin-terser';
+import chokidar from 'chokidar';
+import { getPackageInfo } from 'local-pkg';
+import process$1 from 'node:process';
+import { rollup } from 'rollup';
+import { minify } from 'terser';
+import { performance } from 'perf_hooks';
 
 var version = "7.29.2";
 var pk = {
@@ -929,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) {
@@ -1263,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参数
@@ -1333,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);
@@ -3432,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;
 }
 /**
  * 处理事件名转换
@@ -4589,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;
@@ -4598,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 };
 }
 /**
@@ -4623,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 供后续使用
@@ -4793,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([]);
@@ -5094,7 +5002,7 @@ function generateUsingComponents(imports, thirdPartyComponents) {
     });
     return usingComponents;
 }
-async function transformVueToMiniProgram(filePath, outputDir, isPage = false, cb, baseDir) {
+async function transformVueToMiniProgram(filePath, outputDir, isPage = false, cb) {
     const vueContent = readFileSync(filePath, 'utf-8');
     const { descriptor } = parse$1(vueContent, {
         filename: filePath,
@@ -5117,7 +5025,7 @@ async function transformVueToMiniProgram(filePath, outputDir, isPage = false, cb
         // 4. 转换 styles
         const css = parseStyles(styles);
         // 5. 生成文件夹
-        const componentDir = join(outputDir, relative(baseDir ?? srcDir, dirname(filePath)));
+        const componentDir = join(outputDir, relative(srcDir, dirname(filePath)));
         if (!existsSync(componentDir)) {
             await mkdir(componentDir, { recursive: true });
         }
@@ -5205,4 +5113,672 @@ async function writeFileIfChangedAsync(filePath, newContent) {
     }
 }
 
-export { OUTPUT_DIR as O, copyProjectConfigFile as a, config as b, copyPolyfillFiles as c, traverse$1 as d, getErrorMessage as g, handleCompileError as h, transformVueToMiniProgram as t, userConfig as u };
+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
+ */
+async function loadPagePaths() {
+    if (pagePaths)
+        return pagePaths;
+    const appJsonPath = path.join(sourceDir, 'app.json');
+    pagePaths = new Set();
+    try {
+        const appJson = await fs.readJson(appJsonPath);
+        // 处理主包 pages
+        if (appJson.pages) {
+            for (const page of appJson.pages) {
+                // page 格式: pages/index/Index
+                pagePaths.add(page);
+            }
+        }
+        // 处理分包 subPackages
+        if (appJson.subPackages) {
+            for (const pkg of appJson.subPackages) {
+                const root = pkg.root;
+                for (const page of pkg.pages) {
+                    // 分包页面格式: subHome/pages/home/HomeIndex
+                    pagePaths.add(`${root}/${page}`);
+                }
+            }
+        }
+        console.log(bold(green(`加载到 ${pagePaths.size} 个页面路径`)));
+    }
+    catch (error) {
+        console.warn('读取 app.json 失败:', getErrorMessage(error));
+    }
+    return pagePaths;
+}
+/**
+ * 判断文件路径是否为页面组件
+ * @param filePath 文件路径，如 src/pages/index/Index.vue
+ * @returns 是否为页面组件
+ */
+function isPageComponent(filePath) {
+    // 检查缓存
+    const cached = pageComponentCache.get(filePath);
+    if (typeof cached === 'boolean')
+        return cached;
+    if (!pagePaths || pagePaths.size === 0) {
+        pageComponentCache.set(filePath, false);
+        return false;
+    }
+    // 移除 sourceDir 前缀和 .vue 后缀
+    const normalizedPath = path.relative(sourceDir, filePath).replace(/\.vue$/, '');
+    const isPage = pagePaths.has(normalizedPath);
+    pageComponentCache.set(filePath, isPage);
+    return isPage;
+}
+// 使用用户配置或默认值
+const sourceDir = userConfig.sourceDir;
+// copyOnly 模式：跳过 Babel、直接复制的文件匹配规则
+const copyOnlyPatterns = userConfig.copyOnly ?? [];
+// 判断文件是否应跳过 Babel 编译直接复制
+function isCopyOnly(filePath) {
+    // .min.js 是已压缩的第三方文件，无需 Babel 编译
+    if (filePath.endsWith('.min.js'))
+        return true;
+    // .d.ts 类型声明文件不需要输出，直接跳过
+    // （在 cb 中单独处理为 skip）
+    // 用户自定义的 copyOnly 规则
+    return copyOnlyPatterns.some((pattern) => filePath.includes(pattern));
+}
+// 获取 @/ 路径替换配置
+const aliasPath = userConfig.alias?.['@'] || `./${sourceDir}`;
+// 更新 babel 配置中的别名
+if (config.plugins) {
+    const moduleResolverPlugin = config.plugins.find((plugin) => Array.isArray(plugin) && plugin[0] === 'module-resolver');
+    if (moduleResolverPlugin &&
+        Array.isArray(moduleResolverPlugin) &&
+        moduleResolverPlugin[1] &&
+        typeof moduleResolverPlugin[1] === 'object') {
+        const options = moduleResolverPlugin[1];
+        if (options.alias) {
+            options.alias['@'] = aliasPath;
+        }
+    }
+}
+let topLevelJobs = [];
+let bundleJobs = [];
+const startTime = Date.now();
+let __PROD__ = false;
+const terserOptions = {
+    ecma: 2016,
+    toplevel: true,
+    safari10: true,
+    format: { comments: false },
+};
+let independentPackages = [];
+// 文件忽略规则 - 提取为常量避免重复定义
+const IGNORED_FILES = (file, stats) => {
+    if (!stats?.isFile())
+        return false;
+    return (file.endsWith('.gitkeep') ||
+        file.endsWith('.DS_Store') ||
+        file.endsWith('.d.ts') || // 类型声明文件不需要处理
+        file.includes('node_modules') ||
+        file.includes('.git'));
+};
+// 并行处理配置
+const CONCURRENT_LIMIT = 5; // 同时处理的文件数量限制
+// 开发模式使用更高并发（默认 5，可根据 CPU 核心数调整）
+const DEV_CONCURRENT_LIMIT = 5;
+// 批量并行处理函数
+async function batchProcess(items, processor, concurrency = CONCURRENT_LIMIT) {
+    // 将 items 分成多个批次，每批并发处理
+    for (let i = 0; i < items.length; i += concurrency) {
+        const batch = items.slice(i, i + concurrency);
+        await Promise.all(batch.map((item) => processor(item).catch((error) => {
+            console.error(`处理失败:`, error);
+        })));
+    }
+}
+// 路径转换缓存 - 避免重复计算
+const pathCache = new Map();
+function getOutputPath(inputPath) {
+    let cached = pathCache.get(inputPath);
+    if (!cached) {
+        cached = inputPath.replace(sourceDir, OUTPUT_DIR);
+        pathCache.set(inputPath, cached);
+    }
+    return cached;
+}
+// 清空路径缓存（在构建完成后调用）
+function clearPathCache() {
+    pathCache.clear();
+}
+async function findIndependentPackages() {
+    const appJson = await fs.readJson(path.resolve(sourceDir, 'app.json'));
+    if (appJson.subpackages) {
+        independentPackages = appJson.subpackages
+            .filter(({ independent }) => independent)
+            .map(({ root }) => root);
+    }
+}
+const builtLibraries = [];
+const bundledModules = new Map();
+async function bundleModule(module, pkg) {
+    const bundled = bundledModules.get(pkg);
+    if (bundled?.has(module) || builtLibraries.some((library) => module.startsWith(library))) {
+        return false;
+    }
+    if (bundled) {
+        bundled.add(module);
+    }
+    else {
+        bundledModules.set(pkg, new Set([module]));
+    }
+    const pkInfo = await getPackageInfo(module);
+    if (pkInfo) {
+        const { packageJson: { peerDependencies }, } = pkInfo;
+        // 这里判断下，如果module在目标位置已存在，则直接返回true
+        const targetExists = await fs.pathExists(path.resolve(pkg.replace(sourceDir, OUTPUT_DIR), 'miniprogram_npm', module));
+        if (targetExists) {
+            return true;
+        }
+        const bundle = await rollup({
+            input: module,
+            external: peerDependencies ? Object.keys(peerDependencies) : undefined,
+            plugins: [
+                commonjs(),
+                replace({
+                    preventAssignment: true,
+                    values: {
+                        'process.env.NODE_ENV': JSON.stringify(NODE_ENV),
+                    },
+                }),
+                resolve$1(),
+                __PROD__ && terser(terserOptions),
+            ].filter(Boolean),
+        });
+        await bundle.write({
+            exports: 'named',
+            file: `${pkg.replace(sourceDir, OUTPUT_DIR)}/miniprogram_npm/${module}/index.js`,
+            format: 'cjs',
+        });
+        return true;
+    }
+    else {
+        console.warn(`未找到 ${module} 的依赖信息`);
+        return false;
+    }
+}
+function traverseAST(ast, pkg, babelOnly = false) {
+    traverse$1(ast, {
+        CallExpression({ node }) {
+            if (!t__default.isIdentifier(node.callee) ||
+                node.callee.name !== 'require' ||
+                !t__default.isStringLiteral(node.arguments[0]) ||
+                node.arguments[0].value.startsWith('.') ||
+                (babelOnly && !node.arguments[0].value.startsWith('@babel/runtime'))) {
+                return;
+            }
+            const module = node.arguments[0].value;
+            let promise = bundleModule(module, pkg);
+            if (babelOnly) {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-expect-error
+                promise = promise.then((valid) => {
+                    if (!valid)
+                        return;
+                    return Promise.all(independentPackages.map((item) => {
+                        const bundled = bundledModules.get(item);
+                        if (bundled) {
+                            bundled.add(module);
+                        }
+                        else {
+                            bundledModules.set(item, new Set([module]));
+                        }
+                        return fs.copy(path.join(OUTPUT_DIR, 'miniprogram_npm', module), path.join(OUTPUT_DIR, item, 'miniprogram_npm', module));
+                    }));
+                });
+            }
+            bundleJobs?.push(promise);
+        },
+    });
+}
+async function buildComponentLibrary(name) {
+    const pkInfo = await getPackageInfo(name);
+    if (pkInfo) {
+        const { rootPath, packageJson: { miniprogram }, } = pkInfo;
+        let source = '';
+        if (miniprogram) {
+            source = path.join(rootPath, miniprogram);
+        }
+        else {
+            try {
+                const dist = path.join(rootPath, 'miniprogram_dist');
+                const stats = await fs.stat(dist);
+                if (stats.isDirectory()) {
+                    source = dist;
+                }
+            }
+            catch {
+                // Empty
+            }
+        }
+        if (!source)
+            return;
+        const destination = path.resolve(OUTPUT_DIR, 'miniprogram_npm', name);
+        builtLibraries.push(name);
+        // ✅ 检查目标位置是否已存在文件夹
+        const destinationExists = await fs.pathExists(destination);
+        if (destinationExists) {
+            return;
+        }
+        await fs.copy(source, destination);
+        // 递归获取所有 .js 文件并处理（替代 watcher，更简洁可靠）
+        const processJsFiles = async (dir) => {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            const jsFiles = [];
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    await processJsFiles(fullPath);
+                }
+                else if (entry.isFile() && entry.name.endsWith('.js')) {
+                    jsFiles.push(fullPath);
+                }
+            }
+            // 并行处理所有 .js 文件
+            await Promise.all(jsFiles.map(async (filePath) => {
+                try {
+                    const result = await transformFileAsync(filePath, { ast: true, ...config });
+                    if (result) {
+                        traverseAST(result.ast, sourceDir, true);
+                        const code = (__PROD__ ? (await minify(result.code, terserOptions)).code : result.code);
+                        await fs.writeFile(filePath, code);
+                    }
+                }
+                catch (error) {
+                    console.error(`处理 ${filePath} 失败:`, getErrorMessage(error));
+                }
+            }));
+        };
+        await processJsFiles(destination);
+        // 复制到独立包
+        if (independentPackages.length > 0) {
+            await Promise.all(independentPackages.map(async (item) => {
+                const independentDestination = path.join(OUTPUT_DIR, item, 'miniprogram_npm', name);
+                const independentDestExists = await fs.pathExists(independentDestination);
+                if (!independentDestExists) {
+                    return fs.copy(destination, independentDestination);
+                }
+            }));
+        }
+    }
+    else {
+        console.warn(`未找到 ${name} 的依赖信息`);
+    }
+}
+async function scanDependencies() {
+    try {
+        const { dependencies } = await fs.readJson('package.json');
+        if (dependencies) {
+            // 并行处理所有依赖，提高启动速度
+            const depNames = Object.keys(dependencies);
+            console.log(bold(green(`扫描到 ${depNames.length} 个依赖，开始并行处理...`)));
+            const startDepTime = Date.now();
+            // 使用批量并行处理依赖
+            await batchProcess(depNames, async (name) => {
+                await buildComponentLibrary(name);
+            }, 5); // 依赖构建限制为 5 个并发，避免过多资源占用
+            console.log(bold(green(`依赖处理完成，耗时：${Date.now() - startDepTime}ms`)));
+        }
+    }
+    catch (error) {
+        console.warn('读取 package.json 失败:', getErrorMessage(error));
+    }
+}
+// 缓存独立包路径的 normalize 结果
+const normalizedPkgPaths = new Map();
+async function dealScriptCode(filePath, result) {
+    const ast = result.ast;
+    let code = result.code;
+    // 使用缓存避免重复 path.normalize 计算
+    let pkg = independentPackages.find((item) => {
+        let normalized = normalizedPkgPaths.get(item);
+        if (!normalized) {
+            normalized = path.normalize(`${sourceDir}/${item}`);
+            normalizedPkgPaths.set(item, normalized);
+        }
+        return filePath.startsWith(normalized);
+    });
+    // The `src/` prefix is added to to distinguish `src` and `src/src`.
+    traverseAST(ast, pkg ? path.join(sourceDir, pkg) : sourceDir);
+    if (__PROD__) {
+        code = (await minify(code, terserOptions)).code;
+    }
+    return code;
+}
+async function processScript(filePath) {
+    try {
+        const result = await transformFileAsync(path.resolve(filePath), {
+            ast: true,
+            ...config,
+        });
+        if (result) {
+            const code = await dealScriptCode(filePath, result);
+            const destination = path.join(getOutputPath(filePath).replace(/\.ts$/, '.js'));
+            // 确保目录存在
+            await fs.ensureDir(path.dirname(destination));
+            // 直接写入，不需要先复制源文件
+            await fs.writeFile(destination, code);
+        }
+    }
+    catch (error) {
+        // 使用统一的编译错误处理（支持 code-frame 定位）
+        handleCompileError('', error, filePath);
+        if (__PROD__)
+            throw error;
+        // 开发模式：打印后继续，不中断整个构建
+    }
+}
+const cb = async (filePath, callbacks) => {
+    if (filePath.endsWith('.vue')) {
+        const t = performance.now();
+        try {
+            await transformVueToMiniProgram(filePath, OUTPUT_DIR, isPageComponent(filePath), async (generatedCode) => {
+                try {
+                    // 先生成代码，再进行转换，这样可以更好地利用默认配置
+                    const result = await transformAsync(generatedCode, {
+                        filename: filePath.replace('.vue', '.js'),
+                        ...config,
+                    });
+                    if (result) {
+                        return dealScriptCode(filePath, result);
+                    }
+                    return `Failed to transformAsync ${filePath}`;
+                }
+                catch (error) {
+                    // 使用统一的编译错误处理（支持 code-frame 定位）
+                    handleCompileError('', error, filePath);
+                    // 返回错误占位代码，保证输出文件存在，开发模式下不中断构建
+                    return `console.error('Failed to compile ${filePath}: ${error.message?.replace(/'/g, "\\'")}');`;
+                }
+            });
+        }
+        catch (error) {
+            // transformer.ts 内部已调用 handleCompileError 输出带 code-frame 的错误信息
+            // 此处仅在生产模式下 rethrow，开发模式静默继续，不重复打印
+            if (__PROD__)
+                throw error;
+            return;
+        }
+        finally {
+            callbacks?.vueCb?.(performance.now() - t);
+        }
+        return;
+    }
+    // .d.ts 类型声明文件不需要输出，直接跳过
+    if (filePath.endsWith('.d.ts'))
+        return;
+    // copyOnly 模式：跳过 Babel、直接复制（.min.js 及用户配置的 copyOnly 规则）
+    if (isCopyOnly(filePath)) {
+        const t = performance.now();
+        const destinationPath = getOutputPath(filePath);
+        await fs.ensureDir(path.dirname(destinationPath));
+        await fs.copy(filePath, destinationPath);
+        callbacks?.othersCb?.(performance.now() - t);
+        return;
+    }
+    if (filePath.endsWith('.ts') || filePath.endsWith('.js')) {
+        const t = performance.now();
+        await processScript(filePath);
+        callbacks?.jsCb?.(performance.now() - t);
+        return;
+    }
+    const t = performance.now();
+    const destinationPath = path.join(getOutputPath(filePath));
+    await fs.copy(filePath, path.normalize(destinationPath));
+    callbacks?.othersCb?.(performance.now() - t);
+};
+async function dev() {
+    __PROD__ = false;
+    const t0 = Date.now();
+    // 复制polyfill文件
+    copyPolyfillFiles()
+        .then(() => {
+        console.log(bold(green(`[timing] copyPolyfillFiles: ${Date.now() - t0}ms`)));
+        return copyProjectConfigFile();
+    })
+        .then(() => {
+        console.log(bold(green(`[timing] copyProjectConfigFile: ${Date.now() - t0}ms`)));
+        return loadPagePaths();
+    })
+        .then(() => {
+        console.log(bold(green(`[timing] loadPagePaths: ${Date.now() - t0}ms`)));
+        return findIndependentPackages();
+    })
+        .then(() => {
+        console.log(bold(green(`[timing] findIndependentPackages: ${Date.now() - t0}ms`)));
+        return scanDependencies();
+    })
+        .then(() => {
+        console.log(bold(green(`[timing] scanDependencies: ${Date.now() - t0}ms`)));
+        // 用于跟踪正在处理的文件，避免重复处理
+        const processingFiles = new Set();
+        // 用于排队：编译期间又触发了 change 的文件
+        const pendingFiles = new Set();
+        // 用于收集初始扫描的文件，进行批量并行处理
+        const initialFiles = [];
+        let isInitialScan = true;
+        chokidar
+            .watch([sourceDir], {
+            awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 50 },
+            ignored: IGNORED_FILES,
+            usePolling: false,
+            interval: 100,
+        })
+            .on('add', (filePath) => {
+            if (isInitialScan) {
+                // 初始扫描阶段，收集文件用于批量处理
+                initialFiles.push(filePath);
+            }
+            else {
+                // 运行时新增文件，立即处理
+                const promise = cb(filePath);
+                topLevelJobs?.push(promise);
+            }
+        })
+            .on('addDir', (dirPath) => {
+            // 新建目录时，在输出目录同步创建
+            const outputDir = getOutputPath(dirPath);
+            const promise = fs.ensureDir(outputDir);
+            topLevelJobs?.push(promise);
+        })
+            .on('unlink', async (filePath) => {
+            // 文件删除时同步删除目标文件
+            const outputPath = getOutputPath(filePath);
+            const basePath = outputPath.replace(/\.vue$/, '');
+            const filesToDelete = filePath.endsWith('.vue')
+                ? [`${basePath}.js`, `${basePath}.wxml`, `${basePath}.wxss`, `${basePath}.json`]
+                : [path.join(outputPath)];
+            try {
+                await Promise.all(filesToDelete.map((f) => fs.remove(f)));
+                // 同步移除 pathCache 中的缓存
+                pathCache.delete(filePath);
+            }
+            catch (error) {
+                console.warn(`删除目标文件失败：${filesToDelete.join(', ')}`, getErrorMessage(error));
+            }
+        })
+            .on('unlinkDir', async (dirPath) => {
+            // 目录删除时同步删除输出目录
+            const outputDir = getOutputPath(dirPath);
+            try {
+                await fs.remove(outputDir);
+            }
+            catch (error) {
+                console.warn(`删除目标目录失败：${outputDir}`, getErrorMessage(error));
+            }
+        })
+            .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);
+                return;
+            }
+            // 使用循环代替递归，避免调用栈过深
+            const runCompile = async (initialPath) => {
+                let targetPath = initialPath;
+                while (targetPath) {
+                    processingFiles.add(targetPath);
+                    const date = Date.now();
+                    console.log(bold(green(`文件已修改：${targetPath}`)));
+                    let shouldContinue = false;
+                    try {
+                        await cb(targetPath);
+                        console.log(bold(green(`文件已处理完毕，耗时：${Date.now() - date}ms`)));
+                    }
+                    finally {
+                        processingFiles.delete(targetPath);
+                        // 如果编译期间又有新的保存，继续循环处理
+                        if (pendingFiles.has(targetPath)) {
+                            pendingFiles.delete(targetPath);
+                            shouldContinue = true;
+                        }
+                    }
+                    if (!shouldContinue) {
+                        break;
+                    }
+                }
+            };
+            await runCompile(filePath);
+        })
+            .on('ready', async () => {
+            // 标记初始扫描完成
+            isInitialScan = false;
+            console.log(bold(green(`[timing] chokidar ready（文件扫描完成）: ${Date.now() - t0}ms，共 ${initialFiles.length} 个文件`)));
+            // 统计文件类型
+            const vueFiles = initialFiles.filter((f) => f.endsWith('.vue'));
+            const tsFiles = initialFiles.filter((f) => f.endsWith('.ts') || f.endsWith('.js'));
+            const otherFiles = initialFiles.filter((f) => !f.endsWith('.vue') && !f.endsWith('.ts') && !f.endsWith('.js'));
+            console.log(bold(green(`[timing] 文件分布：vue=${vueFiles.length}, ts/js=${tsFiles.length}, 其他=${otherFiles.length}`)));
+            // 文件处理器（带计时）
+            let vueTime = 0, tsTime = 0, otherTime = 0;
+            const fileProcessor = async (filePath) => {
+                await cb(filePath, {
+                    vueCb: (elapsed) => {
+                        vueTime += elapsed;
+                    },
+                    jsCb: (elapsed) => {
+                        tsTime += elapsed;
+                    },
+                    othersCb: (elapsed) => {
+                        otherTime += elapsed;
+                    },
+                });
+            };
+            // 使用批量并行处理初始文件（开发模式使用更高并发）
+            if (initialFiles.length > 0) {
+                console.log(bold(green(`开始并行处理 ${initialFiles.length} 个文件（并发=${DEV_CONCURRENT_LIMIT}）...`)));
+                const processStartTime = Date.now();
+                await batchProcess(initialFiles, fileProcessor, DEV_CONCURRENT_LIMIT);
+                console.log(bold(green(`[timing] 并行处理完成：${Date.now() - processStartTime}ms（总耗时 ${Date.now() - t0}ms）`)));
+                console.log(bold(green(`[timing] 耗时分布：vue=${vueTime}ms, ts/js=${tsTime}ms, 其他=${otherTime}ms`)));
+            }
+            await Promise.all(bundleJobs);
+            console.log(bold(green(`启动完成，耗时：${Date.now() - startTime}ms`)));
+            console.log(bold(green('监听文件变化中...')));
+            // Release memory.
+            topLevelJobs = null;
+            bundleJobs = null;
+            // 开发模式下不清空缓存，保持性能优势
+        });
+    });
+}
+async function prod(options) {
+    __PROD__ = true;
+    return new Promise((resolve, reject) => {
+        fs.remove(OUTPUT_DIR)
+            .then(() => copyPolyfillFiles())
+            .then(() => copyProjectConfigFile())
+            .then(() => loadPagePaths())
+            .then(() => findIndependentPackages())
+            .then(() => scanDependencies())
+            .then(() => {
+            const initialFiles = [];
+            let isInitialScan = true;
+            const watcher = chokidar.watch([sourceDir], {
+                ignored: IGNORED_FILES,
+            });
+            watcher.on('add', (filePath) => {
+                if (isInitialScan) {
+                    initialFiles.push(filePath);
+                }
+                else {
+                    const promise = cb(filePath);
+                    topLevelJobs.push(promise);
+                }
+            });
+            watcher.on('ready', async () => {
+                isInitialScan = false;
+                // 文件处理器
+                const fileProcessor = async (filePath) => {
+                    await cb(filePath);
+                };
+                // 使用批量并行处理初始文件（生产环境使用更高的并发数）
+                if (initialFiles.length > 0) {
+                    console.log(bold(green(`开始并行处理 ${initialFiles.length} 个文件...`)));
+                    const processStartTime = Date.now();
+                    await batchProcess(initialFiles, fileProcessor, CONCURRENT_LIMIT);
+                    console.log(bold(green(`并行处理完成，耗时：${Date.now() - processStartTime}ms`)));
+                }
+                const promise = watcher.close();
+                topLevelJobs.push(promise);
+                await Promise.all(topLevelJobs);
+                await Promise.all(bundleJobs);
+                // Release memory and clear cache.
+                topLevelJobs = null;
+                bundleJobs = null;
+                clearPathCache();
+                normalizedPkgPaths.clear();
+                if (options.upload) {
+                    const { default: ci } = await import('miniprogram-ci');
+                    const project = new ci.Project({
+                        appid: userConfig.wx.appid,
+                        type: 'miniProgram',
+                        projectPath: OUTPUT_DIR,
+                        privateKeyPath: userConfig.wx.privateKeyPath,
+                        ignores: [],
+                    });
+                    console.log(bold(green('上传中...')));
+                    // 读取位于 projectPath 下的 project.config.json
+                    const uploadResult = await ci.upload({
+                        project,
+                        version: userConfig.wx.version,
+                        desc: userConfig.wx.description,
+                        setting: {
+                            useProjectConfig: true,
+                        },
+                        onProgressUpdate: void 0,
+                    });
+                    console.log(bold(green(`上传结果：`)), uploadResult, '当前编译环境：', NODE_ENV);
+                }
+                resolve();
+            });
+        })
+            .catch(reject);
+    });
+}
+
+export { dev, prod };