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

package/dist/auto-routes.cjs

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
-var _chunkEL4WI75Zcjs = require('./chunk-EL4WI75Z.cjs');
+var _chunkKBGC6ODZcjs = require('./chunk-KBGC6ODZ.cjs');
 require('./chunk-IEICAJDZ.cjs');
 require('./chunk-E34K6TPD.cjs');
 require('./chunk-SJSLFDTA.cjs');
@@ -25,7 +25,7 @@ function createGetter(resolver) {
     get: resolver
   };
 }
-var ctx = _chunkEL4WI75Zcjs.getCompilerContext.call(void 0, );
+var ctx = _chunkKBGC6ODZcjs.getCompilerContext.call(void 0, );
 var service = ctx.autoRoutesService;
 var routes = {};
 Object.defineProperties(routes, {

package/dist/auto-routes.mjs

@@ -1,6 +1,6 @@
 import {
   getCompilerContext
-} from "./chunk-4P5KX3LT.mjs";
+} from "./chunk-IHHBS4DF.mjs";
 import "./chunk-MK4LDVBT.mjs";
 import "./chunk-YXFADQPY.mjs";
 import "./chunk-O6633IWP.mjs";

package/dist/{chunk-FB7KR7SH.cjs → chunk-CBPLMYFL.cjs}

@@ -2,7 +2,7 @@
 
 
 
-var _chunkEL4WI75Zcjs = require('./chunk-EL4WI75Z.cjs');
+var _chunkKBGC6ODZcjs = require('./chunk-KBGC6ODZ.cjs');
 
 
 var _chunkTZGJRA2Ycjs = require('./chunk-TZGJRA2Y.cjs');
@@ -12,10 +12,10 @@ _chunkTZGJRA2Ycjs.init_cjs_shims.call(void 0, );
 async function createCompilerContext(options) {
   const key = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _ => _.key]), () => ( "default"));
   if (!_optionalChain([options, 'optionalAccess', _2 => _2.key])) {
-    _chunkEL4WI75Zcjs.resetCompilerContext.call(void 0, key);
+    _chunkKBGC6ODZcjs.resetCompilerContext.call(void 0, key);
   }
-  _chunkEL4WI75Zcjs.setActiveCompilerContextKey.call(void 0, key);
-  const ctx = _chunkEL4WI75Zcjs.getCompilerContext.call(void 0, key);
+  _chunkKBGC6ODZcjs.setActiveCompilerContextKey.call(void 0, key);
+  const ctx = _chunkKBGC6ODZcjs.getCompilerContext.call(void 0, key);
   const { configService, scanService, autoRoutesService } = ctx;
   await configService.load(options);
   if (autoRoutesService) {

package/dist/{chunk-VKLSO3EM.mjs → chunk-GGB7MGZY.mjs}

@@ -2,7 +2,7 @@ import {
   getCompilerContext,
   resetCompilerContext,
   setActiveCompilerContextKey
-} from "./chunk-4P5KX3LT.mjs";
+} from "./chunk-IHHBS4DF.mjs";
 import {
   init_esm_shims
 } from "./chunk-5CBZRYDL.mjs";

package/dist/{chunk-4P5KX3LT.mjs → chunk-IHHBS4DF.mjs}

