weapp-vite 6.0.0-alpha.1 → 6.0.0-alpha.2

package/dist/{chunk-EL4WI75Z.cjs → chunk-KBGC6ODZ.cjs}

@@ -16311,9 +16311,9 @@ pp$5.parseArrowExpression = function(node, params, isAsync, forInit) {
   return this.finishNode(node, "ArrowFunctionExpression");
 };
 pp$5.parseFunctionBody = function(node, isArrowFunction, isMethod, forInit) {
-  var isExpression = isArrowFunction && this.type !== types$1.braceL;
+  var isExpression2 = isArrowFunction && this.type !== types$1.braceL;
   var oldStrict = this.strict, useStrict = false;
-  if (isExpression) {
+  if (isExpression2) {
     node.body = this.parseMaybeAssign(forInit);
     node.expression = true;
     this.checkParams(node, false);
@@ -24545,6 +24545,156 @@ _chunkTZGJRA2Ycjs.init_cjs_shims.call(void 0, );
 
 
 var _compilercore = require('@vue/compiler-core');
+var generate = _nullishCoalesce(_generator2.default.default, () => ( _generator2.default));
+function generateExpression(node) {
+  const { code } = generate(node, {
+    compact: true,
+    jsescOption: { quotes: "single" }
+  });
+  return code;
+}
+function parseBabelExpression(exp) {
+  try {
+    const ast = _parser.parse.call(void 0, `(${exp})`, {
+      sourceType: "module",
+      plugins: ["typescript"]
+    });
+    const stmt = ast.program.body[0];
+    if (!stmt || !("expression" in stmt)) {
+      return null;
+    }
+    return stmt.expression;
+  } catch (e33) {
+    return null;
+  }
+}
+function normalizeClassBindingExpression(exp, context) {
+  const ast = parseBabelExpression(exp);
+  if (!ast) {
+    return [normalizeWxmlExpression(exp)];
+  }
+  const out = [];
+  const pushExpr = (node) => {
+    out.push(normalizeWxmlExpression(generateExpression(node)));
+  };
+  const visit = (node) => {
+    if (!node) {
+      return;
+    }
+    if (t2.isArrayExpression(node)) {
+      for (const el of node.elements) {
+        if (!el) {
+          continue;
+        }
+        if (t2.isSpreadElement(el)) {
+          context.warnings.push("Spread syntax in :class is not supported in mini-programs, ignoring it");
+          continue;
+        }
+        if (t2.isExpression(el)) {
+          visit(el);
+        }
+      }
+      return;
+    }
+    if (t2.isObjectExpression(node)) {
+      for (const prop of node.properties) {
+        if (t2.isSpreadElement(prop)) {
+          context.warnings.push("Spread syntax in :class object is not supported in mini-programs, ignoring it");
+          continue;
+        }
+        if (!t2.isObjectProperty(prop)) {
+          continue;
+        }
+        const value = prop.value;
+        if (!t2.isExpression(value)) {
+          continue;
+        }
+        const test = value;
+        if (prop.computed) {
+          const keyExpr = prop.key;
+          if (!t2.isExpression(keyExpr)) {
+            continue;
+          }
+          pushExpr(t2.conditionalExpression(test, keyExpr, t2.stringLiteral("")));
+        } else if (t2.isIdentifier(prop.key)) {
+          pushExpr(t2.conditionalExpression(test, t2.stringLiteral(prop.key.name), t2.stringLiteral("")));
+        } else if (t2.isStringLiteral(prop.key)) {
+          pushExpr(t2.conditionalExpression(test, t2.stringLiteral(prop.key.value), t2.stringLiteral("")));
+        }
+      }
+      return;
+    }
+    pushExpr(node);
+  };
+  visit(ast);
+  if (!out.length) {
+    return [normalizeWxmlExpression(exp)];
+  }
+  return out;
+}
+function renderClassAttribute(staticClass, classExpressions) {
+  const parts = [];
+  if (_optionalChain([staticClass, 'optionalAccess', _452 => _452.trim, 'call', _453 => _453()])) {
+    parts.push(staticClass.trim());
+  }
+  for (const exp of _nullishCoalesce(classExpressions, () => ( []))) {
+    if (!exp) {
+      continue;
+    }
+    parts.push(`{{${exp}}}`);
+  }
+  return `class="${parts.join(" ")}"`;
+}
+function renderStyleAttribute(staticStyle, dynamicStyleExp, vShowExp) {
+  let merged = "";
+  if (_optionalChain([staticStyle, 'optionalAccess', _454 => _454.trim, 'call', _455 => _455()])) {
+    merged += staticStyle.trim();
+  }
+  if (merged && !/;\s*$/.test(merged)) {
+    merged += ";";
+  }
+  if (dynamicStyleExp) {
+    const expValue = normalizeWxmlExpression(dynamicStyleExp);
+    merged += `{{${expValue}}}`;
+  }
+  if (vShowExp) {
+    const hiddenStyle = merged ? ";display: none" : "display: none";
+    merged += `{{${vShowExp} ? '' : '${hiddenStyle}'}}`;
+  }
+  return `style="${merged}"`;
+}
+function parseInlineHandler(exp) {
+  try {
+    const ast = _parser.parse.call(void 0, `(${exp})`, {
+      sourceType: "module",
+      plugins: ["typescript"]
+    });
+    const stmt = ast.program.body[0];
+    if (!stmt || !("expression" in stmt)) {
+      return null;
+    }
+    const expression = stmt.expression;
+    if (!t2.isCallExpression(expression) || !t2.isIdentifier(expression.callee)) {
+      return null;
+    }
+    const name = expression.callee.name;
+    const args = [];
+    for (const arg of expression.arguments) {
+      if (t2.isIdentifier(arg) && arg.name === "$event") {
+        args.push("$event");
+      } else if (t2.isStringLiteral(arg) || t2.isNumericLiteral(arg) || t2.isBooleanLiteral(arg)) {
+        args.push(arg.value);
+      } else if (t2.isNullLiteral(arg)) {
+        args.push(null);
+      } else {
+        return null;
+      }
+    }
+    return { name, args };
+  } catch (e34) {
+    return null;
+  }
+}
 function templateLiteralToConcat(node) {
   const segments = [];
   node.quasis.forEach((quasi, index) => {
@@ -24583,12 +24733,12 @@ function normalizeWxmlExpression(exp) {
     }
     const expression = stmt.expression;
     const normalized = t2.isTemplateLiteral(expression) ? templateLiteralToConcat(expression) : expression;
-    const { code } = _generator2.default.call(void 0, normalized, {
+    const { code } = generate(normalized, {
       compact: true,
       jsescOption: { quotes: "single" }
     });
     return code;
-  } catch (e33) {
+  } catch (e35) {
     if (exp.startsWith("`") && exp.endsWith("`")) {
       const inner = exp.slice(1, -1);
       let rewritten = `'${inner.replace(/\$\{([^}]+)\}/g, "' + ($1) + '")}'`;
@@ -24641,23 +24791,63 @@ function transformElement(node, context) {
 function transformNormalElement(node, context) {
   const { tag, props } = node;
   const attrs = [];
+  let staticClass;
+  let dynamicClassExp;
+  let staticStyle;
+  let dynamicStyleExp;
+  let vShowExp;
+  let vTextExp;
   for (const prop of props) {
     if (prop.type === _compilercore.NodeTypes.ATTRIBUTE) {
+      if (prop.name === "class" && _optionalChain([prop, 'access', _456 => _456.value, 'optionalAccess', _457 => _457.type]) === _compilercore.NodeTypes.TEXT) {
+        staticClass = prop.value.content;
+        continue;
+      }
+      if (prop.name === "style" && _optionalChain([prop, 'access', _458 => _458.value, 'optionalAccess', _459 => _459.type]) === _compilercore.NodeTypes.TEXT) {
+        staticStyle = prop.value.content;
+        continue;
+      }
       const attr = transformAttribute(prop, context);
       if (attr) {
         attrs.push(attr);
       }
     } else if (prop.type === _compilercore.NodeTypes.DIRECTIVE) {
+      if (prop.name === "bind" && _optionalChain([prop, 'access', _460 => _460.arg, 'optionalAccess', _461 => _461.type]) === _compilercore.NodeTypes.SIMPLE_EXPRESSION && prop.arg.content === "class" && _optionalChain([prop, 'access', _462 => _462.exp, 'optionalAccess', _463 => _463.type]) === _compilercore.NodeTypes.SIMPLE_EXPRESSION) {
+        dynamicClassExp = prop.exp.content;
+        continue;
+      }
+      if (prop.name === "bind" && _optionalChain([prop, 'access', _464 => _464.arg, 'optionalAccess', _465 => _465.type]) === _compilercore.NodeTypes.SIMPLE_EXPRESSION && prop.arg.content === "style" && _optionalChain([prop, 'access', _466 => _466.exp, 'optionalAccess', _467 => _467.type]) === _compilercore.NodeTypes.SIMPLE_EXPRESSION) {
+        dynamicStyleExp = prop.exp.content;
+        continue;
+      }
+      if (prop.name === "show" && _optionalChain([prop, 'access', _468 => _468.exp, 'optionalAccess', _469 => _469.type]) === _compilercore.NodeTypes.SIMPLE_EXPRESSION) {
+        vShowExp = normalizeWxmlExpression(prop.exp.content);
+        continue;
+      }
+      if (prop.name === "text" && _optionalChain([prop, 'access', _470 => _470.exp, 'optionalAccess', _471 => _471.type]) === _compilercore.NodeTypes.SIMPLE_EXPRESSION) {
+        vTextExp = normalizeWxmlExpression(prop.exp.content);
+        continue;
+      }
       const dir = transformDirective(prop, context, node);
       if (dir) {
         attrs.push(dir);
       }
     }
   }
+  if (staticClass || dynamicClassExp) {
+    const expressions = dynamicClassExp ? normalizeClassBindingExpression(dynamicClassExp, context) : void 0;
+    attrs.unshift(renderClassAttribute(staticClass, expressions));
+  }
+  if (staticStyle || dynamicStyleExp || vShowExp) {
+    attrs.unshift(renderStyleAttribute(staticStyle, dynamicStyleExp, vShowExp));
+  }
   let children = "";
   if (node.children.length > 0) {
     children = node.children.map((child) => transformNode(child, context)).join("");
   }
+  if (vTextExp !== void 0) {
+    children = `{{${vTextExp}}}`;
+  }
   const attrString = attrs.length ? ` ${attrs.join(" ")}` : "";
   return children ? `<${tag}${attrString}>${children}</${tag}>` : `<${tag}${attrString} />`;
 }
@@ -24673,6 +24863,7 @@ function transformAttribute(node, _context) {
 }
 function transformDirective(node, context, elementNode, forInfo) {
   const { name, exp, arg } = node;
+  const isSimpleHandler = (value) => /^[A-Z_$][\w$]*$/i.test(value);
   if (name === "bind") {
     if (!arg) {
       return null;
@@ -24685,13 +24876,13 @@ function transformDirective(node, context, elementNode, forInfo) {
     const expValue = normalizeWxmlExpression(rawExpValue);
     if (argValue === "key") {
       const trimmed = expValue.trim();
-      if (_optionalChain([forInfo, 'optionalAccess', _452 => _452.item]) && trimmed === forInfo.item) {
+      if (_optionalChain([forInfo, 'optionalAccess', _472 => _472.item]) && trimmed === forInfo.item) {
         return 'wx:key="*this"';
       }
-      if (_optionalChain([forInfo, 'optionalAccess', _453 => _453.key]) && trimmed === forInfo.key) {
+      if (_optionalChain([forInfo, 'optionalAccess', _473 => _473.key]) && trimmed === forInfo.key) {
         return 'wx:key="*this"';
       }
-      if (_optionalChain([forInfo, 'optionalAccess', _454 => _454.item]) && trimmed.startsWith(`${forInfo.item}.`)) {
+      if (_optionalChain([forInfo, 'optionalAccess', _474 => _474.item]) && trimmed.startsWith(`${forInfo.item}.`)) {
         const remainder = trimmed.slice(forInfo.item.length + 1);
         const firstSegment = remainder.split(".")[0] || remainder;
         return `wx:key="${firstSegment}"`;
@@ -24710,6 +24901,8 @@ function transformDirective(node, context, elementNode, forInfo) {
     }
     const rawExpValue = exp.type === _compilercore.NodeTypes.SIMPLE_EXPRESSION ? exp.content : "";
     const expValue = normalizeWxmlExpression(rawExpValue);
+    const isInlineExpression = rawExpValue && !isSimpleHandler(rawExpValue);
+    const inlineHandler = isInlineExpression ? parseInlineHandler(rawExpValue) : null;
     const eventMap = {
       click: "tap",
       dblclick: "tap",
@@ -24733,6 +24926,19 @@ function transformDirective(node, context, elementNode, forInfo) {
       longpress: "longpress"
     };
     const wxEvent = eventMap[argValue] || argValue;
+    if (inlineHandler) {
+      const argsJson = JSON.stringify(inlineHandler.args);
+      const escapedArgs = argsJson.replace(/"/g, "&quot;");
+      return [
+        `data-wv-handler="${inlineHandler.name}"`,
+        `data-wv-args="${escapedArgs}"`,
+        `bind${wxEvent}="__weapp_vite_inline"`
+      ].join(" ");
+    }
+    if (isInlineExpression) {
+      const escaped = rawExpValue.replace(/"/g, "&quot;");
+      return `data-wv-inline="${escaped}" bind${wxEvent}="__weapp_vite_inline"`;
+    }
     return `bind${wxEvent}="${expValue}"`;
   }
   if (name === "model") {
@@ -24749,20 +24955,12 @@ function transformDirective(node, context, elementNode, forInfo) {
     }
     const rawExpValue = exp.type === _compilercore.NodeTypes.SIMPLE_EXPRESSION ? exp.content : "";
     const expValue = normalizeWxmlExpression(rawExpValue);
-    return `style="{{display: ${expValue} ? '' : 'none'}}"`;
+    return `style="{{${expValue} ? '' : 'display: none'}}"`;
   }
   if (name === "html") {
     context.warnings.push("v-html is not supported in mini-programs, use rich-text component instead");
     return null;
   }
-  if (name === "text") {
-    if (!exp) {
-      return null;
-    }
-    const rawExpValue = exp.type === _compilercore.NodeTypes.SIMPLE_EXPRESSION ? exp.content : "";
-    const expValue = normalizeWxmlExpression(rawExpValue);
-    return `>{{${expValue}}`;
-  }
   if (name === "cloak") {
     return null;
   }
@@ -24895,7 +25093,7 @@ function transformComponentElement(node, context) {
   let isDirective;
   for (const prop of node.props) {
     if (prop.type === _compilercore.NodeTypes.DIRECTIVE) {
-      if (prop.name === "bind" && _optionalChain([prop, 'access', _455 => _455.arg, 'optionalAccess', _456 => _456.type]) === _compilercore.NodeTypes.SIMPLE_EXPRESSION && prop.arg.content === "is") {
+      if (prop.name === "bind" && _optionalChain([prop, 'access', _475 => _475.arg, 'optionalAccess', _476 => _476.type]) === _compilercore.NodeTypes.SIMPLE_EXPRESSION && prop.arg.content === "is") {
         isDirective = prop;
         break;
       }
@@ -24947,35 +25145,92 @@ function transformKeepAliveElement(node, context) {
 }
 function transformTemplateElement(node, context) {
   let slotDirective;
+  let nameAttr = "";
+  let isAttr = "";
+  let dataAttr = "";
+  let hasOtherDirective = false;
+  let structuralDirective;
   for (const prop of node.props) {
     if (prop.type === _compilercore.NodeTypes.DIRECTIVE && prop.name === "slot") {
       slotDirective = prop;
       break;
     }
+    if (prop.type === _compilercore.NodeTypes.DIRECTIVE) {
+      hasOtherDirective = true;
+      if (!structuralDirective && (prop.name === "if" || prop.name === "else-if" || prop.name === "else" || prop.name === "for")) {
+        structuralDirective = prop;
+      }
+    }
+    if (prop.type === _compilercore.NodeTypes.ATTRIBUTE && prop.name === "name") {
+      nameAttr = prop.value && prop.value.type === _compilercore.NodeTypes.TEXT ? prop.value.content : "";
+    }
+    if (prop.type === _compilercore.NodeTypes.ATTRIBUTE && prop.name === "is") {
+      isAttr = prop.value && prop.value.type === _compilercore.NodeTypes.TEXT ? prop.value.content : "";
+    }
+    if (prop.type === _compilercore.NodeTypes.ATTRIBUTE && prop.name === "data") {
+      dataAttr = prop.value && prop.value.type === _compilercore.NodeTypes.TEXT ? prop.value.content : "";
+    }
   }
-  if (!slotDirective) {
-    context.warnings.push(
-      "<template> element without v-slot is not supported in mini-programs, converting to <block>"
-    );
-    return transformNormalElement(node, context).replace(/<template/g, "<block").replace(/<\/template>/g, "</block>");
-  }
-  const slotName = slotDirective.arg ? slotDirective.arg.type === _compilercore.NodeTypes.SIMPLE_EXPRESSION ? slotDirective.arg.content : "" : "";
-  const slotProps = slotDirective.exp ? slotDirective.exp.type === _compilercore.NodeTypes.SIMPLE_EXPRESSION ? slotDirective.exp.content : "" : "";
   const children = node.children.map((child) => transformNode(child, context)).join("");
+  if (!slotDirective && !nameAttr && !isAttr && !dataAttr) {
+    if (_optionalChain([structuralDirective, 'optionalAccess', _477 => _477.name]) === "for") {
+      return transformForElement({ ...node, tag: "block" }, context);
+    }
+    if (structuralDirective && (structuralDirective.name === "if" || structuralDirective.name === "else-if" || structuralDirective.name === "else")) {
+      const dir = structuralDirective;
+      const base = node.props.filter((prop) => prop !== dir);
+      const fakeNode = { ...node, tag: "block", props: base };
+      if (dir.name === "if" && dir.exp) {
+        const rawExpValue = dir.exp.type === _compilercore.NodeTypes.SIMPLE_EXPRESSION ? dir.exp.content : "";
+        const expValue = normalizeWxmlExpression(rawExpValue);
+        return `<block wx:if="{{${expValue}}}">${children}</block>`;
+      }
+      if (dir.name === "else-if" && dir.exp) {
+        const rawExpValue = dir.exp.type === _compilercore.NodeTypes.SIMPLE_EXPRESSION ? dir.exp.content : "";
+        const expValue = normalizeWxmlExpression(rawExpValue);
+        return `<block wx:elif="{{${expValue}}}">${children}</block>`;
+      }
+      if (dir.name === "else") {
+        return `<block wx:else>${children}</block>`;
+      }
+      return transformIfElement(fakeNode, context);
+    }
+    if (hasOtherDirective) {
+      return transformNormalElement(node, context).replace(/<template/g, "<block").replace(/<\/template>/g, "</block>");
+    }
+    return children;
+  }
   const attrs = [];
-  if (slotName) {
-    attrs.push(`slot="${slotName}"`);
-  } else {
-    attrs.push('slot=""');
+  if (nameAttr) {
+    attrs.push(`name="${nameAttr}"`);
   }
-  if (slotProps) {
-    context.warnings.push(
-      `Scoped slots with v-slot="${slotProps}" require runtime support. Generated code may need adjustment.`
-    );
-    attrs.push(`data="${slotProps}"`);
+  if (isAttr) {
+    attrs.push(`is="${isAttr}"`);
+  }
+  if (dataAttr) {
+    attrs.push(`data="${dataAttr}"`);
+  }
+  if (slotDirective) {
+    const slotName = slotDirective.arg ? slotDirective.arg.type === _compilercore.NodeTypes.SIMPLE_EXPRESSION ? slotDirective.arg.content : "" : "";
+    const slotProps = slotDirective.exp ? slotDirective.exp.type === _compilercore.NodeTypes.SIMPLE_EXPRESSION ? slotDirective.exp.content : "" : "";
+    if (slotName) {
+      attrs.push(`slot="${slotName}"`);
+    } else {
+      attrs.push('slot=""');
+    }
+    if (slotProps) {
+      context.warnings.push(
+        `Scoped slots with v-slot="${slotProps}" require runtime support. Generated code may need adjustment.`
+      );
+      attrs.push(`data="${slotProps}"`);
+    }
+  }
+  if (!slotDirective && !nameAttr && !isAttr && !dataAttr) {
+    return children;
   }
   const attrString = attrs.length ? ` ${attrs.join(" ")}` : "";
-  return `<template${attrString}>${children}</template>`;
+  const tagName = slotDirective ? "block" : "template";
+  return `<${tagName}${attrString}>${children}</${tagName}>`;
 }
 function parseForExpression(exp) {
   const match2 = exp.match(/^\(([^,]+),\s*([^,]+),\s*([^)]+)\)\s+in\s+(.+)$/);
@@ -25189,7 +25444,7 @@ async function collectVuePages(root) {
         results.push(full);
       }
     }
-  } catch (e34) {
+  } catch (e36) {
   }
   return results;
 }
@@ -25302,7 +25557,7 @@ function transformScript(source, options) {
         path38.remove();
         return;
       }
-      if (_optionalChain([path38, 'access', _457 => _457.node, 'access', _458 => _458.specifiers, 'optionalAccess', _459 => _459.length])) {
+      if (_optionalChain([path38, 'access', _478 => _478.node, 'access', _479 => _479.specifiers, 'optionalAccess', _480 => _480.length])) {
         const remaining = path38.node.specifiers.filter((spec) => {
           if (t3.isExportSpecifier(spec)) {
             return spec.exportKind !== "type";
@@ -25337,7 +25592,7 @@ function transformScript(source, options) {
       defaultExportPath = path38;
     },
     CallExpression(path38) {
-      if (t3.isIdentifier(path38.node.callee, { name: "__expose" }) && _optionalChain([path38, 'access', _460 => _460.parentPath, 'optionalAccess', _461 => _461.isExpressionStatement, 'call', _462 => _462()])) {
+      if (t3.isIdentifier(path38.node.callee, { name: "__expose" }) && _optionalChain([path38, 'access', _481 => _481.parentPath, 'optionalAccess', _482 => _482.isExpressionStatement, 'call', _483 => _483()])) {
         path38.parentPath.remove();
         transformed = true;
         return;
@@ -25429,7 +25684,7 @@ function transformScript(source, options) {
       defineComponentDecls,
       defineComponentAliases
     );
-    if (componentExpr && _optionalChain([options, 'optionalAccess', _463 => _463.skipComponentTransform])) {
+    if (componentExpr && _optionalChain([options, 'optionalAccess', _484 => _484.skipComponentTransform])) {
       exportPath.replaceWith(t3.exportDefaultDeclaration(componentExpr));
       transformed = true;
     } else if (componentExpr) {
@@ -25496,7 +25751,7 @@ async function evaluateJsLikeConfig(source, filename, lang) {
       filepath: tempFile,
       cwd: dir
     });
-    let resolved = _nullishCoalesce(_optionalChain([mod, 'optionalAccess', _464 => _464.default]), () => ( mod));
+    let resolved = _nullishCoalesce(_optionalChain([mod, 'optionalAccess', _485 => _485.default]), () => ( mod));
     if (typeof resolved === "function") {
       resolved = resolved();
     }
@@ -25510,14 +25765,14 @@ async function evaluateJsLikeConfig(source, filename, lang) {
   } finally {
     try {
       await _fsextra2.default.remove(tempFile);
-    } catch (e35) {
+    } catch (e37) {
     }
     try {
       const remains = await _fsextra2.default.readdir(tempDir);
       if (remains.length === 0) {
         await _fsextra2.default.remove(tempDir);
       }
-    } catch (e36) {
+    } catch (e38) {
     }
   }
 }
@@ -25557,6 +25812,10 @@ async function compileVueFile(source, filename) {
     throw new Error(`Failed to parse ${filename}: ${error.message}`);
   }
   const result = {};
+  result.meta = {
+    hasScriptSetup: !!descriptor.scriptSetup,
+    hasSetupOption: !!descriptor.script && /\bsetup\s*\(/.test(descriptor.script.content)
+  };
   const isAppFile = /[\\/]app\.vue$/.test(filename);
   if (descriptor.script || descriptor.scriptSetup) {
     const scriptCompiled = _compilersfc.compileScript.call(void 0, descriptor, {
@@ -25650,7 +25909,7 @@ function createVueTransformPlugin(ctx) {
         };
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        console.error(`[Vue transform] Error transforming ${filename}: ${message}`);
+        logger_default.error(`[Vue transform] Error transforming ${filename}: ${message}`);
         throw error;
       }
     },
@@ -25666,6 +25925,8 @@ function createVueTransformPlugin(ctx) {
         if (!relativeBase) {
           continue;
         }
+        const isAppVue = /[\\/]app\.vue$/.test(filename);
+        const shouldEmitComponentJson = !isAppVue;
         if (result.template) {
           const wxmlFileName = `${relativeBase}.wxml`;
           if (!bundle[wxmlFileName]) {
@@ -25686,37 +25947,55 @@ function createVueTransformPlugin(ctx) {
             });
           }
         }
-        if (result.config) {
+        if (result.config || shouldEmitComponentJson) {
           const jsonFileName = `${relativeBase}.json`;
           const existing = bundle[jsonFileName];
+          const defaultConfig = shouldEmitComponentJson ? { component: true } : void 0;
+          let nextConfig;
+          if (result.config) {
+            try {
+              nextConfig = JSON.parse(result.config);
+            } catch (e39) {
+              nextConfig = void 0;
+            }
+          }
+          if (defaultConfig) {
+            nextConfig = { ...defaultConfig, ..._nullishCoalesce(nextConfig, () => ( {})) };
+            nextConfig.component = true;
+          }
+          if (!nextConfig && defaultConfig) {
+            nextConfig = defaultConfig;
+          }
+          if (!nextConfig) {
+            continue;
+          }
           if (existing && existing.type === "asset") {
             try {
               const existingConfig = JSON.parse(existing.source.toString());
-              const newConfig = JSON.parse(result.config);
-              const merged = { ...existingConfig, ...newConfig };
+              const merged = { ...existingConfig, ...nextConfig };
               this.emitFile({
                 type: "asset",
                 fileName: jsonFileName,
                 source: JSON.stringify(merged, null, 2)
               });
-            } catch (e37) {
+            } catch (e40) {
               this.emitFile({
                 type: "asset",
                 fileName: jsonFileName,
-                source: result.config
+                source: JSON.stringify(nextConfig, null, 2)
               });
             }
           } else if (!bundle[jsonFileName]) {
             this.emitFile({
               type: "asset",
               fileName: jsonFileName,
-              source: result.config
+              source: JSON.stringify(nextConfig, null, 2)
             });
           }
         }
       }
       let pageList = [];
-      if (_optionalChain([scanService, 'optionalAccess', _465 => _465.appEntry, 'optionalAccess', _466 => _466.json, 'optionalAccess', _467 => _467.pages, 'optionalAccess', _468 => _468.length])) {
+      if (_optionalChain([scanService, 'optionalAccess', _486 => _486.appEntry, 'optionalAccess', _487 => _487.json, 'optionalAccess', _488 => _488.pages, 'optionalAccess', _489 => _489.length])) {
         pageList = scanService.appEntry.json.pages;
       } else {
         const appJsonPath = _pathe2.default.join(configService.cwd, "dist", "app.json");
@@ -25724,7 +26003,7 @@ function createVueTransformPlugin(ctx) {
           const appJsonContent = await _fsextra2.default.readFile(appJsonPath, "utf-8");
           const appJson = JSON.parse(appJsonContent);
           pageList = appJson.pages || [];
-        } catch (e38) {
+        } catch (e41) {
         }
       }
       const collectedEntries = /* @__PURE__ */ new Set();
@@ -25771,16 +26050,26 @@ function createVueTransformPlugin(ctx) {
               source: result.style
             });
           }
-          if (result.config && !bundle[`${relativeBase}.json`]) {
+          if (!bundle[`${relativeBase}.json`]) {
+            let nextConfig;
+            if (result.config) {
+              try {
+                nextConfig = JSON.parse(result.config);
+              } catch (e42) {
+                nextConfig = void 0;
+              }
+            }
+            nextConfig = { component: true, ..._nullishCoalesce(nextConfig, () => ( {})) };
+            nextConfig.component = true;
             this.emitFile({
               type: "asset",
               fileName: `${relativeBase}.json`,
-              source: result.config
+              source: JSON.stringify(nextConfig, null, 2)
             });
           }
         } catch (error) {
           const message = error instanceof Error ? error.message : String(error);
-          console.error(`[Vue transform] Error compiling ${vuePath}: ${message}`);
+          logger_default.error(`[Vue transform] Error compiling ${vuePath}: ${message}`);
         }
       }
     },
@@ -25826,7 +26115,7 @@ function createVueWatchPlugin(_ctx) {
 // src/plugins/vue/index.ts
 var VUE_PLUGIN_NAME = "weapp-vite:vue";
 function vuePlugin(ctx, options) {
-  if (_optionalChain([options, 'optionalAccess', _469 => _469.enable]) === false) {
+  if (_optionalChain([options, 'optionalAccess', _490 => _490.enable]) === false) {
     return [];
   }
   return [
@@ -25869,8 +26158,8 @@ function createWorkerBuildPlugin(ctx) {
     name: "weapp-vite:workers",
     enforce: "pre",
     async options(options) {
-      const workerConfig = _optionalChain([configService, 'access', _470 => _470.weappViteConfig, 'optionalAccess', _471 => _471.worker]);
-      const entries = Array.isArray(_optionalChain([workerConfig, 'optionalAccess', _472 => _472.entry])) ? workerConfig.entry : [_optionalChain([workerConfig, 'optionalAccess', _473 => _473.entry])];
+      const workerConfig = _optionalChain([configService, 'access', _491 => _491.weappViteConfig, 'optionalAccess', _492 => _492.worker]);
+      const entries = Array.isArray(_optionalChain([workerConfig, 'optionalAccess', _493 => _493.entry])) ? workerConfig.entry : [_optionalChain([workerConfig, 'optionalAccess', _494 => _494.entry])];
       const normalized = (await Promise.all(entries.filter(Boolean).map((entry) => resolveWorkerEntry(ctx, entry)))).filter((result) => Boolean(result.value)).reduce((acc, cur) => {
         acc[cur.key] = cur.value;
         return acc;
@@ -25927,7 +26216,7 @@ async function transformWxsFile(state, wxsPath) {
     const { result, importees } = transformWxsCode(rawCode, {
       filename: wxsPath
     });
-    if (typeof _optionalChain([result, 'optionalAccess', _474 => _474.code]) === "string") {
+    if (typeof _optionalChain([result, 'optionalAccess', _495 => _495.code]) === "string") {
       code = result.code;
     }
     const dirname5 = _pathe2.default.dirname(wxsPath);
@@ -26016,13 +26305,13 @@ function createContextPlugin(ctx) {
 }
 function attachRuntimePlugins(ctx, plugins) {
   const runtimePlugins = ctx[RUNTIME_PLUGINS_SYMBOL];
-  if (!_optionalChain([runtimePlugins, 'optionalAccess', _475 => _475.length])) {
+  if (!_optionalChain([runtimePlugins, 'optionalAccess', _496 => _496.length])) {
     return plugins;
   }
   return [...runtimePlugins, ...plugins];
 }
 function applyInspect(ctx, plugins) {
-  const inspectOptions = _optionalChain([ctx, 'access', _476 => _476.configService, 'access', _477 => _477.weappViteConfig, 'optionalAccess', _478 => _478.debug, 'optionalAccess', _479 => _479.inspect]);
+  const inspectOptions = _optionalChain([ctx, 'access', _497 => _497.configService, 'access', _498 => _498.weappViteConfig, 'optionalAccess', _499 => _499.debug, 'optionalAccess', _500 => _500.inspect]);
   if (!inspectOptions) {
     return plugins;
   }
@@ -26036,7 +26325,7 @@ function flatten(groups) {
 }
 function vitePluginWeapp(ctx, subPackageMeta) {
   const groups = [[createContextPlugin(ctx)], preflight(ctx), vue(ctx)];
-  const autoRoutesEnabled = _optionalChain([ctx, 'access', _480 => _480.configService, 'optionalAccess', _481 => _481.weappViteConfig, 'optionalAccess', _482 => _482.autoRoutes]) === true;
+  const autoRoutesEnabled = _optionalChain([ctx, 'access', _501 => _501.configService, 'optionalAccess', _502 => _502.weappViteConfig, 'optionalAccess', _503 => _503.autoRoutes]) === true;
   if (!subPackageMeta) {
     groups.push(asset(ctx));
     if (autoRoutesEnabled) {
@@ -26158,7 +26447,7 @@ function createMergeFactories(options) {
     const currentOptions = getOptions2();
     applyRuntimePlatform("miniprogram");
     const external = [];
-    if (_optionalChain([currentOptions, 'access', _483 => _483.packageJson, 'optionalAccess', _484 => _484.dependencies])) {
+    if (_optionalChain([currentOptions, 'access', _504 => _504.packageJson, 'optionalAccess', _505 => _505.dependencies])) {
       external.push(
         ...Object.keys(currentOptions.packageJson.dependencies).map((pkg) => {
           return new RegExp(`^${pkg.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&")}(\\/|$)`);
@@ -26173,7 +26462,7 @@ function createMergeFactories(options) {
       const watchInclude = [
         _pathe2.default.join(currentOptions.cwd, currentOptions.srcRoot, "**")
       ];
-      const pluginRootConfig = _optionalChain([currentOptions, 'access', _485 => _485.config, 'access', _486 => _486.weapp, 'optionalAccess', _487 => _487.pluginRoot]);
+      const pluginRootConfig = _optionalChain([currentOptions, 'access', _506 => _506.config, 'access', _507 => _507.weapp, 'optionalAccess', _508 => _508.pluginRoot]);
       if (pluginRootConfig) {
         const absolutePluginRoot = _pathe2.default.resolve(currentOptions.cwd, pluginRootConfig);
         const relativeToSrc = _pathe2.default.relative(
@@ -26231,7 +26520,7 @@ function createMergeFactories(options) {
     arrangePlugins(inlineConfig, subPackageMeta);
     inlineConfig.logLevel = "info";
     injectBuiltinAliases(inlineConfig);
-    const currentRoot = _optionalChain([subPackageMeta, 'optionalAccess', _488 => _488.subPackage, 'access', _489 => _489.root]);
+    const currentRoot = _optionalChain([subPackageMeta, 'optionalAccess', _509 => _509.subPackage, 'access', _510 => _510.root]);
     setOptions({
       ...currentOptions,
       currentSubPackageRoot: currentRoot
@@ -26242,7 +26531,7 @@ function createMergeFactories(options) {
     ensureConfigService();
     const currentOptions = getOptions2();
     const web = currentOptions.weappWeb;
-    if (!_optionalChain([web, 'optionalAccess', _490 => _490.enabled])) {
+    if (!_optionalChain([web, 'optionalAccess', _511 => _511.enabled])) {
       return void 0;
     }
     applyRuntimePlatform("web");
@@ -26327,7 +26616,7 @@ function createConfigService(ctx) {
   const toPosix3 = (value) => value.replace(/\\/g, "/");
   const fromPosix = (value) => _pathe2.default.sep === "/" ? value : value.split("/").join(_pathe2.default.sep);
   const resolveAbsolutePluginRoot = () => {
-    const pluginRootConfig = _optionalChain([options, 'access', _491 => _491.config, 'access', _492 => _492.weapp, 'optionalAccess', _493 => _493.pluginRoot]);
+    const pluginRootConfig = _optionalChain([options, 'access', _512 => _512.config, 'access', _513 => _513.weapp, 'optionalAccess', _514 => _514.pluginRoot]);
     if (!pluginRootConfig) {
       return void 0;
     }
@@ -26345,7 +26634,7 @@ function createConfigService(ctx) {
     if (!absolutePluginRoot) {
       return void 0;
     }
-    const configured = _optionalChain([options, 'access', _494 => _494.projectConfig, 'optionalAccess', _495 => _495.pluginRoot]);
+    const configured = _optionalChain([options, 'access', _515 => _515.projectConfig, 'optionalAccess', _516 => _516.pluginRoot]);
     if (configured) {
       return _pathe2.default.resolve(options.cwd, configured);
     }
@@ -26389,7 +26678,7 @@ function createConfigService(ctx) {
     defineEnv[key] = value;
   }
   function getDefineImportMetaEnv() {
-    const mpPlatform = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _496 => _496.platform]), () => ( DEFAULT_MP_PLATFORM));
+    const mpPlatform = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _517 => _517.platform]), () => ( DEFAULT_MP_PLATFORM));
     const resolvedPlatform = _nullishCoalesce(defineEnv.PLATFORM, () => ( mpPlatform));
     const env = {
       PLATFORM: resolvedPlatform,
@@ -26405,7 +26694,7 @@ function createConfigService(ctx) {
   }
   function applyRuntimePlatform(runtime) {
     const isWeb = runtime === "web";
-    const mpPlatform = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _497 => _497.platform]), () => ( DEFAULT_MP_PLATFORM));
+    const mpPlatform = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _518 => _518.platform]), () => ( DEFAULT_MP_PLATFORM));
     const resolvedPlatform = isWeb ? "web" : mpPlatform;
     setDefineEnv("PLATFORM", resolvedPlatform);
     setDefineEnv("IS_WEB", isWeb);
@@ -26516,7 +26805,7 @@ function createConfigService(ctx) {
       return options.srcRoot;
     },
     get pluginRoot() {
-      return _optionalChain([options, 'access', _498 => _498.config, 'access', _499 => _499.weapp, 'optionalAccess', _500 => _500.pluginRoot]);
+      return _optionalChain([options, 'access', _519 => _519.config, 'access', _520 => _520.weapp, 'optionalAccess', _521 => _521.pluginRoot]);
     },
     get absolutePluginRoot() {
       return resolveAbsolutePluginRoot();
@@ -26608,10 +26897,10 @@ function createJsonService(ctx) {
       }
       let resultJson;
       if (/app\.json(?:\.[jt]s)?$/.test(filepath)) {
-        await _optionalChain([ctx, 'access', _501 => _501.autoRoutesService, 'optionalAccess', _502 => _502.ensureFresh, 'call', _503 => _503()]);
+        await _optionalChain([ctx, 'access', _522 => _522.autoRoutesService, 'optionalAccess', _523 => _523.ensureFresh, 'call', _524 => _524()]);
       }
       if (/\.json\.[jt]s$/.test(filepath)) {
-        const routesReference = _optionalChain([ctx, 'access', _504 => _504.autoRoutesService, 'optionalAccess', _505 => _505.getReference, 'call', _506 => _506()]);
+        const routesReference = _optionalChain([ctx, 'access', _525 => _525.autoRoutesService, 'optionalAccess', _526 => _526.getReference, 'call', _527 => _527()]);
         const fallbackRoutes = _nullishCoalesce(routesReference, () => ( { pages: [], entries: [], subPackages: [] }));
         const routesModule = {
           routes: fallbackRoutes,
@@ -26661,7 +26950,7 @@ function createJsonService(ctx) {
       return resultJson;
     } catch (error) {
       logger_default.error(`\u6B8B\u7834\u7684JSON\u6587\u4EF6: ${filepath}`);
-      _optionalChain([debug, 'optionalCall', _507 => _507(error)]);
+      _optionalChain([debug, 'optionalCall', _528 => _528(error)]);
     }
   }
   function resolve8(entry) {
@@ -26717,7 +27006,7 @@ function createNpmService(ctx) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before writing npm cache");
     }
-    if (_optionalChain([ctx, 'access', _508 => _508.configService, 'access', _509 => _509.weappViteConfig, 'optionalAccess', _510 => _510.npm, 'optionalAccess', _511 => _511.cache])) {
+    if (_optionalChain([ctx, 'access', _529 => _529.configService, 'access', _530 => _530.weappViteConfig, 'optionalAccess', _531 => _531.npm, 'optionalAccess', _532 => _532.cache])) {
       await _fsextra2.default.outputJSON(getDependenciesCacheFilePath(root), {
         hash: dependenciesCacheHash()
       });
@@ -26730,7 +27019,7 @@ function createNpmService(ctx) {
     }
   }
   async function checkDependenciesCacheOutdate(root) {
-    if (_optionalChain([ctx, 'access', _512 => _512.configService, 'optionalAccess', _513 => _513.weappViteConfig, 'optionalAccess', _514 => _514.npm, 'optionalAccess', _515 => _515.cache])) {
+    if (_optionalChain([ctx, 'access', _533 => _533.configService, 'optionalAccess', _534 => _534.weappViteConfig, 'optionalAccess', _535 => _535.npm, 'optionalAccess', _536 => _536.cache])) {
       const json = await readDependenciesCache(root);
       if (_shared.isObject.call(void 0, json)) {
         return dependenciesCacheHash() !== json.hash;
@@ -26744,7 +27033,7 @@ function createNpmService(ctx) {
       configFile: false,
       publicDir: false,
       logLevel: "silent",
-      root: _nullishCoalesce(_optionalChain([ctx, 'access', _516 => _516.configService, 'optionalAccess', _517 => _517.cwd]), () => ( _process2.default.cwd())),
+      root: _nullishCoalesce(_optionalChain([ctx, 'access', _537 => _537.configService, 'optionalAccess', _538 => _538.cwd]), () => ( _process2.default.cwd())),
       define: {
         "process.env.NODE_ENV": JSON.stringify("production")
       },
@@ -26768,7 +27057,7 @@ function createNpmService(ctx) {
         }
       }
     });
-    const resolvedOptions = _optionalChain([ctx, 'access', _518 => _518.configService, 'optionalAccess', _519 => _519.weappViteConfig, 'optionalAccess', _520 => _520.npm, 'optionalAccess', _521 => _521.buildOptions, 'optionalCall', _522 => _522(
+    const resolvedOptions = _optionalChain([ctx, 'access', _539 => _539.configService, 'optionalAccess', _540 => _540.weappViteConfig, 'optionalAccess', _541 => _541.npm, 'optionalAccess', _542 => _542.buildOptions, 'optionalCall', _543 => _543(
       mergedOptions,
       { name, entry }
     )]);
@@ -26881,7 +27170,7 @@ function createNpmService(ctx) {
       throw new Error("configService must be initialized before resolving npm relation list");
     }
     let packNpmRelationList = [];
-    if (_optionalChain([ctx, 'access', _523 => _523.configService, 'access', _524 => _524.projectConfig, 'access', _525 => _525.setting, 'optionalAccess', _526 => _526.packNpmManually]) && Array.isArray(ctx.configService.projectConfig.setting.packNpmRelationList)) {
+    if (_optionalChain([ctx, 'access', _544 => _544.configService, 'access', _545 => _545.projectConfig, 'access', _546 => _546.setting, 'optionalAccess', _547 => _547.packNpmManually]) && Array.isArray(ctx.configService.projectConfig.setting.packNpmRelationList)) {
       packNpmRelationList = ctx.configService.projectConfig.setting.packNpmRelationList;
     } else {
       packNpmRelationList = [
@@ -26894,10 +27183,10 @@ function createNpmService(ctx) {
     return packNpmRelationList;
   }
   async function build3(options) {
-    if (!_optionalChain([ctx, 'access', _527 => _527.configService, 'optionalAccess', _528 => _528.weappViteConfig, 'optionalAccess', _529 => _529.npm, 'optionalAccess', _530 => _530.enable])) {
+    if (!_optionalChain([ctx, 'access', _548 => _548.configService, 'optionalAccess', _549 => _549.weappViteConfig, 'optionalAccess', _550 => _550.npm, 'optionalAccess', _551 => _551.enable])) {
       return;
     }
-    _optionalChain([debug, 'optionalCall', _531 => _531("buildNpm start")]);
+    _optionalChain([debug, 'optionalCall', _552 => _552("buildNpm start")]);
     const packNpmRelationList = getPackNpmRelationList();
     const [mainRelation, ...subRelations] = packNpmRelationList;
     const packageJsonPath = _pathe2.default.resolve(ctx.configService.cwd, mainRelation.packageJsonPath);
@@ -26972,7 +27261,7 @@ function createNpmService(ctx) {
         }
       }
     }
-    _optionalChain([debug, 'optionalCall', _532 => _532("buildNpm end")]);
+    _optionalChain([debug, 'optionalCall', _553 => _553("buildNpm end")]);
   }
   return {
     getDependenciesCacheFilePath,
@@ -27016,7 +27305,7 @@ var TimeoutError = (_class16 = class _TimeoutError extends Error {
   __init36() {this.name = "TimeoutError"}
   constructor(message, options) {
     super(message, options);_class16.prototype.__init36.call(this);;
-    _optionalChain([Error, 'access', _533 => _533.captureStackTrace, 'optionalCall', _534 => _534(this, _TimeoutError)]);
+    _optionalChain([Error, 'access', _554 => _554.captureStackTrace, 'optionalCall', _555 => _555(this, _TimeoutError)]);
   }
 }, _class16);
 var getAbortedReason = (signal) => _nullishCoalesce(signal.reason, () => ( new DOMException("This operation was aborted.", "AbortError")));
@@ -27034,7 +27323,7 @@ function pTimeout(promise, options) {
     if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
-    if (_optionalChain([signal, 'optionalAccess', _535 => _535.aborted])) {
+    if (_optionalChain([signal, 'optionalAccess', _556 => _556.aborted])) {
       reject(getAbortedReason(signal));
       return;
     }
@@ -27132,7 +27421,7 @@ var PriorityQueue = class {
   }
   dequeue() {
     const item = this.#queue.shift();
-    return _optionalChain([item, 'optionalAccess', _536 => _536.run]);
+    return _optionalChain([item, 'optionalAccess', _557 => _557.run]);
   }
   filter(options) {
     return this.#queue.filter((element) => element.priority === options.priority).map((element) => element.run);
@@ -27193,10 +27482,10 @@ var PQueue = class extends import_index5.default {
       ...options
     };
     if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
-      throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${_nullishCoalesce(_optionalChain([options, 'access', _537 => _537.intervalCap, 'optionalAccess', _538 => _538.toString, 'call', _539 => _539()]), () => ( ""))}\` (${typeof options.intervalCap})`);
+      throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${_nullishCoalesce(_optionalChain([options, 'access', _558 => _558.intervalCap, 'optionalAccess', _559 => _559.toString, 'call', _560 => _560()]), () => ( ""))}\` (${typeof options.intervalCap})`);
     }
     if (options.interval === void 0 || !(Number.isFinite(options.interval) && options.interval >= 0)) {
-      throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${_nullishCoalesce(_optionalChain([options, 'access', _540 => _540.interval, 'optionalAccess', _541 => _541.toString, 'call', _542 => _542()]), () => ( ""))}\` (${typeof options.interval})`);
+      throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${_nullishCoalesce(_optionalChain([options, 'access', _561 => _561.interval, 'optionalAccess', _562 => _562.toString, 'call', _563 => _563()]), () => ( ""))}\` (${typeof options.interval})`);
     }
     this.#carryoverIntervalCount = _nullishCoalesce(_nullishCoalesce(options.carryoverIntervalCount, () => ( options.carryoverConcurrencyCount)), () => ( false));
     this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
@@ -27397,7 +27686,7 @@ var PQueue = class extends import_index5.default {
         let eventListener;
         try {
           try {
-            _optionalChain([options, 'access', _543 => _543.signal, 'optionalAccess', _544 => _544.throwIfAborted, 'call', _545 => _545()]);
+            _optionalChain([options, 'access', _564 => _564.signal, 'optionalAccess', _565 => _565.throwIfAborted, 'call', _566 => _566()]);
           } catch (error) {
             if (!this.#isIntervalIgnored) {
               this.#intervalCount--;
@@ -27429,7 +27718,7 @@ var PQueue = class extends import_index5.default {
           this.emit("error", error);
         } finally {
           if (eventListener) {
-            _optionalChain([options, 'access', _546 => _546.signal, 'optionalAccess', _547 => _547.removeEventListener, 'call', _548 => _548("abort", eventListener)]);
+            _optionalChain([options, 'access', _567 => _567.signal, 'optionalAccess', _568 => _568.removeEventListener, 'call', _569 => _569("abort", eventListener)]);
           }
           this.#runningTasks.delete(taskSymbol);
           queueMicrotask(() => {
@@ -27779,7 +28068,7 @@ var FileCache = class {
       return true;
     }
     const cachedMtime = this.mtimeMap.get(id);
-    const nextSignature = _optionalChain([options, 'optionalAccess', _549 => _549.content]) !== void 0 ? createSignature(options.content) : void 0;
+    const nextSignature = _optionalChain([options, 'optionalAccess', _570 => _570.content]) !== void 0 ? createSignature(options.content) : void 0;
     const updateSignature = () => {
       if (nextSignature !== void 0) {
         this.signatureMap.set(id, nextSignature);
@@ -28014,7 +28303,7 @@ function coerceStyleConfig(entry) {
   if (!entry || typeof entry !== "object") {
     return void 0;
   }
-  const source = _optionalChain([entry, 'access', _550 => _550.source, 'optionalAccess', _551 => _551.toString, 'call', _552 => _552(), 'access', _553 => _553.trim, 'call', _554 => _554()]);
+  const source = _optionalChain([entry, 'access', _571 => _571.source, 'optionalAccess', _572 => _572.toString, 'call', _573 => _573(), 'access', _574 => _574.trim, 'call', _575 => _575()]);
   if (!source) {
     return void 0;
   }
@@ -28190,7 +28479,7 @@ function normalizeSubPackageStyleEntries(styles, subPackage, configService) {
   if (!service) {
     return void 0;
   }
-  const root = _optionalChain([subPackage, 'access', _555 => _555.root, 'optionalAccess', _556 => _556.trim, 'call', _557 => _557()]);
+  const root = _optionalChain([subPackage, 'access', _576 => _576.root, 'optionalAccess', _577 => _577.trim, 'call', _578 => _578()]);
   if (!root) {
     return void 0;
   }
@@ -28316,7 +28605,7 @@ function createScanService(ctx) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before scanning subpackages");
     }
-    const json = _optionalChain([scanState, 'access', _558 => _558.appEntry, 'optionalAccess', _559 => _559.json]);
+    const json = _optionalChain([scanState, 'access', _579 => _579.appEntry, 'optionalAccess', _580 => _580.json]);
     if (scanState.isDirty || subPackageMap.size === 0) {
       subPackageMap.clear();
       independentSubPackageMap.clear();
@@ -28334,16 +28623,16 @@ function createScanService(ctx) {
             subPackage,
             entries: resolveSubPackageEntries(subPackage)
           };
-          const subPackageConfig = _optionalChain([ctx, 'access', _560 => _560.configService, 'access', _561 => _561.weappViteConfig, 'optionalAccess', _562 => _562.subPackages, 'optionalAccess', _563 => _563[subPackage.root]]);
-          meta.subPackage.dependencies = _optionalChain([subPackageConfig, 'optionalAccess', _564 => _564.dependencies]);
-          meta.subPackage.inlineConfig = _optionalChain([subPackageConfig, 'optionalAccess', _565 => _565.inlineConfig]);
-          meta.autoImportComponents = _optionalChain([subPackageConfig, 'optionalAccess', _566 => _566.autoImportComponents]);
+          const subPackageConfig = _optionalChain([ctx, 'access', _581 => _581.configService, 'access', _582 => _582.weappViteConfig, 'optionalAccess', _583 => _583.subPackages, 'optionalAccess', _584 => _584[subPackage.root]]);
+          meta.subPackage.dependencies = _optionalChain([subPackageConfig, 'optionalAccess', _585 => _585.dependencies]);
+          meta.subPackage.inlineConfig = _optionalChain([subPackageConfig, 'optionalAccess', _586 => _586.inlineConfig]);
+          meta.autoImportComponents = _optionalChain([subPackageConfig, 'optionalAccess', _587 => _587.autoImportComponents]);
           meta.styleEntries = normalizeSubPackageStyleEntries(
-            _optionalChain([subPackageConfig, 'optionalAccess', _567 => _567.styles]),
+            _optionalChain([subPackageConfig, 'optionalAccess', _588 => _588.styles]),
             subPackage,
             ctx.configService
           );
-          meta.watchSharedStyles = _nullishCoalesce(_optionalChain([subPackageConfig, 'optionalAccess', _568 => _568.watchSharedStyles]), () => ( true));
+          meta.watchSharedStyles = _nullishCoalesce(_optionalChain([subPackageConfig, 'optionalAccess', _589 => _589.watchSharedStyles]), () => ( true));
           metas.push(meta);
           if (subPackage.root) {
             subPackageMap.set(subPackage.root, meta);
@@ -28399,11 +28688,11 @@ function createScanService(ctx) {
     loadSubPackages,
     isMainPackageFileName,
     get workersOptions() {
-      return _optionalChain([scanState, 'access', _569 => _569.appEntry, 'optionalAccess', _570 => _570.json, 'optionalAccess', _571 => _571.workers]);
+      return _optionalChain([scanState, 'access', _590 => _590.appEntry, 'optionalAccess', _591 => _591.json, 'optionalAccess', _592 => _592.workers]);
     },
     get workersDir() {
-      const workersOptions = _optionalChain([scanState, 'access', _572 => _572.appEntry, 'optionalAccess', _573 => _573.json, 'optionalAccess', _574 => _574.workers]);
-      return typeof workersOptions === "object" ? _optionalChain([workersOptions, 'optionalAccess', _575 => _575.path]) : workersOptions;
+      const workersOptions = _optionalChain([scanState, 'access', _593 => _593.appEntry, 'optionalAccess', _594 => _594.json, 'optionalAccess', _595 => _595.workers]);
+      return typeof workersOptions === "object" ? _optionalChain([workersOptions, 'optionalAccess', _596 => _596.path]) : workersOptions;
     },
     markDirty() {
       scanState.isDirty = true;
@@ -28450,7 +28739,7 @@ function createWatcherService(ctx) {
     },
     setRollupWatcher(watcher, root = "/") {
       const oldWatcher = rollupWatcherMap.get(root);
-      _optionalChain([oldWatcher, 'optionalAccess', _576 => _576.close, 'call', _577 => _577()]);
+      _optionalChain([oldWatcher, 'optionalAccess', _597 => _597.close, 'call', _598 => _598()]);
       rollupWatcherMap.set(root, watcher);
     },
     closeAll() {
@@ -28463,7 +28752,7 @@ function createWatcherService(ctx) {
         });
       });
       sidecarWatcherMap.clear();
-      void _optionalChain([ctx, 'access', _578 => _578.webService, 'optionalAccess', _579 => _579.close, 'call', _580 => _580(), 'access', _581 => _581.catch, 'call', _582 => _582(() => {
+      void _optionalChain([ctx, 'access', _599 => _599.webService, 'optionalAccess', _600 => _600.close, 'call', _601 => _601(), 'access', _602 => _602.catch, 'call', _603 => _603(() => {
       })]);
     },
     close(root = "/") {
@@ -28479,7 +28768,7 @@ function createWatcherService(ctx) {
         sidecarWatcherMap.delete(root);
       }
       if (rollupWatcherMap.size === 0 && sidecarWatcherMap.size === 0) {
-        void _optionalChain([ctx, 'access', _583 => _583.webService, 'optionalAccess', _584 => _584.close, 'call', _585 => _585(), 'access', _586 => _586.catch, 'call', _587 => _587(() => {
+        void _optionalChain([ctx, 'access', _604 => _604.webService, 'optionalAccess', _605 => _605.close, 'call', _606 => _606(), 'access', _607 => _607.catch, 'call', _608 => _608(() => {
         })]);
       }
     }
@@ -28492,7 +28781,7 @@ function createWatcherServicePlugin(ctx) {
     name: "weapp-runtime:watcher-service",
     closeBundle() {
       const configService = ctx.configService;
-      const isWatchMode = _optionalChain([configService, 'optionalAccess', _588 => _588.isDev]) || Boolean(_optionalChain([configService, 'optionalAccess', _589 => _589.inlineConfig, 'optionalAccess', _590 => _590.build, 'optionalAccess', _591 => _591.watch]));
+      const isWatchMode = _optionalChain([configService, 'optionalAccess', _609 => _609.isDev]) || Boolean(_optionalChain([configService, 'optionalAccess', _610 => _610.inlineConfig, 'optionalAccess', _611 => _611.build, 'optionalAccess', _612 => _612.watch]));
       if (!isWatchMode) {
         service.closeAll();
       }
@@ -28509,10 +28798,10 @@ function createWebService(ctx) {
   }
   let devServer;
   function isEnabled() {
-    return Boolean(_optionalChain([ctx, 'access', _592 => _592.configService, 'optionalAccess', _593 => _593.weappWebConfig, 'optionalAccess', _594 => _594.enabled]));
+    return Boolean(_optionalChain([ctx, 'access', _613 => _613.configService, 'optionalAccess', _614 => _614.weappWebConfig, 'optionalAccess', _615 => _615.enabled]));
   }
   async function startDevServer() {
-    if (!_optionalChain([ctx, 'access', _595 => _595.configService, 'optionalAccess', _596 => _596.isDev])) {
+    if (!_optionalChain([ctx, 'access', _616 => _616.configService, 'optionalAccess', _617 => _617.isDev])) {
       return void 0;
     }
     if (!isEnabled()) {
@@ -28521,7 +28810,7 @@ function createWebService(ctx) {
     if (devServer) {
       return devServer;
     }
-    const inlineConfig = _optionalChain([ctx, 'access', _597 => _597.configService, 'optionalAccess', _598 => _598.mergeWeb, 'call', _599 => _599()]);
+    const inlineConfig = _optionalChain([ctx, 'access', _618 => _618.configService, 'optionalAccess', _619 => _619.mergeWeb, 'call', _620 => _620()]);
     if (!inlineConfig) {
       return void 0;
     }
@@ -28534,7 +28823,7 @@ function createWebService(ctx) {
     if (!isEnabled()) {
       return void 0;
     }
-    const inlineConfig = _optionalChain([ctx, 'access', _600 => _600.configService, 'optionalAccess', _601 => _601.mergeWeb, 'call', _602 => _602()]);
+    const inlineConfig = _optionalChain([ctx, 'access', _621 => _621.configService, 'optionalAccess', _622 => _622.mergeWeb, 'call', _623 => _623()]);
     if (!inlineConfig) {
       return void 0;
     }
@@ -28564,7 +28853,7 @@ function createWebServicePlugin(ctx) {
   return {
     name: "weapp-runtime:web-service",
     async closeBundle() {
-      if (!_optionalChain([ctx, 'access', _603 => _603.configService, 'optionalAccess', _604 => _604.isDev])) {
+      if (!_optionalChain([ctx, 'access', _624 => _624.configService, 'optionalAccess', _625 => _625.isDev])) {
         await service.close();
       }
     }
@@ -31215,7 +31504,7 @@ function createWxmlService(ctx) {
     return set3;
   }
   function clearAll() {
-    const currentRoot = _optionalChain([ctx, 'access', _605 => _605.configService, 'optionalAccess', _606 => _606.currentSubPackageRoot]);
+    const currentRoot = _optionalChain([ctx, 'access', _626 => _626.configService, 'optionalAccess', _627 => _627.currentSubPackageRoot]);
     if (!currentRoot) {
       depsMap.clear();
       tokenMap.clear();
@@ -31274,7 +31563,7 @@ function createWxmlService(ctx) {
     if (!ctx.configService) {
       throw new Error("configService must be initialized before scanning wxml");
     }
-    const wxmlConfig = _nullishCoalesce(_optionalChain([ctx, 'access', _607 => _607.configService, 'access', _608 => _608.weappViteConfig, 'optionalAccess', _609 => _609.wxml]), () => ( _optionalChain([ctx, 'access', _610 => _610.configService, 'access', _611 => _611.weappViteConfig, 'optionalAccess', _612 => _612.enhance, 'optionalAccess', _613 => _613.wxml])));
+    const wxmlConfig = _nullishCoalesce(_optionalChain([ctx, 'access', _628 => _628.configService, 'access', _629 => _629.weappViteConfig, 'optionalAccess', _630 => _630.wxml]), () => ( _optionalChain([ctx, 'access', _631 => _631.configService, 'access', _632 => _632.weappViteConfig, 'optionalAccess', _633 => _633.enhance, 'optionalAccess', _634 => _634.wxml])));
     return scanWxml(wxml, {
       platform: ctx.configService.platform,
       ...wxmlConfig === true ? {} : wxmlConfig