@moluoxixi/vite-config 0.0.25-beta.1

package/README.md

@@ -0,0 +1,32 @@
+# ViteConfig
+
+一行集成稳定的 Vite 配置：内置 Vue 生态、自动引入、自动路由、微前端、构建优化与 CDN 等能力，并提供清晰开关。
+
+## 快速开始
+
+```ts
+// vite.config.ts
+import viteConfig, { wrapperEnv } from '@moluoxixi/viteconfig'
+import path from 'node:path'
+import { loadEnv } from 'vite'
+
+export default viteConfig(({ mode }) => {
+  const env = loadEnv(mode!, process.cwd())
+  const viteEnv = wrapperEnv(env)
+  return {
+    rootPath: path.resolve(),
+    mode: {
+      base: { VITE_GLOB_APP_TITLE: viteEnv.VITE_GLOB_APP_TITLE, VITE_GLOB_APP_CODE: viteEnv.VITE_GLOB_APP_CODE, VITE_AUTO_ROUTES: true },
+      development: { VITE_DEVTOOLS: true },
+      production: {},
+    },
+    viteConfig: {},
+    autoRoutes: { routeConfig: {} },
+  }
+})
+```
+
+## API 概览
+
+- `createViteConfig(Config: ViteConfigType): UserConfigExport`
+- 配置项主要包含：`rootPath`、`mode`、`viteConfig`、`autoRoutes`、`unpluginAutoImportOptions`、`unpluginVueComponentsOptions`、`CDNImportOptions`

package/es/index.d.ts

@@ -0,0 +1,4 @@
+import { createViteConfig, getViteConfig } from './src/index.ts';
+export default createViteConfig;
+export { wrapperEnv } from './src/_utils/index.ts';
+export { getViteConfig, createViteConfig as ViteConfig };

package/es/index.mjs

