weapp-vite 6.7.3 → 6.7.4

package/dist/{chunk-O2O4C4LW.mjs → chunk-MKXI5POD.mjs}

@@ -14,16 +14,16 @@ import {
   templateExtensions,
   touch,
   vueExtensions
-} from "./chunk-S2D6SRQW.mjs";
+} from "./chunk-3ULSPLMB.mjs";
 import {
   configureLogger,
   default as default2
-} from "./chunk-3STNMT72.mjs";
+} from "./chunk-VZEM2LX3.mjs";
 import {
   __commonJS,
   __toESM,
   init_esm_shims
-} from "./chunk-QBSVUTNO.mjs";
+} from "./chunk-BQM4WPKJ.mjs";
 
 // ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/debug.js
 var require_debug = __commonJS({
@@ -3018,6 +3018,13 @@ var JSON_TYPE_ALIASES = {
   Null: "null",
   Any: "any"
 };
+function mergeTypeCandidates(candidates) {
+  const merged = candidates.filter((item) => Boolean(item)).flatMap((item) => item.split("|").map((part) => part.trim()).filter(Boolean));
+  if (merged.length === 0) {
+    return void 0;
+  }
+  return Array.from(new Set(merged)).join(" | ");
+}
 function normalizeJsonPropertyType(raw) {
   if (typeof raw === "string") {
     const key = raw.trim();
@@ -3028,12 +3035,10 @@ function normalizeJsonPropertyType(raw) {
     return normalized.length > 0 ? normalized.join(" | ") : void 0;
   }
   if (raw && typeof raw === "object") {
-    if (raw.type !== void 0) {
-      return normalizeJsonPropertyType(raw.type);
-    }
-    if (Array.isArray(raw.optionalTypes)) {
-      return normalizeJsonPropertyType(raw.optionalTypes);
-    }
+    return mergeTypeCandidates([
+      raw.type !== void 0 ? normalizeJsonPropertyType(raw.type) : void 0,
+      Array.isArray(raw.optionalTypes) ? normalizeJsonPropertyType(raw.optionalTypes) : void 0
+    ]);
   }
   return void 0;
 }
@@ -3049,7 +3054,7 @@ function extractJsonPropMetadata(json) {
   }
   for (const [propName, rawConfig] of Object.entries(properties)) {
     const config = rawConfig ?? {};
-    const type = normalizeJsonPropertyType(config.type) ?? "any";
+    const type = normalizeJsonPropertyType(rawConfig) ?? "any";
     props.set(propName, type);
     const description = config.description;
     if (typeof description === "string" && description.trim().length > 0) {
@@ -8077,6 +8082,8 @@ init_esm_shims();
 // src/runtime/autoRoutesPlugin/routes/format.ts
 init_esm_shims();
 var INDENT = "    ";
+var TS_STRING_PLACEHOLDER = "${string}";
+var TS_PATH_PLACEHOLDER = "${Path}";
 function formatTuple(values, baseIndent = "") {
   if (values.length === 0) {
     return "[]";
@@ -8099,6 +8106,7 @@ function formatSubPackagesTuple(subPackages, baseIndent = "") {
     lines.push(`${fieldIndent}readonly root: ${JSON.stringify(pkg.root)};`);
     const pages = formatTuple(pkg.pages, fieldIndent);
     lines.push(`${fieldIndent}readonly pages: ${pages};`);
+    lines.push(`${fieldIndent}[k: string]: unknown;`);
     lines.push(`${objectIndent}}${index < subPackages.length - 1 ? "," : ""}`);
   });
   lines.push(`${baseIndent}]`);
@@ -8114,6 +8122,8 @@ function createTypedRouterDefinition(routes) {
     "// oxlint-disable",
     "// ------",
     "// \u7531 weapp-vite \u81EA\u52A8\u751F\u6210\uFF0C\u8BF7\u52FF\u7F16\u8F91\u3002",
+    "import 'wevu/router';",
+    "",
     "declare module 'weapp-vite/auto-routes' {",
     `    export type AutoRoutesPages = ${pagesType};`,
     `    export type AutoRoutesEntries = ${entriesType};`,
@@ -8124,12 +8134,33 @@ function createTypedRouterDefinition(routes) {
     "        readonly entries: AutoRoutesEntries;",
     "        readonly subPackages: AutoRoutesSubPackages;",
     "    }",
+    "    export type AutoRouteEntry = AutoRoutesEntries[number];",
+    `    export type AutoRoutesRelativeUrl = \`./${TS_STRING_PLACEHOLDER}\` | \`../${TS_STRING_PLACEHOLDER}\`;`,
+    `    export type AutoRoutesAbsoluteUrl<Path extends string> = Path | \`/${TS_PATH_PLACEHOLDER}\` | \`${TS_PATH_PLACEHOLDER}?${TS_STRING_PLACEHOLDER}\` | \`/${TS_PATH_PLACEHOLDER}?${TS_STRING_PLACEHOLDER}\`;`,
+    "    export type AutoRoutesUrl = AutoRoutesAbsoluteUrl<AutoRouteEntry> | AutoRoutesRelativeUrl;",
+    "    export type AutoRouteNavigateOption = {",
+    "        readonly url: AutoRoutesUrl;",
+    "    } & Record<string, any>;",
+    "    export interface AutoRoutesWxRouter {",
+    "        switchTab: (option: AutoRouteNavigateOption) => unknown;",
+    "        reLaunch: (option: AutoRouteNavigateOption) => unknown;",
+    "        redirectTo: (option: AutoRouteNavigateOption) => unknown;",
+    "        navigateTo: (option: AutoRouteNavigateOption) => unknown;",
+    "        navigateBack: (option?: Record<string, any>) => unknown;",
+    "    }",
     "    export const routes: AutoRoutes;",
     "    export const pages: AutoRoutesPages;",
     "    export const entries: AutoRoutesEntries;",
     "    export const subPackages: AutoRoutesSubPackages;",
+    "    export const wxRouter: AutoRoutesWxRouter;",
     "    export default routes;",
     "}",
+    "",
+    "declare module 'wevu/router' {",
+    "    interface WevuTypedRouterRouteMap {",
+    "        entries: import('weapp-vite/auto-routes').AutoRoutesEntries[number];",
+    "    }",
+    "}",
     ""
   ].join("\n");
 }
@@ -8291,7 +8322,26 @@ async function scanRoutes(ctx, candidatesMap) {
     "const pages = routes.pages;",
     "const entries = routes.entries;",
     "const subPackages = routes.subPackages;",
-    "export { routes, pages, entries, subPackages };",
+    "const resolveMiniProgramGlobal = () => (globalThis.wx ?? globalThis.tt ?? globalThis.my);",
+    "const callRouteMethod = (methodName, option) => {",
+    "  const miniProgramGlobal = resolveMiniProgramGlobal();",
+    "  const routeMethod = miniProgramGlobal?.[methodName];",
+    '  if (typeof routeMethod !== "function") {',
+    '    throw new Error("[weapp-vite] \u5F53\u524D\u8FD0\u884C\u73AF\u5883\u4E0D\u652F\u6301\u8DEF\u7531\u65B9\u6CD5: " + methodName);',
+    "  }",
+    "  if (option === undefined) {",
+    "    return routeMethod.call(miniProgramGlobal);",
+    "  }",
+    "  return routeMethod.call(miniProgramGlobal, option);",
+    "};",
+    "const wxRouter = {",
+    '  switchTab(option) { return callRouteMethod("switchTab", option); },',
+    '  reLaunch(option) { return callRouteMethod("reLaunch", option); },',
+    '  redirectTo(option) { return callRouteMethod("redirectTo", option); },',
+    '  navigateTo(option) { return callRouteMethod("navigateTo", option); },',
+    '  navigateBack(option) { return callRouteMethod("navigateBack", option); },',
+    "};",
+    "export { routes, pages, entries, subPackages, wxRouter };",
     "export default routes;"
   ].join("\n");
   return {
@@ -8350,22 +8400,22 @@ function matchesRouteFile(ctx, candidate) {
   if (!pathWithoutQuery) {
     return false;
   }
-  const normalized = path20.isAbsolute(pathWithoutQuery) ? pathWithoutQuery : path20.resolve(configService.cwd, pathWithoutQuery);
-  if (!normalized.startsWith(configService.absoluteSrcRoot)) {
-    return false;
-  }
-  const relative3 = toPosixPath(path20.relative(configService.absoluteSrcRoot, normalized));
-  if (!relative3 || relative3.startsWith("..")) {
+  const normalizedSrcRoot = normalizePath(configService.absoluteSrcRoot);
+  const normalizedCandidate = normalizePath(
+    path20.isAbsolute(pathWithoutQuery) ? pathWithoutQuery : path20.resolve(configService.cwd, pathWithoutQuery)
+  );
+  const relative3 = toPosixPath(path20.relative(normalizedSrcRoot, normalizedCandidate));
+  if (!relative3 || relative3.startsWith("..") || path20.isAbsolute(relative3)) {
     return false;
   }
   const isPagesPath = relative3.startsWith("pages/") || relative3.includes("/pages/");
   if (!isPagesPath) {
     return false;
   }
-  if (isConfigFile(normalized)) {
+  if (isConfigFile(normalizedCandidate)) {
     return true;
   }
-  if (isVueFile(normalized) || isScriptFile(normalized) || isTemplateFile(normalized) || isStyleFile(normalized)) {
+  if (isVueFile(normalizedCandidate) || isScriptFile(normalizedCandidate) || isTemplateFile(normalizedCandidate) || isStyleFile(normalizedCandidate)) {
     return true;
   }
   return false;
@@ -8424,13 +8474,11 @@ async function updateCandidateFromFile(ctx, stateCandidates, filePath, event, ma
     return true;
   }
   const absolutePath = path20.isAbsolute(pathWithoutQuery) ? pathWithoutQuery : path20.resolve(ctx.configService.cwd, pathWithoutQuery);
-  if (!absolutePath.startsWith(ctx.configService.absoluteSrcRoot)) {
-    markNeedsFullRescan?.();
-    return true;
-  }
-  const base = removeExtensionDeep5(absolutePath);
-  const relativeBase = toPosixPath(path20.relative(ctx.configService.absoluteSrcRoot, base));
-  if (!relativeBase || relativeBase.startsWith("..")) {
+  const normalizedSrcRoot = normalizePath(ctx.configService.absoluteSrcRoot);
+  const normalizedAbsolutePath = normalizePath(absolutePath);
+  const base = removeExtensionDeep5(normalizedAbsolutePath);
+  const relativeBase = toPosixPath(path20.relative(normalizedSrcRoot, base));
+  if (!relativeBase || relativeBase.startsWith("..") || path20.isAbsolute(relativeBase)) {
     markNeedsFullRescan?.();
     return true;
   }
@@ -8487,7 +8535,26 @@ function createAutoRoutesService(ctx) {
       "const pages = routes.pages;",
       "const entries = routes.entries;",
       "const subPackages = routes.subPackages;",
-      "export { routes, pages, entries, subPackages };",
+      "const resolveMiniProgramGlobal = () => (globalThis.wx ?? globalThis.tt ?? globalThis.my);",
+      "const callRouteMethod = (methodName, option) => {",
+      "  const miniProgramGlobal = resolveMiniProgramGlobal();",
+      "  const routeMethod = miniProgramGlobal?.[methodName];",
+      '  if (typeof routeMethod !== "function") {',
+      '    throw new Error("[weapp-vite] \u5F53\u524D\u8FD0\u884C\u73AF\u5883\u4E0D\u652F\u6301\u8DEF\u7531\u65B9\u6CD5: " + methodName);',
+      "  }",
+      "  if (option === undefined) {",
+      "    return routeMethod.call(miniProgramGlobal);",
+      "  }",
+      "  return routeMethod.call(miniProgramGlobal, option);",
+      "};",
+      "const wxRouter = {",
+      '  switchTab(option) { return callRouteMethod("switchTab", option); },',
+      '  reLaunch(option) { return callRouteMethod("reLaunch", option); },',
+      '  redirectTo(option) { return callRouteMethod("redirectTo", option); },',
+      '  navigateTo(option) { return callRouteMethod("navigateTo", option); },',
+      '  navigateBack(option) { return callRouteMethod("navigateBack", option); },',
+      "};",
+      "export { routes, pages, entries, subPackages, wxRouter };",
       "export default routes;"
     ].join("\n");
     updateWatchTargets(state.watchFiles, /* @__PURE__ */ new Set());
@@ -25733,12 +25800,12 @@ function createAutoRoutesPlugin(ctx) {
     if (!pathWithoutQuery) {
       return false;
     }
-    const normalized = path43.isAbsolute(pathWithoutQuery) ? pathWithoutQuery : path43.resolve(configService.cwd, pathWithoutQuery);
-    if (!normalized.startsWith(configService.absoluteSrcRoot)) {
-      return false;
-    }
-    const relative3 = toPosixPath(path43.relative(configService.absoluteSrcRoot, normalized));
-    if (!relative3 || relative3.startsWith("..")) {
+    const normalizedSrcRoot = normalizePath(configService.absoluteSrcRoot);
+    const normalizedCandidate = normalizePath(
+      path43.isAbsolute(pathWithoutQuery) ? pathWithoutQuery : path43.resolve(configService.cwd, pathWithoutQuery)
+    );
+    const relative3 = toPosixPath(path43.relative(normalizedSrcRoot, normalizedCandidate));
+    if (!relative3 || relative3.startsWith("..") || path43.isAbsolute(relative3)) {
       return false;
     }
     return relative3 === "pages" || relative3.startsWith("pages/") || relative3.includes("/pages/");
@@ -30098,6 +30165,192 @@ import fs33 from "fs-extra";
 import path67 from "pathe";
 import { compileJsxFile as compileJsxFile2, compileVueFile as compileVueFile2 } from "wevu/compiler";
 
+// src/plugins/performance/onPageScrollDiagnostics.ts
+init_esm_shims();
+function isStaticPropertyName(key) {
+  if (key.type === "Identifier") {
+    return key.name;
+  }
+  if (key.type === "StringLiteral") {
+    return key.value;
+  }
+  return void 0;
+}
+function getMemberExpressionPropertyName(node) {
+  if (node.computed) {
+    return node.property.type === "StringLiteral" ? node.property.value : void 0;
+  }
+  return node.property.type === "Identifier" ? node.property.name : void 0;
+}
+function isOnPageScrollCallee(callee, hookNames, namespaceImports) {
+  if (callee.type === "Identifier") {
+    return hookNames.has(callee.name);
+  }
+  if (callee.type === "MemberExpression" || callee.type === "OptionalMemberExpression") {
+    const object = callee.object;
+    const propName = getMemberExpressionPropertyName(callee);
+    return object.type === "Identifier" && namespaceImports.has(object.name) && propName === "onPageScroll";
+  }
+  return false;
+}
+function getCallExpressionCalleeName(callee) {
+  if (callee.type === "Identifier") {
+    return callee.name;
+  }
+  if (callee.type === "MemberExpression" || callee.type === "OptionalMemberExpression") {
+    return getMemberExpressionPropertyName(callee);
+  }
+  return void 0;
+}
+function collectPageScrollInspection(functionPath, node) {
+  const inspection = {
+    empty: node.body.type === "BlockStatement" && node.body.body.length === 0,
+    hasSetDataCall: false,
+    syncApis: /* @__PURE__ */ new Set()
+  };
+  functionPath.traverse({
+    Function(innerPath) {
+      if (innerPath !== functionPath) {
+        innerPath.skip();
+      }
+    },
+    CallExpression(callPath) {
+      const callee = callPath.node.callee;
+      const calleeName = getCallExpressionCalleeName(callee);
+      if (calleeName === "setData") {
+        inspection.hasSetDataCall = true;
+      }
+      if (callee.type === "MemberExpression" || callee.type === "OptionalMemberExpression") {
+        const object = callee.object;
+        if (object.type === "Identifier" && object.name === "wx") {
+          const propertyName = getMemberExpressionPropertyName(callee);
+          if (propertyName && propertyName.endsWith("Sync")) {
+            inspection.syncApis.add(`wx.${propertyName}`);
+          }
+        }
+      }
+    },
+    OptionalCallExpression(callPath) {
+      const callee = callPath.node.callee;
+      const calleeName = getCallExpressionCalleeName(callee);
+      if (calleeName === "setData") {
+        inspection.hasSetDataCall = true;
+      }
+      if (callee.type === "MemberExpression" || callee.type === "OptionalMemberExpression") {
+        const object = callee.object;
+        if (object.type === "Identifier" && object.name === "wx") {
+          const propertyName = getMemberExpressionPropertyName(callee);
+          if (propertyName && propertyName.endsWith("Sync")) {
+            inspection.syncApis.add(`wx.${propertyName}`);
+          }
+        }
+      }
+    }
+  });
+  return inspection;
+}
+function createWarningPrefix(filename, line, column) {
+  const pos = typeof line === "number" && typeof column === "number" ? `${line}:${column}` : "?:?";
+  return `[weapp-vite][onPageScroll] ${filename}:${pos}`;
+}
+function collectOnPageScrollPerformanceWarnings(code, filename) {
+  let ast;
+  try {
+    ast = parseJsLike(code);
+  } catch {
+    return [];
+  }
+  const onPageScrollHookNames = /* @__PURE__ */ new Set(["onPageScroll"]);
+  const namespaceImports = /* @__PURE__ */ new Set();
+  for (const statement of ast.program.body) {
+    if (statement.type !== "ImportDeclaration" || statement.source.value !== "wevu") {
+      continue;
+    }
+    for (const specifier of statement.specifiers) {
+      if (specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "onPageScroll") {
+        onPageScrollHookNames.add(specifier.local.name);
+      }
+      if (specifier.type === "ImportNamespaceSpecifier") {
+        namespaceImports.add(specifier.local.name);
+      }
+    }
+  }
+  const warnings = [];
+  const warningSet = /* @__PURE__ */ new Set();
+  const addWarning = (warning) => {
+    if (warningSet.has(warning)) {
+      return;
+    }
+    warningSet.add(warning);
+    warnings.push(warning);
+  };
+  const reportInspection = (functionPath, node, sourceLabel) => {
+    const inspection = collectPageScrollInspection(functionPath, node);
+    const line = node.loc?.start.line;
+    const column = typeof node.loc?.start.column === "number" ? node.loc.start.column + 1 : void 0;
+    const prefix = createWarningPrefix(filename, line, column);
+    if (inspection.empty) {
+      addWarning(`${prefix} \u68C0\u6D4B\u5230\u7A7A\u7684 ${sourceLabel} \u56DE\u8C03\uFF0C\u5EFA\u8BAE\u79FB\u9664\u65E0\u6548\u76D1\u542C\u4EE5\u964D\u4F4E\u6EDA\u52A8\u65F6\u8C03\u5EA6\u5F00\u9500\u3002`);
+    }
+    if (inspection.hasSetDataCall) {
+      addWarning(`${prefix} \u68C0\u6D4B\u5230 ${sourceLabel} \u5185\u8C03\u7528 setData\uFF0C\u5EFA\u8BAE\u6539\u7528\u8282\u6D41\u3001IntersectionObserver \u6216\u5408\u5E76\u66F4\u65B0\u3002`);
+    }
+    for (const syncApi of inspection.syncApis) {
+      addWarning(`${prefix} \u68C0\u6D4B\u5230 ${sourceLabel} \u5185\u8C03\u7528\u540C\u6B65 API\uFF08${syncApi}\uFF09\uFF0C\u53EF\u80FD\u963B\u585E\u6E32\u67D3\u7EBF\u7A0B\u3002`);
+    }
+  };
+  traverse(ast, {
+    ObjectMethod(path81) {
+      const keyName = isStaticPropertyName(path81.node.key);
+      if (keyName !== "onPageScroll") {
+        return;
+      }
+      reportInspection(path81, path81.node, "onPageScroll");
+    },
+    ObjectProperty(path81) {
+      if (path81.node.computed) {
+        return;
+      }
+      const keyName = isStaticPropertyName(path81.node.key);
+      if (keyName !== "onPageScroll") {
+        return;
+      }
+      const value = path81.node.value;
+      if (value.type !== "FunctionExpression" && value.type !== "ArrowFunctionExpression") {
+        return;
+      }
+      reportInspection(path81.get("value"), value, "onPageScroll");
+    },
+    CallExpression(path81) {
+      if (!isOnPageScrollCallee(path81.node.callee, onPageScrollHookNames, namespaceImports)) {
+        return;
+      }
+      const arg0 = path81.node.arguments[0];
+      if (!arg0 || arg0.type === "SpreadElement") {
+        return;
+      }
+      if (arg0.type !== "FunctionExpression" && arg0.type !== "ArrowFunctionExpression") {
+        return;
+      }
+      reportInspection(path81.get("arguments.0"), arg0, "onPageScroll(...)");
+    },
+    OptionalCallExpression(path81) {
+      if (!isOnPageScrollCallee(path81.node.callee, onPageScrollHookNames, namespaceImports)) {
+        return;
+      }
+      const arg0 = path81.node.arguments[0];
+      if (!arg0 || arg0.type === "SpreadElement") {
+        return;
+      }
+      if (arg0.type !== "FunctionExpression" && arg0.type !== "ArrowFunctionExpression") {
+        return;
+      }
+      reportInspection(path81.get("arguments.0"), arg0, "onPageScroll(...)");
+    }
+  });
+  return warnings;
+}
+
 // src/plugins/wevu.ts
 init_esm_shims();
 import path63 from "pathe";
@@ -30186,6 +30439,9 @@ function createWevuAutoPageFeaturesPlugin(ctx) {
       if (!await pageMatcher.isPageFile(filename)) {
         return null;
       }
+      for (const warning of collectOnPageScrollPerformanceWarnings(code, filename)) {
+        default2.warn(warning);
+      }
       const result = await injectWevuPageFeaturesInJsWithResolver(code, {
         id: filename,
         resolver: createViteResolverAdapter(
@@ -33041,6 +33297,92 @@ function createUsingComponentPathResolver(ctx, configService, reExportResolution
   };
 }
 
+// src/plugins/vue/transform/wevuPreset.ts
+init_esm_shims();
+var PERFORMANCE_PRESET_DEFAULTS = {
+  app: {
+    setData: {
+      strategy: "patch",
+      suspendWhenHidden: true,
+      diagnostics: "fallback",
+      highFrequencyWarning: {
+        enabled: true,
+        devOnly: true
+      }
+    }
+  },
+  component: {
+    setData: {
+      strategy: "patch",
+      suspendWhenHidden: true,
+      diagnostics: "fallback",
+      highFrequencyWarning: {
+        enabled: true,
+        devOnly: true
+      }
+    }
+  }
+};
+function getPlainRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  return value;
+}
+function mergeDefaults(defaults, options) {
+  if (!defaults) {
+    return options;
+  }
+  if (!options) {
+    return defaults;
+  }
+  const merged = {
+    ...defaults,
+    ...options
+  };
+  const defaultSetData = getPlainRecord(defaults.setData);
+  const optionSetData = getPlainRecord(options.setData);
+  if (defaultSetData || optionSetData) {
+    merged.setData = {
+      ...defaultSetData ?? {},
+      ...optionSetData ?? {}
+    };
+  }
+  const defaultOptions3 = getPlainRecord(defaults.options);
+  const optionOptions = getPlainRecord(options.options);
+  if (defaultOptions3 || optionOptions) {
+    merged.options = {
+      ...defaultOptions3 ?? {},
+      ...optionOptions ?? {}
+    };
+  }
+  return merged;
+}
+function mergeWevuDefaults(base, next) {
+  return {
+    app: mergeDefaults(base.app, next.app),
+    component: mergeDefaults(base.component, next.component)
+  };
+}
+function resolveWevuPreset(config) {
+  return config?.wevu?.preset;
+}
+function resolveWevuDefaultsWithPreset(config) {
+  const userDefaults = config?.wevu?.defaults;
+  const preset = resolveWevuPreset(config);
+  if (preset !== "performance") {
+    return userDefaults;
+  }
+  return mergeWevuDefaults(PERFORMANCE_PRESET_DEFAULTS, userDefaults ?? {});
+}
+function isAutoSetDataPickEnabledWithPreset(config) {
+  const explicit = config?.wevu?.autoSetDataPick;
+  if (typeof explicit === "boolean") {
+    return explicit;
+  }
+  return resolveWevuPreset(config) === "performance";
+}
+
 // src/plugins/vue/transform/compileOptions.ts
 function createCompileVueFileOptions(ctx, pluginCtx, vuePath, isPage, isApp, configService, state) {
   const scopedSlotsCompiler = configService.weappViteConfig?.vue?.template?.scopedSlotsCompiler ?? "auto";
@@ -33070,7 +33412,7 @@ function createCompileVueFileOptions(ctx, pluginCtx, vuePath, isPage, isApp, con
     }
   }
   const jsonConfig = configService.weappViteConfig?.json;
-  const wevuDefaults = configService.weappViteConfig?.wevu?.defaults;
+  const wevuDefaults = resolveWevuDefaultsWithPreset(configService.weappViteConfig);
   const jsonKind = isApp ? "app" : isPage ? "page" : "component";
   const templatePlatform = getMiniProgramTemplatePlatform(configService.platform);
   return {
@@ -33297,6 +33639,331 @@ async function injectWevuPageFeaturesInJsWithViteResolver(ctx, source, id, optio
   });
 }
 
+// src/plugins/vue/transform/injectSetDataPick.ts
+init_esm_shims();
+var TEMPLATE_MUSTACHE_RE = /\{\{([\s\S]*?)\}\}/g;
+var WX_FOR_TAG_RE = /<[^>]*\bwx:for\s*=\s*(?:"[^"]*"|'[^']*')[^>]*>/g;
+var WX_FOR_ITEM_RE = /\bwx:for-item\s*=\s*(?:"([^"]+)"|'([^']+)')/;
+var WX_FOR_INDEX_RE = /\bwx:for-index\s*=\s*(?:"([^"]+)"|'([^']+)')/;
+var JS_GLOBAL_IDENTIFIERS = /* @__PURE__ */ new Set([
+  "undefined",
+  "NaN",
+  "Infinity",
+  "globalThis",
+  "Math",
+  "Number",
+  "String",
+  "Boolean",
+  "Object",
+  "Array",
+  "Date",
+  "JSON",
+  "RegExp",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "decodeURI",
+  "decodeURIComponent",
+  "encodeURI",
+  "encodeURIComponent"
+]);
+function isAutoSetDataPickEnabled(config) {
+  return isAutoSetDataPickEnabledWithPreset(config);
+}
+function isTargetWevuComponentCall(callee) {
+  if (callee.type === "Identifier") {
+    return callee.name === "createWevuComponent" || callee.name === "defineComponent";
+  }
+  if (callee.type !== "MemberExpression" || callee.computed) {
+    return false;
+  }
+  return callee.property.type === "Identifier" && (callee.property.name === "createWevuComponent" || callee.property.name === "defineComponent");
+}
+function getObjectPropertyByKey(objectExpression, key) {
+  for (const member of objectExpression.properties) {
+    if (member.type !== "ObjectProperty") {
+      continue;
+    }
+    if (member.key.type === "Identifier" && member.key.name === key) {
+      return member;
+    }
+    if (member.key.type === "StringLiteral" && member.key.value === key) {
+      return member;
+    }
+  }
+  return void 0;
+}
+function unwrapExpression(node) {
+  let current2 = node;
+  while (true) {
+    if (current2.type === "TSAsExpression" || current2.type === "TSTypeAssertion" || current2.type === "TSNonNullExpression" || current2.type === "ParenthesizedExpression" || current2.type === "TSSatisfiesExpression") {
+      current2 = current2.expression;
+      continue;
+    }
+    return current2;
+  }
+}
+function resolveOptionsObjectExpression2(expression, scope) {
+  if (!expression) {
+    return void 0;
+  }
+  const unwrapped = unwrapExpression(expression);
+  if (unwrapped.type === "ObjectExpression") {
+    return unwrapped;
+  }
+  if (unwrapped.type === "Identifier") {
+    const binding = scope.getBinding(unwrapped.name);
+    if (!binding || !binding.path.isVariableDeclarator()) {
+      return void 0;
+    }
+    const init = binding.path.node.init;
+    if (!init || init.type !== "ObjectExpression" && init.type !== "CallExpression" && init.type !== "Identifier") {
+      return void 0;
+    }
+    return resolveOptionsObjectExpression2(init, binding.path.scope);
+  }
+  if (unwrapped.type === "CallExpression" && unwrapped.callee.type === "MemberExpression" && !unwrapped.callee.computed && unwrapped.callee.object.type === "Identifier" && unwrapped.callee.object.name === "Object" && unwrapped.callee.property.type === "Identifier" && unwrapped.callee.property.name === "assign") {
+    for (let i = unwrapped.arguments.length - 1; i >= 0; i--) {
+      const arg = unwrapped.arguments[i];
+      if (arg.type !== "SpreadElement") {
+        const resolved = resolveOptionsObjectExpression2(arg, scope);
+        if (resolved) {
+          return resolved;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function createPickArrayExpression(keys) {
+  return {
+    type: "ArrayExpression",
+    elements: keys.map((key) => ({ type: "StringLiteral", value: key }))
+  };
+}
+function mergePickArrayExpression(arrayExpression, keys) {
+  const existing = /* @__PURE__ */ new Set();
+  for (const element of arrayExpression.elements) {
+    if (element && element.type === "StringLiteral") {
+      existing.add(element.value);
+    }
+  }
+  let changed = false;
+  for (const key of keys) {
+    if (existing.has(key)) {
+      continue;
+    }
+    arrayExpression.elements.push({ type: "StringLiteral", value: key });
+    existing.add(key);
+    changed = true;
+  }
+  return changed;
+}
+function injectPickIntoSetDataObject(setDataObject, keys) {
+  const pickProp = getObjectPropertyByKey(setDataObject, "pick");
+  if (!pickProp) {
+    setDataObject.properties.unshift({
+      type: "ObjectProperty",
+      key: { type: "Identifier", name: "pick" },
+      computed: false,
+      shorthand: false,
+      value: createPickArrayExpression(keys)
+    });
+    return true;
+  }
+  if (pickProp.value.type !== "ArrayExpression") {
+    return false;
+  }
+  return mergePickArrayExpression(pickProp.value, keys);
+}
+function injectPickIntoOptionsObject(optionsObject, keys) {
+  const setDataProp = getObjectPropertyByKey(optionsObject, "setData");
+  if (!setDataProp) {
+    optionsObject.properties.unshift({
+      type: "ObjectProperty",
+      key: { type: "Identifier", name: "setData" },
+      computed: false,
+      shorthand: false,
+      value: {
+        type: "ObjectExpression",
+        properties: [
+          {
+            type: "ObjectProperty",
+            key: { type: "Identifier", name: "pick" },
+            computed: false,
+            shorthand: false,
+            value: createPickArrayExpression(keys)
+          }
+        ]
+      }
+    });
+    return true;
+  }
+  const setDataValue = unwrapExpression(setDataProp.value);
+  if (setDataValue.type === "ObjectExpression") {
+    return injectPickIntoSetDataObject(setDataValue, keys);
+  }
+  if (setDataValue.type === "Identifier" || setDataValue.type === "MemberExpression" || setDataValue.type === "CallExpression") {
+    setDataProp.value = {
+      type: "ObjectExpression",
+      properties: [
+        {
+          type: "ObjectProperty",
+          key: { type: "Identifier", name: "pick" },
+          computed: false,
+          shorthand: false,
+          value: createPickArrayExpression(keys)
+        },
+        {
+          type: "SpreadElement",
+          argument: setDataValue
+        }
+      ]
+    };
+    return true;
+  }
+  return false;
+}
+function collectLoopScopeAliases(template) {
+  const aliases = /* @__PURE__ */ new Set();
+  const tagMatches = template.match(WX_FOR_TAG_RE) ?? [];
+  for (const tag of tagMatches) {
+    const itemMatch = tag.match(WX_FOR_ITEM_RE);
+    if (itemMatch) {
+      const itemAlias = (itemMatch[1] ?? itemMatch[2] ?? "").trim();
+      if (itemAlias) {
+        aliases.add(itemAlias);
+      }
+    } else {
+      aliases.add("item");
+    }
+    const indexMatch = tag.match(WX_FOR_INDEX_RE);
+    if (indexMatch) {
+      const indexAlias = (indexMatch[1] ?? indexMatch[2] ?? "").trim();
+      if (indexAlias) {
+        aliases.add(indexAlias);
+      }
+    } else {
+      aliases.add("index");
+    }
+  }
+  return aliases;
+}
+function extractTemplateExpressions(template) {
+  const expressions = [];
+  let match = TEMPLATE_MUSTACHE_RE.exec(template);
+  while (match) {
+    const expression = (match[1] ?? "").trim();
+    if (expression) {
+      expressions.push(expression);
+    }
+    match = TEMPLATE_MUSTACHE_RE.exec(template);
+  }
+  TEMPLATE_MUSTACHE_RE.lastIndex = 0;
+  return expressions;
+}
+function collectIdentifiersFromExpression(expression) {
+  const collected = /* @__PURE__ */ new Set();
+  let ast;
+  try {
+    ast = parse(`const __weappViteExpr = (${expression});`, {
+      ...BABEL_TS_MODULE_PARSER_OPTIONS,
+      sourceType: "module"
+    });
+  } catch {
+    return collected;
+  }
+  traverse(ast, {
+    Identifier(path81) {
+      if (!path81.isReferencedIdentifier()) {
+        return;
+      }
+      const name = path81.node.name;
+      if (name === "__weappViteExpr") {
+        return;
+      }
+      if (path81.scope.hasBinding(name, true)) {
+        return;
+      }
+      if (JS_GLOBAL_IDENTIFIERS.has(name)) {
+        return;
+      }
+      collected.add(name);
+    },
+    MemberExpression(path81) {
+      const member = path81.node;
+      if (member.computed || member.object.type !== "ThisExpression" || member.property.type !== "Identifier") {
+        return;
+      }
+      collected.add(member.property.name);
+    },
+    OptionalMemberExpression(path81) {
+      const member = path81.node;
+      if (member.computed || member.object.type !== "ThisExpression" || member.property.type !== "Identifier") {
+        return;
+      }
+      collected.add(member.property.name);
+    }
+  });
+  return collected;
+}
+function collectSetDataPickKeysFromTemplate(template) {
+  const templateExpressions = extractTemplateExpressions(template);
+  if (!templateExpressions.length) {
+    return [];
+  }
+  const loopAliases = collectLoopScopeAliases(template);
+  const keys = /* @__PURE__ */ new Set();
+  for (const expression of templateExpressions) {
+    const identifiers = collectIdentifiersFromExpression(expression);
+    for (const identifier3 of identifiers) {
+      if (!loopAliases.has(identifier3)) {
+        keys.add(identifier3);
+      }
+    }
+  }
+  return Array.from(keys).sort((a3, b) => a3.localeCompare(b));
+}
+function injectSetDataPickInJs(source, pickKeys) {
+  if (!pickKeys.length) {
+    return { code: source, transformed: false };
+  }
+  const ast = parseJsLike(source);
+  const candidateOptions = /* @__PURE__ */ new Set();
+  traverse(ast, {
+    CallExpression(path81) {
+      if (!isTargetWevuComponentCall(path81.node.callee)) {
+        return;
+      }
+      const firstArg = path81.node.arguments[0];
+      if (!firstArg || firstArg.type === "SpreadElement") {
+        return;
+      }
+      const resolvedOptions = resolveOptionsObjectExpression2(firstArg, path81.scope);
+      if (resolvedOptions) {
+        candidateOptions.add(resolvedOptions);
+      }
+    }
+  });
+  if (!candidateOptions.size) {
+    return { code: source, transformed: false };
+  }
+  let changed = false;
+  for (const optionsObject of candidateOptions) {
+    changed = injectPickIntoOptionsObject(optionsObject, pickKeys) || changed;
+  }
+  if (!changed) {
+    return { code: source, transformed: false };
+  }
+  const generated = generate(ast, { retainLines: true });
+  return { code: generated.code, transformed: true };
+}
+
 // src/plugins/vue/transform/scopedSlot.ts
 init_esm_shims();
 import { buildClassStyleComputedCode, createJsonMerger as createJsonMerger2, getClassStyleWxsSource, WE_VU_MODULE_ID, WE_VU_RUNTIME_APIS } from "wevu/compiler";
@@ -33694,6 +34361,13 @@ async function emitVueBundleAssets(bundle, state) {
               compiled.script = injected.code;
             }
           }
+          if (!isApp && compiled.script && compiled.template && isAutoSetDataPickEnabled(configService.weappViteConfig)) {
+            const keys = collectSetDataPickKeysFromTemplate(compiled.template);
+            const injectedPick = injectSetDataPickInJs(compiled.script, keys);
+            if (injectedPick.transformed) {
+              compiled.script = injectedPick.code;
+            }
+          }
           cached.source = source;
           cached.result = compiled;
           result = compiled;
@@ -33803,6 +34477,13 @@ async function emitVueBundleAssets(bundle, state) {
           result.script = injected.code;
         }
       }
+      if (result.script && result.template && isAutoSetDataPickEnabled(configService.weappViteConfig)) {
+        const keys = collectSetDataPickKeysFromTemplate(result.template);
+        const injectedPick = injectSetDataPickInJs(result.script, keys);
+        if (injectedPick.transformed) {
+          result.script = injectedPick.code;
+        }
+      }
       if (result.template) {
         const normalizedTemplate = normalizeVueTemplateForPlatform(result.template, {
           platform: configService.platform,
@@ -34041,6 +34722,9 @@ function createVueTransformPlugin(ctx) {
           }
         }
         if (isPage && result.script) {
+          for (const warning of collectOnPageScrollPerformanceWarnings(result.script, filename)) {
+            default2.warn(warning);
+          }
           const injected = await injectWevuPageFeaturesInJsWithViteResolver(this, result.script, filename, {
             checkMtime: configService.isDev
           });
@@ -34048,6 +34732,13 @@ function createVueTransformPlugin(ctx) {
             result.script = injected.code;
           }
         }
+        if (!isApp && result.script && result.template && isAutoSetDataPickEnabled(configService.weappViteConfig)) {
+          const keys = collectSetDataPickKeysFromTemplate(result.template);
+          const injectedPick = injectSetDataPickInJs(result.script, keys);
+          if (injectedPick.transformed) {
+            result.script = injectedPick.code;
+          }
+        }
         compilationCache.set(filename, { result, source, isPage });
         const relativeBase = configService.relativeOutputPath(getEntryBasePath(filename));
         if (relativeBase) {
@@ -36994,7 +37685,26 @@ function createRuntimeState() {
         "const pages = routes.pages;",
         "const entries = routes.entries;",
         "const subPackages = routes.subPackages;",
-        "export { routes, pages, entries, subPackages };",
+        "const resolveMiniProgramGlobal = () => (globalThis.wx ?? globalThis.tt ?? globalThis.my);",
+        "const callRouteMethod = (methodName, option) => {",
+        "  const miniProgramGlobal = resolveMiniProgramGlobal();",
+        "  const routeMethod = miniProgramGlobal?.[methodName];",
+        '  if (typeof routeMethod !== "function") {',
+        '    throw new Error("[weapp-vite] \u5F53\u524D\u8FD0\u884C\u73AF\u5883\u4E0D\u652F\u6301\u8DEF\u7531\u65B9\u6CD5: " + methodName);',
+        "  }",
+        "  if (option === undefined) {",
+        "    return routeMethod.call(miniProgramGlobal);",
+        "  }",
+        "  return routeMethod.call(miniProgramGlobal, option);",
+        "};",
+        "const wxRouter = {",
+        '  switchTab(option) { return callRouteMethod("switchTab", option); },',
+        '  reLaunch(option) { return callRouteMethod("reLaunch", option); },',
+        '  redirectTo(option) { return callRouteMethod("redirectTo", option); },',
+        '  navigateTo(option) { return callRouteMethod("navigateTo", option); },',
+        '  navigateBack(option) { return callRouteMethod("navigateBack", option); },',
+        "};",
+        "export { routes, pages, entries, subPackages, wxRouter };",
         "export default routes;"
       ].join("\n"),
       typedDefinition: "",
@@ -37408,7 +38118,7 @@ function createScanService(ctx) {
       vueAppPath = await findVueEntry(appBasename);
     }
     if (!appConfigFile && vueAppPath) {
-      const { extractConfigFromVue: extractConfigFromVue2 } = await import("./file-5JL4CYT6.mjs");
+      const { extractConfigFromVue: extractConfigFromVue2 } = await import("./file-IRTTGBIN.mjs");
       configFromVue = await extractConfigFromVue2(vueAppPath);
       if (configFromVue) {
         appConfigFile = vueAppPath;