rspack-plugin-mock 0.1.0 → 0.3.0

package/dist/{chunk-G53QRHGV.cjs → chunk-I54ZNZWL.cjs}

@@ -1,99 +1,14 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// src/core/requestRecovery.ts
-var _buffer = require('buffer');
-var requestCollectCache = /* @__PURE__ */ new WeakMap();
-function collectRequest(req) {
-  const chunks = [];
-  req.addListener("data", (chunk) => {
-    chunks.push(_buffer.Buffer.from(chunk));
-  });
-  req.addListener("end", () => {
-    if (chunks.length)
-      requestCollectCache.set(req, _buffer.Buffer.concat(chunks));
-  });
-}
-function rewriteRequest(proxyReq, req) {
-  const buffer = requestCollectCache.get(req);
-  if (buffer) {
-    requestCollectCache.delete(req);
-    if (!proxyReq.headersSent)
-      proxyReq.setHeader("Content-Length", buffer.byteLength);
-    if (!proxyReq.writableEnded)
-      proxyReq.write(buffer);
-  }
-}
-
-// src/core/mockMiddleware.ts
-var _process = require('process'); var _process2 = _interopRequireDefault(_process);
-var _utils = require('@pengzhanbo/utils');
-var _cors = require('cors'); var _cors2 = _interopRequireDefault(_cors);
-var _pathtoregexp = require('path-to-regexp');
-
-// src/core/resolvePluginOptions.ts
-
-function resolvePluginOptions({
-  prefix = [],
-  // wsPrefix = [],
-  cwd,
-  include = ["mock/**/*.mock.{js,ts,cjs,mjs,json,json5}"],
-  exclude = ["**/node_modules/**", "**/.vscode/**", "**/.git/**"],
-  // reload = false,
-  log = "info",
-  cors: cors2 = true,
-  formidableOptions = {},
-  // build = false,
-  cookiesOptions = {},
-  bodyParserOptions = {},
-  priority = {}
-} = {}, context) {
-  const pluginOptions = {
-    prefix,
-    // wsPrefix,
-    cwd: cwd || context || _process2.default.cwd(),
-    include,
-    exclude,
-    // reload,
-    cors: cors2,
-    cookiesOptions,
-    log,
-    formidableOptions: {
-      multiples: true,
-      ...formidableOptions
-    },
-    bodyParserOptions,
-    priority
-    // build: build
-    //   ? Object.assign(
-    //     {
-    //       serverPort: 8080,
-    //       dist: 'mockServer',
-    //       log: 'error',
-    //     },
-    //     typeof build === 'object' ? build : {},
-    //   )
-    //   : false,
-  };
-  return pluginOptions;
-}
-
-// src/core/mockCompiler.ts
-var _events = require('events'); var _events2 = _interopRequireDefault(_events);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// src/core/utils.ts
 var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
-
 var _path = require('path'); var _path2 = _interopRequireDefault(_path);
-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/utils.ts
-
-
 var _querystring = require('querystring');
 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";
 }
