@moluoxixi/vite-config 0.0.27 → 0.0.30

package/lib/index.cjs

@@ -0,0 +1,1218 @@
+"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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const fs = require("node:fs");
+const path = require("node:path");
+const process$1 = require("node:process");
+require("vue");
+require("dotenv");
+const tailwindcss = require("@tailwindcss/postcss");
+const autoprefixer = require("autoprefixer");
+const vite = require("vite");
+const vitePluginHtml = require("vite-plugin-html");
+const lodashEs = require("lodash-es");
+function getType(obj, type) {
+  {
+    return Object.prototype.toString.call(obj).slice(8, -1).toLowerCase() === type.toLowerCase();
+  }
+}
+async function dynamicImport(modulePromise, exportName = "default") {
+  const module2 = await modulePromise;
+  if (exportName === "default") {
+    return module2.default ?? module2;
+  }
+  if (!(exportName in module2)) {
+    throw new Error(`模块中不存在导出 "${exportName}"`);
+  }
+  return module2[exportName];
+}
+function isObject(value) {
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+function deepMerge(target, source) {
+  if (!isObject(source)) {
+    return target;
+  }
+  return Object.keys(source).reduce((acc, key) => {
+    const sourceValue = source[key];
+    const targetValue = acc[key];
+    if (isObject(sourceValue) && isObject(targetValue)) {
+      acc[key] = deepMerge(targetValue, sourceValue);
+    } else if (isObject(sourceValue)) {
+      acc[key] = deepMerge({}, sourceValue);
+    } else {
+      acc[key] = sourceValue;
+    }
+    return acc;
+  }, { ...target });
+}
+function validateMutuallyExclusive(values, defaultKey) {
+  const keys = Object.keys(values);
+  const enabledKeys = [];
+  for (const key of keys) {
+    if (values[key] === true) {
+      enabledKeys.push(key);
+    }
+  }
+  if (enabledKeys.length > 1) {
+    const keysStr = enabledKeys.join("、");
+    const allKeysStr = keys.join("、");
+    const selectedKey = enabledKeys.includes(defaultKey) ? defaultKey : enabledKeys[0];
+    console.warn(
+      `[validateMutuallyExclusive] ${allKeysStr} 只能启用一个，但当前启用了：${keysStr}。已自动选择：${String(selectedKey)}`
+    );
+    const result2 = {};
+    for (const key of keys) {
+      result2[key] = key === selectedKey;
+    }
+    return result2;
+  }
+  const hasEnabledKey = enabledKeys.length > 0;
+  const result = {};
+  for (const key of keys) {
+    if (!hasEnabledKey && defaultKey && key === defaultKey) {
+      result[key] = true;
+    } else {
+      result[key] = values[key] ?? false;
+    }
+  }
+  return result;
+}
+function detectFramework(config, rootDir) {
+  const root = rootDir || process$1.cwd();
+  const packageJsonPath = path.resolve(root, "package.json");
+  let vue = config.vue;
+  let react = config.react;
+  let vitepress = config.vitepress;
+  const hasExplicitFramework = vue === true || react === true || vitepress === true;
+  if (!hasExplicitFramework) {
+    let dependencies = {};
+    let devDependencies = {};
+    if (fs.existsSync(packageJsonPath)) {
+      try {
+        const packageJsonContent = fs.readFileSync(packageJsonPath, "utf-8");
+        const packageJson = JSON.parse(packageJsonContent);
+        dependencies = packageJson.dependencies || {};
+        devDependencies = packageJson.devDependencies || {};
+      } catch (error) {
+        console.warn(`无法读取 package.json: ${packageJsonPath}`, error);
+      }
+    }
+    if (vue === void 0) {
+      if (dependencies.vue || devDependencies.vue) {
+        vue = true;
+      }
+    }
+    if (react === void 0 && vue !== true) {
+      if (dependencies.react || devDependencies.react) {
+        react = true;
+      }
+    }
+    if (vitepress === void 0 && vue !== true && react !== true) {
+      if (dependencies.vitepress || devDependencies.vitepress) {
+        vitepress = true;
+      }
+    }
+  }
+  return {
+    vue: vue ?? false,
+    react: react ?? false,
+    vitepress: vitepress ?? false
+  };
+}
+function changeHtmlClassPrefix(htmlString = "", oldPrefix = "", newPrefix = "") {
+  const regex = new RegExp(
+    `(class|style)\\s*:\\s*((["']((${oldPrefix}\\b)-).*["'])|((_normalizeClass|_normalizeStyle)\\(.*(${oldPrefix}\\b)-.*\\)))`,
+    "g"
+  );
+  return htmlString.replace(regex, (match = "") => {
+    return match.replace(oldPrefix, newPrefix);
+  });
+}
+function changeSelectorPrefix(cssString = "", oldPrefix = "", newPrefix = "") {
+  const regex = new RegExp(`(\\.${oldPrefix}\\b|#${oldPrefix}\\b|--${oldPrefix}\\b)`, "g");
+  return cssString.replace(regex, (match = "") => {
+    return match.replace(oldPrefix, newPrefix);
+  });
+}
+function addScopedAndReplacePrefixPlugin({
+  prefixScoped = "",
+  oldPrefix = "",
+  newPrefix = "",
+  useDevMode = false
+}) {
+  let isProduction;
+  return {
+    name: "addScopedAndReplacePrefix",
+    configResolved(config) {
+      isProduction = config.command === "build" || config.isProduction;
+    },
+    transform(code = "", id = "") {
+      if (!isProduction && !useDevMode)
+        return code;
+      if (!oldPrefix || !newPrefix)
+        return code;
+      if (id.includes("node_modules"))
+        return code;
+      const cssLangs = ["css", "scss", "less", "stylus", "styl"];
+      let newCode = code;
+      if (id.endsWith(".vue")) {
+        newCode = changeHtmlClassPrefix(newCode, oldPrefix, newPrefix);
+      } else if (cssLangs.some((lang) => id.endsWith(`.${lang}`))) {
+        if (oldPrefix && newPrefix) {
+          newCode = changeSelectorPrefix(newCode, oldPrefix, newPrefix);
+        }
+        if (prefixScoped) {
+          newCode = `${newCode}${prefixScoped}{${newCode}}`;
+        }
+        return newCode;
+      }
+      return newCode;
+    }
+  };
+}
+async function getViteConfig(Config, params) {
+  const configResult = typeof Config === "function" ? Config(params) : Config;
+  const config = configResult;
+  const { mode = "base" } = params || {};
+  const rootPath = config.rootPath || process.cwd();
+  const modeConfig = config.mode || {};
+  const baseConfig = modeConfig.base || {};
+  const currentModeConfig = modeConfig[mode] || {};
+  const viteEnv = { ...baseConfig, ...currentModeConfig };
+  const isDev = mode === "development";
+  const {
+    autoImport = config.autoImport ?? true,
+    autoComponent = config.autoComponent ?? true,
+    compression = config.compression ?? true,
+    imagemin = config.imagemin ?? true,
+    codeInspector = config.codeInspector ?? true,
+    port = config.port,
+    visualizer = config.visualizer ?? false,
+    autoRoutes = config.autoRoutes ?? false,
+    cdn = config.cdn ?? false,
+    pageRoutes = config.pageRoutes ?? false,
+    pwa = config.pwa ?? false,
+    devtools = config.devtools,
+    open = config.open,
+    qiankunDevMode = config.qiankunDevMode,
+    qiankun = config.qiankun,
+    namespace = config.namespace,
+    dropConsole = config.dropConsole,
+    vue: vueRaw = config.vue,
+    react: reactRaw = config.react,
+    vitepress: vitepressRaw = config.vitepress
+  } = viteEnv;
+  const frameworkResult = detectFramework(
+    {
+      vue: vueRaw,
+      react: reactRaw,
+      vitepress: vitepressRaw
+    },
+    rootPath
+  );
+  const { vue, react, vitepress } = validateMutuallyExclusive(
+    frameworkResult,
+    "vue"
+  );
+  const appTitle = config.appTitle;
+  const appCode = config.appCode;
+  const isVueOrVitepress = vue || vitepress;
+  const envSystemCode = isDev && !qiankunDevMode ? "el" : namespace ?? appCode;
+  const plugins = [
+    vitePluginHtml.createHtmlPlugin({
+      inject: {
+        data: {
+          title: appTitle
+        }
+      }
+    })
+  ];
+  if (vue) {
+    const pluginVue = await dynamicImport(import("@vitejs/plugin-vue"));
+    plugins.push(pluginVue());
+  }
+  if (react) {
+    const pluginReact = await dynamicImport(import("@vitejs/plugin-react"));
+    plugins.push(pluginReact());
+  }
+  if (isVueOrVitepress) {
+    const vueJsx = await dynamicImport(import("@vitejs/plugin-vue-jsx"));
+    plugins.push(vueJsx());
+  }
+  if (pageRoutes) {
+    const Pages = await dynamicImport(import("vite-plugin-pages"));
+    const extensions = [];
+    if (vue) {
+      extensions.push("vue");
+    }
+    if (react) {
+      extensions.push("tsx", "jsx");
+    }
+    plugins.push(Pages(
+      deepMerge(
+        {
+          dirs: "src/pages",
+          extensions,
+          exclude: [
+            "**/components/**",
+            "**/__tests__/**"
+          ]
+        },
+        pageRoutes
+      )
+    ));
+  }
+  if (isDev && devtools && isVueOrVitepress) {
+    const vueDevTools = await dynamicImport(import("vite-plugin-vue-devtools"));
+    plugins.push(vueDevTools());
+  }
+  if (autoImport && isVueOrVitepress) {
+    const AutoImport = await dynamicImport(import("unplugin-auto-import/vite"));
+    const ElementPlusResolverModule = await dynamicImport(import("unplugin-vue-components/resolvers"));
+    const { ElementPlusResolver } = ElementPlusResolverModule;
+    plugins.push(AutoImport(
+      deepMerge(
+        {
+          imports: ["vue"],
+          resolvers: [ElementPlusResolver()],
+          dts: path.resolve(rootPath, "./typings/auto-imports.d.ts")
+        },
+        autoImport
+      )
+    ));
+  }
+  if (autoComponent && isVueOrVitepress) {
+    const Components = await dynamicImport(import("unplugin-vue-components/vite"));
+    const ElementPlusResolverModule = await dynamicImport(import("unplugin-vue-components/resolvers"));
+    const { ElementPlusResolver } = ElementPlusResolverModule;
+    plugins.push(Components(
+      deepMerge(
+        {
+          resolvers: [ElementPlusResolver()],
+          globs: [],
+          dts: path.resolve(rootPath, "./typings/components.d.ts")
+        },
+        autoComponent
+      )
+    ));
+  }
+  if (compression) {
+    const viteCompression = await dynamicImport(import("vite-plugin-compression"));
+    const compressionPlugin = viteCompression;
+    plugins.push(compressionPlugin(
+      deepMerge(
+        {
+          algorithm: "brotliCompress",
+          verbose: true,
+          disable: false,
+          ext: ".gz",
+          threshold: 10240,
+          deleteOriginFile: false
+        },
+        compression
+      )
+    ));
+  }
+  if (imagemin) {
+    const viteImagemin = await dynamicImport(import("vite-plugin-imagemin"));
+    const imageminPlugin = viteImagemin;
+    plugins.push(imageminPlugin(
+      deepMerge(
+        {
+          gifsicle: { optimizationLevel: 7, interlaced: false },
+          optipng: { optimizationLevel: 7 },
+          mozjpeg: { quality: 20 },
+          pngquant: { quality: [0.8, 0.9], speed: 4 },
+          svgo: {
+            plugins: [{ name: "removeViewBox" }, { name: "removeEmptyAttrs", active: false }]
+          }
+        },
+        imagemin
+      )
+    ));
+  }
+  if (cdn) {
+    const importToCDN = await dynamicImport(import("vite-plugin-cdn-import"));
+    const { modules: modules2 } = await dynamicImport(Promise.resolve().then(() => index$1));
+    plugins.push(importToCDN(
+      deepMerge(
+        {
+          enableInDevMode: false,
+          prodUrl: "/{name}@{version}{path}",
+          modules: modules2,
+          generateScriptTag: (_name, scriptUrl) => {
+            const esmArr = ["esm", ".mjs"];
+            const isESM = esmArr.some((item) => scriptUrl.includes(item));
+            if (isESM) {
+              return {
+                attrs: {
+                  src: scriptUrl,
+                  type: "module",
+                  crossorigin: "anonymous"
+                },
+                injectTo: "head"
+              };
+            } else {
+              return {
+                attrs: {
+                  src: scriptUrl,
+                  crossorigin: "anonymous"
+                },
+                injectTo: "head"
+              };
+            }
+          }
+        },
+        cdn
+      )
+    ));
+  }
+  if (visualizer) {
+    const visualizerModule = await dynamicImport(import("rollup-plugin-visualizer"));
+    const { visualizer: visualizerPlugin } = visualizerModule;
+    plugins.push(visualizerPlugin(
+      deepMerge(
+        {
+          open: true
+        },
+        visualizer
+      )
+    ));
+  }
+  if (pwa) {
+    const pwaModule = await dynamicImport(import("vite-plugin-pwa"));
+    const { VitePWA } = pwaModule;
+    plugins.push(VitePWA(
+      deepMerge(
+        {
+          strategies: "generateSW",
+          registerType: "autoUpdate",
+          // 开发模式下也启用
+          devOptions: {
+            enabled: true
+          },
+          includeAssets: ["favicon.ico", "apple-touch-icon.png", "mask-icon.svg"],
+          manifest: {
+            id: appCode ? `/${appCode}/` : "/",
+            start_url: appCode ? `/${appCode}/` : "/",
+            name: appTitle || "应用",
+            short_name: appTitle || "应用",
+            description: "渐进式 Web 应用",
+            display: "standalone",
+            background_color: "#ffffff",
+            theme_color: "#BA42BF"
+          }
+        },
+        pwa
+      )
+    ));
+  }
+  if (isDev && codeInspector) {
+    const codeInspectorModule = await dynamicImport(import("code-inspector-plugin"));
+    const { codeInspectorPlugin } = codeInspectorModule;
+    plugins.push(codeInspectorPlugin(
+      deepMerge(
+        {
+          bundler: "vite",
+          showSwitch: true
+        },
+        codeInspector
+      )
+    ));
+  }
+  if (qiankun) {
+    const qiankunPlugin = await dynamicImport(import("vite-plugin-qiankun"));
+    const qiankunPluginFn = qiankunPlugin;
+    plugins.push(qiankunPluginFn(envSystemCode || "el", { useDevMode: qiankunDevMode }));
+    if (appCode) {
+      plugins.push(addScopedAndReplacePrefixPlugin({
+        prefixScoped: `div[data-qiankun='${envSystemCode}']`,
+        oldPrefix: "el",
+        newPrefix: appCode,
+        useDevMode: qiankunDevMode
+      }));
+    }
+  }
+  if (autoRoutes && isVueOrVitepress) {
+    const AutoRoutesPlugin = await dynamicImport(Promise.resolve().then(() => index));
+    plugins.push(AutoRoutesPlugin(
+      deepMerge(
+        {
+          root: rootPath,
+          routeConfig: {
+            views: ["/src/views/**/index.vue", "!/src/views/**/components/*"],
+            examples: "/src/examples/**/index.vue",
+            componentExamples: {
+              glob: ["/src/components/**/Example.vue", "!/src/components/**/components/*"],
+              baseRoute: "组件示例"
+            }
+          },
+          dts: path.resolve(rootPath, "./typings/auto-routes.d.ts")
+        },
+        autoRoutes
+      )
+    ));
+  }
+  const defaultConfig = {
+    plugins,
+    esbuild: {
+      pure: !isDev && dropConsole ? ["console.log", "console.info", "console.debug"] : []
+    },
+    build: {
+      sourcemap: isDev,
+      outDir: appCode || "dist",
+      cssCodeSplit: true,
+      chunkSizeWarningLimit: 1500,
+      minify: "esbuild",
+      rollupOptions: {
+        external: [],
+        output: {
+          globals: {},
+          chunkFileNames: "static/js/[name]-[hash].js",
+          entryFileNames: "static/js/[name]-[hash].js",
+          assetFileNames: "static/[ext]/[name]-[hash].[ext]",
+          manualChunks: (id) => {
+            if (id.includes("node_modules")) {
+              if (id.includes("lodash-es")) {
+                return "lodash-vendor";
+              }
+              if (id.includes("element-plus")) {
+                return "el-vendor";
+              }
+              if (id.includes("@vue") || id.includes("vue")) {
+                return "vue-vendor";
+              }
+              if (id.includes("antd") || id.includes("@ant-design")) {
+                return "antd-vendor";
+              }
+              if (id.includes("react-dom")) {
+                return "react-dom-vendor";
+              }
+              if (id.includes("react")) {
+                return "react-vendor";
+              }
+              return "vendor";
+            }
+          }
+        }
+      }
+    },
+    define: {
+      __SYSTEM_CODE__: JSON.stringify(envSystemCode),
+      process: deepMerge({
+        env: {
+          VUE_APP_VXE_ENV: "production"
+        }
+      }, process)
+    },
+    css: {
+      preprocessorOptions: {
+        scss: {
+          api: "modern-compiler"
+        }
+      },
+      postcss: {
+        plugins: [tailwindcss(), autoprefixer()]
+      },
+      devSourcemap: isDev
+    },
+    resolve: {
+      extensions: [".js", ".jsx", ".ts", ".tsx", ".vue"],
+      alias: {
+        "@": path.resolve(rootPath, "./src")
+      }
+    },
+    server: {
+      host: "0.0.0.0",
+      port,
+      open,
+      cors: true,
+      proxy: {}
+    }
+  };
+  if (!vitepress && appCode) {
+    defaultConfig.base = `/${appCode}`;
+  }
+  const viteConfig = typeof config.viteConfig === "function" ? config.viteConfig(params) : config.viteConfig;
+  const viteConfigPluginNames = ((viteConfig == null ? void 0 : viteConfig.plugins) || []).map((i) => {
+    const plugin = Array.isArray(i) ? i[0] : i;
+    return plugin == null ? void 0 : plugin.name;
+  }).filter((name) => Boolean(name));
+  const defaultPluginNamesMap = (defaultConfig.plugins || []).reduce((nameMap, i) => {
+    const plugin = Array.isArray(i) ? i[0] : i;
+    const name = plugin == null ? void 0 : plugin.name;
+    if (name) {
+      nameMap[name] = i;
+    }
+    return nameMap;
+  }, {});
+  const uniquePlugin = [];
+  Object.keys(defaultPluginNamesMap).forEach((name) => {
+    if (!viteConfigPluginNames.includes(name)) {
+      uniquePlugin.push(defaultPluginNamesMap[name]);
+    }
+  });
+  defaultConfig.plugins = uniquePlugin;
+  return vite.mergeConfig(defaultConfig, viteConfig || {});
+}
+function createViteConfig(Config) {
+  return vite.defineConfig(async (params) => await getViteConfig(Config, params));
+}
+function wrapperEnv(env) {
+  const result = {};
+  for (const key in env) {
+    if (Object.prototype.hasOwnProperty.call(env, key)) {
+      const value = env[key].trim();
+      if (value === "true" || value === "false") {
+        result[key] = value === "true";
+      } else if (!Number.isNaN(Number(value))) {
+        result[key] = Number(value);
+      } else if (value === "") {
+        result[key] = null;
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+function getCamelCase(str) {
+  return str.replace(/[-_]+/g, " ").replace(/(?:^|\s)\w/g, (match) => match.toUpperCase()).replace(/\s+/g, "");
+}
+function getCdnModules(modules2) {
+  function getPath(str) {
+    if (!str)
+      return "";
+    return str.startsWith("/") ? str : `/${str}`;
+  }
+  return modules2.map((item) => {
+    if (typeof item === "string") {
+      return {
+        name: item,
+        var: getCamelCase(item),
+        path: ""
+      };
+    } else {
+      return item;
+    }
+  }).map((item) => {
+    return {
+      name: item.name,
+      var: item.var || getCamelCase(item.name),
+      path: getPath(item.path),
+      css: getPath(item.css)
+    };
+  });
+}
+const modules = getCdnModules([]);
+const index$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  modules
+}, Symbol.toStringTag, { value: "Module" }));
+function resolvePatternsToAbsolute(patterns, rootDir) {
+  return patterns.map((p) => vite.normalizePath(path.isAbsolute(p) ? p : path.resolve(rootDir, p)));
+}
+function extractStaticPrefixFromGlob(absPattern) {
+  const special = ["*", "?", "{", "}", "!", "(", ")", "[", "]"];
+  const idx = absPattern.split("").findIndex((ch) => special.includes(ch));
+  return idx === -1 ? absPattern : absPattern.slice(0, idx);
+}
+function createMatcher(prefixes) {
+  return (absFile) => prefixes.some((prefix) => absFile.startsWith(prefix));
+}
+class VirtualModuleState {
+  constructor() {
+    /** 标记服务器是否正在关闭，避免关闭阶段再触发无效操作 */
+    __publicField(this, "isServerClosing", false);
+    /** 标记初始化是否完成，初始化期间的变化会被延迟处理 */
+    __publicField(this, "isInitialized", false);
+    /** 标记初始化期间是否有文件变化，初始化完成后会处理这些变化 */
+    __publicField(this, "hasPendingChange", false);
+    /** HMR 热更新的防抖函数，lodash-es debounce 返回的函数有 cancel 方法，可以手动取消 */
+    __publicField(this, "hmrDebouncedInvalidate");
+    /** watchChange 钩子的防抖函数，用于清理模块缓存 */
+    __publicField(this, "watchChangeDebouncedClear");
+    /** 文件监听器的防抖函数 */
+    __publicField(this, "watcherDebouncedInvalidate");
+  }
+  /**
+   * 清理所有防抖定时器
+   * 在服务器关闭时调用，确保不会有待执行的防抖任务
+   */
+  clearAll() {
+    var _a, _b, _c;
+    (_a = this.hmrDebouncedInvalidate) == null ? void 0 : _a.cancel();
+    (_b = this.watchChangeDebouncedClear) == null ? void 0 : _b.cancel();
+    (_c = this.watcherDebouncedInvalidate) == null ? void 0 : _c.cancel();
+  }
+}
+function invalidateModules(server, virtualModuleId, moduleCache) {
+  const ids = Array.from(moduleCache.keys()).filter(
+    (k) => k === virtualModuleId || k.startsWith(`${virtualModuleId}/`)
+  );
+  const mods = [];
+  for (const vid of ids) {
+    moduleCache.delete(vid);
+    const mod = server.moduleGraph.getModuleById(vid);
+    if (mod) {
+      server.moduleGraph.invalidateModule(mod);
+      mods.push(mod);
+    }
+  }
+  return mods;
+}
+function sendHmrUpdate(server, mods) {
+  var _a;
+  if (mods.length === 0) {
+    server == null ? void 0 : server.ws.send({ type: "full-reload" });
+    return;
+  }
+  try {
+    for (const mod of mods) {
+      try {
+        (_a = server.reloadModule) == null ? void 0 : _a.call(server, mod);
+      } catch {
+      }
+    }
+    server == null ? void 0 : server.ws.send({
+      type: "update",
+      updates: mods.map((mod) => ({
+        type: "js-update",
+        path: mod.url,
+        acceptedPath: mod.url,
+        timestamp: Date.now()
+      }))
+    });
+  } catch {
+    server == null ? void 0 : server.ws.send({ type: "full-reload" });
+  }
+}
+function setupFileWatcher(options) {
+  var _a;
+  const { server, watchPatterns, isWatchedPath, onInvalidate, debounceMs, onInitialized } = options;
+  let watcherReady = false;
+  let netReady = false;
+  let enabled = false;
+  const debouncedInvalidate = lodashEs.debounce(onInvalidate, debounceMs, {
+    trailing: true,
+    leading: false
+  });
+  const maybeEnable = () => {
+    var _a2;
+    if (enabled || !watcherReady || !netReady)
+      return;
+    enabled = true;
+    try {
+      if (watchPatterns.length > 0)
+        server.watcher.add(watchPatterns);
+    } catch {
+    }
+    const handleFileChange = (eventName, file) => {
+      if (eventName === "change" || eventName === "unlink" || eventName === "unlinkDir" || watcherReady && (eventName === "add" || eventName === "addDir")) {
+        const abs = vite.normalizePath(
+          path.isAbsolute(file) ? file : path.resolve(server.config.root, file)
+        );
+        if (isWatchedPath(abs))
+          debouncedInvalidate();
+      }
+    };
+    server.watcher.on("all", handleFileChange);
+    const cleanup = () => {
+      debouncedInvalidate.cancel();
+      server.watcher.off("all", handleFileChange);
+    };
+    server.watcher.once("close", cleanup);
+    (_a2 = server.httpServer) == null ? void 0 : _a2.once("close", cleanup);
+    onInitialized == null ? void 0 : onInitialized();
+  };
+  server.watcher.once("ready", () => {
+    watcherReady = true;
+    maybeEnable();
+  });
+  (_a = server.httpServer) == null ? void 0 : _a.once("listening", () => {
+    netReady = true;
+    maybeEnable();
+  });
+  const wsAny = server.ws;
+  if (typeof (wsAny == null ? void 0 : wsAny.on) === "function") {
+    const connectionHandler = () => {
+      var _a2, _b;
+      netReady = true;
+      maybeEnable();
+      try {
+        (_a2 = wsAny.off) == null ? void 0 : _a2.call(wsAny, "connection", connectionHandler);
+      } catch {
+      }
+      try {
+        (_b = wsAny.removeListener) == null ? void 0 : _b.call(wsAny, "connection", connectionHandler);
+      } catch {
+      }
+    };
+    wsAny.on("connection", connectionHandler);
+  }
+}
+function writeDtsFile(config, rootDir, dts, generateDts) {
+  if (dts === false || !generateDts)
+    return;
+  try {
+    const dtsPath = typeof dts === "string" ? path.isAbsolute(dts) ? dts : path.resolve(rootDir, dts) : path.resolve(rootDir, "./src/typings/virtual-module.d.ts");
+    const content = generateDts({ config });
+    const normalized = vite.normalizePath(dtsPath);
+    const dir = path.dirname(normalized);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(normalized, content, "utf-8");
+  } catch {
+  }
+}
+function callUserHook(hook, context, ...args) {
+  if (!hook)
+    return void 0;
+  if (typeof hook === "function") {
+    return hook.call(context, ...args);
+  } else if (hook.handler) {
+    return hook.handler.call(context, ...args);
+  }
+  return void 0;
+}
+function createVirtualPlugin(userConfig) {
+  const {
+    virtualModuleId,
+    dts,
+    root,
+    watch,
+    debounceMs = 2e3,
+    ...restConfig
+  } = userConfig;
+  const VIRTUAL_MODULE_ID = virtualModuleId;
+  const {
+    resolveId,
+    load,
+    configResolved,
+    configureServer,
+    handleHotUpdate,
+    watchChange,
+    generateModule,
+    generateDts,
+    ...restHooks
+  } = restConfig;
+  const moduleCache = /* @__PURE__ */ new Map();
+  const state = new VirtualModuleState();
+  let resolvedViteConfig;
+  let watchPatterns = [];
+  let isWatchedPath = () => true;
+  const performInvalidate = (server) => {
+    if (state.isServerClosing)
+      return;
+    const mods = invalidateModules(server, VIRTUAL_MODULE_ID, moduleCache);
+    sendHmrUpdate(server, mods);
+  };
+  const handleFileChange = (server) => {
+    if (!state.isInitialized) {
+      state.hasPendingChange = true;
+      return;
+    }
+    performInvalidate(server);
+  };
+  return {
+    /**
+     * 解析虚拟模块 ID
+     * 当 import 语句引用虚拟模块时，Vite 会调用此方法
+     * @param args - resolveId 的所有参数
+     * @returns 如果匹配虚拟模块 ID，返回该 ID；否则返回 undefined
+     */
+    resolveId(...args) {
+      const [id] = args;
+      if (id === VIRTUAL_MODULE_ID || id.startsWith(`${VIRTUAL_MODULE_ID}/`))
+        return id;
+      return callUserHook(resolveId, this, ...args);
+    },
+    /**
+     * 配置解析完成钩子
+     * 在 Vite 配置解析完成后调用，用于初始化监听路径和生成类型声明文件
+     * @param args - configResolved 的所有参数
+     */
+    configResolved(...args) {
+      const [config] = args;
+      resolvedViteConfig = config;
+      const rootDir = root || config.root;
+      const patterns = Array.isArray(watch) ? watch : watch ? [watch] : [];
+      watchPatterns = resolvePatternsToAbsolute(patterns, rootDir);
+      const watchPrefixes = watchPatterns.map(extractStaticPrefixFromGlob);
+      isWatchedPath = watchPrefixes.length === 0 ? () => true : createMatcher(watchPrefixes);
+      writeDtsFile(config, rootDir, dts, generateDts);
+      callUserHook(configResolved, this, ...args);
+    },
+    /**
+     * 配置开发服务器钩子
+     * 在开发服务器启动时调用，用于设置文件监听、信号处理和清理逻辑
+     * @param args - configureServer 的所有参数
+     */
+    configureServer(...args) {
+      var _a;
+      const [server] = args;
+      const handleSignal = () => {
+        var _a2;
+        if (state.isServerClosing)
+          return;
+        state.isServerClosing = true;
+        Promise.resolve((_a2 = server == null ? void 0 : server.close) == null ? void 0 : _a2.call(server)).finally(() => {
+          try {
+            process$1.exit(0);
+          } catch {
+          }
+        });
+      };
+      process$1.once("SIGINT", handleSignal);
+      process$1.once("SIGTERM", handleSignal);
+      (_a = server.httpServer) == null ? void 0 : _a.once("close", () => {
+        state.isServerClosing = true;
+        state.clearAll();
+      });
+      setupFileWatcher({
+        server,
+        watchPatterns,
+        isWatchedPath,
+        onInvalidate: () => handleFileChange(server),
+        debounceMs,
+        onInitialized: () => {
+          state.isInitialized = true;
+          if (state.hasPendingChange) {
+            state.hasPendingChange = false;
+            setTimeout(() => {
+              if (!state.isServerClosing)
+                performInvalidate(server);
+            }, 0);
+          }
+        }
+      });
+      callUserHook(configureServer, this, ...args);
+    },
+    /**
+     * 处理热更新钩子
+     * 当 Vite 检测到文件变化时调用，用于触发虚拟模块的失效和更新
+     * @param args - handleHotUpdate 的所有参数
+     * @returns 空数组，表示不阻止其他插件的处理
+     * @remarks
+     * - 使用防抖机制避免频繁触发
+     * - 初始化期间的变化会被延迟处理
+     * - 只处理匹配监听路径的文件变化
+     */
+    handleHotUpdate(...args) {
+      const [ctx] = args;
+      const { server } = ctx;
+      const rootDir = root || (resolvedViteConfig == null ? void 0 : resolvedViteConfig.root) || server.config.root;
+      const abs = vite.normalizePath(
+        path.isAbsolute(ctx.file) ? ctx.file : path.resolve(rootDir, ctx.file)
+      );
+      if (!isWatchedPath(abs) || state.isServerClosing)
+        return;
+      if (!state.isInitialized) {
+        state.hasPendingChange = true;
+        return [];
+      }
+      if (!state.hmrDebouncedInvalidate) {
+        state.hmrDebouncedInvalidate = lodashEs.debounce(
+          () => {
+            if (state.isServerClosing)
+              return;
+            performInvalidate(server);
+          },
+          debounceMs,
+          { trailing: true, leading: false }
+        );
+      }
+      state.hmrDebouncedInvalidate();
+      return callUserHook(handleHotUpdate, this, ...args) || [];
+    },
+    /**
+     * 监听文件变化钩子
+     * 当 Vite 的依赖预构建或文件系统检测到变化时调用
+     * 主要用于清理模块缓存，让下次加载时重新生成
+     * @param args - watchChange 的所有参数
+     * @remarks
+     * - 与 handleHotUpdate 不同，此钩子主要用于清理缓存，不触发 HMR
+     * - 使用防抖机制避免频繁清理
+     * - 初始化期间的变化会被延迟处理
+     */
+    watchChange(...args) {
+      try {
+        const [id] = args;
+        const rootDir = root || (resolvedViteConfig == null ? void 0 : resolvedViteConfig.root) || process$1.cwd();
+        const absId = vite.normalizePath(path.isAbsolute(id) ? id : path.resolve(rootDir, id));
+        if (!isWatchedPath(absId) || state.isServerClosing) {
+          return;
+        }
+        if (!state.isInitialized) {
+          state.hasPendingChange = true;
+          return;
+        }
+        if (!state.watchChangeDebouncedClear) {
+          state.watchChangeDebouncedClear = lodashEs.debounce(
+            () => {
+              if (state.isServerClosing)
+                return;
+              for (const k of Array.from(moduleCache.keys())) {
+                if (k === VIRTUAL_MODULE_ID || k.startsWith(`${VIRTUAL_MODULE_ID}/`))
+                  moduleCache.delete(k);
+              }
+            },
+            debounceMs,
+            { trailing: true, leading: false }
+          );
+        }
+        state.watchChangeDebouncedClear();
+        return callUserHook(watchChange, this, ...args);
+      } catch {
+      }
+    },
+    /**
+     * 加载虚拟模块内容
+     * 当 import 语句引用虚拟模块时，Vite 会调用此方法获取模块代码
+     * @param args - load 的所有参数
+     * @returns 模块代码字符串，如果 ID 不匹配则返回 undefined
+     * @remarks
+     * - 支持同步和异步的 generateModule 函数
+     * - 生成的代码会被缓存，直到模块被失效
+     * - 子路径导入（如 'virtual:routes/sub'）会传入完整 ID 给 generateModule
+     */
+    async load(...args) {
+      const [id] = args;
+      if (id === VIRTUAL_MODULE_ID || id.startsWith(`${VIRTUAL_MODULE_ID}/`)) {
+        const code = getType(generateModule, "asyncfunction") ? await generateModule({ id, config: resolvedViteConfig }) : generateModule({ id, config: resolvedViteConfig });
+        moduleCache.set(id, code);
+        return code;
+      }
+      return await callUserHook(load, this, ...args);
+    },
+    // 使用 rest 参数包含所有其他未使用的钩子（包括 name, transform, enforce 等）
+    ...restHooks
+  };
+}
+function cleanRoute(route) {
+  const cleaned = { ...route };
+  if (cleaned.children) {
+    if (Array.isArray(cleaned.children) && cleaned.children.length > 0) {
+      cleaned.children = cleaned.children.map(cleanRoute);
+    } else {
+      delete cleaned.children;
+    }
+  }
+  return cleaned;
+}
+function findParentRouteHandle(modules2, parentPath) {
+  for (const route of modules2) {
+    if (route.path === parentPath) {
+      return route;
+    }
+    if (route.children) {
+      const found = findParentRouteHandle(route.children, parentPath);
+      if (found)
+        return found;
+    }
+  }
+  return void 0;
+}
+function parseModulePath(modulePath) {
+  const pathArr = modulePath.split("/").filter((item) => item && !item.includes("."));
+  if (pathArr.at(-1) === "src") {
+    pathArr.pop();
+  }
+  const componentName = pathArr.at(-1);
+  const path2 = `/${pathArr.join("/")}`;
+  const parentPath = `/${pathArr.slice(0, -1).join("/")}`;
+  return { pathArr, componentName, path: path2, parentPath };
+}
+function processComponent(componentLoader, componentName, eager) {
+  if (eager) {
+    return {
+      component: componentLoader,
+      metaTitle: (componentLoader == null ? void 0 : componentLoader.name) || componentName
+    };
+  }
+  return {
+    component: typeof componentLoader === "function" ? componentLoader : componentLoader,
+    metaTitle: componentName
+  };
+}
+function generateRoutes(files, prefix = "", baseRoute, eager = false) {
+  const newBaseRoute = typeof baseRoute === "string" ? { name: baseRoute } : baseRoute;
+  const modules2 = newBaseRoute ? [newBaseRoute] : [];
+  const fileKeys = Object.keys(files);
+  if (fileKeys.length === 0) {
+    return [];
+  }
+  return fileKeys.sort((a, b) => {
+    const aLength = a.split("/").length;
+    const bLength = b.split("/").length;
+    return bLength > aLength ? -1 : 1;
+  }).reduce((modules22 = [], modulePath) => {
+    const componentLoader = files[modulePath];
+    if (!componentLoader || modulePath === "install") {
+      return modules22;
+    }
+    const { path: path2, parentPath, componentName } = parseModulePath(modulePath);
+    if (!componentName) {
+      return modules22;
+    }
+    let parentRoute;
+    if (newBaseRoute) {
+      newBaseRoute.children = newBaseRoute.children || [];
+      newBaseRoute.name = newBaseRoute.name || prefix;
+      newBaseRoute.path = `/${(newBaseRoute.path || parentPath).split("/").filter((item) => item && !item.includes(".")).join("/")}`;
+      parentRoute = newBaseRoute;
+    } else {
+      parentRoute = findParentRouteHandle(modules22, parentPath);
+    }
+    const { component, metaTitle } = processComponent(componentLoader, componentName, eager);
+    const routeItem = {
+      path: path2,
+      name: componentName,
+      meta: {
+        title: metaTitle
+      },
+      component
+    };
+    if (parentRoute) {
+      if (!parentRoute.children) {
+        parentRoute.children = [];
+      }
+      parentRoute.children.push(routeItem);
+    } else {
+      modules22.push(routeItem);
+    }
+    return modules22;
+  }, modules2).map(cleanRoute).filter((route) => {
+    return !(route.children && Array.isArray(route.children) && route.children.length === 0);
+  });
+}
+function findDefaultRouteHandle(routes) {
+  var _a, _b, _c;
+  if (!routes || routes.length === 0) {
+    return "";
+  }
+  for (const route of routes) {
+    if ((_a = route.meta) == null ? void 0 : _a.default) {
+      return route.path || "";
+    }
+    if ((_b = route.children) == null ? void 0 : _b.length) {
+      const childPath = findDefaultRouteHandle(route.children);
+      if (childPath) {
+        return childPath;
+      }
+    }
+  }
+  return ((_c = routes[0]) == null ? void 0 : _c.path) || "";
+}
+function extractGlob(globVal) {
+  return globVal.glob || globVal;
+}
+function getEagerOption(globVal, globalEager) {
+  return globVal.eager ?? globalEager ?? false;
+}
+function generateImportCode(varName, glob, eager) {
+  if (eager) {
+    return `const ${varName} = import.meta.glob(${JSON.stringify(glob)}, { eager: true, import: 'default' });
+`;
+  }
+  return `const ${varName} = import.meta.glob(${JSON.stringify(glob)});
+`;
+}
+function createAutoRoutesPlugin({ routeConfig, virtualModuleId, dts, root, eager: globalEager }) {
+  const VIRTUAL_MODULE_ID = virtualModuleId || "virtual:auto-routes";
+  const watchGlobs = Object.values(routeConfig).flatMap((globVal) => {
+    const g = extractGlob(globVal);
+    return Array.isArray(g) ? g : [g];
+  });
+  return createVirtualPlugin(
+    {
+      name: "vite-plugin-auto-routes",
+      virtualModuleId: VIRTUAL_MODULE_ID,
+      dts,
+      root,
+      watch: watchGlobs,
+      enforce: "pre",
+      // 生成虚拟模块代码：仅负责产出字符串，监听/HMR/缓存由工厂统一处理
+      generateModule: () => {
+        const imports = [];
+        const routes = [];
+        Object.entries(routeConfig).forEach(([prefix, globVal], index2) => {
+          const varName = `files${index2}`;
+          const glob = extractGlob(globVal);
+          const eager = getEagerOption(globVal, globalEager);
+          const baseRoute = globVal.baseRoute;
+          const baseRouteParam = baseRoute !== void 0 ? JSON.stringify(baseRoute) : "undefined";
+          imports.push(generateImportCode(varName, glob, eager));
+          routes.push(`...generateRoutes(${varName}, '${prefix}',${baseRouteParam}, ${eager})`);
+        });
+        const routesCode = routes.length > 0 ? `[${routes.join(",\n")}]` : "[]";
+        return `
+          ${imports.join("\n")}
+          ${findParentRouteHandle}
+          ${parseModulePath}
+          ${processComponent}
+          ${cleanRoute}
+          ${findDefaultRouteHandle}
+
+          const findParentRoute = ${findParentRouteHandle}
+          // 用于routes
+          const generateRoutes = ${generateRoutes};
+          // 用于导出
+          const findDefaultRoute = ${findDefaultRouteHandle};
+
+          const routes = ${routesCode}.flat().filter(Boolean);
+
+          export { routes, findDefaultRoute };
+          export default routes;
+        `;
+      },
+      // 生成类型声明文件
+      generateDts: () => `// 此文件由ViteConfig自动生成，请勿手动修改
+declare module 'virtual:auto-routes' {
+  interface RouteModule {
+    path: string
+    name: string
+    meta?: any
+    component: () => Promise<any>
+    children?: RouteModule[]
+  }
+
+  const routes: RouteModule[]
+  const findDefaultRoute: (routes: any[]) => string
+  export { findDefaultRoute, routes }
+  export default routes
+}`
+    }
+  );
+}
+const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: createAutoRoutesPlugin
+}, Symbol.toStringTag, { value: "Module" }));
+exports.ViteConfig = createViteConfig;
+exports.default = createViteConfig;
+exports.getViteConfig = getViteConfig;
+exports.wrapperEnv = wrapperEnv;