@moluoxixi/vite-config 0.0.33 → 0.0.35

package/README.md

@@ -6,7 +6,7 @@
 
 ```ts
 // vite.config.ts
-import viteConfig, { wrapperEnv } from '@moluoxixi/viteconfig'
+import viteConfig, { wrapperEnv } from '@moluoxixi/vite-config'
 import path from 'node:path'
 import { loadEnv } from 'vite'
 

package/es/AutoRoutesPlugin/index.mjs

@@ -0,0 +1,86 @@
+import { createVirtualPlugin } from "../_utils/virtual.mjs";
+import { findParentRouteHandle, parseModulePath, processComponent, cleanRoute, findDefaultRouteHandle, generateRoutes } from "./routeGenerator.mjs";
+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], index) => {
+          const varName = `files${index}`;
+          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
+}`
+    }
+  );
+}
+export {
+  createAutoRoutesPlugin as default
+};

package/es/AutoRoutesPlugin/routeGenerator.mjs

@@ -0,0 +1,123 @@
+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(modules, parentPath) {
+  for (const route of modules) {
+    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 path = `/${pathArr.join("/")}`;
+  const parentPath = `/${pathArr.slice(0, -1).join("/")}`;
+  return { pathArr, componentName, path, 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 modules = 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((modules2 = [], modulePath) => {
+    const componentLoader = files[modulePath];
+    if (!componentLoader || modulePath === "install") {
+      return modules2;
+    }
+    const { path, parentPath, componentName } = parseModulePath(modulePath);
+    if (!componentName) {
+      return modules2;
+    }
+    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(modules2, parentPath);
+    }
+    const { component, metaTitle } = processComponent(componentLoader, componentName, eager);
+    const routeItem = {
+      path,
+      name: componentName,
+      meta: {
+        title: metaTitle
+      },
+      component
+    };
+    if (parentRoute) {
+      if (!parentRoute.children) {
+        parentRoute.children = [];
+      }
+      parentRoute.children.push(routeItem);
+    } else {
+      modules2.push(routeItem);
+    }
+    return modules2;
+  }, modules).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) || "";
+}
+export {
+  cleanRoute,
+  findDefaultRouteHandle,
+  findParentRouteHandle,
+  generateRoutes,
+  parseModulePath,
+  processComponent
+};

package/es/_utils/base.mjs

@@ -0,0 +1,8 @@
+function getType(obj, type) {
+  {
+    return Object.prototype.toString.call(obj).slice(8, -1).toLowerCase() === type.toLowerCase();
+  }
+}
+export {
+  getType
+};

package/es/_utils/dynamicImport.mjs

@@ -0,0 +1,13 @@
+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];
+}
+export {
+  dynamicImport
+};

package/es/_utils/object.mjs

@@ -0,0 +1,56 @@
+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;
+}
+export {
+  deepMerge,
+  validateMutuallyExclusive
+};

package/es/_utils/virtual.mjs

@@ -0,0 +1,389 @@
+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 { getType } from "./base.mjs";
+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.exit(0);
+          } catch {
+          }
+        });
+      };
+      Process.once("SIGINT", handleSignal);
+      Process.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.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
+  };
+}
+export {
+  createMatcher,
+  createVirtualPlugin,
+  extractStaticPrefixFromGlob,
+  resolvePatternsToAbsolute
+};

package/es/index.d.ts

@@ -1,4 +1,6 @@
+import { AutoRoutesConfig, CDNOptions, CompressionPlugin, ImageminPlugin, PluginConfig, PluginType, QiankunPlugin, VisualizerOptions, ViteConfigType } from './src/_types';
 import { createViteConfig, getViteConfig } from './src/index.ts';
 export default createViteConfig;
 export { wrapperEnv } from './src/_utils/index.ts';
 export { getViteConfig, createViteConfig as ViteConfig };
+export type { AutoRoutesConfig, CDNOptions, CompressionPlugin, ImageminPlugin, PluginConfig, PluginType, QiankunPlugin, VisualizerOptions, ViteConfigType };