@@ -16310,9 +16310,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);
@@ -24420,7 +24420,7 @@ function getSourceFromVirtualId(id) {
 // src/plugins/vue/transform.ts
 init_esm_shims();
 var import_merge = __toESM(require_src(), 1);
-import generateModule from "@babel/generator";
+import generateModule2 from "@babel/generator";
 import { parse as babelParse2 } from "@babel/parser";
 import traverseModule from "@babel/traverse";
 import * as t3 from "@babel/types";
@@ -24537,13 +24537,163 @@ function generateHash(str) {
 
 // src/plugins/vue/compiler/template.ts
 init_esm_shims();
-import generate from "@babel/generator";
+import generateModule from "@babel/generator";
 import { parse as babelParse } from "@babel/parser";
 import * as t2 from "@babel/types";
 import {
   NodeTypes,
   baseParse as parse9
 } from "@vue/compiler-core";
+var generate = generateModule.default ?? generateModule;
+function generateExpression(node) {
+  const { code } = generate(node, {
+    compact: true,
+    jsescOption: { quotes: "single" }
+  });
+  return code;
+}
+function parseBabelExpression(exp) {
+  try {
+    const ast = babelParse(`(${exp})`, {
+      sourceType: "module",
+      plugins: ["typescript"]
+    });
+    const stmt = ast.program.body[0];
+    if (!stmt || !("expression" in stmt)) {
+      return null;
+    }
+    return stmt.expression;
+  } catch {
+    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 (staticClass?.trim()) {
+    parts.push(staticClass.trim());
+  }
+  for (const exp of classExpressions ?? []) {
+    if (!exp) {
+      continue;
+    }
+    parts.push(`{{${exp}}}`);
+  }
+  return `class="${parts.join(" ")}"`;
+}
+function renderStyleAttribute(staticStyle, dynamicStyleExp, vShowExp) {
+  let merged = "";
+  if (staticStyle?.trim()) {
+    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 = babelParse(`(${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 {
+    return null;
+  }
+}
 function templateLiteralToConcat(node) {
   const segments = [];
   node.quasis.forEach((quasi, index) => {
@@ -24640,23 +24790,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 === NodeTypes.ATTRIBUTE) {
+      if (prop.name === "class" && prop.value?.type === NodeTypes.TEXT) {
+        staticClass = prop.value.content;
+        continue;
+      }
+      if (prop.name === "style" && prop.value?.type === NodeTypes.TEXT) {
+        staticStyle = prop.value.content;
+        continue;
+      }
       const attr = transformAttribute(prop, context);
       if (attr) {
         attrs.push(attr);
       }
     } else if (prop.type === NodeTypes.DIRECTIVE) {
+      if (prop.name === "bind" && prop.arg?.type === NodeTypes.SIMPLE_EXPRESSION && prop.arg.content === "class" && prop.exp?.type === NodeTypes.SIMPLE_EXPRESSION) {
+        dynamicClassExp = prop.exp.content;
+        continue;
+      }
+      if (prop.name === "bind" && prop.arg?.type === NodeTypes.SIMPLE_EXPRESSION && prop.arg.content === "style" && prop.exp?.type === NodeTypes.SIMPLE_EXPRESSION) {
+        dynamicStyleExp = prop.exp.content;
+        continue;
+      }
+      if (prop.name === "show" && prop.exp?.type === NodeTypes.SIMPLE_EXPRESSION) {
+        vShowExp = normalizeWxmlExpression(prop.exp.content);
+        continue;
+      }
+      if (prop.name === "text" && prop.exp?.type === 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} />`;
 }
@@ -24672,6 +24862,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;
@@ -24709,6 +24900,8 @@ function transformDirective(node, context, elementNode, forInfo) {
     }
     const rawExpValue = exp.type === 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",
@@ -24732,6 +24925,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") {
@@ -24748,20 +24954,12 @@ function transformDirective(node, context, elementNode, forInfo) {
     }
     const rawExpValue = exp.type === 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 === NodeTypes.SIMPLE_EXPRESSION ? exp.content : "";
-    const expValue = normalizeWxmlExpression(rawExpValue);
-    return `>{{${expValue}}`;
-  }
   if (name === "cloak") {
     return null;
   }
@@ -24946,35 +25144,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 === NodeTypes.DIRECTIVE && prop.name === "slot") {
       slotDirective = prop;
       break;
     }
+    if (prop.type === NodeTypes.DIRECTIVE) {
+      hasOtherDirective = true;
+      if (!structuralDirective && (prop.name === "if" || prop.name === "else-if" || prop.name === "else" || prop.name === "for")) {
+        structuralDirective = prop;
+      }
+    }
+    if (prop.type === NodeTypes.ATTRIBUTE && prop.name === "name") {
+      nameAttr = prop.value && prop.value.type === NodeTypes.TEXT ? prop.value.content : "";
+    }
+    if (prop.type === NodeTypes.ATTRIBUTE && prop.name === "is") {
+      isAttr = prop.value && prop.value.type === NodeTypes.TEXT ? prop.value.content : "";
+    }
+    if (prop.type === NodeTypes.ATTRIBUTE && prop.name === "data") {
+      dataAttr = prop.value && prop.value.type === 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 === NodeTypes.SIMPLE_EXPRESSION ? slotDirective.arg.content : "" : "";
-  const slotProps = slotDirective.exp ? slotDirective.exp.type === NodeTypes.SIMPLE_EXPRESSION ? slotDirective.exp.content : "" : "";
   const children = node.children.map((child) => transformNode(child, context)).join("");
+  if (!slotDirective && !nameAttr && !isAttr && !dataAttr) {
+    if (structuralDirective?.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 === 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 === 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 === NodeTypes.SIMPLE_EXPRESSION ? slotDirective.arg.content : "" : "";
+    const slotProps = slotDirective.exp ? slotDirective.exp.type === 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+(.+)$/);
@@ -25115,7 +25370,7 @@ function compileVueTemplateToWxml(template, filename) {
 
 // src/plugins/vue/transform.ts
 var RUNTIME_IMPORT_PATH = "wevu";
-var generate2 = generateModule.default ?? generateModule;
+var generate2 = generateModule2.default ?? generateModule2;
 var traverse2 = traverseModule.default ?? traverseModule;
 function isDefineComponentCall(node, aliases) {
   return t3.isIdentifier(node.callee) && aliases.has(node.callee.name);
@@ -25556,6 +25811,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 = compileScript(descriptor, {
@@ -25649,7 +25908,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;
       }
     },
@@ -25665,6 +25924,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]) {
@@ -25685,14 +25946,32 @@ 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 {
+              nextConfig = void 0;
+            }
+          }
+          if (defaultConfig) {
+            nextConfig = { ...defaultConfig, ...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,
@@ -25702,14 +25981,14 @@ function createVueTransformPlugin(ctx) {
               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)
             });
           }
         }
@@ -25770,16 +26049,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 {
+                nextConfig = void 0;
+              }
+            }
+            nextConfig = { component: true, ...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}`);
         }
       }
     },