@@ -0,0 +1,996 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import "vue";
+import fs from "node:fs";
+import path from "node:path";
+import process$1 from "node:process";
+import "dotenv";
+import tailwindcss from "@tailwindcss/postcss";
+import autoprefixer from "autoprefixer";
+import { defineConfig, mergeConfig, normalizePath } from "vite";
+import { createHtmlPlugin } from "vite-plugin-html";
+import { debounce } from "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 module = await modulePromise;
+  if (exportName === "default") {
+    return module.default ?? module;
+  }
+  if (!(exportName in module)) {
+    throw new Error(`模块中不存在导出 "${exportName}"`);
+  }
+  return module[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 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;
+  if (!configResult || !configResult.rootPath) {
+    throw new Error("rootPath is required in ViteConfig");
+  }
+  const config = configResult;
+  const { mode = "base" } = params || {};
+  const rootPath = config.rootPath;
+  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 = config.vue ?? true,
+    react = config.react,
+    vitepress = config.vitepress
+  } = viteEnv;
+  const appTitle = config.appTitle;
+  const appCode = config.appCode;
+  const isOnlyVue = !vitepress && !react && vue;
+  const isVueOrVitepress = vue || vitepress;
+  const envSystemCode = isDev && !qiankunDevMode ? "el" : namespace ?? appCode;
+  const plugins = [
+    createHtmlPlugin({
+      inject: {
+        data: {
+          title: appTitle
+        }
+      }
+    })
+  ];
+  if (isOnlyVue) {
+    const pluginVue = await dynamicImport(import("@vitejs/plugin-vue"));
+    plugins.push(pluginVue());
+  }
+  if (isVueOrVitepress) {
+    const vueJsx = await dynamicImport(import("@vitejs/plugin-vue-jsx"));
+    plugins.push(vueJsx());
+  }
+  if (pageRoutes) {
+    const Pages = await dynamicImport(import("vite-plugin-pages"));
+    plugins.push(Pages(
+      deepMerge(
+        {
+          dirs: "src/pages",
+          extensions: [isOnlyVue && "vue"].filter(Boolean),
+          exclude: [
+            "**/components/**",
+            "**/__tests__/**"
+          ]
+        },
+        pageRoutes
+      )
+    ));
+  }
+  if (isDev && devtools) {
+    const vueDevTools = await dynamicImport(import("vite-plugin-vue-devtools"));
+    plugins.push(vueDevTools());
+  }
+  if (autoImport) {
+    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: isVueOrVitepress ? [ElementPlusResolver()] : [],
+          dts: path.resolve(rootPath, "./typings/auto-imports.d.ts")
+        },
+        autoImport
+      )
+    ));
+  }
+  if (autoComponent) {
+    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: isVueOrVitepress ? [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 || "Vue 应用",
+            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) {
+    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";
+              }
+              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 mergeConfig(defaultConfig, viteConfig || {});
+}
+function createViteConfig(Config) {
+  return 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) => 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);
+    __publicField(this, "hmrDebouncedInvalidate");
+    __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 = 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 = 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 = 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 {
+    resolveId(...args) {
+      const [id] = args;
+      if (id === VIRTUAL_MODULE_ID || id.startsWith(`${VIRTUAL_MODULE_ID}/`))
+        return id;
+      return callUserHook(resolveId, this, ...args);
+    },
+    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);
+    },
+    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);
+    },
+    handleHotUpdate(...args) {
+      const [ctx] = args;
+      const { server } = ctx;
+      const rootDir = root || (resolvedViteConfig == null ? void 0 : resolvedViteConfig.root) || server.config.root;
+      const abs = 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 = debounce(
+          () => {
+            if (state.isServerClosing)
+              return;
+            performInvalidate(server);
+          },
+          debounceMs,
+          { trailing: true, leading: false }
+        );
+      }
+      state.hmrDebouncedInvalidate();
+      return callUserHook(handleHotUpdate, this, ...args) || [];
+    },
+    watchChange(...args) {
+      try {
+        const [id] = args;
+        const rootDir = root || (resolvedViteConfig == null ? void 0 : resolvedViteConfig.root) || process$1.cwd();
+        const absId = 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 = 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 {
+      }
+    },
+    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);
+    },
+    ...restHooks
+  };
+}
+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 generateRoutes(files, prefix = "", baseRoute, eager = false) {
+  const newBaseRoute = typeof baseRoute === "string" ? { name: baseRoute } : baseRoute;
+  const modules2 = newBaseRoute ? [newBaseRoute] : [];
+  return Object.keys(files).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 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("/")}`;
+    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);
+    }
+    let component;
+    let metaTitle = componentName;
+    if (eager) {
+      component = componentLoader;
+      metaTitle = (component == null ? void 0 : component.name) || componentName;
+    } else {
+      component = typeof componentLoader === "function" ? componentLoader : componentLoader;
+      metaTitle = componentName;
+    }
+    if (parentRoute) {
+      if (!parentRoute.children)
+        parentRoute.children = [];
+      parentRoute.children.push({
+        path: path2,
+        name: componentName,
+        meta: {
+          title: metaTitle
+        },
+        component
+      });
+    } else {
+      modules22.push({
+        path: path2,
+        name: componentName,
+        meta: {
+          title: metaTitle
+        },
+        component
+      });
+    }
+    return modules22;
+  }, modules2);
+}
+function findDefaultRouteHandle(routes) {
+  var _a, _b, _c;
+  for (const route of routes) {
+    if ((_a = route.meta) == null ? void 0 : _a.default) {
+      return route.path;
+    } else {
+      if ((_b = route.children) == null ? void 0 : _b.length) {
+        return findDefaultRouteHandle(route.children);
+      }
+    }
+  }
+  return (_c = routes == null ? void 0 : routes[0]) == null ? void 0 : _c.path;
+}
+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 = globVal.glob || globVal;
+    return Array.isArray(g) ? g : [g];
+  });
+  return createVirtualPlugin(
+    {
+      name: "vite-plugin-auto-routes",
+      virtualModuleId: VIRTUAL_MODULE_ID,
+      dts,
+      root,
+      watch: watchGlobs,
+      enforce: "pre",
+      generateModule: () => {
+        const imports = [];
+        const routes = [];
+        Object.entries(routeConfig).forEach(([prefix, globVal], index2) => {
+          const varName = `files${index2}`;
+          const glob = globVal.glob || globVal;
+          const eager = globVal.eager ?? globalEager ?? false;
+          if (eager) {
+            imports.push(
+              `const ${varName} = import.meta.glob(${JSON.stringify(glob)}, { eager: true, import: 'default' });
+`
+            );
+          } else {
+            imports.push(
+              `const ${varName} = import.meta.glob(${JSON.stringify(glob)});
+`
+            );
+          }
+          const baseRoute = globVal.baseRoute;
+          routes.push(`...generateRoutes(${varName}, '${prefix}',${JSON.stringify(baseRoute)}, ${eager})`);
+        });
+        return `
+          ${imports.join("\n")}
+          const findParentRoute = ${findParentRouteHandle}
+
+          const generateRoutes = ${generateRoutes};
+
+          const findDefaultRoute = ${findDefaultRouteHandle};
+
+          ${findParentRouteHandle}
+          ${findDefaultRouteHandle}
+          const routes = [${routes.join(",\n")}];
+
+          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" }));
+export {
+  createViteConfig as ViteConfig,
+  createViteConfig as default,
+  getViteConfig,
+  wrapperEnv
+};

