rspack-plugin-mock/dist/index.js

inject api mock server to development server

import {
  MockCompiler,
  buildMockServer,
  createMockCompiler,
  createMockMiddleware,
  resolvePluginOptions
} from "./chunk-HV5L72CY.js";
import {
  mockWebSocket,
  rewriteRequest,
  waitingFor
} from "./chunk-OGWV5ZGG.js";

// src/rspack.ts
import path from "node:path";
import process from "node:process";
import { isString, toArray } from "@pengzhanbo/utils";
import rspack from "@rspack/core";
var PLUGIN_NAME = "rspack-plugin-mock";
var MockServerPlugin = class {
  constructor(options = {}) {
    this.options = options;
  }
  apply(compiler) {
    const compilerOptions = compiler.options;
    const options = resolvePluginOptions2(compiler, this.options);
    if (process.env.NODE_ENV !== "production") {
      const mockCompiler = createMockCompiler(options);
      const mockMiddleware = createMockMiddleware(mockCompiler, options);
      const setupMiddlewares = compilerOptions.devServer?.setupMiddlewares;
      const waitServerForMockWebSocket = waitingFor((server) => {
        mockWebSocket(mockCompiler, server, options);
      });
      compilerOptions.devServer = {
        ...compilerOptions.devServer,
        setupMiddlewares: (middlewares, devServer) => {
          middlewares = setupMiddlewares?.(middlewares, devServer) || middlewares;
          const reload = () => {
            if (devServer.webSocketServer?.clients)
              devServer.sendMessage(devServer.webSocketServer.clients, "static-changed");
          };
          middlewares = mockMiddleware(middlewares, reload) || middlewares;
          waitServerForMockWebSocket(() => devServer.server);
          return middlewares;
        }
      };
      const wsPrefix = toArray(options.wsPrefix);
      if (compilerOptions.devServer?.proxy?.length) {
        const proxy = compilerOptions.devServer.proxy;
        compilerOptions.devServer.proxy = proxy.filter((item) => {
          if (typeof item !== "function" && item.ws === true && wsPrefix.length) {
            return !toArray(item.context).filter(isString).some((context) => wsPrefix.includes(context));
          }
          return true;
        }).map((item) => {
          if (typeof item !== "function" && !item.ws) {
            const onProxyReq = item.onProxyReq;
            item.onProxyReq = (proxyReq, req, ...args) => {
              onProxyReq?.(proxyReq, req, ...args);
              rewriteRequest(proxyReq, req);
            };
          }
          return item;
        });
      }
      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")
      ));
    }
  }
};
function resolvePluginOptions2(compiler, options) {
  const compilerOptions = compiler.options;
  const alias = compilerOptions.resolve?.alias || {};
  const context = compilerOptions.context;
  const definePluginInstance = compilerOptions.plugins?.find(
    (plugin) => plugin instanceof rspack.DefinePlugin
  );
  const proxies = (compilerOptions.devServer?.proxy || []).flatMap((item) => {
    if (typeof item !== "function" && item.context && !item.ws) {
      return item.context;
    }
    return [];
  });
  return resolvePluginOptions(options, {
    alias,
    context,
    plugins: toArray(definePluginInstance),
    proxies
  });
}
export {
  MockCompiler,
  MockServerPlugin,
  createMockCompiler,
  createMockMiddleware,
  mockWebSocket,
  resolvePluginOptions2 as resolvePluginOptions
};