@@ -103,7 +18,7 @@ function isReadableStream(stream) {
 function getDirname(importMetaUrl) {
   return _path2.default.dirname(_url.fileURLToPath.call(void 0, importMetaUrl));
 }
-var debug = _debug2.default.call(void 0, "rspack:mock-server");
+var debug = _debug2.default.call(void 0, "rspack:mock");
 function lookupFile(dir, formats, options) {
   for (const format of formats) {
     const fullPath = _path2.default.join(dir, format);
@@ -144,33 +59,42 @@ function slash(p) {
 function normalizePath(id) {
   return _path2.default.posix.normalize(isWindows ? slash(id) : id);
 }
-
-// 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) {
+function waitingFor(onSuccess, maxRetry = 5) {
+  return function wait(getter, retry = 0) {
+    const value = getter();
+    if (value) {
+      onSuccess(value);
+    } else if (retry < maxRetry) {
+      setTimeout(() => wait(getter, retry + 1), 100);
     }
+  };
+}
+
+// src/core/requestRecovery.ts
+var _buffer = require('buffer');
+var requestCollectCache = /* @__PURE__ */ new WeakMap();
+function collectRequest(req) {
+  const chunks = [];
+  req.addListener("data", (chunk) => {
+    chunks.push(_buffer.Buffer.from(chunk));
+  });
+  req.addListener("end", () => {
+    if (chunks.length)
+      requestCollectCache.set(req, _buffer.Buffer.concat(chunks));
+  });
+}
+function rewriteRequest(proxyReq, req) {
+  const buffer = requestCollectCache.get(req);
+  if (buffer) {
+    requestCollectCache.delete(req);
+    if (!proxyReq.headersSent)
+      proxyReq.setHeader("Content-Length", buffer.byteLength);
+    if (!proxyReq.writableEnded)
+      proxyReq.write(buffer);
   }
 }
 
-// src/core/transform.ts
+// src/core/baseMiddleware.ts
 
 
 
@@ -179,433 +103,106 @@ async function loadFromCode({
 
 
 
-// src/core/validator.ts
+var _utils = require('@pengzhanbo/utils');
+var _cookies = require('cookies'); var _cookies2 = _interopRequireDefault(_cookies);
+var _httpstatus = require('http-status'); var _httpstatus2 = _interopRequireDefault(_httpstatus);
+var _mimetypes = require('mime-types'); var mime = _interopRequireWildcard(_mimetypes);
 
-function validate(request, validator) {
-  return isObjectSubset(request.headers, validator.headers) && isObjectSubset(request.body, validator.body) && isObjectSubset(request.params, validator.params) && isObjectSubset(request.query, validator.query) && isObjectSubset(request.refererQuery, validator.refererQuery);
+var _picocolors = require('picocolors'); var _picocolors2 = _interopRequireDefault(_picocolors);
+
+// src/core/matchingWeight.ts
+
+
+
+
+
+
+
+
+var tokensCache = {};
+function getTokens(rule) {
+  if (tokensCache[rule])
+    return tokensCache[rule];
+  const { tokens: tks } = _pathtoregexp.parse.call(void 0, rule);
+  const tokens = [];
+  for (const tk of tks) {
+    if (!_utils.isString.call(void 0, tk)) {
+      tokens.push(tk);
+    } else {
+      const hasPrefix = tk[0] === "/";
+      const subTks = hasPrefix ? tk.slice(1).split("/") : tk.split("/");
+      tokens.push(
+        `${hasPrefix ? "/" : ""}${subTks[0]}`,
+        ...subTks.slice(1).map((t) => `/${t}`)
+      );
+    }
+  }
+  tokensCache[rule] = tokens;
+  return tokens;
 }
-function isObjectSubset(source, target) {
-  if (!target)
-    return true;
-  for (const key in target) {
-    if (!isIncluded(source[key], target[key]))
-      return false;
+function getHighest(rules) {
+  let weights = rules.map((rule) => getTokens(rule).length);
+  weights = weights.length === 0 ? [1] : weights;
+  return Math.max(...weights) + 2;
+}
+function sortFn(rule) {
+  const tokens = getTokens(rule);
+  let w = 0;
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (!_utils.isString.call(void 0, token))
+      w += 10 ** (i + 1);
+    w += 10 ** (i + 1);
   }
-  return true;
+  return w;
 }
-function isIncluded(source, target) {
-  if (_utils.isArray.call(void 0, source) && _utils.isArray.call(void 0, target)) {
-    const seen = /* @__PURE__ */ new Set();
-    return target.every(
-      (ti) => source.some((si, i) => {
-        if (seen.has(i))
-          return false;
-        const included = isIncluded(si, ti);
-        if (included)
-          seen.add(i);
-        return included;
-      })
-    );
+function preSort(rules) {
+  let matched = [];
+  const preMatch = [];
+  for (const rule of rules) {
+    const tokens = getTokens(rule);
+    const len = tokens.filter((token) => typeof token !== "string").length;
+    if (!preMatch[len])
+      preMatch[len] = [];
+    preMatch[len].push(rule);
   }
-  if (_utils.isObject.call(void 0, source) && _utils.isObject.call(void 0, target))
-    return isObjectSubset(source, target);
-  return Object.is(source, target);
+  for (const match2 of preMatch.filter((v) => v && v.length > 0))
+    matched = [...matched, ..._utils.sortBy.call(void 0, match2, sortFn).reverse()];
+  return matched;
 }
-
-// src/core/transform.ts
-function transformRawData(rawData) {
-  return rawData.filter((item) => item[0]).map(([raw, __filepath__]) => {
-    let mockConfig;
-    if (raw.default) {
-      if (Array.isArray(raw.default)) {
-        mockConfig = raw.default.map((item) => ({ ...item, __filepath__ }));
+function defaultPriority(rules) {
+  const highest = getHighest(rules);
+  return _utils.sortBy.call(void 0, rules, (rule) => {
+    const tokens = getTokens(rule);
+    const dym = tokens.filter((token) => typeof token !== "string");
+    if (dym.length === 0)
+      return 0;
+    let weight = dym.length;
+    let exp = 0;
+    for (let i = 0; i < tokens.length; i++) {
+      const token = tokens[i];
+      const isDynamic = !_utils.isString.call(void 0, token);
+      const {
+        pattern = "",
+        modifier,
+        prefix,
+        name
+      } = isDynamic ? token : {};
+      const isGlob = pattern && pattern.includes(".*");
+      const isSlash = prefix === "/";
+      const isNamed = _utils.isString.call(void 0, name);
+      exp += isDynamic && isSlash ? 1 : 0;
+      if (i === tokens.length - 1 && isGlob) {
+        weight += 5 * 10 ** (tokens.length === 1 ? highest + 1 : highest);
       } else {
-        mockConfig = { ...raw.default, __filepath__ };
-      }
-    } else if ("url" in raw) {
-      mockConfig = { ...raw, __filepath__ };
-    } else {
-      mockConfig = [];
-      Object.keys(raw || {}).forEach((key) => {
-        if (Array.isArray(raw[key])) {
-          mockConfig.push(...raw[key].map((item) => ({ ...item, __filepath__ })));
-        } else {
-          mockConfig.push({ ...raw[key], __filepath__ });
-        }
-      });
-    }
-    return mockConfig;
-  });
-}
-function transformMockData(mockList) {
-  const list = [];
-  for (const [, handle] of mockList.entries()) {
-    if (handle)
-      list.push(..._utils.toArray.call(void 0, handle));
-  }
-  const mocks = {};
-  list.filter((mock) => _utils.isObject.call(void 0, mock) && mock.enabled !== false && mock.url).forEach((mock) => {
-    const { pathname, query } = urlParse(mock.url);
-    const list2 = mocks[pathname] ??= [];
-    const current = { ...mock, url: pathname };
-    if (current.ws !== true) {
-      const validator = current.validator;
-      if (!_utils.isEmptyObject.call(void 0, query)) {
-        if (_utils.isFunction.call(void 0, validator)) {
-          current.validator = function(request) {
-            return isObjectSubset(request.query, query) && validator(request);
-          };
-        } else if (validator) {
-          current.validator = { ...validator };
-          current.validator.query = current.validator.query ? { ...query, ...current.validator.query } : query;
-        } else {
-          current.validator = { query };
-        }
-      }
-    }
-    list2.push(current);
-  });
-  Object.keys(mocks).forEach((key) => {
-    mocks[key] = sortByValidator(mocks[key]);
-  });
-  return mocks;
-}
-function sortByValidator(mocks) {
-  return _utils.sortBy.call(void 0, mocks, (item) => {
-    if (item.ws === true)
-      return 0;
-    const { validator } = item;
-    if (!validator || _utils.isEmptyObject.call(void 0, validator))
-      return 2;
-    if (_utils.isFunction.call(void 0, validator))
-      return 0;
-    const count = Object.keys(validator).reduce(
-      (prev, key) => prev + keysCount(validator[key]),
-      0
-    );
-    return 1 / count;
-  });
-}
-function keysCount(obj) {
-  if (!obj)
-    return 0;
-  return Object.keys(obj).length;
-}
-
-// src/core/resolveRspackOptions.ts
-
-var _dirname = getDirname(import.meta.url);
-function resolveRspackOptions({
-  cwd,
-  isEsm,
-  entryFile,
-  outputFile,
-  plugins,
-  alias,
-  watch = false
-}) {
-  const targets = ["node >= 18.0.0"];
-  return {
-    mode: "production",
-    context: cwd,
-    entry: entryFile,
-    watch,
-    target: "node18.0",
-    externalsType: isEsm ? "module" : "commonjs2",
-    externals: /^[^./].*/,
-    resolve: {
-      alias,
-      extensions: [".js", ".ts", ".cjs", ".mjs", ".json5", ".json"]
-    },
-    plugins,
-    output: {
-      library: { type: !isEsm ? "commonjs2" : "module" },
-      filename: outputFile,
-      path: "/"
-    },
-    experiments: { outputModule: isEsm },
-    module: {
-      rules: [
-        {
-          test: /\.json5?$/,
-          loader: _path2.default.join(_dirname, "json5-loader.cjs"),
-          type: "javascript/auto"
-        },
-        {
-          test: /\.[cm]?js$/,
-          use: [
-            {
-              loader: "builtin:swc-loader",
-              options: {
-                jsc: { parser: { syntax: "ecmascript" } },
-                env: { targets }
-              }
-            }
-          ]
-        },
-        {
-          test: /\.[cm]?ts$/,
-          use: [
-            {
-              loader: "builtin:swc-loader",
-              options: {
-                jsc: { parser: { syntax: "typescript" } },
-                env: { targets }
-              }
-            }
-          ]
-        }
-      ]
-    }
-  };
-}
-
-// src/core/mockCompiler.ts
-var vfs = _memfs.createFsFromVolume.call(void 0, new (0, _memfs.Volume)());
-function createMockCompiler(options) {
-  return new MockCompiler(options);
-}
-var MockCompiler = (_class = class extends _events2.default {
-  constructor(options) {
-    super();_class.prototype.__init.call(this);_class.prototype.__init2.call(this);;
-    this.options = options;
-    this.cwd = options.cwd || _process2.default.cwd();
-    const { include, exclude } = this.options;
-    this.fileFilter = _pluginutils.createFilter.call(void 0, include, exclude, {
-      resolve: false
-    });
-    try {
-      const pkg = lookupFile(this.cwd, ["package.json"]);
-      this.moduleType = !!pkg && JSON.parse(pkg).type === "module" ? "esm" : "cjs";
-    } catch (e3) {
-    }
-    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 = {}}
-  
-  
-  get mockData() {
-    return this._mockData;
-  }
-  async run() {
-    await this.updateMockEntry();
-    this.watchMockFiles();
-    this.createCompiler(async (err, stats) => {
-      const name = "[rspack:mock]";
-      if (err) {
-        const error = _optionalChain([stats, 'optionalAccess', _5 => _5.compilation, 'access', _6 => _6.getLogger, 'call', _7 => _7(name), 'access', _8 => _8.error]) || ((...args) => console.error(name, ...args));
-        error(err.stack || err);
-        if ("details" in err) {
-          error(err.details);
-        }
-        return;
-      }
-      if (_optionalChain([stats, 'optionalAccess', _9 => _9.hasErrors, 'call', _10 => _10()])) {
-        stats.compilation.getLogger(name).error(stats.toString({ colors: true }));
-        return;
-      }
-      const content = vfs.readFileSync(`/${this.outputFile}`, "utf-8");
-      try {
-        const result = await loadFromCode({
-          filepath: this.outputFile,
-          code: content,
-          isESM: this.moduleType === "esm",
-          cwd: this.cwd
-        });
-        this._mockData = transformMockData(transformRawData(result));
-        this.emit("update");
-      } catch (e) {
-        console.error("[rspack:mock-server]", e);
-      }
-    });
-  }
-  close() {
-    this.mockWatcher.close();
-    _optionalChain([this, 'access', _11 => _11.compiler, 'optionalAccess', _12 => _12.close, 'call', _13 => _13(() => {
-    })]);
-    this.emit("close");
-  }
-  updateAlias(alias) {
-    this.options.alias = {
-      ...this.options.alias,
-      ...alias
-    };
-  }
-  async updateMockEntry() {
-    const files = await this.getMockFiles();
-    await this.resolveEntryFile(files);
-  }
-  async getMockFiles() {
-    const { include } = this.options;
-    const files = await _fastglob2.default.call(void 0, include, { cwd: this.cwd });
-    return files.filter(this.fileFilter);
-  }
-  watchMockFiles() {
-    const { include } = this.options;
-    const [firstGlob, ...otherGlob] = include;
-    const watcher = this.mockWatcher = _chokidar2.default.watch(firstGlob, {
-      ignoreInitial: true,
-      cwd: this.cwd
-    });
-    if (otherGlob.length > 0)
-      otherGlob.forEach((glob) => watcher.add(glob));
-    watcher.on("add", () => {
-      this.updateMockEntry();
-    });
-    watcher.on("unlink", async () => {
-      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 options = resolveRspackOptions({
-      isEsm: this.moduleType === "esm",
-      cwd: this.cwd,
-      plugins: this.options.plugins,
-      entryFile: this.entryFile,
-      outputFile: this.outputFile,
-      alias: this.options.alias,
-      watch: true
-    });
-    this.compiler = rspackCore.rspack(options, callback);
-    if (this.compiler)
-      this.compiler.outputFileSystem = vfs;
-  }
-}, _class);
-
-// src/core/baseMiddleware.ts
-
-
-
-
-
-
-
-
-
-var _cookies = require('cookies'); var _cookies2 = _interopRequireDefault(_cookies);
-var _httpstatus = require('http-status'); var _httpstatus2 = _interopRequireDefault(_httpstatus);
-var _mimetypes = require('mime-types'); var mime = _interopRequireWildcard(_mimetypes);
-
-var _picocolors = require('picocolors'); var _picocolors2 = _interopRequireDefault(_picocolors);
-
-// src/core/matchingWeight.ts
-
-
-
-
-
-
-
-
-var tokensCache = {};
-function getTokens(rule) {
-  if (tokensCache[rule])
-    return tokensCache[rule];
-  const { tokens: tks } = _pathtoregexp.parse.call(void 0, rule);
-  const tokens = [];
-  for (const tk of tks) {
-    if (!_utils.isString.call(void 0, tk)) {
-      tokens.push(tk);
-    } else {
-      const hasPrefix = tk[0] === "/";
-      const subTks = hasPrefix ? tk.slice(1).split("/") : tk.split("/");
-      tokens.push(
-        `${hasPrefix ? "/" : ""}${subTks[0]}`,
-        ...subTks.slice(1).map((t) => `/${t}`)
-      );
-    }
-  }
-  tokensCache[rule] = tokens;
-  return tokens;
-}
-function getHighest(rules) {
-  let weights = rules.map((rule) => getTokens(rule).length);
-  weights = weights.length === 0 ? [1] : weights;
-  return Math.max(...weights) + 2;
-}
-function sortFn(rule) {
-  const tokens = getTokens(rule);
-  let w = 0;
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i];
-    if (!_utils.isString.call(void 0, token))
-      w += 10 ** (i + 1);
-    w += 10 ** (i + 1);
-  }
-  return w;
-}
-function preSort(rules) {
-  let matched = [];
-  const preMatch = [];
-  for (const rule of rules) {
-    const tokens = getTokens(rule);
-    const len = tokens.filter((token) => typeof token !== "string").length;
-    if (!preMatch[len])
-      preMatch[len] = [];
-    preMatch[len].push(rule);
-  }
-  for (const match2 of preMatch.filter((v) => v && v.length > 0))
-    matched = [...matched, ..._utils.sortBy.call(void 0, match2, sortFn).reverse()];
-  return matched;
-}
-function defaultPriority(rules) {
-  const highest = getHighest(rules);
-  return _utils.sortBy.call(void 0, rules, (rule) => {
-    const tokens = getTokens(rule);
-    const dym = tokens.filter((token) => typeof token !== "string");
-    if (dym.length === 0)
-      return 0;
-    let weight = dym.length;
-    let exp = 0;
-    for (let i = 0; i < tokens.length; i++) {
-      const token = tokens[i];
-      const isDynamic = !_utils.isString.call(void 0, token);
-      const {
-        pattern = "",
-        modifier,
-        prefix,
-        name
-      } = isDynamic ? token : {};
-      const isGlob = pattern && pattern.includes(".*");
-      const isSlash = prefix === "/";
-      const isNamed = _utils.isString.call(void 0, name);
-      exp += isDynamic && isSlash ? 1 : 0;
-      if (i === tokens.length - 1 && isGlob) {
-        weight += 5 * 10 ** (tokens.length === 1 ? highest + 1 : highest);
-      } else {
-        if (isGlob) {
-          weight += 3 * 10 ** (highest - 1);
-        } else if (pattern) {
-          if (isSlash) {
-            weight += (isNamed ? 2 : 1) * 10 ** (exp + 1);
-          } else {
-            weight -= 1 * 10 ** exp;
-          }
+        if (isGlob) {
+          weight += 3 * 10 ** (highest - 1);
+        } else if (pattern) {
+          if (isSlash) {
+            weight += (isNamed ? 2 : 1) * 10 ** (exp + 1);
+          } else {
+            weight -= 1 * 10 ** exp;
+          }
         }
       }
       if (modifier === "+")
@@ -640,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]);
     }
   }
@@ -666,7 +263,7 @@ async function parseReqBody(req, formidableOptions, bodyParserOptions = {}) {
   const method = req.method.toUpperCase();
   if (["GET", "DELETE", "HEAD"].includes(method))
     return void 0;
-  const type = _optionalChain([req, 'access', _14 => _14.headers, 'access', _15 => _15["content-type"], 'optionalAccess', _16 => _16.toLocaleLowerCase, 'call', _17 => _17()]) || "";
+  const type = _optionalChain([req, 'access', _5 => _5.headers, 'access', _6 => _6["content-type"], 'optionalAccess', _7 => _7.toLocaleLowerCase, 'call', _8 => _8()]) || "";
   const { limit, formLimit, jsonLimit, textLimit, ...rest } = bodyParserOptions;
   try {
     if (type.startsWith("application/json")) {
@@ -707,6 +304,39 @@ async function parseMultipart(req, options) {
   });
 }
 
+// src/core/validator.ts
+
+function validate(request, validator) {
+  return isObjectSubset(request.headers, validator.headers) && isObjectSubset(request.body, validator.body) && isObjectSubset(request.params, validator.params) && isObjectSubset(request.query, validator.query) && isObjectSubset(request.refererQuery, validator.refererQuery);
+}
+function isObjectSubset(source, target) {
+  if (!target)
+    return true;
+  for (const key in target) {
+    if (!isIncluded(source[key], target[key]))
+      return false;
+  }
+  return true;
+}
+function isIncluded(source, target) {
+  if (_utils.isArray.call(void 0, source) && _utils.isArray.call(void 0, target)) {
+    const seen = /* @__PURE__ */ new Set();
+    return target.every(
+      (ti) => source.some((si, i) => {
+        if (seen.has(i))
+          return false;
+        const included = isIncluded(si, ti);
+        if (included)
+          seen.add(i);
+        return included;
+      })
+    );
+  }
+  if (_utils.isObject.call(void 0, source) && _utils.isObject.call(void 0, target))
+    return isObjectSubset(source, target);
+  return Object.is(source, target);
+}
+
 // src/core/baseMiddleware.ts
 function baseMiddleware(compiler, {
   formidableOptions = {},
@@ -970,6 +600,50 @@ function requestLog(request, filepath) {
   return `${ms} ${pathname}${qs}${ps}${bs}${file}`;
 }
 
+// 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));
+    const corsMiddleware = createCorsMiddleware(compiler, options);
+    if (corsMiddleware) {
+      middlewares.unshift(corsMiddleware);
+    }
+    if (options.reload) {
+      compiler.on("update", () => _optionalChain([reload, 'optionalCall', _9 => _9()]));
+    }
+    return middlewares;
+  }
+  return mockMiddleware;
+}
+function createCorsMiddleware(compiler, options) {
+  let corsOptions = {};
+  const enabled = options.cors !== false;
+  if (enabled) {
+    corsOptions = {
+      ...corsOptions,
+      ...typeof options.cors === "boolean" ? {} : options.cors
+    };
+  }
+  const proxies = options.proxies;
+  return !enabled ? void 0 : function(req, res, next) {
+    const { pathname } = urlParse(req.url);
+    if (!pathname || proxies.length === 0 || !proxies.some(
+      (context) => doesProxyContextMatchUrl(context, req.url, req)
+    )) {
+      return next();
+    }
+    const mockData = compiler.mockData;
+    const mockUrl = Object.keys(mockData).find(
+      (key) => _pathtoregexp.pathToRegexp.call(void 0, key).test(pathname)
+    );
+    if (!mockUrl)
+      return next();
+    _cors2.default.call(void 0, corsOptions)(req, res, next);
+  };
+}
+
 // src/core/logger.ts
 
 
@@ -994,96 +668,757 @@ function createLogger(prefix, defaultLevel = "info") {
       console[method](format);
     }
   }
-  const logger = {
-    debug(msg, level = defaultLevel) {
-      output("debug", msg, level);
-    },
-    info(msg, level = defaultLevel) {
-      output("info", msg, level);
-    },
-    warn(msg, level = defaultLevel) {
-      output("warn", msg, level);
+  const logger = {
+    debug(msg, level = defaultLevel) {
+      output("debug", msg, level);
+    },
+    info(msg, level = defaultLevel) {
+      output("info", msg, level);
+    },
+    warn(msg, level = defaultLevel) {
+      output("warn", msg, level);
+    },
+    error(msg, level = defaultLevel) {
+      output("error", msg, level);
+    }
+  };
+  return logger;
+}
+
+// src/core/resolvePluginOptions.ts
+var _process = require('process'); var _process2 = _interopRequireDefault(_process);
+
+function resolvePluginOptions({
+  prefix = [],
+  wsPrefix = [],
+  cwd,
+  include = ["mock/**/*.mock.{js,ts,cjs,mjs,json,json5}"],
+  exclude = ["**/node_modules/**", "**/.vscode/**", "**/.git/**"],
+  reload = false,
+  log = "info",
+  cors: cors2 = true,
+  formidableOptions = {},
+  build = false,
+  cookiesOptions = {},
+  bodyParserOptions = {},
+  priority = {}
+} = {}, { alias, context, plugins, proxies }) {
+  const logger = createLogger(
+    "rspack:mock",
+    _utils.isBoolean.call(void 0, log) ? log ? "info" : "error" : log
+  );
+  return {
+    prefix,
+    wsPrefix,
+    cwd: cwd || context || _process2.default.cwd(),
+    include,
+    exclude,
+    reload,
+    cors: cors2,
+    cookiesOptions,
+    log,
+    formidableOptions: {
+      multiples: true,
+      ...formidableOptions
+    },
+    bodyParserOptions,
+    priority,
+    build: build ? Object.assign(
+      {
+        serverPort: 8080,
+        dist: "mockServer",
+        log: "error"
+      },
+      typeof build === "object" ? build : {}
+    ) : false,
+    alias,
+    plugins,
+    proxies,
+    wsProxies: _utils.toArray.call(void 0, wsPrefix),
+    logger
+  };
+}
+
+// src/core/transform.ts
+
+
+
+
+
+
+
+function transformRawData(rawData) {
+  return rawData.filter((item) => item[0]).map(([raw, __filepath__]) => {
+    let mockConfig;
+    if (raw.default) {
+      if (Array.isArray(raw.default)) {
+        mockConfig = raw.default.map((item) => ({ ...item, __filepath__ }));
+      } else {
+        mockConfig = { ...raw.default, __filepath__ };
+      }
+    } else if ("url" in raw) {
+      mockConfig = { ...raw, __filepath__ };
+    } else {
+      mockConfig = [];
+      Object.keys(raw || {}).forEach((key) => {
+        if (Array.isArray(raw[key])) {
+          mockConfig.push(...raw[key].map((item) => ({ ...item, __filepath__ })));
+        } else {
+          mockConfig.push({ ...raw[key], __filepath__ });
+        }
+      });
+    }
+    return mockConfig;
+  });
+}
+function transformMockData(mockList) {
+  const list = [];
+  for (const [, handle] of mockList.entries()) {
+    if (handle)
+      list.push(..._utils.toArray.call(void 0, handle));
+  }
+  const mocks = {};
+  list.filter((mock) => _utils.isObject.call(void 0, mock) && mock.enabled !== false && mock.url).forEach((mock) => {
+    const { pathname, query } = urlParse(mock.url);
+    const list2 = mocks[pathname] ??= [];
+    const current = { ...mock, url: pathname };
+    if (current.ws !== true) {
+      const validator = current.validator;
+      if (!_utils.isEmptyObject.call(void 0, query)) {
+        if (_utils.isFunction.call(void 0, validator)) {
+          current.validator = function(request) {
+            return isObjectSubset(request.query, query) && validator(request);
+          };
+        } else if (validator) {
+          current.validator = { ...validator };
+          current.validator.query = current.validator.query ? { ...query, ...current.validator.query } : query;
+        } else {
+          current.validator = { query };
+        }
+      }
+    }
+    list2.push(current);
+  });
+  Object.keys(mocks).forEach((key) => {
+    mocks[key] = sortByValidator(mocks[key]);
+  });
+  return mocks;
+}
+function sortByValidator(mocks) {
+  return _utils.sortBy.call(void 0, mocks, (item) => {
+    if (item.ws === true)
+      return 0;
+    const { validator } = item;
+    if (!validator || _utils.isEmptyObject.call(void 0, validator))
+      return 2;
+    if (_utils.isFunction.call(void 0, validator))
+      return 0;
+    const count = Object.keys(validator).reduce(
+      (prev, key) => prev + keysCount(validator[key]),
+      0
+    );
+    return 1 / count;
+  });
+}
+function keysCount(obj) {
+  if (!obj)
+    return 0;
+  return Object.keys(obj).length;
+}
+
+// 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 _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 = true,
+  entryFile,
+  plugins,
+  alias,
+  watch = false
+}) {
+  const targets = ["node >= 18.0.0"];
+  return {
+    mode: "production",
+    context: cwd,
+    entry: entryFile,
+    watch,
+    target: "node18.0",
+    externalsType: isEsm ? "module" : "commonjs2",
+    externals: /^[^./].*/,
+    resolve: {
+      alias,
+      extensions: [".js", ".ts", ".cjs", ".mjs", ".json5", ".json"]
+    },
+    plugins,
+    output: {
+      library: { type: !isEsm ? "commonjs2" : "module" },
+      filename: "output.js",
+      path: "/"
+    },
+    experiments: { outputModule: isEsm },
+    optimization: { minimize: !watch },
+    module: {
+      rules: [
+        {
+          test: /\.json5?$/,
+          loader: _path2.default.join(packageDir, "json5-loader.cjs"),
+          type: "javascript/auto"
+        },
+        {
+          test: /\.[cm]?js$/,
+          use: [
+            {
+              loader: "builtin:swc-loader",
+              options: {
+                jsc: { parser: { syntax: "ecmascript" } },
+                env: { targets }
+              }
+            }
+          ]
+        },
+        {
+          test: /\.[cm]?ts$/,
+          use: [
+            {
+              loader: "builtin:swc-loader",
+              options: {
+                jsc: { parser: { syntax: "typescript" } },
+                env: { targets }
+              }
+            }
+          ]
+        }
+      ]
+    }
+  };
+}
+
+// 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"
     },
-    error(msg, level = defaultLevel) {
-      output("error", msg, level);
+    dependencies: {
+      connect: "^3.7.0",
+      [name]: `^${version}`,
+      cors: "^2.8.5"
     }
   };
-  return logger;
+  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';
 
-// src/core/mockMiddleware.ts
-function createManuallyMockMiddleware({ alias, proxies, context = _process2.default.cwd(), plugins }, pluginOptions) {
-  const options = resolvePluginOptions(pluginOptions, context);
-  const logger = createLogger(
-    "rspack:mock",
-    _utils.isBoolean.call(void 0, options.log) ? options.log ? "info" : "error" : options.log
-  );
-  const compiler = createMockCompiler({
-    alias,
-    plugins,
-    cwd: options.cwd,
-    include: _utils.toArray.call(void 0, options.include),
-    exclude: _utils.toArray.call(void 0, options.exclude)
-  });
-  function mockMiddleware(middlewares) {
-    middlewares.unshift(baseMiddleware(compiler, {
-      formidableOptions: options.formidableOptions,
-      proxies,
-      cookiesOptions: options.cookiesOptions,
-      bodyParserOptions: options.bodyParserOptions,
-      priority: options.priority,
-      logger
-    }));
-    const corsMiddleware = createCorsMiddleware(compiler, proxies, options);
-    if (corsMiddleware) {
-      middlewares.unshift(corsMiddleware);
+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"));
     }
-    return middlewares;
+  } catch (e2) {
   }
   return {
-    mockMiddleware,
-    run: () => compiler.run(),
-    close: () => compiler.close(),
-    updateAlias: compiler.updateAlias.bind(compiler)
+    name: pkg.name || "rspack-plugin-mock",
+    version: pkg.version || "latest"
   };
 }
-function createMockMiddleware(middlewareOptions, pluginOptions) {
-  const { mockMiddleware, run, close } = createManuallyMockMiddleware(
-    middlewareOptions,
-    pluginOptions
-  );
-  run();
-  _process2.default.on("exit", () => close());
-  return mockMiddleware;
+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 };
 }
-function createCorsMiddleware(compiler, proxies, options) {
-  let corsOptions = {};
-  const enabled = options.cors !== false;
-  if (enabled) {
-    corsOptions = {
-      ...corsOptions,
-      ...typeof options.cors === "boolean" ? {} : options.cors
+
+// 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
+function createMockCompiler(options) {
+  return new MockCompiler(options);
+}
+var MockCompiler = (_class = class extends _events2.default {
+  constructor(options) {
+    super();_class.prototype.__init.call(this);_class.prototype.__init2.call(this);;
+    this.options = options;
+    this.cwd = options.cwd || _process2.default.cwd();
+    const { include, exclude } = this.options;
+    this.fileFilter = _pluginutils.createFilter.call(void 0, include, exclude, { resolve: false });
+    try {
+      const pkg = lookupFile(this.cwd, ["package.json"]);
+      this.moduleType = !!pkg && JSON.parse(pkg).type === "module" ? "esm" : "cjs";
+    } catch (e5) {
+    }
+    this.entryFile = _path2.default.resolve(_process2.default.cwd(), "node_modules/.cache/mock-server/mock-server.ts");
+  }
+  
+  
+  __init() {this.moduleType = "cjs"}
+  
+  __init2() {this._mockData = {}}
+  
+  
+  
+  get mockData() {
+    return this._mockData;
+  }
+  async run() {
+    await this.updateMockEntry();
+    this.watchMockFiles();
+    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: "mock.bundle.js",
+          code,
+          isESM: this.moduleType === "esm",
+          cwd: this.cwd
+        });
+        this._mockData = transformMockData(transformRawData(result));
+        this.emit("update", this.watchInfo || {});
+      } catch (e) {
+        this.options.logger.error(e.stack || e.message);
+      }
+    });
   }
-  return !enabled ? void 0 : function(req, res, next) {
-    const { pathname } = urlParse(req.url);
-    if (!pathname || proxies.length === 0 || !proxies.some(
-      (context) => doesProxyContextMatchUrl(context, req.url, req)
-    )) {
-      return next();
+  close() {
+    this.mockWatcher.close();
+    _optionalChain([this, 'access', _23 => _23.compiler, 'optionalAccess', _24 => _24.close, 'call', _25 => _25(() => {
+    })]);
+    this.emit("close");
+  }
+  updateAlias(alias) {
+    this.options.alias = {
+      ...this.options.alias,
+      ...alias
+    };
+  }
+  async updateMockEntry() {
+    const files = await this.getMockFiles();
+    await writeMockEntryFile(this.entryFile, files, this.cwd);
+  }
+  async getMockFiles() {
+    const { include } = this.options;
+    const files = await _fastglob2.default.call(void 0, include, { cwd: this.cwd });
+    return files.filter(this.fileFilter);
+  }
+  watchMockFiles() {
+    const { include } = this.options;
+    const [firstGlob, ...otherGlob] = _utils.toArray.call(void 0, include);
+    const watcher = this.mockWatcher = _chokidar2.default.watch(firstGlob, {
+      ignoreInitial: true,
+      cwd: this.cwd
+    });
+    if (otherGlob.length > 0)
+      otherGlob.forEach((glob) => watcher.add(glob));
+    watcher.on("add", (filepath) => {
+      if (this.fileFilter(filepath)) {
+        this.watchInfo = { filepath, type: "add" };
+        this.updateMockEntry();
+      }
+    });
+    watcher.on("change", (filepath) => {
+      if (this.fileFilter(filepath)) {
+        this.watchInfo = { filepath, type: "change" };
+      }
+    });
+    watcher.on("unlink", async (filepath) => {
+      this.watchInfo = { filepath, type: "unlink" };
+      this.updateMockEntry();
+    });
+  }
+}, _class);
+
+// src/core/mockWebsocket.ts
+
+
+
+var _ws = require('ws');
+function mockWebSocket(compiler, httpServer, {
+  wsProxies: proxies,
+  cookiesOptions,
+  logger
+}) {
+  const hmrMap = /* @__PURE__ */ new Map();
+  const poolMap = /* @__PURE__ */ new Map();
+  const wssContextMap = /* @__PURE__ */ new WeakMap();
+  const getWssMap = (mockUrl) => {
+    let wssMap = poolMap.get(mockUrl);
+    if (!wssMap)
+      poolMap.set(mockUrl, wssMap = /* @__PURE__ */ new Map());
+    return wssMap;
+  };
+  const getWss = (wssMap, pathname) => {
+    let wss = wssMap.get(pathname);
+    if (!wss)
+      wssMap.set(pathname, wss = new (0, _ws.WebSocketServer)({ noServer: true }));
+    return wss;
+  };
+  const addHmr = (filepath, mockUrl) => {
+    let urlList = hmrMap.get(filepath);
+    if (!urlList)
+      hmrMap.set(filepath, urlList = /* @__PURE__ */ new Set());
+    urlList.add(mockUrl);
+  };
+  const setupWss = (wssMap, wss, mock, context, pathname, filepath) => {
+    try {
+      _optionalChain([mock, 'access', _26 => _26.setup, 'optionalCall', _27 => _27(wss, context)]);
+      wss.on("close", () => wssMap.delete(pathname));
+      wss.on("error", (e) => {
+        logger.error(
+          `${_picocolors2.default.red(
+            `WebSocket mock error at ${wss.path}`
+          )}
+${e}
+  at setup (${filepath})`,
+          mock.log
+        );
+      });
+    } catch (e) {
+      logger.error(
+        `${_picocolors2.default.red(
+          `WebSocket mock error at ${wss.path}`
+        )}
+${e}
+  at setup (${filepath})`,
+        mock.log
+      );
     }
-    const mockData = compiler.mockData;
-    const mockUrl = Object.keys(mockData).find(
-      (key) => _pathtoregexp.pathToRegexp.call(void 0, key).test(pathname)
+  };
+  const emitConnection = (wss, ws, req, connectionList) => {
+    wss.emit("connection", ws, req);
+    ws.on("close", () => {
+      const i = connectionList.findIndex((item) => item.ws === ws);
+      if (i !== -1)
+        connectionList.splice(i, 1);
+    });
+  };
+  const restartWss = (wssMap, wss, mock, pathname, filepath) => {
+    const { cleanupList, connectionList, context } = wssContextMap.get(wss);
+    cleanupRunner(cleanupList);
+    connectionList.forEach(({ ws }) => ws.removeAllListeners());
+    wss.removeAllListeners();
+    setupWss(wssMap, wss, mock, context, pathname, filepath);
+    connectionList.forEach(
+      ({ ws, req }) => emitConnection(wss, ws, req, connectionList)
     );
-    if (!mockUrl)
-      return next();
-    _cors2.default.call(void 0, corsOptions)(req, res, next);
   };
+  compiler.on("update", ({ filepath }) => {
+    if (!hmrMap.has(filepath))
+      return;
+    const mockUrlList = hmrMap.get(filepath);
+    if (!mockUrlList)
+      return;
+    for (const mockUrl of mockUrlList.values()) {
+      for (const mock of compiler.mockData[mockUrl]) {
+        if (!mock.ws || mock.__filepath__ !== filepath)
+          return;
+        const wssMap = getWssMap(mockUrl);
+        for (const [pathname, wss] of wssMap.entries())
+          restartWss(wssMap, wss, mock, pathname, filepath);
+      }
+    }
+  });
+  _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;
+    }
+    const mockData = compiler.mockData;
+    const mockUrl = Object.keys(mockData).find((key) => {
+      return _pathtoregexp.pathToRegexp.call(void 0, key).test(pathname);
+    });
+    if (!mockUrl)
+      return;
+    const mock = mockData[mockUrl].find((mock2) => {
+      return mock2.url && mock2.ws && _pathtoregexp.pathToRegexp.call(void 0, mock2.url).test(pathname);
+    });
+    if (!mock)
+      return;
+    const filepath = mock.__filepath__;
+    addHmr(filepath, mockUrl);
+    const wssMap = getWssMap(mockUrl);
+    const wss = getWss(wssMap, pathname);
+    let wssContext = wssContextMap.get(wss);
+    if (!wssContext) {
+      const cleanupList = [];
+      const context = {
+        onCleanup: (cleanup) => cleanupList.push(cleanup)
+      };
+      wssContext = { cleanupList, context, connectionList: [] };
+      wssContextMap.set(wss, wssContext);
+      setupWss(wssMap, wss, mock, context, pathname, filepath);
+    }
+    const request = req;
+    const cookies = new (0, _cookies2.default)(req, req, cookiesOptions);
+    const { query: refererQuery } = urlParse(req.headers.referer || "");
+    request.query = query;
+    request.refererQuery = refererQuery;
+    request.params = parseParams(mockUrl, pathname);
+    request.getCookie = cookies.get.bind(cookies);
+    wss.handleUpgrade(request, socket, head, (ws) => {
+      logger.info(
+        `${_picocolors2.default.magenta(_picocolors2.default.bold("WebSocket"))} ${_picocolors2.default.green(
+          req.url
+        )} connected ${_picocolors2.default.dim(`(${filepath})`)}`,
+        mock.log
+      );
+      wssContext.connectionList.push({ req: request, ws });
+      emitConnection(wss, ws, request, wssContext.connectionList);
+    });
+  })]);
+  _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);
+        cleanupRunner(wssContext.cleanupList);
+        wss.close();
+      }
+      wssMap.clear();
+    }
+    poolMap.clear();
+    hmrMap.clear();
+  })]);
+}
+function cleanupRunner(cleanupList) {
+  let cleanup;
+  while (cleanup = cleanupList.shift())
+    _optionalChain([cleanup, 'optionalCall', _32 => _32()]);
 }
 
 
 
 
 
-exports.rewriteRequest = rewriteRequest; exports.createManuallyMockMiddleware = createManuallyMockMiddleware; exports.createMockMiddleware = createMockMiddleware;
+
+
+
+
+
+
+
+
+
+
+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;