rspack-plugin-mock 0.2.0 → 0.3.0

package/dist/{chunk-2S4KCTKW.cjs → chunk-I54ZNZWL.cjs}

@@ -6,6 +6,9 @@ var _url = require('url');
 var _os = require('os'); var _os2 = _interopRequireDefault(_os);
 var _debug = require('debug'); var _debug2 = _interopRequireDefault(_debug);
 var _pathtoregexp = require('path-to-regexp');
+var _memfs = require('memfs');
+var packageDir = getDirname(import.meta.url);
+var vfs = _memfs.createFsFromVolume.call(void 0, new (0, _memfs.Volume)());
 function isStream(stream) {
   return stream !== null && typeof stream === "object" && typeof stream.pipe === "function";
 }
@@ -91,10 +94,6 @@ function rewriteRequest(proxyReq, req) {
   }
 }
 
-// src/core/mockMiddleware.ts
-var _cors = require('cors'); var _cors2 = _interopRequireDefault(_cors);
-
-
 // src/core/baseMiddleware.ts
 
 
@@ -238,7 +237,7 @@ function matchingWeight(rules, url, priority) {
   const options = special[specialRule];
   const { rules: lowerRules, when } = _utils.isArray.call(void 0, options) ? { rules: options, when: [] } : options;
   if (lowerRules.includes(matched[0])) {
-    if (when.length === 0 || when.some((path5) => _pathtoregexp.pathToRegexp.call(void 0, path5).test(url))) {
+    if (when.length === 0 || when.some((path6) => _pathtoregexp.pathToRegexp.call(void 0, path6).test(url))) {
       matched = _utils.uniq.call(void 0, [specialRule, ...matched]);
     }
   }
@@ -602,6 +601,8 @@ function requestLog(request, filepath) {
 }
 
 // src/core/mockMiddleware.ts
+var _cors = require('cors'); var _cors2 = _interopRequireDefault(_cors);
+
 function createMockMiddleware(compiler, options) {
   function mockMiddleware(middlewares, reload) {
     middlewares.unshift(baseMiddleware(compiler, options));
@@ -643,10 +644,6 @@ function createCorsMiddleware(compiler, options) {
   };
 }
 
-// src/core/resolvePluginOptions.ts
-var _process = require('process'); var _process2 = _interopRequireDefault(_process);
-
-
 // src/core/logger.ts
 
 
@@ -689,6 +686,8 @@ function createLogger(prefix, defaultLevel = "info") {
 }
 
 // src/core/resolvePluginOptions.ts
+var _process = require('process'); var _process2 = _interopRequireDefault(_process);
+
 function resolvePluginOptions({
   prefix = [],
   wsPrefix = [],
@@ -740,44 +739,6 @@ function resolvePluginOptions({
   };
 }
 
-// src/core/mockCompiler.ts
-var _events = require('events'); var _events2 = _interopRequireDefault(_events);
-
-
-
-var _fastglob = require('fast-glob'); var _fastglob2 = _interopRequireDefault(_fastglob);
-var _chokidar = require('chokidar'); var _chokidar2 = _interopRequireDefault(_chokidar);
-var _pluginutils = require('@rollup/pluginutils');
-var _core = require('@rspack/core'); var rspackCore = _interopRequireWildcard(_core);
-var _memfs = require('memfs');
-
-
-
-// src/core/loadFromCode.ts
-
-
-async function loadFromCode({
-  filepath,
-  code,
-  isESM,
-  cwd
-}) {
-  filepath = _path2.default.resolve(cwd, filepath);
-  const fileBase = `${filepath}.timestamp-${Date.now()}`;
-  const ext = isESM ? ".mjs" : ".cjs";
-  const fileNameTmp = `${fileBase}${ext}`;
-  await _fs.promises.writeFile(fileNameTmp, code, "utf8");
-  try {
-    const result = await Promise.resolve().then(() => _interopRequireWildcard(require(fileNameTmp)));
-    return result.default || result;
-  } finally {
-    try {
-      _fs2.default.unlinkSync(fileNameTmp);
-    } catch (e2) {
-    }
-  }
-}
-
 // src/core/transform.ts
 
 
@@ -865,14 +826,84 @@ function keysCount(obj) {
   return Object.keys(obj).length;
 }
 
-// src/core/resolveRspackOptions.ts
+// src/core/build.ts
+
+var _promises = require('fs/promises'); var _promises2 = _interopRequireDefault(_promises);
+
+
+var _fastglob = require('fast-glob'); var _fastglob2 = _interopRequireDefault(_fastglob);
+var _pluginutils = require('@rollup/pluginutils');
+
+
+
+// src/core/createRspackCompiler.ts
 
-var _dirname = getDirname(import.meta.url);
+var _core = require('@rspack/core'); var rspackCore = _interopRequireWildcard(_core);
+
+var _iscoremodule = require('is-core-module'); var _iscoremodule2 = _interopRequireDefault(_iscoremodule);
+function createCompiler(options, callback) {
+  const rspackOptions = resolveRspackOptions(options);
+  const isWatch = rspackOptions.watch === true;
+  async function handler(err, stats) {
+    const name = "[rspack:mock]";
+    const logError = _optionalChain([stats, 'optionalAccess', _10 => _10.compilation, 'access', _11 => _11.getLogger, 'call', _12 => _12(name), 'access', _13 => _13.error]) || ((...args) => console.error(_picocolors2.default.red(name), ...args));
+    if (err) {
+      logError(err.stack || err);
+      if ("details" in err) {
+        logError(err.details);
+      }
+      return;
+    }
+    if (_optionalChain([stats, 'optionalAccess', _14 => _14.hasErrors, 'call', _15 => _15()])) {
+      const info = stats.toJson();
+      logError(info.errors);
+    }
+    const code = vfs.readFileSync("/output.js", "utf-8");
+    const externals = [];
+    if (!isWatch) {
+      const modules = _optionalChain([stats, 'optionalAccess', _16 => _16.toJson, 'call', _17 => _17(), 'access', _18 => _18.modules]) || [];
+      const aliasList = Object.keys(options.alias || {}).map((key) => key.replace(/\$$/g, ""));
+      for (const { name: name2 } of modules) {
+        if (_optionalChain([name2, 'optionalAccess', _19 => _19.startsWith, 'call', _20 => _20("external")])) {
+          const packageName = normalizePackageName(name2);
+          if (!_iscoremodule2.default.call(void 0, packageName) && !aliasList.includes(packageName))
+            externals.push(normalizePackageName(name2));
+        }
+      }
+    }
+    await callback({ code, externals });
+  }
+  const compiler = rspackCore.rspack(rspackOptions, isWatch ? handler : void 0);
+  if (compiler)
+    compiler.outputFileSystem = vfs;
+  if (!isWatch) {
+    _optionalChain([compiler, 'optionalAccess', _21 => _21.run, 'call', _22 => _22(async (...args) => {
+      await handler(...args);
+      compiler.close(() => {
+      });
+    })]);
+  }
+  return compiler;
+}
+function transformWithRspack(options) {
+  return new Promise((resolve) => {
+    createCompiler({ ...options, watch: false }, (result) => {
+      resolve(result);
+    });
+  });
+}
+function normalizePackageName(name) {
+  const filepath = name.replace("external ", "").slice(1, -1);
+  const [scope, packageName] = filepath.split("/");
+  if (filepath[0] === "@") {
+    return `${scope}/${packageName}`;
+  }
+  return scope;
+}
 function resolveRspackOptions({
   cwd,
-  isEsm,
+  isEsm = true,
   entryFile,
-  outputFile,
   plugins,
   alias,
   watch = false
@@ -893,15 +924,16 @@ function resolveRspackOptions({
     plugins,
     output: {
       library: { type: !isEsm ? "commonjs2" : "module" },
-      filename: outputFile,
+      filename: "output.js",
       path: "/"
     },
     experiments: { outputModule: isEsm },
+    optimization: { minimize: !watch },
     module: {
       rules: [
         {
           test: /\.json5?$/,
-          loader: _path2.default.join(_dirname, "json5-loader.cjs"),
+          loader: _path2.default.join(packageDir, "json5-loader.cjs"),
           type: "javascript/auto"
         },
         {
@@ -933,8 +965,188 @@ function resolveRspackOptions({
   };
 }
 
+// src/core/build.ts
+async function buildMockServer(options, outputDir) {
+  const entryFile = _path2.default.resolve(_process2.default.cwd(), "node_modules/.cache/mock-server/mock-server.ts");
+  const mockFileList = await getMockFileList(options);
+  await writeMockEntryFile(entryFile, mockFileList, options.cwd);
+  const { code, externals } = await transformWithRspack({
+    entryFile,
+    cwd: options.cwd,
+    plugins: options.plugins,
+    alias: options.alias
+  });
+  await _promises2.default.unlink(entryFile);
+  const outputList = [
+    { filename: "mock-data.js", source: code },
+    { filename: "index.js", source: generatorServerEntryCode(options) },
+    { filename: "package.json", source: generatePackageJson(options, externals) }
+  ];
+  const dist = _path2.default.resolve(outputDir, options.build.dist);
+  options.logger.info(
+    `${_picocolors2.default.green("\u2713")} generate mock server in ${_picocolors2.default.cyan(_path2.default.relative(_process2.default.cwd(), dist))}`
+  );
+  if (!_fs2.default.existsSync(dist)) {
+    await _promises2.default.mkdir(dist, { recursive: true });
+  }
+  for (const { filename, source } of outputList) {
+    await _promises2.default.writeFile(_path2.default.join(dist, filename), source, "utf8");
+    const sourceSize = (source.length / 1024).toFixed(2);
+    const space = filename.length < 24 ? " ".repeat(24 - filename.length) : "";
+    options.logger.info(` ${_picocolors2.default.green(filename)}${space}${_picocolors2.default.bold(_picocolors2.default.dim(`${sourceSize} kB`))}`);
+  }
+}
+function generatePackageJson(options, externals) {
+  const deps = getHostDependencies(options.cwd);
+  const { name, version } = getPluginPackageInfo();
+  const mockPkg = {
+    name: "mock-server",
+    type: "module",
+    scripts: {
+      start: "node index.js"
+    },
+    dependencies: {
+      connect: "^3.7.0",
+      [name]: `^${version}`,
+      cors: "^2.8.5"
+    }
+  };
+  externals.forEach((dep) => {
+    mockPkg.dependencies[dep] = deps[dep] || "latest";
+  });
+  return JSON.stringify(mockPkg, null, 2);
+}
+function generatorServerEntryCode({
+  proxies,
+  wsPrefix,
+  cookiesOptions,
+  bodyParserOptions,
+  priority,
+  build
+}) {
+  const { serverPort, log } = build;
+  return `import { createServer } from 'node:http';
+import connect from 'connect';
+import corsMiddleware from 'cors';
+import { 
+  baseMiddleware,
+  createLogger,
+  mockWebSocket,
+  transformMockData,
+  transformRawData
+} from 'rspack-plugin-mock';
+import rawData from './mock-data.js';
+
+const app = connect();
+const server = createServer(app);
+const logger = createLogger('mock-server', '${log}');
+const proxies = ${JSON.stringify(proxies)};
+const wsProxies = ${JSON.stringify(_utils.toArray.call(void 0, wsPrefix))};
+const cookiesOptions = ${JSON.stringify(cookiesOptions)};
+const bodyParserOptions = ${JSON.stringify(bodyParserOptions)};
+const priority = ${JSON.stringify(priority)};
+const data = { mockData: transformMockData(transformRawData(rawData)) };
+
+mockWebSocket(data, server, { wsProxies, cookiesOptions, logger });
+
+app.use(corsMiddleware());
+app.use(baseMiddleware(data, {
+  formidableOptions: { multiples: true },
+  proxies,
+  priority,
+  cookiesOptions,
+  bodyParserOptions,
+  logger,
+}));
+
+server.listen(${serverPort});
+
+console.log('listen: http://localhost:${serverPort}');
+`;
+}
+async function getMockFileList({ cwd, include, exclude }) {
+  const filter = _pluginutils.createFilter.call(void 0, include, exclude, { resolve: false });
+  return await _fastglob2.default.call(void 0, include, { cwd }).then((files) => files.filter(filter));
+}
+async function writeMockEntryFile(entryFile, files, cwd) {
+  const importers = [];
+  const exporters = [];
+  for (const [index, filepath] of files.entries()) {
+    const file = normalizePath(_path2.default.join(cwd, filepath));
+    importers.push(`import * as m${index} from '${file}'`);
+    exporters.push(`[m${index}, '${filepath}']`);
+  }
+  const code = `${importers.join("\n")}
+
+export default [
+  ${exporters.join(",\n  ")}
+]`;
+  const dirname = _path2.default.dirname(entryFile);
+  if (!_fs2.default.existsSync(dirname)) {
+    await _promises2.default.mkdir(dirname, { recursive: true });
+  }
+  await _promises2.default.writeFile(entryFile, code, "utf8");
+}
+function getPluginPackageInfo() {
+  let pkg = {};
+  try {
+    const filepath = _path2.default.join(packageDir, "../package.json");
+    if (_fs2.default.existsSync(filepath)) {
+      pkg = JSON.parse(_fs2.default.readFileSync(filepath, "utf8"));
+    }
+  } catch (e2) {
+  }
+  return {
+    name: pkg.name || "rspack-plugin-mock",
+    version: pkg.version || "latest"
+  };
+}
+function getHostDependencies(context) {
+  let pkg = {};
+  try {
+    const content = lookupFile(context, ["package.json"]);
+    if (content)
+      pkg = JSON.parse(content);
+  } catch (e3) {
+  }
+  return { ...pkg.dependencies, ...pkg.devDependencies };
+}
+
+// src/core/mockCompiler.ts
+var _events = require('events'); var _events2 = _interopRequireDefault(_events);
+
+
+
+var _chokidar = require('chokidar'); var _chokidar2 = _interopRequireDefault(_chokidar);
+
+
+
+// src/core/loadFromCode.ts
+
+
+async function loadFromCode({
+  filepath,
+  code,
+  isESM,
+  cwd
+}) {
+  filepath = _path2.default.resolve(cwd, filepath);
+  const fileBase = `${filepath}.timestamp-${Date.now()}`;
+  const ext = isESM ? ".mjs" : ".cjs";
+  const fileNameTmp = `${fileBase}${ext}`;
+  await _fs.promises.writeFile(fileNameTmp, code, "utf8");
+  try {
+    const result = await Promise.resolve().then(() => _interopRequireWildcard(require(fileNameTmp)));
+    return result.default || result;
+  } finally {
+    try {
+      _fs2.default.unlinkSync(fileNameTmp);
+    } catch (e4) {
+    }
+  }
+}
+
 // src/core/mockCompiler.ts
-var vfs = _memfs.createFsFromVolume.call(void 0, new (0, _memfs.Volume)());
 function createMockCompiler(options) {
   return new MockCompiler(options);
 }
@@ -948,16 +1160,14 @@ var MockCompiler = (_class = class extends _events2.default {
     try {
       const pkg = lookupFile(this.cwd, ["package.json"]);
       this.moduleType = !!pkg && JSON.parse(pkg).type === "module" ? "esm" : "cjs";
-    } catch (e3) {
+    } catch (e5) {
     }
     this.entryFile = _path2.default.resolve(_process2.default.cwd(), "node_modules/.cache/mock-server/mock-server.ts");
-    this.outputFile = "mock.bundle.js";
   }
   
   
   __init() {this.moduleType = "cjs"}
   
-  
   __init2() {this._mockData = {}}
   
   
@@ -968,39 +1178,33 @@ var MockCompiler = (_class = class extends _events2.default {
   async run() {
     await this.updateMockEntry();
     this.watchMockFiles();
-    this.createCompiler(async (err, stats) => {
-      const name = "[rspack:mock]";
-      const logError = _optionalChain([stats, 'optionalAccess', _10 => _10.compilation, 'access', _11 => _11.getLogger, 'call', _12 => _12(name), 'access', _13 => _13.error]) || ((...args) => console.error(_picocolors2.default.red(name), ...args));
-      if (err) {
-        logError(err.stack || err);
-        if ("details" in err) {
-          logError(err.details);
-        }
-        return;
-      }
-      if (_optionalChain([stats, 'optionalAccess', _14 => _14.hasErrors, 'call', _15 => _15()])) {
-        const info = stats.toJson();
-        logError(info.errors);
-        return;
-      }
-      const content = vfs.readFileSync(`/${this.outputFile}`, "utf-8");
+    const { plugins, alias } = this.options;
+    const options = {
+      isEsm: this.moduleType === "esm",
+      cwd: this.cwd,
+      plugins,
+      entryFile: this.entryFile,
+      alias,
+      watch: true
+    };
+    this.compiler = createCompiler(options, async ({ code }) => {
       try {
         const result = await loadFromCode({
-          filepath: this.outputFile,
-          code: content,
+          filepath: "mock.bundle.js",
+          code,
           isESM: this.moduleType === "esm",
           cwd: this.cwd
         });
         this._mockData = transformMockData(transformRawData(result));
         this.emit("update", this.watchInfo || {});
       } catch (e) {
-        logError(e);
+        this.options.logger.error(e.stack || e.message);
       }
     });
   }
   close() {
     this.mockWatcher.close();
-    _optionalChain([this, 'access', _16 => _16.compiler, 'optionalAccess', _17 => _17.close, 'call', _18 => _18(() => {
+    _optionalChain([this, 'access', _23 => _23.compiler, 'optionalAccess', _24 => _24.close, 'call', _25 => _25(() => {
     })]);
     this.emit("close");
   }
@@ -1012,7 +1216,7 @@ var MockCompiler = (_class = class extends _events2.default {
   }
   async updateMockEntry() {
     const files = await this.getMockFiles();
-    await this.resolveEntryFile(files);
+    await writeMockEntryFile(this.entryFile, files, this.cwd);
   }
   async getMockFiles() {
     const { include } = this.options;
@@ -1044,40 +1248,6 @@ var MockCompiler = (_class = class extends _events2.default {
       this.updateMockEntry();
     });
   }
-  async resolveEntryFile(fileList) {
-    const importers = [];
-    const exporters = [];
-    for (const [index, filepath] of fileList.entries()) {
-      const file = normalizePath(_path2.default.join(this.cwd, filepath));
-      importers.push(`import * as m${index} from '${file}'`);
-      exporters.push(`[m${index}, '${filepath}']`);
-    }
-    const code = `${importers.join("\n")}
-
-export default [
-  ${exporters.join(",\n  ")}
-]`;
-    const dirname = _path2.default.dirname(this.entryFile);
-    if (!_fs2.default.existsSync(dirname)) {
-      await _fs.promises.mkdir(dirname, { recursive: true });
-    }
-    await _fs.promises.writeFile(this.entryFile, code, "utf8");
-  }
-  createCompiler(callback) {
-    const { plugins, alias } = this.options;
-    const options = resolveRspackOptions({
-      isEsm: this.moduleType === "esm",
-      cwd: this.cwd,
-      plugins,
-      entryFile: this.entryFile,
-      outputFile: this.outputFile,
-      alias,
-      watch: true
-    });
-    this.compiler = rspackCore.rspack(options, callback);
-    if (this.compiler)
-      this.compiler.outputFileSystem = vfs;
-  }
 }, _class);
 
 // src/core/mockWebsocket.ts
@@ -1113,7 +1283,7 @@ function mockWebSocket(compiler, httpServer, {
   };
   const setupWss = (wssMap, wss, mock, context, pathname, filepath) => {
     try {
-      _optionalChain([mock, 'access', _19 => _19.setup, 'optionalCall', _20 => _20(wss, context)]);
+      _optionalChain([mock, 'access', _26 => _26.setup, 'optionalCall', _27 => _27(wss, context)]);
       wss.on("close", () => wssMap.delete(pathname));
       wss.on("error", (e) => {
         logger.error(
@@ -1170,7 +1340,7 @@ ${e}
       }
     }
   });
-  _optionalChain([httpServer, 'optionalAccess', _21 => _21.on, 'call', _22 => _22("upgrade", (req, socket, head) => {
+  _optionalChain([httpServer, 'optionalAccess', _28 => _28.on, 'call', _29 => _29("upgrade", (req, socket, head) => {
     const { pathname, query } = urlParse(req.url);
     if (!pathname || proxies.length === 0 || !proxies.some((context) => doesProxyContextMatchUrl(context, req.url, req))) {
       return;
@@ -1218,7 +1388,7 @@ ${e}
       emitConnection(wss, ws, request, wssContext.connectionList);
     });
   })]);
-  _optionalChain([httpServer, 'optionalAccess', _23 => _23.on, 'call', _24 => _24("close", () => {
+  _optionalChain([httpServer, 'optionalAccess', _30 => _30.on, 'call', _31 => _31("close", () => {
     for (const wssMap of poolMap.values()) {
       for (const wss of wssMap.values()) {
         const wssContext = wssContextMap.get(wss);
@@ -1234,7 +1404,7 @@ ${e}
 function cleanupRunner(cleanupList) {
   let cleanup;
   while (cleanup = cleanupList.shift())
-    _optionalChain([cleanup, 'optionalCall', _25 => _25()]);
+    _optionalChain([cleanup, 'optionalCall', _32 => _32()]);
 }
 
 
@@ -1244,4 +1414,11 @@ function cleanupRunner(cleanupList) {
 
 
 
-exports.waitingFor = waitingFor; exports.rewriteRequest = rewriteRequest; exports.createMockMiddleware = createMockMiddleware; exports.resolvePluginOptions = resolvePluginOptions; exports.createMockCompiler = createMockCompiler; exports.mockWebSocket = mockWebSocket;
+
+
+
+
+
+
+
+exports.waitingFor = waitingFor; exports.rewriteRequest = rewriteRequest; exports.baseMiddleware = baseMiddleware; exports.createMockMiddleware = createMockMiddleware; exports.logLevels = logLevels; exports.createLogger = createLogger; exports.resolvePluginOptions = resolvePluginOptions; exports.transformRawData = transformRawData; exports.transformMockData = transformMockData; exports.sortByValidator = sortByValidator; exports.buildMockServer = buildMockServer; exports.createMockCompiler = createMockCompiler; exports.mockWebSocket = mockWebSocket;

package/dist/{chunk-T4AI3L6R.cjs → chunk-OYBMX3GQ.cjs}

@@ -5,10 +5,12 @@
 
 
 
-var _chunk2S4KCTKWcjs = require('./chunk-2S4KCTKW.cjs');
+
+var _chunkI54ZNZWLcjs = require('./chunk-I54ZNZWL.cjs');
 
 // src/rspack.ts
 var _process = require('process'); var _process2 = _interopRequireDefault(_process);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
 var _core = require('@rspack/core'); var _core2 = _interopRequireDefault(_core);
 var _utils = require('@pengzhanbo/utils');
 var PLUGIN_NAME = "rspack-plugin-mock";
@@ -18,13 +20,13 @@ var MockServerPlugin = class {
   }
   apply(compiler) {
     const compilerOptions = compiler.options;
+    const options = resolvePluginOptions2(compiler, this.options);
     if (_process2.default.env.NODE_ENV !== "production") {
-      const options = resolvePluginOptions2(compiler, this.options);
-      const mockCompiler = _chunk2S4KCTKWcjs.createMockCompiler.call(void 0, options);
-      const mockMiddleware = _chunk2S4KCTKWcjs.createMockMiddleware.call(void 0, mockCompiler, options);
+      const mockCompiler = _chunkI54ZNZWLcjs.createMockCompiler.call(void 0, options);
+      const mockMiddleware = _chunkI54ZNZWLcjs.createMockMiddleware.call(void 0, mockCompiler, options);
       const setupMiddlewares = _optionalChain([compilerOptions, 'access', _ => _.devServer, 'optionalAccess', _2 => _2.setupMiddlewares]);
-      const waitServer = _chunk2S4KCTKWcjs.waitingFor.call(void 0, (server) => {
-        _chunk2S4KCTKWcjs.mockWebSocket.call(void 0, mockCompiler, server, options);
+      const waitServer = _chunkI54ZNZWLcjs.waitingFor.call(void 0, (server) => {
+        _chunkI54ZNZWLcjs.mockWebSocket.call(void 0, mockCompiler, server, options);
       });
       compilerOptions.devServer = {
         ...compilerOptions.devServer,
@@ -47,7 +49,7 @@ var MockServerPlugin = class {
             const onProxyReq = item.onProxyReq;
             item.onProxyReq = (proxyReq, req, ...args) => {
               _optionalChain([onProxyReq, 'optionalCall', _8 => _8(proxyReq, req, ...args)]);
-              _chunk2S4KCTKWcjs.rewriteRequest.call(void 0, proxyReq, req);
+              _chunkI54ZNZWLcjs.rewriteRequest.call(void 0, proxyReq, req);
             };
           }
           return item;
@@ -60,6 +62,11 @@ var MockServerPlugin = class {
       }
       compiler.hooks.watchRun.tap(PLUGIN_NAME, () => mockCompiler.run());
       compiler.hooks.watchClose.tap(PLUGIN_NAME, () => mockCompiler.close());
+    } else if (options.build !== false) {
+      compiler.hooks.afterEmit.tap(PLUGIN_NAME, () => _chunkI54ZNZWLcjs.buildMockServer.call(void 0, 
+        options,
+        compilerOptions.output.path || _path2.default.resolve(_process2.default.cwd(), "dist")
+      ));
     }
   }
 };
@@ -76,7 +83,7 @@ function resolvePluginOptions2(compiler, options) {
     }
     return [];
   });
-  return _chunk2S4KCTKWcjs.resolvePluginOptions.call(void 0, options, {
+  return _chunkI54ZNZWLcjs.resolvePluginOptions.call(void 0, options, {
     alias,
     context,
     plugins: _utils.toArray.call(void 0, definePluginInstance),

package/dist/{chunk-P6DRAHHI.js → chunk-P5FOCSCE.js}

@@ -1,14 +1,16 @@
 import {
+  buildMockServer,
   createMockCompiler,
   createMockMiddleware,
   mockWebSocket,
   resolvePluginOptions,
   rewriteRequest,
   waitingFor
-} from "./chunk-UJAKORAH.js";
+} from "./chunk-YSJVV4SH.js";
 
 // src/rspack.ts
 import process from "process";
+import path from "path";
 import rspack from "@rspack/core";
 import { isString, toArray } from "@pengzhanbo/utils";
 var PLUGIN_NAME = "rspack-plugin-mock";
@@ -18,8 +20,8 @@ var MockServerPlugin = class {
   }
   apply(compiler) {
     const compilerOptions = compiler.options;
+    const options = resolvePluginOptions2(compiler, this.options);
     if (process.env.NODE_ENV !== "production") {
-      const options = resolvePluginOptions2(compiler, this.options);
       const mockCompiler = createMockCompiler(options);
       const mockMiddleware = createMockMiddleware(mockCompiler, options);
       const setupMiddlewares = compilerOptions.devServer?.setupMiddlewares;
@@ -60,6 +62,11 @@ var MockServerPlugin = class {
       }
       compiler.hooks.watchRun.tap(PLUGIN_NAME, () => mockCompiler.run());
       compiler.hooks.watchClose.tap(PLUGIN_NAME, () => mockCompiler.close());
+    } else if (options.build !== false) {
+      compiler.hooks.afterEmit.tap(PLUGIN_NAME, () => buildMockServer(
+        options,
+        compilerOptions.output.path || path.resolve(process.cwd(), "dist")
+      ));
     }
   }
 };