package/es/src/_types/index.d.ts

@@ -0,0 +1,89 @@
+import { visualizer } from 'rollup-plugin-visualizer';
+import { Options as unpluginAutoImportOptions } from 'unplugin-auto-import/types';
+import { Options as unpluginVueComponentsOptions } from 'unplugin-vue-components/types';
+import { ConfigEnv, PluginOption, UserConfig } from 'vite';
+import { default as importToCDN } from 'vite-plugin-cdn-import';
+import { UserOptions as PagesOptions } from 'vite-plugin-pages';
+import { Options as VitePWAOptions } from 'vite-plugin-pwa';
+type ViteCompressionModule = typeof import('vite-plugin-compression');
+type ViteImageminModule = typeof import('vite-plugin-imagemin');
+export type CompressionOptions = ViteCompressionModule extends {
+    default: infer F;
+} ? F extends (...args: any[]) => any ? Parameters<F>[0] : never : never;
+export type ImageminOptions = ViteImageminModule extends {
+    default: infer F;
+} ? F extends (...args: any[]) => any ? Parameters<F>[0] : never : never;
+export type CompressionPlugin = (options?: CompressionOptions) => PluginOption;
+export type ImageminPlugin = (options?: ImageminOptions) => PluginOption;
+export type QiankunPlugin = (name: string, options?: {
+    useDevMode?: boolean;
+}) => PluginOption;
+export type CDNOptions = Parameters<typeof importToCDN>[0] & {
+    baseUrl?: string;
+    enableInDevMode?: boolean;
+};
+export type VisualizerOptions = Parameters<typeof visualizer>[0];
+export interface PluginConfig {
+    autoImport?: boolean | unpluginAutoImportOptions;
+    autoComponent?: boolean | (unpluginVueComponentsOptions & {
+        elementExcludes?: string[];
+        globs?: string[];
+    });
+    compression?: boolean | CompressionOptions;
+    imagemin?: boolean | ImageminOptions;
+    cdn?: boolean | CDNOptions;
+    visualizer?: boolean | VisualizerOptions;
+    autoRoutes?: boolean | AutoRoutesConfig;
+    pageRoutes?: boolean | PagesOptions;
+    devtools?: boolean;
+    port?: number;
+    open?: boolean;
+    qiankunDevMode?: boolean;
+    qiankun?: boolean;
+    namespace?: string;
+    dropConsole?: boolean;
+    pwa?: boolean | VitePWAOptions;
+    codeInspector?: boolean | Parameters<typeof import('code-inspector-plugin').codeInspectorPlugin>[0];
+    vitepress?: boolean;
+    vue?: boolean;
+    react?: boolean;
+    appTitle?: string;
+    appCode?: string;
+}
+export interface ModeConfig extends PluginConfig {
+}
+export interface objRouteConfig {
+    glob: string | string[];
+    baseRoute?: {
+        path: string;
+        name: string;
+        meta?: any;
+        children?: any[];
+    } | string;
+}
+export interface RouteConfig {
+    [prefix: string]: string | string[] | objRouteConfig;
+}
+export interface AutoRoutesConfig {
+    routeConfig: RouteConfig;
+    virtualModuleId?: string;
+    dts?: string | boolean;
+    root?: string;
+}
+export interface Config extends PluginConfig {
+    rootPath: string;
+    mode?: {
+        base?: ModeConfig;
+        development?: ModeConfig;
+        production?: ModeConfig;
+    };
+    viteConfig?: UserConfig | ((mode: ConfigEnv) => UserConfig);
+}
+export type ViteConfigType = Config | ((mode: ConfigEnv) => Config);
+export type PluginType = PluginOption & {
+    name: string;
+};
+export interface PluginMap {
+    [key: string]: PluginOption;
+}
+export {};

