@uni-helper/vite-plugin-uni-pages 0.3.2 → 0.3.4

package/dist/index.cjs

@@ -2,39 +2,67 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const path = require('node:path');
 const node_child_process = require('node:child_process');
+const path = require('node:path');
 const process = require('node:process');
-const vite = require('vite');
-const MagicString = require('magic-string');
+const astKit = require('ast-kit');
 const chokidar = require('chokidar');
-const unconfig = require('unconfig');
-const Debug = require('debug');
+const kolorist = require('kolorist');
+const MagicString = require('magic-string');
+const vite = require('vite');
 const uniEnv = require('@uni-helper/uni-env');
+const commentJson = require('comment-json');
+const Debug = require('debug');
 const detectIndent = require('detect-indent');
 const detectNewline = require('detect-newline');
-const commentJson = require('comment-json');
+const unconfig = require('unconfig');
 const fs = require('node:fs');
 const promises = require('node:fs/promises');
+const fg = require('fast-glob');
+const node_module = require('node:module');
+const vm = require('node:vm');
+const babelGenerator = require('@babel/generator');
 const groupBy = require('lodash.groupby');
+const ts = require('typescript');
+const t = require('@babel/types');
+const compilerSfc = require('@vue/compiler-sfc');
 const JSON5 = require('json5');
 const yaml = require('yaml');
-const compilerSfc = require('@vue/compiler-sfc');
-const fg = require('fast-glob');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
+function _interopNamespaceCompat(e) {
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  const n = Object.create(null);
+  if (e) {
+    for (const k in e) {
+      n[k] = e[k];
+    }
+  }
+  n.default = e;
+  return n;
+}
+
 const path__default = /*#__PURE__*/_interopDefaultCompat(path);
 const process__default = /*#__PURE__*/_interopDefaultCompat(process);
-const MagicString__default = /*#__PURE__*/_interopDefaultCompat(MagicString);
 const chokidar__default = /*#__PURE__*/_interopDefaultCompat(chokidar);
+const MagicString__default = /*#__PURE__*/_interopDefaultCompat(MagicString);
 const Debug__default = /*#__PURE__*/_interopDefaultCompat(Debug);
 const detectIndent__default = /*#__PURE__*/_interopDefaultCompat(detectIndent);
 const detectNewline__default = /*#__PURE__*/_interopDefaultCompat(detectNewline);
 const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const fg__default = /*#__PURE__*/_interopDefaultCompat(fg);
+const vm__default = /*#__PURE__*/_interopDefaultCompat(vm);
+const babelGenerator__default = /*#__PURE__*/_interopDefaultCompat(babelGenerator);
 const groupBy__default = /*#__PURE__*/_interopDefaultCompat(groupBy);
+const ts__namespace = /*#__PURE__*/_interopNamespaceCompat(ts);
+const t__namespace = /*#__PURE__*/_interopNamespaceCompat(t);
 const JSON5__default = /*#__PURE__*/_interopDefaultCompat(JSON5);
