@fchc8/vite-plugin-multi-page 1.1.1 → 1.3.0

package/dist/index.mjs

@@ -1,21 +1,6 @@
-// @ts-nocheck
-
 // src/index.ts
-import * as path4 from "node:path";
-import * as fs3 from "node:fs";
-import { glob as glob3 } from "glob";
-
-// src/utils.ts
-function escapeRegExp(string) {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function createLogger(debug) {
-  return (...args) => {
-    if (debug) {
-      console.log("[vite-plugin-multi-page]", ...args);
-    }
-  };
-}
+import * as fs4 from "node:fs";
+import { mergeConfig as mergeConfig2 } from "vite";
 
 // src/dev-server.ts
 import * as path2 from "node:path";
@@ -27,7 +12,10 @@ import * as path from "node:path";
 function filterEntryFiles(files, entry, exclude, log) {
   const result = [];
   const nameToFile = /* @__PURE__ */ new Map();
-  const basePattern = entry.replace(/\/\*\*.*$/, "");
+  let basePattern = entry.replace(/\/\*.*$/, "");
+  if (!basePattern || basePattern === entry) {
+    basePattern = path.dirname(entry.split("*")[0]);
+  }
   log("\u57FA\u7840\u76EE\u5F55\u6A21\u5F0F:", basePattern);
   const candidateFiles = [];
   for (const file of files) {
@@ -61,30 +49,38 @@ function filterEntryFiles(files, entry, exclude, log) {
   for (const candidate of candidateFiles) {
     const existing = nameToFile.get(candidate.name);
     if (!existing) {
-      nameToFile.set(candidate.name, candidate.file);
+      nameToFile.set(candidate.name, { file: candidate.file, priority: candidate.priority });
       log(`\u2705 \u6DFB\u52A0\u9875\u9762: ${candidate.name} -> ${candidate.file}`);
     } else {
-      const existingCandidate = candidateFiles.find((c) => c.file === existing);
-      if (existingCandidate && candidate.priority > existingCandidate.priority) {
-        nameToFile.set(candidate.name, candidate.file);
-        log(`\u{1F504} \u66FF\u6362\u9875\u9762: ${candidate.name} -> ${candidate.file} (\u66FF\u6362 ${existing})`);
+      if (candidate.priority > existing.priority) {
+        nameToFile.set(candidate.name, { file: candidate.file, priority: candidate.priority });
+        log(
+          `\u{1F504} \u66FF\u6362\u9875\u9762: ${candidate.name} -> ${candidate.file} (\u66FF\u6362 ${existing.file}, \u76EE\u5F55\u4F18\u5148)`
+        );
       } else {
-        log(`\u26A0\uFE0F \u51B2\u7A81\u8DF3\u8FC7: ${candidate.name} -> ${candidate.file} (\u4FDD\u7559 ${existing})`);
+        log(`\u26A0\uFE0F \u51B2\u7A81\u8DF3\u8FC7: ${candidate.name} -> ${candidate.file} (\u4FDD\u7559 ${existing.file})`);
       }
     }
   }
-  for (const [name, file] of nameToFile.entries()) {
+  for (const [name, { file }] of nameToFile.entries()) {
     result.push({ name, file });
   }
   return result;
 }
 
-// src/dev-server.ts
-function simpleMatch(pattern, text) {
-  const regexPattern = pattern.replace(/\*\*/g, "__DOUBLE_STAR__").replace(/\*/g, "[^/]*").replace(/__DOUBLE_STAR__/g, ".*");
-  const regex = new RegExp(`^${regexPattern}$`);
-  return regex.test(text);
+// src/utils.ts
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function createLogger(debug) {
+  return (...args) => {
+    if (debug) {
+      console.log("[vite-plugin-multi-page]", ...args);
+    }
+  };
 }
+
+// src/page-config.ts
 function getPageConfig(pageConfigs, context, log) {
   if (!pageConfigs)
     return null;
@@ -117,460 +113,684 @@ function getPageConfig(pageConfigs, context, log) {
   }
   return null;
 }
-function applyDevStrategy(server, strategy, log) {
-  if (!strategy)
-    return;
-  log("\u5F00\u53D1\u6A21\u5F0F\u5E94\u7528\u6784\u5EFA\u7B56\u7565:", strategy);
-  if (strategy.define) {
-    log("\u5F00\u53D1\u73AF\u5883\u53D8\u91CF\u914D\u7F6E:", strategy.define);
-  }
-  if (strategy.alias) {
-    log("\u5F00\u53D1\u522B\u540D\u914D\u7F6E:", strategy.alias);
-  }
-  if (strategy.server) {
-    log("\u670D\u52A1\u5668\u914D\u7F6E:", strategy.server);
-  }
-  if (strategy.css) {
-    log("CSS\u914D\u7F6E:", strategy.css);
-  }
-  if (strategy.optimizeDeps) {
-    log("\u4F9D\u8D56\u4F18\u5316\u914D\u7F6E:", strategy.optimizeDeps);
-  }
+function simpleMatch(pattern, text) {
+  const regexPattern = pattern.replace(/\*\*/g, "__DOUBLE_STAR__").replace(/\*/g, "[^/]*").replace(/__DOUBLE_STAR__/g, ".*");
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(text);
 }
+
+// src/dev-server.ts
 function configureDevServer(server, options, log) {
-  const allFiles = glob.sync(options.entry, { cwd: process.cwd() });
-  const entryFiles = filterEntryFiles(allFiles, options.entry, options.exclude, log);
-  const pageMap = /* @__PURE__ */ new Map();
-  entryFiles.forEach(({ name, file }) => {
-    const pageConfig = getPageConfig(
-      options.pageConfigs,
-      {
-        pageName: name,
-        filePath: file,
-        relativePath: path2.relative(process.cwd(), file),
-        strategy: void 0,
-        isMatched: false
-      },
-      log
-    );
-    const strategy = (pageConfig == null ? void 0 : pageConfig.strategy) || "default";
-    pageMap.set(name, {
-      file,
-      config: pageConfig,
-      strategy
-    });
-    if (options.buildStrategies && (pageConfig == null ? void 0 : pageConfig.strategy)) {
-      const buildStrategy = options.buildStrategies[pageConfig.strategy];
-      if (buildStrategy) {
-        applyDevStrategy(server, buildStrategy, log);
-      }
+  try {
+    const allFiles = glob.sync(options.entry, { cwd: process.cwd() });
+    let entryFiles = filterEntryFiles(allFiles, options.entry, options.exclude, log);
+    if (entryFiles.length === 0) {
+      log("\u8B66\u544A: \u672A\u627E\u5230\u5339\u914D\u7684\u5165\u53E3\u6587\u4EF6");
+      return;
     }
-  });
-  const pageNames = Array.from(pageMap.keys());
-  log("Available pages:", pageNames);
-  log("Page mapping with configs:", Object.fromEntries(pageMap));
-  server.middlewares.use((req, res, next) => {
-    var _a;
-    const originalUrl = req.url;
-    const url = originalUrl == null ? void 0 : originalUrl.split("?")[0];
-    if (!url) {
-      return next();
-    }
-    log(`\u5904\u7406\u8BF7\u6C42: ${url}`);
-    if (url === "/" && pageNames.length > 0) {
-      const defaultPage = pageNames.includes("index") ? "index" : pageNames[0];
-      log(`\u6839\u8DEF\u5F84\u91CD\u5B9A\u5411\u5230: ${defaultPage}`);
-      req.url = `/${defaultPage}.html`;
+    const cliStrategy = server.config.__cliStrategy || server.config.strategy;
+    if (cliStrategy) {
+      log(`\u5F00\u53D1\u670D\u52A1\u5668\u4F7F\u7528\u6307\u5B9A\u7684\u7B56\u7565: ${cliStrategy}`);
+      entryFiles = entryFiles.filter((file) => {
+        var _a;
+        const pageName = file.name;
+        const pageStrategy = ((_a = options.appliedStrategies) == null ? void 0 : _a.get(pageName)) || void 0;
+        if (cliStrategy === "default") {
+          return !pageStrategy || pageStrategy === "default";
+        }
+        return pageStrategy === cliStrategy;
+      });
+      log(`\u7B56\u7565 "${cliStrategy}" \u4E0B\u53EF\u7528\u7684\u9875\u9762: ${entryFiles.map((f) => f.name).join(", ") || "\u65E0"}`);
     }
-    const finalUrl = (_a = req.url) == null ? void 0 : _a.split("?")[0];
-    const pageMatch = finalUrl == null ? void 0 : finalUrl.match(/^\/([^\/\.]+)(\.html)?$/);
-    if (pageMatch) {
-      const pageName = pageMatch[1];
-      log(`\u5339\u914D\u5230\u9875\u9762: ${pageName}`);
-      log(`\u53EF\u7528\u9875\u9762\u5217\u8868: ${pageNames.join(", ")}`);
-      if (pageMap.has(pageName)) {
-        const pageInfo = pageMap.get(pageName);
-        if (!pageInfo) {
-          log(`\u9875\u9762\u4FE1\u606F\u83B7\u53D6\u5931\u8D25: ${pageName}`);
+    log("\u5F00\u53D1\u670D\u52A1\u5668\u5E94\u7528\u7684\u5165\u53E3\u6587\u4EF6:", entryFiles);
+    server.middlewares.use(async (req, res, next) => {
+      var _a;
+      try {
+        const url = req.url || "";
+        const pathWithoutQuery = url.split("?")[0];
+        if (pathWithoutQuery === "/") {
+          const indexHtml = generateIndexHtml(entryFiles, options, log);
+          res.statusCode = 200;
+          res.setHeader("Content-Type", "text/html");
+          res.end(indexHtml);
+          return;
+        }
+        if (pathWithoutQuery.match(/\.(js|css|png|jpg|jpeg|gif|svg|ico|woff|woff2|ttf|eot)$/) && !pathWithoutQuery.endsWith(".html")) {
           return next();
         }
-        const relativeEntryPath = pageInfo.file;
-        const pageConfig = pageInfo.config;
-        const entryPath = path2.resolve(process.cwd(), relativeEntryPath);
-        log(`\u9875\u9762 ${pageName} \u5BF9\u5E94\u6587\u4EF6: ${relativeEntryPath}`);
-        log(`\u9875\u9762\u914D\u7F6E:`, pageConfig);
-        if (fs.existsSync(entryPath)) {
-          log(`\u627E\u5230\u5165\u53E3\u6587\u4EF6: ${entryPath}`);
-          const templateFile = (pageConfig == null ? void 0 : pageConfig.template) || options.template;
-          const templatePath = path2.resolve(process.cwd(), templateFile);
-          if (fs.existsSync(templatePath)) {
-            let html = fs.readFileSync(templatePath, "utf-8");
-            log(`\u8BFB\u53D6\u6A21\u677F\u6587\u4EF6: ${templatePath}`);
-            log(`\u6A21\u677F\u5185\u5BB9\u5305\u542B\u5360\u4F4D\u7B26: ${html.includes(options.placeholder)}`);
-            if (!html.includes(options.placeholder)) {
-              console.warn(
-                `[vite-plugin-multi-page] \u6A21\u677F\u6587\u4EF6\u4E2D\u6CA1\u6709\u627E\u5230\u5360\u4F4D\u7B26: ${options.placeholder}`
-              );
-              return next();
-            }
-            const entryFile = `/${relativeEntryPath}`;
-            html = html.replace(new RegExp(escapeRegExp(options.placeholder), "g"), entryFile);
-            if (pageConfig == null ? void 0 : pageConfig.define) {
-              const defineScript = Object.entries(pageConfig.define).map(([key, value]) => `window.${key} = ${JSON.stringify(value)};`).join("\n");
-              if (defineScript) {
-                const scriptTag = `<script>
-                  // \u9875\u9762\u7EA7\u73AF\u5883\u53D8\u91CF
-                  ${defineScript}
-                </script>`;
-                html = html.replace("</head>", `${scriptTag}
-</head>`);
-                log(`\u6CE8\u5165\u9875\u9762\u73AF\u5883\u53D8\u91CF:`, pageConfig.define);
-              }
-            }
-            log(`\u5360\u4F4D\u7B26 ${options.placeholder} \u66FF\u6362\u4E3A: ${entryFile}`);
-            log(`\u4F7F\u7528\u6A21\u677F: ${templateFile}`);
-            res.setHeader("Content-Type", "text/html");
-            res.end(html);
-            return;
-          } else {
-            log(`\u6A21\u677F\u6587\u4EF6\u4E0D\u5B58\u5728: ${templatePath}`);
+        let pageName = "";
+        if (pathWithoutQuery.endsWith(".html")) {
+          pageName = path2.basename(pathWithoutQuery, ".html");
+        } else if (pathWithoutQuery.startsWith("/")) {
+          pageName = pathWithoutQuery.substring(1);
+        }
+        if (!pageName) {
+          return next();
+        }
+        const matchedFile = entryFiles.find((file) => file.name === pageName);
+        if (!matchedFile) {
+          return next();
+        }
+        const pageContext = {
+          pageName: matchedFile.name,
+          filePath: matchedFile.file,
+          relativePath: path2.relative(process.cwd(), matchedFile.file),
+          strategy: void 0,
+          isMatched: false
+        };
+        const pageConfig = getPageConfig(options.pageConfigs, pageContext, log);
+        if (pageConfig == null ? void 0 : pageConfig.strategy) {
+          pageContext.strategy = pageConfig.strategy;
+        } else if ((_a = options.appliedStrategies) == null ? void 0 : _a.has(pageName)) {
+          const strategyName = options.appliedStrategies.get(pageName);
+          if (strategyName) {
+            pageContext.strategy = strategyName;
           }
+        }
+        let templatePath = "";
+        const pageSpecificTemplate = path2.resolve(process.cwd(), `${pageName}.html`);
+        if (fs.existsSync(pageSpecificTemplate)) {
+          templatePath = pageSpecificTemplate;
+        } else if (pageConfig == null ? void 0 : pageConfig.template) {
+          templatePath = path2.resolve(process.cwd(), pageConfig.template);
         } else {
-          log(`\u5165\u53E3\u6587\u4EF6\u4E0D\u5B58\u5728: ${entryPath}`);
+          templatePath = path2.resolve(process.cwd(), options.template);
         }
-      } else {
-        log(`\u9875\u9762 ${pageName} \u4E0D\u5728\u53EF\u7528\u5217\u8868\u4E2D`);
+        if (!fs.existsSync(templatePath)) {
+          return next();
+        }
+        let html = fs.readFileSync(templatePath, "utf-8");
+        const containsPlaceholder = html.includes(options.placeholder);
+        if (containsPlaceholder) {
+          const originalHtml = html;
+          html = html.split(options.placeholder).join(`/${matchedFile.file}`);
+          if (html === originalHtml) {
+            const escapedPlaceholder = escapeRegExp(options.placeholder);
+            const placeholderRegex = new RegExp(escapedPlaceholder, "g");
+            html = originalHtml.replace(placeholderRegex, `/${matchedFile.file}`);
+            if (html === originalHtml) {
+              html = originalHtml.replace(/\{\{ENTRY_FILE\}\}/g, `/${matchedFile.file}`);
+            }
+          }
+        }
+        if (pageConfig == null ? void 0 : pageConfig.define) {
+          const defineScript = Object.entries(pageConfig.define).map(([key, value]) => {
+            const stringValue = typeof value === "string" ? `"${value}"` : JSON.stringify(value);
+            return `window.${key} = ${stringValue};`;
+          }).join("\n");
+          if (defineScript) {
+            html = html.replace(
+              /<\/head>/i,
+              `<script type="text/javascript">
+${defineScript}
+</script>
+</head>`
+            );
+          }
+        }
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "text/html");
+        res.end(html);
+      } catch (error) {
+        log(`\u5F00\u53D1\u670D\u52A1\u5668\u5904\u7406\u8BF7\u6C42\u5931\u8D25: ${error}`);
+        next(error);
       }
-    }
-    next();
-  });
+    });
+    log("\u5F00\u53D1\u670D\u52A1\u5668\u914D\u7F6E\u5B8C\u6210");
+  } catch (error) {
+    log(`\u914D\u7F6E\u5F00\u53D1\u670D\u52A1\u5668\u5931\u8D25: ${error}`);
+    throw error;
+  }
+}
+var setupDevMiddleware = configureDevServer;
+function generateIndexHtml(entryFiles, options, log) {
+  try {
+    const pageItems = entryFiles.map((file) => {
+      var _a;
+      const pageContext = {
+        pageName: file.name,
+        filePath: file.file,
+        relativePath: path2.relative(process.cwd(), file.file),
+        strategy: void 0,
+        isMatched: false
+      };
+      const pageConfig = getPageConfig(options.pageConfigs, pageContext, log);
+      let strategy = "default";
+      if (pageConfig == null ? void 0 : pageConfig.strategy) {
+        strategy = pageConfig.strategy;
+      } else if ((_a = options.appliedStrategies) == null ? void 0 : _a.has(file.name)) {
+        const strategyName = options.appliedStrategies.get(file.name);
+        if (strategyName) {
+          strategy = strategyName;
+        }
+      }
+      const strategyBadge = strategy !== "default" ? `<span class="badge">${strategy}</span>` : "";
+      return `
+        <div class="page-item">
+          <a href="${file.name}.html" class="page-link">
+            ${file.name}${strategyBadge}
+          </a>
+          <div class="page-path">${file.file}</div>
+        </div>`;
+    }).join("");
+    return `
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+      <meta charset="UTF-8">
+      <meta name="viewport" content="width=device-width, initial-scale=1.0">
+      <title>\u591A\u9875\u9762\u5E94\u7528\u7D22\u5F15</title>
+      <style>
+        body {
+          font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+          line-height: 1.6;
+          color: #333;
+          max-width: 1200px;
+          margin: 0 auto;
+          padding: 20px;
+          background-color: #f5f5f7;
+        }
+        h1 {
+          font-size: 24px;
+          margin-bottom: 20px;
+          color: #111;
+        }
+        .page-list {
+          display: grid;
+          grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+          gap: 16px;
+        }
+        .page-item {
+          background-color: white;
+          border-radius: 8px;
+          padding: 16px;
+          box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+          transition: transform 0.2s, box-shadow 0.2s;
+        }
+        .page-item:hover {
+          transform: translateY(-2px);
+          box-shadow: 0 4px 8px rgba(0,0,0,0.1);
+        }
+        .page-link {
+          display: flex;
+          align-items: center;
+          justify-content: space-between;
+          font-size: 18px;
+          font-weight: 500;
+          color: #0066cc;
+          text-decoration: none;
+          margin-bottom: 8px;
+        }
+        .page-path {
+          font-size: 14px;
+          color: #666;
+          word-break: break-all;
+        }
+        .badge {
+          display: inline-block;
+          font-size: 12px;
+          padding: 2px 8px;
+          border-radius: 12px;
+          background-color: #e6f2ff;
+          color: #0066cc;
+          margin-left: 8px;
+        }
+        .stats {
+          margin-bottom: 20px;
+          font-size: 14px;
+          color: #666;
+        }
+      </style>
+    </head>
+    <body>
+      <h1>\u591A\u9875\u9762\u5E94\u7528\u7D22\u5F15</h1>
+      <div class="stats">
+        \u627E\u5230 ${entryFiles.length} \u4E2A\u9875\u9762
+      </div>
+      <div class="page-list">
+        ${pageItems}
+      </div>
+    </body>
+    </html>
+    `;
+  } catch (error) {
+    log(`\u751F\u6210\u7D22\u5F15\u9875\u5931\u8D25: ${error}`);
+    return `
+    <!DOCTYPE html>
+    <html>
+    <head>
+      <title>\u9519\u8BEF</title>
+    </head>
+    <body>
+      <h1>\u751F\u6210\u7D22\u5F15\u9875\u65F6\u53D1\u751F\u9519\u8BEF</h1>
+      <p>${error}</p>
+    </body>
+    </html>
+    `;
+  }
 }
 
 // src/build-config.ts
+import { mergeConfig } from "vite";
+import { glob as glob2 } from "glob";
 import * as path3 from "node:path";
 import * as fs2 from "node:fs";
-import { glob as glob2 } from "glob";
-function simpleMatch2(pattern, str) {
-  const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-  const regex = new RegExp(`^${regexPattern}$`);
-  return regex.test(str);
-}
-function createBuildConfig(config, options, log, tempFiles, pageMapping) {
-  var _a, _b, _c;
-  const allFiles = glob2.sync(options.entry, { cwd: process.cwd() });
-  const entryFiles = filterEntryFiles(allFiles, options.entry, options.exclude, log);
-  if (entryFiles.length === 0) {
-    console.warn("[vite-plugin-multi-page] No entry files found matching pattern:", options.entry);
-    return;
-  }
-  log("\u626B\u63CF\u5230\u7684\u6240\u6709\u6587\u4EF6:", allFiles);
-  log("\u8FC7\u6EE4\u540E\u7684\u5165\u53E3\u6587\u4EF6:", entryFiles);
-  const existingTempFiles = glob2.sync("temp-*.html", { cwd: process.cwd() });
-  existingTempFiles.forEach((file) => {
-    const fullPath = path3.resolve(process.cwd(), file);
-    if (fs2.existsSync(fullPath)) {
-      fs2.unlinkSync(fullPath);
-      log(`\u6E05\u7406\u65E7\u7684\u4E34\u65F6\u6587\u4EF6: ${file}`);
+function generateBuildConfig(options) {
+  var _a;
+  const {
+    entry = "src/pages/*/main.{ts,js}",
+    exclude = [],
+    template = "index.html",
+    placeholder = "<!--VITE_MULTI_PAGE_ENTRY-->",
+    strategies = {},
+    pageConfigs = {},
+    forceBuildStrategy
+  } = options;
+  const log = createLogger(true);
+  const buildConfigs = {};
+  try {
+    const allFiles = glob2.sync(entry, { cwd: process.cwd() });
+    const entryFiles = filterEntryFiles(allFiles, entry, exclude, log);
+    if (entryFiles.length === 0) {
+      log("\u8B66\u544A: \u672A\u627E\u5230\u5339\u914D\u7684\u5165\u53E3\u6587\u4EF6");
+      return {};
     }
-  });
-  const input = {};
-  tempFiles.length = 0;
-  pageMapping.clear();
-  const strategyGroups = {};
-  const defaultStrategy = "default";
-  entryFiles.forEach((entryFile) => {
-    const { name, file } = entryFile;
-    const pageConfig = getPageConfig2(
-      options.pageConfigs,
-      {
-        pageName: name,
-        filePath: file,
-        relativePath: path3.relative(process.cwd(), file),
-        strategy: void 0,
-        isMatched: false
-      },
-      log
-    );
-    const strategy = (pageConfig == null ? void 0 : pageConfig.strategy) || defaultStrategy;
-    if (!strategyGroups[strategy]) {
-      strategyGroups[strategy] = [];
+    log(`\u53D1\u73B0 ${entryFiles.length} \u4E2A\u9875\u9762\u5165\u53E3`);
+    const pageStrategies = /* @__PURE__ */ new Map();
+    const strategyPages = /* @__PURE__ */ new Map();
+    for (const entryFile of entryFiles) {
+      const pageContext = {
+        pageName: entryFile.name,
+        filePath: entryFile.file,
+        relativePath: path3.relative(process.cwd(), entryFile.file)
+      };
+      const pageConfig = getPageConfig(pageConfigs, pageContext, log);
+      const strategyName = (pageConfig == null ? void 0 : pageConfig.strategy) || "default";
+      pageStrategies.set(entryFile.name, strategyName);
+      if (!strategyPages.has(strategyName)) {
+        strategyPages.set(strategyName, []);
+      }
+      (_a = strategyPages.get(strategyName)) == null ? void 0 : _a.push(entryFile.name);
     }
-    strategyGroups[strategy].push(entryFile);
-    const templatePath = (pageConfig == null ? void 0 : pageConfig.template) ? path3.resolve(process.cwd(), pageConfig.template) : path3.resolve(process.cwd(), options.template);
-    const tempHtmlPath = path3.resolve(process.cwd(), `temp-${name}.html`);
-    if (fs2.existsSync(templatePath)) {
-      let html = fs2.readFileSync(templatePath, "utf-8");
-      html = html.replace(new RegExp(escapeRegExp(options.placeholder), "g"), `/${file}`);
-      fs2.writeFileSync(tempHtmlPath, html);
-      tempFiles.push(tempHtmlPath);
-      input[name] = tempHtmlPath;
-      pageMapping.set(`temp-${name}.html`, `${name}.html`);
-      log(`\u521B\u5EFA\u4E34\u65F6\u6587\u4EF6: temp-${name}.html -> ${name}.html (\u7B56\u7565: ${strategy})`);
+    log("\u9875\u9762\u7B56\u7565\u5206\u5E03:", Object.fromEntries(pageStrategies));
+    if (forceBuildStrategy) {
+      const targetPages = strategyPages.get(forceBuildStrategy) || [];
+      if (targetPages.length === 0) {
+        log(`\u8B66\u544A: \u7B56\u7565 "${forceBuildStrategy}" \u4E0B\u6CA1\u6709\u9875\u9762`);
+        return {};
+      }
+      log(`\u5F3A\u5236\u6784\u5EFA\u7B56\u7565: ${forceBuildStrategy}, \u9875\u9762: ${targetPages.join(", ")}`);
+      const config = generateStrategyConfig(
+        forceBuildStrategy,
+        targetPages,
+        entryFiles,
+        strategies[forceBuildStrategy],
+        pageConfigs,
+        template,
+        placeholder,
+        log
+      );
+      buildConfigs[forceBuildStrategy] = config;
+      return buildConfigs;
     }
-  });
-  log("Build input configuration:", input);
-  log("Strategy groups:", Object.keys(strategyGroups));
-  config.build = config.build || {};
-  config.build.rollupOptions = config.build.rollupOptions || {};
-  config.build.rollupOptions.input = input;
-  const defaultStrategyConfig = (_a = options.buildStrategies) == null ? void 0 : _a[defaultStrategy];
-  if (defaultStrategyConfig) {
-    applyBuildStrategy(config, defaultStrategyConfig, log);
-  }
-  const strategyKeys = Object.keys(strategyGroups);
-  if (strategyKeys.length === 1 && strategyKeys[0] !== defaultStrategy) {
-    const singleStrategy = (_b = options.buildStrategies) == null ? void 0 : _b[strategyKeys[0]];
-    if (singleStrategy) {
-      applyBuildStrategy(config, singleStrategy, log);
+    for (const [strategyName, pages] of strategyPages) {
+      if (pages.length === 0)
+        continue;
+      log(`\u751F\u6210\u7B56\u7565 "${strategyName}" \u7684\u6784\u5EFA\u914D\u7F6E, \u9875\u9762: ${pages.join(", ")}`);
+      const strategyConfig = strategies[strategyName];
+      const config = generateStrategyConfig(
+        strategyName,
+        pages,
+        entryFiles,
+        strategyConfig,
+        pageConfigs,
+        template,
+        placeholder,
+        log
+      );
+      buildConfigs[strategyName] = config;
     }
-  }
-  if (strategyKeys.length > 1 || strategyKeys.length === 1 && strategyKeys[0] !== defaultStrategy && ((_c = options.buildStrategies) == null ? void 0 : _c[strategyKeys[0]])) {
-    log("\u68C0\u6D4B\u5230\u591A\u6784\u5EFA\u7B56\u7565\uFF0C\u5C06\u521B\u5EFA\u7B56\u7565\u6620\u5C04");
-    config.__multiPageStrategies = {
-      groups: strategyGroups,
-      strategies: options.buildStrategies,
-      pageConfigs: options.pageConfigs
-    };
+    log(`\u751F\u6210\u4E86 ${Object.keys(buildConfigs).length} \u4E2A\u6784\u5EFA\u914D\u7F6E`);
+    return buildConfigs;
+  } catch (error) {
+    log("\u751F\u6210\u6784\u5EFA\u914D\u7F6E\u5931\u8D25:", error);
+    throw error;
   }
 }
-function getPageConfig2(pageConfigs, context, log) {
-  if (!pageConfigs)
-    return null;
-  if (typeof pageConfigs === "function") {
-    const result = pageConfigs(context);
-    if (result) {
-      log(`\u51FD\u6570\u914D\u7F6E\u5339\u914D\u9875\u9762 ${context.pageName}:`, result);
+function generateStrategyConfig(strategyName, pages, entryFiles, strategyConfig, pageConfigs, defaultTemplate, placeholder, log) {
+  const htmlInputs = {};
+  const tempFiles = [];
+  for (const pageName of pages) {
+    const entryFile = entryFiles.find((f) => f.name === pageName);
+    if (!entryFile)
+      continue;
+    const pageContext = {
+      pageName,
+      filePath: entryFile.file,
+      relativePath: path3.relative(process.cwd(), entryFile.file),
+      strategy: strategyName
+    };
+    const pageConfig = getPageConfig(pageConfigs, pageContext, log);
+    let templatePath = defaultTemplate;
+    const pageSpecificTemplate = `${pageName}.html`;
+    if (fs2.existsSync(path3.resolve(process.cwd(), pageSpecificTemplate))) {
+      templatePath = pageSpecificTemplate;
+    } else if (pageConfig == null ? void 0 : pageConfig.template) {
+      templatePath = pageConfig.template;
     }
-    return result;
-  }
-  for (const [key, config] of Object.entries(pageConfigs)) {
-    if (key === context.pageName) {
-      log(`\u7CBE\u786E\u5339\u914D\u9875\u9762 ${context.pageName}:`, config);
-      return config;
+    const templateFullPath = path3.resolve(process.cwd(), templatePath);
+    if (!fs2.existsSync(templateFullPath)) {
+      log(`\u8B66\u544A: \u6A21\u677F\u6587\u4EF6\u4E0D\u5B58\u5728: ${templatePath}`);
+      continue;
     }
-    if (config.match) {
-      const patterns = Array.isArray(config.match) ? config.match : [config.match];
-      const isMatched = patterns.some(
-        (pattern) => simpleMatch2(pattern, context.pageName) || simpleMatch2(pattern, context.relativePath) || simpleMatch2(pattern, context.filePath)
+    let templateContent = fs2.readFileSync(templateFullPath, "utf-8");
+    if (templateContent.includes(placeholder)) {
+      const entryPath = `./${entryFile.file}`;
+      templateContent = templateContent.replace(
+        new RegExp(placeholder.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"),
+        entryPath
       );
-      if (isMatched) {
-        log(`\u6A21\u5F0F\u5339\u914D\u9875\u9762 ${context.pageName} (\u6A21\u5F0F: ${config.match}):`, config);
-        return { ...config, match: void 0 };
-      }
     }
-    if (simpleMatch2(key, context.pageName)) {
-      log(`Glob\u5339\u914D\u9875\u9762 ${context.pageName} (\u6A21\u5F0F: ${key}):`, config);
-      return config;
+    if (pageConfig == null ? void 0 : pageConfig.define) {
+      const defineScript = Object.entries(pageConfig.define).map(([key, value]) => {
+        const stringValue = typeof value === "string" ? `"${value}"` : JSON.stringify(value);
+        return `window.${key} = ${stringValue};`;
+      }).join("\n");
+      if (defineScript) {
+        templateContent = templateContent.replace(
+          /<\/head>/i,
+          `<script type="text/javascript">
+${defineScript}
+</script>
+</head>`
+        );
+      }
     }
+    const tempHtmlPath = path3.resolve(process.cwd(), `.temp.mp.${pageName}.html`);
+    fs2.writeFileSync(tempHtmlPath, templateContent);
+    tempFiles.push(tempHtmlPath);
+    htmlInputs[pageName] = tempHtmlPath;
   }
-  return null;
-}
-function applyBuildStrategy(config, strategy, log) {
-  log("\u5E94\u7528\u6784\u5EFA\u7B56\u7565:", strategy);
-  if (strategy.viteConfig) {
-    const { build: viteBuild, ...otherViteConfig } = strategy.viteConfig;
-    Object.keys(otherViteConfig).forEach((key) => {
-      if (key !== "plugins") {
-        const configKey = key;
-        const viteConfigValue = otherViteConfig[key];
-        if (viteConfigValue && typeof viteConfigValue === "object") {
-          config[configKey] = {
-            ...config[configKey] || {},
-            ...viteConfigValue
-          };
-        } else {
-          config[configKey] = viteConfigValue;
+  const baseConfig = {
+    build: {
+      rollupOptions: {
+        input: htmlInputs,
+        // 使用临时HTML文件作为输入
+        output: {
+          entryFileNames: "assets/[name]-[hash].js",
+          chunkFileNames: "assets/[name]-[hash].js",
+          assetFileNames: "assets/[name]-[hash][extname]"
         }
-      }
-    });
-    if (viteBuild) {
-      config.build = {
-        ...config.build,
-        ...viteBuild
+      },
+      outDir: `dist/${strategyName}`,
+      // 直接输出到策略目录
+      emptyOutDir: false
+      // 不清空输出目录，避免删除临时HTML文件
+    },
+    define: {}
+  };
+  let config = baseConfig;
+  if (strategyConfig) {
+    config = mergeConfig(baseConfig, strategyConfig);
+  }
+  if (!config.build)
+    config.build = {};
+  if (!config.build.rollupOptions)
+    config.build.rollupOptions = {};
+  config.build.outDir = `dist/${strategyName}`;
+  config.build.rollupOptions.input = htmlInputs;
+  config.build.emptyOutDir = false;
+  log(`\u7B56\u7565 "${strategyName}" - ${pages.length} \u4E2A\u9875\u9762`);
+  return config;
+}
+function getAvailableStrategies(options) {
+  const { entry = "src/pages/*/main.{ts,js}", exclude = [], pageConfigs = {} } = options;
+  const log = createLogger(false);
+  const strategySet = /* @__PURE__ */ new Set();
+  try {
+    const allFiles = glob2.sync(entry, { cwd: process.cwd() });
+    const entryFiles = filterEntryFiles(allFiles, entry, exclude, log);
+    for (const entryFile of entryFiles) {
+      const pageContext = {
+        pageName: entryFile.name,
+        filePath: entryFile.file,
+        relativePath: path3.relative(process.cwd(), entryFile.file)
       };
+      const pageConfig = getPageConfig(pageConfigs, pageContext, log);
+      const strategyName = (pageConfig == null ? void 0 : pageConfig.strategy) || "default";
+      strategySet.add(strategyName);
     }
+    return Array.from(strategySet).sort();
+  } catch (error) {
+    log("\u83B7\u53D6\u53EF\u7528\u7B56\u7565\u5931\u8D25:", error);
+    return ["default"];
   }
-  if (strategy.output) {
-    config.build.rollupOptions.output = {
-      ...config.build.rollupOptions.output,
-      ...strategy.output
-    };
-  }
-  if (strategy.build) {
-    config.build = {
-      ...config.build,
-      ...strategy.build
-    };
-  }
-  if (strategy.define) {
-    config.define = {
-      ...config.define,
-      ...strategy.define
-    };
+}
+
+// src/config-loader.ts
+import * as fs3 from "node:fs";
+import * as path4 from "node:path";
+import { pathToFileURL } from "node:url";
+import { Module } from "node:module";
+var CONFIG_FILES = [
+  "multipage.config.js",
+  "multipage.config.mjs",
+  "multipage.config.ts"
+];
+function hasCustomConfig() {
+  for (const filename of CONFIG_FILES) {
+    const configPath = path4.resolve(process.cwd(), filename);
+    if (fs3.existsSync(configPath)) {
+      return true;
+    }
   }
-  if (strategy.alias) {
-    config.resolve = config.resolve || {};
-    config.resolve.alias = {
-      ...config.resolve.alias,
-      ...strategy.alias
-    };
+  return false;
+}
+async function loadUserConfig(context) {
+  const customConfig = await loadCustomConfig();
+  if (customConfig) {
+    return customConfig(context);
   }
-  if (strategy.server) {
-    config.server = {
-      ...config.server,
-      ...strategy.server
-    };
+  return null;
+}
+async function loadConfigFile(filePath) {
+  if (filePath.endsWith(".ts")) {
+    try {
+      const code = await fs3.promises.readFile(filePath, "utf-8");
+      const esbuild = await import("esbuild");
+      const result = await esbuild.transform(code, {
+        loader: "ts",
+        format: "cjs",
+        // 使用 CommonJS 格式便于使用 Module._compile
+        target: "node16",
+        sourcemap: false
+      });
+      const tempModule = new Module(filePath);
+      tempModule.filename = filePath;
+      tempModule.paths = Module._nodeModulePaths(path4.dirname(filePath));
+      tempModule._compile(result.code, filePath);
+      return tempModule.exports;
+    } catch (esbuildError) {
+      console.warn("esbuild \u8F6C\u8BD1\u5931\u8D25\uFF0C\u5C1D\u8BD5\u7B80\u5355\u8F6C\u6362:", esbuildError);
+      const code = await fs3.promises.readFile(filePath, "utf-8");
+      const jsCode = code.replace(/export\s+default\s+/, "module.exports = ").replace(/import\s+.*?from\s+['"][^'"]*['"];?\s*/g, "").replace(/:\s*[^=,})\]]+/g, "");
+      const tempModule = new Module(filePath);
+      tempModule.filename = filePath;
+      tempModule.paths = Module._nodeModulePaths(path4.dirname(filePath));
+      tempModule._compile(jsCode, filePath);
+      return tempModule.exports;
+    }
   }
-  if (strategy.css) {
-    config.css = {
-      ...config.css,
-      ...strategy.css
-    };
+  if (filePath.endsWith(".js") || filePath.endsWith(".mjs")) {
+    const fileUrl = pathToFileURL(filePath).href;
+    return import(`${fileUrl}?t=${Date.now()}`);
   }
-  if (strategy.optimizeDeps) {
-    config.optimizeDeps = {
-      ...config.optimizeDeps,
-      ...strategy.optimizeDeps
-    };
+  throw new Error(`\u4E0D\u652F\u6301\u7684\u914D\u7F6E\u6587\u4EF6\u7C7B\u578B: ${filePath}`);
+}
+async function loadCustomConfig() {
+  const cwd = process.cwd();
+  for (const configFile of CONFIG_FILES) {
+    const configPath = path4.resolve(cwd, configFile);
+    if (fs3.existsSync(configPath)) {
+      try {
+        const configModule = await loadConfigFile(configPath);
+        const configFunction = configModule.default || configModule;
+        if (typeof configFunction === "function") {
+          return configFunction;
+        } else {
+          console.warn(`\u914D\u7F6E\u6587\u4EF6 ${configFile} \u5FC5\u987B\u9ED8\u8BA4\u5BFC\u51FA\u4E00\u4E2A\u51FD\u6570`);
+        }
+      } catch (error) {
+        if (configFile.endsWith(".ts")) {
+          console.error(`\u52A0\u8F7DTypeScript\u914D\u7F6E\u6587\u4EF6 ${configFile} \u5931\u8D25:`, error);
+          console.log("\u63D0\u793A\uFF1A\u786E\u4FDD\u4F60\u7684\u9879\u76EE\u652F\u6301TypeScript\uFF0C\u6216\u8005\u4F7F\u7528 .js/.mjs \u914D\u7F6E\u6587\u4EF6");
+        } else {
+          console.error(`\u52A0\u8F7D\u914D\u7F6E\u6587\u4EF6 ${configFile} \u5931\u8D25:`, error);
+        }
+      }
+    }
   }
+  return null;
 }
-function createDevConfig(options, log) {
-  const allFiles = glob2.sync(options.entry, { cwd: process.cwd() });
-  const entryFiles = filterEntryFiles(allFiles, options.entry, options.exclude, log);
-  const input = {};
-  entryFiles.forEach(({ name, file }) => {
-    input[name] = path3.resolve(process.cwd(), file);
-  });
-  log("Dev input configuration:", input);
+
+// src/types.ts
+function defineConfig(config) {
+  return config;
+}
+function defineConfigTransform(transform) {
+  return transform;
 }
 
 // src/index.ts
-function viteMultiPage(options = {}) {
-  const {
-    entry = "src/**/*.{ts,js}",
-    template = "index.html",
-    exclude = ["src/main.ts", "src/vite-env.d.ts"],
-    placeholder = "{{ENTRY_FILE}}",
-    debug = false,
-    buildStrategies,
-    pageConfigs
-  } = options;
-  const log = createLogger(debug);
-  let tempFiles = [];
-  const pageMapping = /* @__PURE__ */ new Map();
+function viteMultiPage(transform) {
+  let resolvedOptions;
+  const tempFiles = [];
+  let log = () => {
+  };
   return {
-    name: "vite-plugin-multi-page",
-    config(config, { command }) {
-      if (command === "build") {
-        createBuildConfig(
-          config,
-          { entry, exclude, template, placeholder, buildStrategies, pageConfigs },
-          log,
-          tempFiles,
-          pageMapping
+    name: "vite-multi-page",
+    async configResolved(config) {
+      if (!hasCustomConfig()) {
+        throw new Error(
+          "\u672A\u627E\u5230\u591A\u9875\u9762\u914D\u7F6E\u6587\u4EF6\uFF01\u8BF7\u521B\u5EFA\u4EE5\u4E0B\u914D\u7F6E\u6587\u4EF6\u4E4B\u4E00\uFF1A\n  - multipage.config.js\n  - multipage.config.mjs\n  - multipage.config.ts"
         );
-      } else {
-        createDevConfig({ entry, exclude }, log);
-        if (buildStrategies || pageConfigs) {
-          const allFiles = glob3.sync(entry, { cwd: process.cwd() });
-          const entryFiles = filterEntryFiles(allFiles, entry, exclude, log);
-          const strategiesToApply = /* @__PURE__ */ new Set();
-          entryFiles.forEach(({ name, file }) => {
-            if (typeof pageConfigs === "function") {
-              const pageConfig = pageConfigs({
-                pageName: name,
-                filePath: file,
-                relativePath: path4.relative(process.cwd(), file),
-                strategy: void 0,
-                isMatched: false
-              });
-              if (pageConfig == null ? void 0 : pageConfig.strategy) {
-                strategiesToApply.add(pageConfig.strategy);
-              }
-            } else if (pageConfigs) {
-              const pageConfig = pageConfigs[name];
-              if (pageConfig == null ? void 0 : pageConfig.strategy) {
-                strategiesToApply.add(pageConfig.strategy);
-              }
-            }
+      }
+      const userConfig = await loadUserConfig({
+        mode: config.command === "serve" ? "development" : "production",
+        command: config.command,
+        isCLI: false
+      });
+      if (!userConfig) {
+        throw new Error("\u914D\u7F6E\u6587\u4EF6\u52A0\u8F7D\u5931\u8D25\uFF01");
+      }
+      resolvedOptions = transform ? transform(userConfig, {
+        mode: config.command === "serve" ? "development" : "production",
+        command: config.command,
+        isCLI: false
+      }) : userConfig;
+      const debug = resolvedOptions.debug ?? false;
+      log = debug ? console.log.bind(console, "[vite-multi-page]") : () => {
+      };
+      log("Vite\u914D\u7F6E\u5DF2\u89E3\u6790, \u4F7F\u7528\u914D\u7F6E:", {
+        strategies: Object.keys(resolvedOptions.strategies || {}),
+        entry: resolvedOptions.entry
+      });
+    },
+    async config(config, { command }) {
+      var _a;
+      if (command === "build") {
+        if (!resolvedOptions) {
+          if (!hasCustomConfig()) {
+            throw new Error(
+              "\u672A\u627E\u5230\u591A\u9875\u9762\u914D\u7F6E\u6587\u4EF6\uFF01\u8BF7\u521B\u5EFA\u4EE5\u4E0B\u914D\u7F6E\u6587\u4EF6\u4E4B\u4E00\uFF1A\n  - multipage.config.js\n  - multipage.config.mjs\n  - multipage.config.ts"
+            );
+          }
+          const userConfig = await loadUserConfig({
+            mode: "production",
+            command: "build",
+            isCLI: false
           });
-          strategiesToApply.forEach((strategyName) => {
-            const strategy = buildStrategies == null ? void 0 : buildStrategies[strategyName];
-            if (strategy) {
-              log(`\u5F00\u53D1\u6A21\u5F0F\u5E94\u7528\u7B56\u7565 ${strategyName}:`, strategy);
-              if (strategy.viteConfig) {
-                const { build, ...otherViteConfig } = strategy.viteConfig;
-                Object.keys(otherViteConfig).forEach((key) => {
-                  if (key !== "plugins") {
-                    const configKey = key;
-                    const viteConfigValue = otherViteConfig[key];
-                    if (viteConfigValue && typeof viteConfigValue === "object") {
-                      config[configKey] = {
-                        ...config[configKey] || {},
-                        ...viteConfigValue
-                      };
-                    } else {
-                      config[configKey] = viteConfigValue;
-                    }
-                  }
-                });
-              }
-              if (strategy.define) {
-                config.define = { ...config.define, ...strategy.define };
-              }
-              if (strategy.alias) {
-                config.resolve = config.resolve || {};
-                config.resolve.alias = { ...config.resolve.alias, ...strategy.alias };
-              }
-              if (strategy.server) {
-                config.server = { ...config.server, ...strategy.server };
-              }
-              if (strategy.css) {
-                config.css = { ...config.css, ...strategy.css };
-              }
-              if (strategy.optimizeDeps) {
-                config.optimizeDeps = { ...config.optimizeDeps, ...strategy.optimizeDeps };
-              }
-            }
+          if (!userConfig) {
+            throw new Error("\u914D\u7F6E\u6587\u4EF6\u52A0\u8F7D\u5931\u8D25\uFF01");
+          }
+          resolvedOptions = transform ? transform(userConfig, {
+            mode: "production",
+            command: "build",
+            isCLI: false
+          }) : userConfig;
+          const debug = resolvedOptions.debug ?? false;
+          log = debug ? console.log.bind(console, "[vite-multi-page]") : () => {
+          };
+        }
+        log("\u914D\u7F6E\u6784\u5EFA\u6A21\u5F0F");
+        const forceBuildStrategy = process.env.VITE_BUILD_STRATEGY;
+        const buildConfigs = generateBuildConfig({
+          entry: resolvedOptions.entry || "src/pages/**/*.{ts,js}",
+          exclude: resolvedOptions.exclude || [],
+          template: resolvedOptions.template || "index.html",
+          placeholder: resolvedOptions.placeholder || "{{ENTRY_FILE}}",
+          strategies: resolvedOptions.strategies || {},
+          pageConfigs: resolvedOptions.pageConfigs || {},
+          forceBuildStrategy
+        });
+        const targetStrategy = Object.keys(buildConfigs)[0];
+        if (targetStrategy && buildConfigs[targetStrategy]) {
+          log(`\u5E94\u7528\u6784\u5EFA\u7B56\u7565: ${targetStrategy}`);
+          const strategyConfig = buildConfigs[targetStrategy];
+          const mergedConfig = mergeConfig2(config, strategyConfig);
+          Object.assign(config, mergedConfig);
+          log(`\u5DF2\u5E94\u7528\u7B56\u7565 "${targetStrategy}" \u7684\u914D\u7F6E:`, {
+            build: !!strategyConfig.build,
+            define: !!strategyConfig.define,
+            plugins: ((_a = strategyConfig.plugins) == null ? void 0 : _a.length) || 0
           });
+        } else {
+          log("\u672A\u627E\u5230\u53EF\u7528\u7684\u6784\u5EFA\u7B56\u7565\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u914D\u7F6E");
         }
       }
     },
     configureServer(server) {
-      configureDevServer(
-        server,
-        { entry, exclude, template, placeholder, buildStrategies, pageConfigs },
-        log
-      );
-    },
-    generateBundle() {
-    },
-    writeBundle(options2) {
-      Array.from(pageMapping.entries()).forEach(([tempName, targetName]) => {
-        const tempPath = path4.resolve(options2.dir || "dist", tempName);
-        const targetPath = path4.resolve(options2.dir || "dist", targetName);
-        if (fs3.existsSync(tempPath)) {
-          fs3.renameSync(tempPath, targetPath);
-          log(`\u91CD\u547D\u540DHTML\u6587\u4EF6: ${tempName} -> ${targetName}`);
-        }
-      });
+      if (server.config.command === "serve") {
+        log("\u914D\u7F6E\u5F00\u53D1\u670D\u52A1\u5668");
+        setupDevMiddleware(
+          server,
+          {
+            entry: resolvedOptions.entry || "src/pages/**/*.{ts,js}",
+            exclude: resolvedOptions.exclude || [],
+            template: resolvedOptions.template || "index.html",
+            placeholder: resolvedOptions.placeholder || "{{ENTRY_FILE}}",
+            strategies: resolvedOptions.strategies || {},
+            pageConfigs: resolvedOptions.pageConfigs || {}
+          },
+          log
+        );
+      }
     },
-    closeBundle() {
-      tempFiles.forEach((filePath) => {
-        if (fs3.existsSync(filePath)) {
-          fs3.unlinkSync(filePath);
-          const fileName = path4.basename(filePath);
-          log(`\u6E05\u7406\u4E34\u65F6\u6587\u4EF6: ${fileName}`);
-        }
-      });
-      tempFiles = [];
-      pageMapping.clear();
+    buildEnd() {
+      if (tempFiles.length > 0) {
+        log(`\u6E05\u7406 ${tempFiles.length} \u4E2A\u4E34\u65F6\u6587\u4EF6`);
+        tempFiles.forEach((file) => {
+          try {
+            if (fs4.existsSync(file)) {
+              fs4.unlinkSync(file);
+              log(`\u5220\u9664\u4E34\u65F6\u6587\u4EF6: ${file}`);
+            }
+          } catch (error) {
+            log(`\u5220\u9664\u4E34\u65F6\u6587\u4EF6\u5931\u8D25: ${file}`, error);
+          }
+        });
+        tempFiles.length = 0;
+      }
     }
   };
 }
 var src_default = viteMultiPage;
 export {
   src_default as default,
+  defineConfig,
+  defineConfigTransform,
+  generateBuildConfig,
+  getAvailableStrategies,
   viteMultiPage
 };
 //# sourceMappingURL=index.mjs.map