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

package/dist/cli.js

@@ -0,0 +1,649 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/.pnpm/tsup@8.0.0_typescript@5.0.2/node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/.pnpm/tsup@8.0.0_typescript@5.0.2/node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/config-loader.ts
+var config_loader_exports = {};
+__export(config_loader_exports, {
+  hasCustomConfig: () => hasCustomConfig,
+  loadUserConfig: () => loadUserConfig
+});
+function hasCustomConfig() {
+  for (const filename of CONFIG_FILES) {
+    const configPath = path3.resolve(process.cwd(), filename);
+    if (fs2.existsSync(configPath)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function loadUserConfig(context) {
+  const customConfig = await loadCustomConfig();
+  if (customConfig) {
+    return customConfig(context);
+  }
+  return null;
+}
+async function loadConfigFile(filePath) {
+  if (filePath.endsWith(".ts")) {
+    try {
+      const code = await fs2.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 import_node_module.Module(filePath);
+      tempModule.filename = filePath;
+      tempModule.paths = import_node_module.Module._nodeModulePaths(path3.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 fs2.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 import_node_module.Module(filePath);
+      tempModule.filename = filePath;
+      tempModule.paths = import_node_module.Module._nodeModulePaths(path3.dirname(filePath));
+      tempModule._compile(jsCode, filePath);
+      return tempModule.exports;
+    }
+  }
+  if (filePath.endsWith(".js") || filePath.endsWith(".mjs")) {
+    const fileUrl = (0, import_node_url.pathToFileURL)(filePath).href;
+    return import(`${fileUrl}?t=${Date.now()}`);
+  }
+  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 = path3.resolve(cwd, configFile);
+    if (fs2.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;
+}
+var fs2, path3, import_node_url, import_node_module, CONFIG_FILES;
+var init_config_loader = __esm({
+  "src/config-loader.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs2 = __toESM(require("fs"));
+    path3 = __toESM(require("path"));
+    import_node_url = require("url");
+    import_node_module = require("module");
+    CONFIG_FILES = [
+      "multipage.config.js",
+      "multipage.config.mjs",
+      "multipage.config.ts"
+    ];
+  }
+});
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  buildAll: () => main
+});
+module.exports = __toCommonJS(cli_exports);
+init_cjs_shims();
+var import_node_child_process = require("child_process");
+var fs3 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var glob2 = __toESM(require("glob"));
+
+// src/build-config.ts
+init_cjs_shims();
+var import_vite = require("vite");
+var import_glob = require("glob");
+var path2 = __toESM(require("path"));
+var fs = __toESM(require("fs"));
+
+// src/file-filter.ts
+init_cjs_shims();
+var path = __toESM(require("path"));
+function filterEntryFiles(files, entry, exclude, log) {
+  const result = [];
+  const nameToFile = /* @__PURE__ */ new Map();
+  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) {
+    if (exclude.includes(file)) {
+      log(`\u8DF3\u8FC7\u6392\u9664\u6587\u4EF6: ${file}`);
+      continue;
+    }
+    const relativePath = path.relative(basePattern, file);
+    const pathParts = relativePath.split(path.sep);
+    log(`\u5904\u7406\u6587\u4EF6: ${file}`);
+    log(`\u76F8\u5BF9\u8DEF\u5F84: ${relativePath}`);
+    log(`\u8DEF\u5F84\u90E8\u5206: ${pathParts}`);
+    if (pathParts.length === 1) {
+      const fileName = pathParts[0];
+      const name = path.basename(fileName, path.extname(fileName));
+      candidateFiles.push({ name, file, priority: 1 });
+      log(`\u{1F4C4} \u7B2C\u4E00\u7EA7\u6587\u4EF6: ${file} -> ${name}.html (\u4F18\u5148\u7EA7: 1)`);
+    } else if (pathParts.length >= 2) {
+      const fileName = path.basename(file, path.extname(file));
+      const dirName = pathParts[0];
+      if (fileName === "main") {
+        candidateFiles.push({ name: dirName, file, priority: 2 });
+        log(`\u{1F4C1} \u76EE\u5F55main\u6587\u4EF6: ${file} -> ${dirName}.html (\u4F18\u5148\u7EA7: 2)`);
+      } else {
+        log(`\u274C \u8DF3\u8FC7\u6587\u4EF6: ${file} (\u4E0D\u662Fmain\u6587\u4EF6)`);
+      }
+    } else {
+      log(`\u274C \u8DF3\u8FC7\u6587\u4EF6: ${file} (\u8DEF\u5F84\u5C42\u7EA7\u4E0D\u7B26\u5408)`);
+    }
+  }
+  for (const candidate of candidateFiles) {
+    const existing = nameToFile.get(candidate.name);
+    if (!existing) {
+      nameToFile.set(candidate.name, { file: candidate.file, priority: candidate.priority });
+      log(`\u2705 \u6DFB\u52A0\u9875\u9762: ${candidate.name} -> ${candidate.file}`);
+    } else {
+      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.file})`);
+      }
+    }
+  }
+  for (const [name, { file }] of nameToFile.entries()) {
+    result.push({ name, file });
+  }
+  return result;
+}
+
+// src/page-config.ts
+init_cjs_shims();
+function getPageConfig(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);
+    }
+    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;
+    }
+    if (config.match) {
+      const patterns = Array.isArray(config.match) ? config.match : [config.match];
+      const isMatched = patterns.some(
+        (pattern) => simpleMatch(pattern, context.pageName) || simpleMatch(pattern, context.relativePath) || simpleMatch(pattern, context.filePath)
+      );
+      if (isMatched) {
+        log(`\u6A21\u5F0F\u5339\u914D\u9875\u9762 ${context.pageName} (\u6A21\u5F0F: ${config.match}):`, config);
+        return { ...config, match: void 0 };
+      }
+    }
+    if (simpleMatch(key, context.pageName)) {
+      log(`Glob\u5339\u914D\u9875\u9762 ${context.pageName} (\u6A21\u5F0F: ${key}):`, config);
+      return config;
+    }
+  }
+  return null;
+}
+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
+init_cjs_shims();
+function createLogger(debug) {
+  return (...args) => {
+    if (debug) {
+      console.log("[vite-plugin-multi-page]", ...args);
+    }
+  };
+}
+
+// src/build-config.ts
+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 = import_glob.glob.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: path2.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"];
+  }
+}
+
+// src/cli.ts
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const viteBuildArgs = [];
+  let debug = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--debug") {
+      debug = true;
+    } else if (arg === "--help" || arg === "-h") {
+      console.log(`
+\u4F7F\u7528\u65B9\u6CD5: vite-multi-page-build [\u9009\u9879]
+
+\u9009\u9879:
+  --debug          \u542F\u7528\u8C03\u8BD5\u6A21\u5F0F
+  --help, -h       \u663E\u793A\u5E2E\u52A9\u4FE1\u606F
+  
+\u5176\u4ED6\u6240\u6709\u53C2\u6570\u5C06\u4F20\u9012\u7ED9 vite build \u547D\u4EE4
+
+\u793A\u4F8B:
+  vite-multi-page-build
+  vite-multi-page-build --debug
+  vite-multi-page-build --host --port 3000
+  vite-multi-page-build --mode production --debug
+`);
+      process.exit(0);
+    } else {
+      viteBuildArgs.push(arg);
+    }
+  }
+  return { viteBuildArgs, debug };
+}
+async function loadViteConfig() {
+  const { loadUserConfig: loadUserConfig2, hasCustomConfig: hasCustomConfig2 } = await Promise.resolve().then(() => (init_config_loader(), config_loader_exports));
+  if (!hasCustomConfig2()) {
+    console.error("\u274C \u672A\u627E\u5230\u591A\u9875\u9762\u914D\u7F6E\u6587\u4EF6\uFF01");
+    console.log("\u8BF7\u521B\u5EFA\u4EE5\u4E0B\u914D\u7F6E\u6587\u4EF6\u4E4B\u4E00\uFF1A");
+    console.log("  - multipage.config.ts");
+    console.log("  - multipage.config.js");
+    console.log("  - multipage.config.mjs");
+    console.log("");
+    console.log("\u914D\u7F6E\u6587\u4EF6\u793A\u4F8B\uFF1A");
+    console.log("");
+    console.log("```typescript");
+    console.log("export default (context) => {");
+    console.log("  const { mode, command, isCLI } = context;");
+    console.log('  const isProduction = mode === "production";');
+    console.log("  ");
+    console.log("  return {");
+    console.log('    entry: "src/pages/**/*.{ts,js}",');
+    console.log('    template: "index.html",');
+    console.log('    placeholder: "{{ENTRY_FILE}}",');
+    console.log("    strategies: {");
+    console.log("      default: {");
+    console.log("        define: { IS_DEFAULT: true },");
+    console.log("        build: { sourcemap: !isProduction },");
+    console.log("      },");
+    console.log("    },");
+    console.log("    pageConfigs: (pageContext) => ({");
+    console.log('      strategy: "default",');
+    console.log("    }),");
+    console.log("  };");
+    console.log("};");
+    console.log("```");
+    process.exit(1);
+  }
+  const userConfig = await loadUserConfig2({
+    mode: "production",
+    command: "build",
+    isCLI: true
+  });
+  if (!userConfig) {
+    console.error("\u274C \u914D\u7F6E\u6587\u4EF6\u52A0\u8F7D\u5931\u8D25\uFF01");
+    process.exit(1);
+  }
+  return userConfig;
+}
+function buildStrategy(strategy, viteBuildArgs, debug) {
+  return new Promise((resolve4) => {
+    var _a;
+    const log = debug ? console.log.bind(console, `[${strategy}]`) : () => {
+    };
+    log(`\u5F00\u59CB\u6784\u5EFA\u7B56\u7565: ${strategy}`);
+    const env = {
+      ...process.env,
+      VITE_BUILD_STRATEGY: strategy
+    };
+    const args = ["build", ...viteBuildArgs];
+    log(`\u6267\u884C\u547D\u4EE4: npx vite ${args.join(" ")}`);
+    const child = (0, import_node_child_process.spawn)("npx", ["vite", ...args], {
+      stdio: debug ? "inherit" : "pipe",
+      env,
+      cwd: process.cwd()
+    });
+    let errorOutput = "";
+    if (!debug) {
+      (_a = child.stderr) == null ? void 0 : _a.on("data", (data) => {
+        errorOutput += data.toString();
+      });
+    }
+    child.on("close", (code) => {
+      const success = code === 0;
+      const outputDir = `dist/${strategy}`;
+      if (success) {
+        log(`\u2705 \u7B56\u7565 ${strategy} \u6784\u5EFA\u6210\u529F`);
+        try {
+          const outputPath = path4.resolve(process.cwd(), outputDir);
+          if (fs3.existsSync(outputPath)) {
+            const files = fs3.readdirSync(outputPath);
+            for (const file of files) {
+              if (file.startsWith(".temp.mp.") && file.endsWith(".html")) {
+                const oldPath = path4.resolve(outputPath, file);
+                const name = file.replace(/^\.temp\.mp\./, "").replace(/\.html$/, "");
+                const newName = `${name}.html`;
+                const newPath = path4.resolve(outputPath, newName);
+                fs3.renameSync(oldPath, newPath);
+                log(`\u91CD\u547D\u540DHTML: ${file} -> ${newName}`);
+              }
+            }
+          }
+        } catch (error) {
+          log(`\u91CD\u547D\u540DHTML\u6587\u4EF6\u5931\u8D25:`, error);
+        }
+      } else {
+        log(`\u274C \u7B56\u7565 ${strategy} \u6784\u5EFA\u5931\u8D25 (\u9000\u51FA\u7801: ${code})`);
+        if (!debug && errorOutput) {
+          console.error(`\u7B56\u7565 ${strategy} \u9519\u8BEF\u8F93\u51FA:`, errorOutput);
+        }
+      }
+      resolve4({
+        strategy,
+        success,
+        error: success ? void 0 : errorOutput || `\u6784\u5EFA\u5931\u8D25\uFF0C\u9000\u51FA\u7801: ${code}`,
+        outputDir
+      });
+    });
+    child.on("error", (error) => {
+      log(`\u274C \u7B56\u7565 ${strategy} \u6784\u5EFA\u51FA\u9519:`, error.message);
+      resolve4({
+        strategy,
+        success: false,
+        error: error.message,
+        outputDir: `dist/${strategy}`
+      });
+    });
+  });
+}
+async function mergeResults(results, debug) {
+  const log = debug ? console.log.bind(console, "[merge]") : () => {
+  };
+  log("\u5F00\u59CB\u5408\u5E76\u6784\u5EFA\u7ED3\u679C...");
+  const distDir = path4.resolve(process.cwd(), "dist");
+  const assetsDir = path4.resolve(distDir, "assets");
+  if (!fs3.existsSync(assetsDir)) {
+    fs3.mkdirSync(assetsDir, { recursive: true });
+  }
+  const htmlFiles = [];
+  const strategyInfo = [];
+  for (const result of results) {
+    strategyInfo.push({
+      strategy: result.strategy,
+      success: result.success,
+      error: result.error
+    });
+    if (!result.success)
+      continue;
+    const sourceDir = path4.resolve(distDir, result.strategy);
+    if (!fs3.existsSync(sourceDir)) {
+      log(`\u8B66\u544A: \u7B56\u7565\u76EE\u5F55\u4E0D\u5B58\u5728: ${sourceDir}`);
+      continue;
+    }
+    log(`\u5904\u7406\u7B56\u7565: ${result.strategy}`);
+    const entries = fs3.readdirSync(sourceDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const sourcePath = path4.resolve(sourceDir, entry.name);
+      if (entry.isFile()) {
+        if (entry.name.endsWith(".html")) {
+          const targetPath = path4.resolve(distDir, entry.name);
+          fs3.copyFileSync(sourcePath, targetPath);
+          htmlFiles.push(entry.name);
+          log(`\u590D\u5236HTML: ${entry.name} -> dist/${entry.name}`);
+        } else {
+          const targetPath = path4.resolve(distDir, entry.name);
+          fs3.copyFileSync(sourcePath, targetPath);
+          log(`\u590D\u5236\u6587\u4EF6: ${entry.name} -> dist/${entry.name}`);
+        }
+      } else if (entry.isDirectory() && entry.name === "assets") {
+        const sourceAssetsDir = sourcePath;
+        const assetEntries = fs3.readdirSync(sourceAssetsDir, { withFileTypes: true });
+        for (const assetEntry of assetEntries) {
+          const assetSourcePath = path4.resolve(sourceAssetsDir, assetEntry.name);
+          const assetTargetPath = path4.resolve(assetsDir, assetEntry.name);
+          if (assetEntry.isFile()) {
+            if (fs3.existsSync(assetTargetPath)) {
+              const sourceContent = fs3.readFileSync(assetSourcePath);
+              const targetContent = fs3.readFileSync(assetTargetPath);
+              if (!sourceContent.equals(targetContent)) {
+                const ext = path4.extname(assetEntry.name);
+                const baseName = path4.basename(assetEntry.name, ext);
+                const newName = `${baseName}-${result.strategy}${ext}`;
+                const newTargetPath = path4.resolve(assetsDir, newName);
+                fs3.copyFileSync(assetSourcePath, newTargetPath);
+                log(`\u590D\u5236\u8D44\u6E90(\u91CD\u547D\u540D): ${assetEntry.name} -> assets/${newName}`);
+              } else {
+                log(`\u8DF3\u8FC7\u91CD\u590D\u8D44\u6E90: ${assetEntry.name}`);
+              }
+            } else {
+              fs3.copyFileSync(assetSourcePath, assetTargetPath);
+              log(`\u590D\u5236\u8D44\u6E90: ${assetEntry.name} -> assets/${assetEntry.name}`);
+            }
+          } else if (assetEntry.isDirectory()) {
+            const subTargetDir = path4.resolve(assetsDir, assetEntry.name);
+            if (!fs3.existsSync(subTargetDir)) {
+              fs3.mkdirSync(subTargetDir, { recursive: true });
+            }
+            fs3.cpSync(assetSourcePath, subTargetDir, { recursive: true });
+            log(`\u590D\u5236\u8D44\u6E90\u76EE\u5F55: ${assetEntry.name} -> assets/${assetEntry.name}`);
+          }
+        }
+      } else if (entry.isDirectory()) {
+        const targetDir = path4.resolve(distDir, entry.name);
+        fs3.cpSync(sourcePath, targetDir, { recursive: true });
+        log(`\u590D\u5236\u76EE\u5F55: ${entry.name} -> dist/${entry.name}`);
+      }
+    }
+  }
+  log("\u2705 \u6784\u5EFA\u7ED3\u679C\u5408\u5E76\u5B8C\u6210");
+  log(`\u{1F4C1} HTML\u6587\u4EF6: ${htmlFiles.join(", ")}`);
+  log(`\u{1F4E6} \u8D44\u6E90\u76EE\u5F55: dist/assets/`);
+}
+async function cleanupTempFiles(debug) {
+  const log = debug ? console.log.bind(console, "[cleanup]") : () => {
+  };
+  log("\u6E05\u7406\u4E34\u65F6HTML\u6587\u4EF6...");
+  const tempHtmlFiles = glob2.sync(".temp.mp.*.html", { cwd: process.cwd() });
+  for (const tempFile of tempHtmlFiles) {
+    const tempPath = path4.resolve(process.cwd(), tempFile);
+    try {
+      fs3.unlinkSync(tempPath);
+      log(`\u5220\u9664\u4E34\u65F6\u6587\u4EF6: ${tempFile}`);
+    } catch (error) {
+      log(`\u5220\u9664\u4E34\u65F6\u6587\u4EF6\u5931\u8D25: ${tempFile}`, error);
+    }
+  }
+  if (tempHtmlFiles.length === 0) {
+    log("\u6CA1\u6709\u627E\u5230\u4E34\u65F6\u6587\u4EF6");
+  } else {
+    log(`\u2705 \u6E05\u7406\u4E86 ${tempHtmlFiles.length} \u4E2A\u4E34\u65F6\u6587\u4EF6`);
+  }
+}
+async function cleanup(strategies, debug) {
+  const log = debug ? console.log.bind(console, "[cleanup]") : () => {
+  };
+  log("\u6E05\u7406\u4E34\u65F6\u6587\u4EF6...");
+  const rootTempFiles = glob2.sync(".temp.mp.*.html", { cwd: process.cwd() });
+  for (const tempFile of rootTempFiles) {
+    const tempPath = path4.resolve(process.cwd(), tempFile);
+    try {
+      fs3.unlinkSync(tempPath);
+      log(`\u5220\u9664\u6839\u76EE\u5F55\u4E34\u65F6\u6587\u4EF6: ${tempFile}`);
+    } catch (error) {
+      log(`\u5220\u9664\u6839\u76EE\u5F55\u4E34\u65F6\u6587\u4EF6\u5931\u8D25: ${tempFile}`, error);
+    }
+  }
+  for (const strategy of strategies) {
+    const strategyDir = path4.resolve(process.cwd(), "dist", strategy);
+    if (fs3.existsSync(strategyDir)) {
+      const strategyTempFiles = glob2.sync("*.mp.temp.html", { cwd: strategyDir });
+      for (const tempFile of strategyTempFiles) {
+        const tempPath = path4.resolve(strategyDir, tempFile);
+        try {
+          fs3.unlinkSync(tempPath);
+          log(`\u5220\u9664\u7B56\u7565\u76EE\u5F55\u4E34\u65F6\u6587\u4EF6: ${strategy}/${tempFile}`);
+        } catch (error) {
+          log(`\u5220\u9664\u7B56\u7565\u76EE\u5F55\u4E34\u65F6\u6587\u4EF6\u5931\u8D25: ${strategy}/${tempFile}`, error);
+        }
+      }
+    }
+  }
+  const distDir = path4.resolve(process.cwd(), "dist");
+  for (const strategy of strategies) {
+    const strategyDir = path4.resolve(distDir, strategy);
+    if (fs3.existsSync(strategyDir)) {
+      try {
+        fs3.rmSync(strategyDir, { recursive: true, force: true });
+        log(`\u5220\u9664\u7B56\u7565\u76EE\u5F55: ${strategy}`);
+      } catch (error) {
+        log(`\u5220\u9664\u7B56\u7565\u76EE\u5F55\u5931\u8D25: ${strategy}`, error);
+      }
+    }
+  }
+  log("\u2705 \u6E05\u7406\u5B8C\u6210");
+}
+async function main() {
+  const { viteBuildArgs, debug } = parseArgs();
+  const log = debug ? console.log.bind(console, "[main]") : () => {
+  };
+  try {
+    log("\u{1F680} \u5F00\u59CB\u591A\u7B56\u7565\u6784\u5EFA...");
+    log("\u{1F4CB} \u52A0\u8F7D\u914D\u7F6E...");
+    const options = await loadViteConfig();
+    const strategies = getAvailableStrategies({
+      entry: options.entry || "src/pages/*/main.{ts,js}",
+      exclude: options.exclude || [],
+      template: options.template || "index.html",
+      placeholder: options.placeholder || "{{ENTRY_FILE}}",
+      pageConfigs: options.pageConfigs || {},
+      strategies: options.strategies || {}
+    });
+    if (strategies.length === 0) {
+      throw new Error("\u672A\u627E\u5230\u4EFB\u4F55\u6784\u5EFA\u7B56\u7565");
+    }
+    log(`\u53D1\u73B0 ${strategies.length} \u4E2A\u7B56\u7565: ${strategies.join(", ")}`);
+    log("\u{1F528} \u5F00\u59CB\u5E76\u884C\u6784\u5EFA...");
+    const buildPromises = strategies.map((strategy) => buildStrategy(strategy, viteBuildArgs, debug));
+    const results = await Promise.all(buildPromises);
+    const successCount = results.filter((r) => r.success).length;
+    const failureCount = results.length - successCount;
+    console.log(`
+\u{1F4CA} \u6784\u5EFA\u7ED3\u679C\u7EDF\u8BA1:`);
+    console.log(`\u2705 \u6210\u529F: ${successCount}`);
+    console.log(`\u274C \u5931\u8D25: ${failureCount}`);
+    if (failureCount > 0) {
+      console.log(`
+\u274C \u5931\u8D25\u7684\u7B56\u7565:`);
+      results.filter((r) => !r.success).forEach((result) => {
+        console.log(`  - ${result.strategy}: ${result.error}`);
+      });
+      await cleanupTempFiles(debug);
+      process.exit(1);
+    }
+    log("\u{1F4E6} \u5408\u5E76\u6784\u5EFA\u7ED3\u679C...");
+    await mergeResults(results, debug);
+    await cleanup(strategies, debug);
+    console.log(`
+\u{1F389} \u6240\u6709\u7B56\u7565\u6784\u5EFA\u6210\u529F\uFF01`);
+    console.log(`\u{1F4C1} \u6784\u5EFA\u7ED3\u679C\u4F4D\u4E8E: dist/`);
+    console.log(
+      `\u{1F310} HTML\u6587\u4EF6: ${results.filter((r) => r.success).map((r) => r.strategy).join(", ")}`
+    );
+  } catch (error) {
+    console.error("\u274C \u6784\u5EFA\u5931\u8D25:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+if (require.main === module) {
+  main().catch((error) => {
+    console.error("\u274C \u672A\u5904\u7406\u7684\u9519\u8BEF:", error);
+    process.exit(1);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildAll
+});