-const fg__default = /*#__PURE__*/_interopDefaultCompat(fg);
+
+const MODULE_ID_VIRTUAL = "virtual:uni-pages";
+const RESOLVED_MODULE_ID_VIRTUAL = `\0${MODULE_ID_VIRTUAL}`;
+const OUTPUT_NAME = "pages.json";
+const FILE_EXTENSIONS = ["vue", "nvue", "uvue"];
 
 function slash(str) {
   return str.replace(/\\/g, "/");
@@ -86,86 +114,6 @@ async function writeDeclaration(ctx, filepath) {
     await writeFile(filepath, code);
 }
 
-const MODULE_ID_VIRTUAL = "virtual:uni-pages";
-const RESOLVED_MODULE_ID_VIRTUAL = `\0${MODULE_ID_VIRTUAL}`;
-const OUTPUT_NAME = "pages.json";
-const FILE_EXTENSIONS = ["vue", "nvue", "uvue"];
-
-async function parseSFC(code) {
-  try {
-    return compilerSfc.parse(code, {
-      pad: "space"
-    }).descriptor || compilerSfc.parse({
-      source: code
-    });
-  } catch (error) {
-    throw new Error(`[vite-plugin-uni-pages] Vue3's "@vue/compiler-sfc" is required. 
-Original error: 
-${error}`);
-  }
-}
-function parseCustomBlock(block, filePath, options) {
-  const lang = block.lang ?? options.routeBlockLang;
-  const attr = {
-    type: "page",
-    ...block.attrs
-  };
-  let content;
-  debug.routeBlock(`use ${lang} parser`);
-  if (lang === "json5") {
-    try {
-      content = JSON5__default.parse(block.content);
-    } catch (err) {
-      throw new Error(
-        `Invalid JSON5 format of <${block.type}> content in ${filePath}
-${err.message}`
-      );
-    }
-  } else if (lang === "jsonc") {
-    try {
-      content = commentJson.parse(block.content);
-    } catch (err) {
-      throw new Error(
-        `Invalid JSONC format of <${block.type}> content in ${filePath}
-${err.message}`
-      );
-    }
-  } else if (lang === "json") {
-    try {
-      content = JSON.parse(block.content);
-    } catch (err) {
-      throw new Error(
-        `Invalid JSON format of <${block.type}> content in ${filePath}
-${err.message}`
-      );
-    }
-  } else if (lang === "yaml" || lang === "yml") {
-    try {
-      content = yaml.parse(block.content);
-    } catch (err) {
-      throw new Error(
-        `Invalid YAML format of <${block.type}> content in ${filePath}
-${err.message}`
-      );
-    }
-  }
-  return {
-    attr,
-    content: content ?? {}
-  };
-}
-async function getRouteSfcBlock(path) {
-  const content = fs__default.readFileSync(path, "utf8");
-  const parsedSFC = await parseSFC(content);
-  const blockStr = parsedSFC?.customBlocks.find((b) => b.type === "route");
-  return blockStr;
-}
-async function getRouteBlock(path, blockStr, options) {
-  if (!blockStr)
-    return;
-  return parseCustomBlock(blockStr, path, options);
-}
-
 function invalidatePagesModule(server) {
   const { moduleGraph } = server;
   const mods = moduleGraph.getModulesByFile(RESOLVED_MODULE_ID_VIRTUAL);
@@ -184,20 +132,21 @@ const debug = {
   subPages: Debug__default("vite-plugin-uni-pages:subPages"),
   error: Debug__default("vite-plugin-uni-pages:error"),
   cache: Debug__default("vite-plugin-uni-pages:cache"),
-  declaration: Debug__default("vite-plugin-uni-pages:declaration")
+  declaration: Debug__default("vite-plugin-uni-pages:declaration"),
+  definePage: Debug__default("vite-plugin-uni-pages:definePage")
 };
 function extsToGlob(extensions) {
   return extensions.length > 1 ? `{${extensions.join(",")}}` : extensions[0] || "";
 }
-function isTargetFile(path) {
-  const ext = path.split(".").pop();
+function isTargetFile(path2) {
+  const ext = path2.split(".").pop();
   return FILE_EXTENSIONS.includes(ext);
 }
 function mergePageMetaDataArray(pageMetaData) {
   const pageMetaDataObj = groupBy__default(pageMetaData, "path");
   const result = [];
-  for (const path in pageMetaDataObj) {
-    const _pageMetaData = pageMetaDataObj[path];
+  for (const path2 in pageMetaDataObj) {
+    const _pageMetaData = pageMetaDataObj[path2];
     const options = _pageMetaData[0];
     for (const page of _pageMetaData) {
       options.style = Object.assign(options.style ?? {}, page.style ?? {});
@@ -207,26 +156,64 @@ function mergePageMetaDataArray(pageMetaData) {
   }
   return result;
 }
-function useCachedPages() {
-  const pages = /* @__PURE__ */ new Map();
-  function parseData(block) {
-    return {
-      content: block?.loc.source.trim() ?? "",
-      attr: block?.attrs ?? ""
-    };
+async function execScript(code, filename) {
+  const jsCode = ts__namespace.transpileModule(code, {
+    compilerOptions: {
+      module: ts__namespace.ModuleKind.CommonJS,
+      target: ts__namespace.ScriptTarget.ESNext
+    }
+  }).outputText;
+  const dir = path__default.dirname(filename);
+  const vmContext = {
+    require: node_module.createRequire(dir),
+    module: {},
+    exports: {},
+    __filename: filename,
+    __dirname: dir
+  };
+  const script = new vm__default.Script(jsCode);
+  try {
+    script.runInNewContext(vmContext);
+  } catch (error) {
+    throw new Error(`${filename}: ${error.message}`);
   }
-  function setCache(filePath, routeBlock) {
-    pages.set(filePath, commentJson.stringify(parseData(routeBlock)));
+  const result = vmContext.exports.default || vmContext.exports;
+  if (typeof result === "function") {
+    return Promise.resolve(result());
   }
-  async function hasChanged(filePath, routeBlock) {
-    if (!routeBlock)
-      routeBlock = await getRouteSfcBlock(vite.normalizePath(filePath));
-    return !pages.has(filePath) || commentJson.stringify(parseData(routeBlock)) !== pages.get(filePath);
+  return Promise.resolve(result);
+}
+function getDefaultExport(expr) {
+  return expr.default === void 0 ? expr : expr.default;
+}
+const babelGenerate = getDefaultExport(babelGenerator__default);
+
+function getPageFiles(path, options) {
+  const { exclude } = options;
+  const ext = extsToGlob(FILE_EXTENSIONS);
+  const files = fg__default.sync(`**/*.${ext}`, {
+    ignore: exclude,
+    onlyFiles: true,
+    cwd: path
+  });
+  return files;
+}
+function checkPagesJsonFile(path) {
+  if (!fs__default.existsSync(path)) {
+    writeFileSync(path, commentJson.stringify({ pages: [{ path: "" }] }, null, 2));
+    return false;
   }
-  return {
-    setCache,
-    hasChanged
-  };
+  return true;
+}
+function readFileSync(path) {
+  try {
+    return fs__default.readFileSync(path, { encoding: "utf-8" });
+  } catch {
+    return "";
+  }
+}
+function writeFileSync(path, content) {
+  fs__default.writeFileSync(path, content, { encoding: "utf-8" });
 }
 
 function resolveOptions(userOptions, viteRoot = process__default.cwd()) {
@@ -300,32 +287,190 @@ function resolvePageDirs(dir, root, exclude) {
   return dirs;
 }
 
-function getPageFiles(path, options) {
-  const { exclude } = options;
-  const ext = extsToGlob(FILE_EXTENSIONS);
-  const files = fg__default.sync(`**/*.${ext}`, {
-    ignore: exclude,
-    onlyFiles: true,
-    cwd: path
-  });
-  return files;
+function parseCustomBlock(block, filePath, routeBlockLang) {
+  const lang = block.lang ?? routeBlockLang;
+  const attr = {
+    type: "page",
+    ...block.attrs
+  };
+  let content;
+  debug.routeBlock(`use ${lang} parser`);
+  if (lang === "json5") {
+    try {
+      content = JSON5__default.parse(block.content);
+    } catch (err) {
+      throw new Error(
+        `Invalid JSON5 format of <${block.type}> content in ${filePath}
+${err.message}`
+      );
+    }
+  } else if (lang === "jsonc") {
+    try {
+      content = commentJson.parse(block.content);
+    } catch (err) {
+      throw new Error(
+        `Invalid JSONC format of <${block.type}> content in ${filePath}
+${err.message}`
+      );
+    }
+  } else if (lang === "json") {
+    try {
+      content = JSON.parse(block.content);
+    } catch (err) {
+      throw new Error(
+        `Invalid JSON format of <${block.type}> content in ${filePath}
+${err.message}`
+      );
+    }
+  } else if (lang === "yaml" || lang === "yml") {
+    try {
+      content = yaml.parse(block.content);
+    } catch (err) {
+      throw new Error(
+        `Invalid YAML format of <${block.type}> content in ${filePath}
+${err.message}`
+      );
+    }
+  }
+  return {
+    attr,
+    content: content ?? {}
+  };
 }
-function checkPagesJsonFile(path) {
-  if (!fs__default.existsSync(path)) {
-    writeFileSync(path, commentJson.stringify({ pages: [{ path: "" }] }, null, 2));
-    return false;
+function getRouteSfcBlock(sfc) {
+  return sfc?.customBlocks.find((b) => b.type === "route");
+}
+function getRouteBlock(path, blockStr, routeBlockLang) {
+  if (!blockStr)
+    return;
+  return parseCustomBlock(blockStr, path, routeBlockLang);
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Page {
+  constructor(ctx, path) {
+    __publicField$1(this, "ctx");
+    __publicField$1(this, "path");
+    __publicField$1(this, "rawOptions", "");
+    __publicField$1(this, "options");
+    this.ctx = ctx;
+    this.path = path;
+  }
+  async getPageMeta(forceUpdate = false) {
+    if (forceUpdate || !this.options) {
+      await this.readPageMeta();
+    }
+    return this.options;
+  }
+  async hasChanged() {
+    const { hasChanged } = await this.readPageMeta();
+    return hasChanged;
+  }
+  async readPageMeta() {
+    try {
+      const { relativePath } = this.path;
+      const { path: path$1, ...others } = await this.readPageMetaFromFile();
+      this.options = {
+        path: path$1 ?? vite.normalizePath(relativePath.replace(path.extname(relativePath), "")),
+        ...others
+      };
+      const raw = this.options ? JSON.stringify(this.options) : "";
+      const hasChanged = this.rawOptions !== raw;
+      this.rawOptions = raw;
+      return {
+        options: this.options,
+        hasChanged
+      };
+    } catch (err) {
+      throw new Error(`Read page options fail in ${this.path.relativePath}
+${err.message}`);
+    }
+  }
+  async readPageMetaFromFile() {
+    const content = fs.readFileSync(this.path.absolutePath, "utf-8");
+    const sfc = parseSFC(content, { filename: this.path.absolutePath });
+    const meta = await tryPageMetaFromMacro(sfc);
+    if (meta) {
+      return meta;
+    }
+    return tryPageMetaFromCustomBlock(sfc, this.ctx.options.routeBlockLang);
   }
-  return true;
 }
-function readFileSync(path) {
+function parseSFC(code, options) {
   try {
-    return fs__default.readFileSync(path, { encoding: "utf-8" });
-  } catch {
-    return "";
+    return compilerSfc.parse(code, {
+      pad: "space",
+      ...options
+    }).descriptor || compilerSfc.parse({
+      source: code,
+      ...options
+    });
+  } catch (error) {
+    throw new Error(`[vite-plugin-uni-pages] Vue3's "@vue/compiler-sfc" is required. 
+Original error: 
+${error}`);
   }
 }
-function writeFileSync(path, content) {
-  fs__default.writeFileSync(path, content, { encoding: "utf-8" });
+async function tryPageMetaFromMacro(sfc) {
+  const sfcScript = sfc.scriptSetup || sfc.script;
+  if (!sfcScript) {
+    return void 0;
+  }
+  const ast = astKit.babelParse(sfcScript.content, sfcScript.lang || "js", {
+    plugins: [["importAttributes", { deprecatedAssertSyntax: true }]]
+  });
+  const macro = findMacro(ast.body, sfc.filename);
+  if (macro) {
+    const imports = findImports(ast.body).map((imp) => babelGenerate(imp).code);
+    const [macroOption] = macro.arguments;
+    const code = babelGenerate(macroOption).code;
+    let script = "";
+    const importScript = imports.join("");
+    script += importScript;
+    script += `export default ${code}`;
+    const result = await execScript(script, sfc.filename);
+    return result;
+  }
+  return void 0;
+}
+async function tryPageMetaFromCustomBlock(sfc, routeBlockLang) {
+  const block = getRouteSfcBlock(sfc);
+  const routeBlock = getRouteBlock(sfc.filename, block, routeBlockLang);
+  const pageMeta = {
+    type: routeBlock?.attr.type ?? "page"
+  };
+  if (routeBlock) {
+    commentJson.assign(pageMeta, routeBlock.content);
+  }
+  return pageMeta;
+}
+function findMacro(stmts, filename) {
+  const nodes = stmts.map((raw) => {
+    let node = raw;
+    if (raw.type === "ExpressionStatement")
+      node = raw.expression;
+    return astKit.isCallOf(node, "definePage") ? node : void 0;
+  }).filter((node) => !!node);
+  if (!nodes.length)
+    return;
+  if (nodes.length > 1) {
+    throw new Error(`\u6BCF\u4E2A\u6587\u4EF6\u53EA\u5141\u8BB8\u8C03\u7528\u4E00\u6B21 definePage(): ${filename}`);
+  }
+  const macro = nodes[0];
+  const [opt] = macro.arguments;
+  if (opt && !t__namespace.isFunctionExpression(opt) && !t__namespace.isArrowFunctionExpression(opt) && !t__namespace.isObjectExpression(opt)) {
+    debug.definePage(`definePage() only accept argument in function or object: ${filename}`);
+    return;
+  }
+  return macro;
+}
+function findImports(stmts) {
+  return stmts.map((node) => node.type === "ImportDeclaration" ? node : void 0).filter((node) => !!node);
 }
 
 var __defProp = Object.defineProperty;
@@ -335,14 +480,15 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 let lsatPagesJson = "";
-const { setCache, hasChanged } = useCachedPages();
 class PageContext {
   constructor(userOptions, viteRoot = process__default.cwd()) {
     __publicField(this, "_server");
     __publicField(this, "pagesGlobConfig");
     __publicField(this, "pagesConfigSourcePaths", []);
-    __publicField(this, "pagesPath", []);
-    __publicField(this, "subPagesPath", {});
+    __publicField(this, "pages", /* @__PURE__ */ new Map());
+    // abs path -> Page
+    __publicField(this, "subPages", /* @__PURE__ */ new Map());
+    // root -> abs path -> page
     __publicField(this, "pageMetaData", []);
     __publicField(this, "subPageMetaData", []);
     __publicField(this, "resolvedPagesJSONPath", "");
@@ -385,17 +531,30 @@ class PageContext {
     const pageDirFiles = this.options.dirs.map((dir) => {
       return { dir, files: getPagePaths(dir, this.options) };
     });
-    this.pagesPath = pageDirFiles.map((page) => page.files).flat();
-    debug.pages(this.pagesPath);
+    const paths = pageDirFiles.map((page) => page.files).flat();
+    debug.pages(paths);
+    const pages = /* @__PURE__ */ new Map();
+    for (const path2 of paths) {
+      const page = this.pages.get(path2.absolutePath) || new Page(this, path2);
+      pages.set(path2.absolutePath, page);
+    }
+    this.pages = pages;
   }
   async scanSubPages() {
-    const subPagesPath = {};
+    const paths = {};
+    const subPages = /* @__PURE__ */ new Map();
     for (const dir of this.options.subPackages) {
       const pagePaths = getPagePaths(dir, this.options);
-      subPagesPath[dir] = pagePaths;
+      paths[dir] = pagePaths;
+      const pages = /* @__PURE__ */ new Map();
+      for (const path2 of pagePaths) {
+        const page = this.subPages.get(dir)?.get(path2.absolutePath) || new Page(this, path2);
+        pages.set(path2.absolutePath, page);
+      }
+      subPages.set(dir, pages);
     }
-    this.subPagesPath = subPagesPath;
-    debug.subPages(this.subPagesPath);
+    debug.subPages(JSON.stringify(paths, null, 2));
+    this.subPages = subPages;
   }
   setupViteServer(server) {
     if (this._server === server)
@@ -456,20 +615,6 @@ class PageContext {
       type: "full-reload"
     });
   }
-  async parsePage(page) {
-    const { relativePath, absolutePath } = page;
-    const routeSfcBlock = await getRouteSfcBlock(absolutePath);
-    const routeBlock = await getRouteBlock(absolutePath, routeSfcBlock, this.options);
-    setCache(absolutePath, routeSfcBlock);
-    const relativePathWithFileName = relativePath.replace(path__default.extname(relativePath), "");
-    const pageMetaDatum = {
-      path: vite.normalizePath(relativePathWithFileName),
-      type: routeBlock?.attr.type ?? "page"
-    };
-    if (routeBlock)
-      commentJson.assign(pageMetaDatum, routeBlock.content);
-    return pageMetaDatum;
-  }
   /**
    * parse pages rules && set page type
    * @param pages page path array
@@ -478,7 +623,11 @@ class PageContext {
    * @returns pages rules
    */
   async parsePages(pages, type, overrides) {
-    const generatedPageMetaData = await Promise.all(pages.map(async (page) => await this.parsePage(page)));
+    const jobs = [];
+    for (const [_, page] of pages) {
+      jobs.push(page.getPageMeta());
+    }
+    const generatedPageMetaData = await Promise.all(jobs);
     const customPageMetaData = overrides || [];
     const result = customPageMetaData.length ? mergePageMetaDataArray(generatedPageMetaData.concat(customPageMetaData)) : generatedPageMetaData;
     const parseMeta = result.filter(
@@ -510,14 +659,14 @@ class PageContext {
     return result;
   }
   async mergePageMetaData() {
-    const pageMetaData = await this.parsePages(this.pagesPath, "main", this.pagesGlobConfig?.pages);
+    const pageMetaData = await this.parsePages(this.pages, "main", this.pagesGlobConfig?.pages);
     this.pageMetaData = pageMetaData;
     debug.pages(this.pageMetaData);
   }
   async mergeSubPageMetaData() {
     const subPageMaps = {};
     const subPackages = this.pagesGlobConfig?.subPackages || [];
-    for (const [dir, pages] of Object.entries(this.subPagesPath)) {
+    for (const [dir, pages] of this.subPages) {
       const basePath = slash(path__default.join(this.options.root, this.options.outDir));
       const root = slash(path__default.relative(basePath, path__default.join(this.options.root, dir)));
       const globPackage = subPackages?.find((v) => v.root === root);
@@ -534,7 +683,18 @@ class PageContext {
   }
   async updatePagesJSON(filepath) {
     if (filepath) {
-      if (!await hasChanged(filepath)) {
+      let page = this.pages.get(filepath);
+      if (!page) {
+        let subPage;
+        for (const [_, pages2] of this.subPages) {
+          subPage = pages2.get(filepath);
+          if (subPage) {
+            break;
+          }
+        }
+        page = subPage;
+      }
+      if (page && !await page.hasChanged()) {
         debug.cache(`The route block on page ${filepath} did not send any changes, skipping`);
         return false;
       }
@@ -662,16 +822,39 @@ function VitePluginUniPages(userOptions = {}) {
     },
     // Applet do not support custom route block, so we need to remove the route block here
     async transform(code, id) {
-      if (!/\.n?vue$/.test(id) && !code.includes("</route>"))
+      if (!FILE_EXTENSIONS.find((ext) => id.endsWith(ext))) {
         return null;
+      }
+      const sfc = parseSFC(code, { filename: id });
+      let macro;
+      if (sfc.scriptSetup) {
+        const ast = astKit.babelParse(sfc.scriptSetup.content, sfc.scriptSetup.lang || "js");
+        macro = findMacro(ast.body, sfc.filename);
+      }
+      if (!macro && sfc.script) {
+        const ast = astKit.babelParse(sfc.script.content, sfc.script.lang || "js");
+        macro = findMacro(ast.body, sfc.filename);
+      }
+      const routeBlock = sfc.customBlocks.find((block) => block.type === "route");
+      if (!macro && !routeBlock)
+        return null;
+      if (macro && routeBlock)
+        throw new Error(`\u4E0D\u652F\u6301\u6DF7\u5408\u4F7F\u7528 definePage() \u548C <route/> ${id}`);
       const s = new MagicString__default(code);
-      const routeBlockMatches = s.original.matchAll(
-        /<route[^>]*>([\s\S]*?)<\/route>/g
-      );
-      for (const match of routeBlockMatches) {
-        const index = match.index;
-        const length = match[0].length;
-        s.remove(index, index + length);
+      if (macro)
+        s.remove(macro.start, macro.end);
+      if (routeBlock) {
+        console.log(kolorist.lightYellow("\u8B66\u544A\uFF1A"), `${kolorist.bold("<route/>")} \u6807\u7B7E\u5DF2\u5E9F\u5F03\uFF0C\u5C06\u5728\u4E0B\u4E00\u4E2A\u7248\u672C\u4E2D\u79FB\u9664\uFF0C\u8BF7\u4F7F\u7528 definePage() \u4EE3\u66FF\uFF1B${kolorist.link("\u67E5\u770B\u8FC1\u79FB\u6307\u5357", "https://uni-helper.js.org/vite-plugin-uni-pages/definePage")}\u3002`);
+        console.log(kolorist.dim(id));
+        console.log();
+        const routeBlockMatches = s.original.matchAll(
+          /<route[^>]*>([\s\S]*?)<\/route>/g
+        );
+        for (const match of routeBlockMatches) {
+          const index = match.index;
+          const length = match[0].length;
+          s.remove(index, index + length);
+        }
       }
       if (s.hasChanged()) {
         return {
@@ -701,14 +884,19 @@ function VitePluginUniPages(userOptions = {}) {
 exports.FILE_EXTENSIONS = FILE_EXTENSIONS;
 exports.MODULE_ID_VIRTUAL = MODULE_ID_VIRTUAL;
 exports.OUTPUT_NAME = OUTPUT_NAME;
+exports.Page = Page;
 exports.PageContext = PageContext;
 exports.RESOLVED_MODULE_ID_VIRTUAL = RESOLVED_MODULE_ID_VIRTUAL;
 exports.VitePluginUniPages = VitePluginUniPages;
+exports.babelGenerate = babelGenerate;
 exports.checkPagesJsonFile = checkPagesJsonFile;
 exports.debug = debug;
 exports.default = VitePluginUniPages;
 exports.defineUniPages = defineUniPages;
+exports.execScript = execScript;
 exports.extsToGlob = extsToGlob;
+exports.findImports = findImports;
+exports.findMacro = findMacro;
 exports.getPageFiles = getPageFiles;
 exports.getRouteBlock = getRouteBlock;
 exports.getRouteSfcBlock = getRouteSfcBlock;
@@ -720,5 +908,6 @@ exports.parseSFC = parseSFC;
 exports.readFileSync = readFileSync;
 exports.resolveOptions = resolveOptions;
 exports.resolvePageDirs = resolvePageDirs;
-exports.useCachedPages = useCachedPages;
+exports.tryPageMetaFromCustomBlock = tryPageMetaFromCustomBlock;
+exports.tryPageMetaFromMacro = tryPageMetaFromMacro;
 exports.writeFileSync = writeFileSync;