package/es/src/_utils/getEnv.d.ts

@@ -0,0 +1,7 @@
+import { objType } from '../../../_types/index.ts';
+export declare function isDevFn(mode: string): boolean;
+export declare function isProdFn(mode: string): boolean;
+export declare function isReportMode(): boolean;
+export declare function wrapperEnv(env: Record<string, string>): objType;
+export declare function getEnvConfig(match?: string, confFiles?: string[]): {};
+export declare function getRootPath(...dir: string[]): string;

package/es/src/_utils/index.d.ts

@@ -0,0 +1 @@
+export * from './getEnv.ts';

package/es/src/constants/index.d.ts

@@ -0,0 +1 @@
+export declare const modules: any;

package/es/src/index.d.ts

@@ -0,0 +1,6 @@
+import { ConfigEnv } from 'vite';
+import { ViteConfigType } from './_types/index.ts';
+declare function getViteConfig(Config: ViteConfigType, params?: ConfigEnv): Promise<Record<string, any>>;
+declare function createViteConfig(Config: ViteConfigType): import('vite').UserConfigFnPromise;
+export { createViteConfig, getViteConfig, };
+export default createViteConfig;

package/es/src/plugins/addScopedAndReplacePrefix.d.ts

@@ -0,0 +1,10 @@
+export default function addScopedAndReplacePrefixPlugin({ prefixScoped, oldPrefix, newPrefix, useDevMode, }: {
+    prefixScoped?: string | undefined;
+    oldPrefix?: string | undefined;
+    newPrefix?: string | undefined;
+    useDevMode?: boolean | undefined;
+}): {
+    name: string;
+    configResolved(config: any): void;
+    transform(code?: string, id?: string): string;
+};

package/es/src/plugins/vitePluginQiankunStyle.d.ts

@@ -0,0 +1,10 @@
+import { Plugin } from 'vite';
+export interface QiankunCssInjectOptions {
+    target?: string;
+    include?: string | string[];
+    exclude?: string | string[];
+    cssInclude?: string | string[];
+    cssExclude?: string | string[];
+    appId?: string;
+}
+export default function qiankunCssInject(options?: QiankunCssInjectOptions): Plugin | false;

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@moluoxixi/vite-config",
+  "version": "0.0.25-beta.1",
+  "description": "ViteConfig 组件",
+  "sideEffects": [
+    "*.css",
+    "*.scss"
+  ],
+  "peerDependencies": {
+    "vite": "6.2.4",
+    "vue": "3.5.19"
+  },
+  "dependencies": {
+    "dotenv": "16.6.1",
+    "@tailwindcss/postcss": "4.1.5",
+    "@vitejs/plugin-vue": "5.2.4",
+    "@vitejs/plugin-vue-jsx": "4.2.0",
+    "autoprefixer": "10.4.21",
+    "code-inspector-plugin": "1.2.10",
+    "rollup-plugin-visualizer": "5.14.0",
+    "unplugin-auto-import": "19.3.0",
+    "unplugin-vue-components": "28.8.0",
+    "vite-plugin-cdn-import": "1.0.1",
+    "vite-plugin-compression": "0.5.1",
+    "vite-plugin-html": "3.2.2",
+    "vite-plugin-imagemin": "0.6.1",
+    "vite-plugin-pages": "0.33.1",
+    "vite-plugin-pwa": "1.1.0",
+    "vite-plugin-qiankun": "1.0.15",
+    "vite-plugin-vue-devtools": "7.7.7",
+    "lodash-es": "4.17.21",
+    "postcss": "8.5.6",
+    "postcss-selector-parser": "7.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "module": "es/index.mjs",
+  "types": "es/index.d.ts",
+  "exports": {
+    "./es": {
+      "import": {
+        "types": "./es/index.d.ts",
+        "default": "./es/index.mjs"
+      }
+    },
+    ".": {
+      "import": {
+        "types": "./es/index.d.ts",
+        "default": "./es/index.mjs"
+      }
+    }
+  }
+}