rspack-plugin-mock/dist/index.cjs

inject api mock server to development server

"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkM7F5AAOFcjs = require('./chunk-M7F5AAOF.cjs');




var _chunkHTVJXQRMcjs = require('./chunk-HTVJXQRM.cjs');

// src/rspack.ts
var _path = require('path'); var _path2 = _interopRequireDefault(_path);
var _process = require('process'); var _process2 = _interopRequireDefault(_process);
var _utils = require('@pengzhanbo/utils');
var _core = require('@rspack/core'); var _core2 = _interopRequireDefault(_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 (_process2.default.env.NODE_ENV !== "production") {
      const mockCompiler = _chunkM7F5AAOFcjs.createMockCompiler.call(void 0, options);
      const mockMiddleware = _chunkM7F5AAOFcjs.createMockMiddleware.call(void 0, mockCompiler, options);
      const setupMiddlewares = _optionalChain([compilerOptions, 'access', _ => _.devServer, 'optionalAccess', _2 => _2.setupMiddlewares]);
      const waitServerForMockWebSocket = _chunkHTVJXQRMcjs.waitingFor.call(void 0, (server) => {
        _chunkHTVJXQRMcjs.mockWebSocket.call(void 0, mockCompiler, server, options);
      });
      compilerOptions.devServer = {
        ...compilerOptions.devServer,
        setupMiddlewares: (middlewares, devServer) => {
          middlewares = _optionalChain([setupMiddlewares, 'optionalCall', _3 => _3(middlewares, devServer)]) || middlewares;
          const reload = () => {
            if (_optionalChain([devServer, 'access', _4 => _4.webSocketServer, 'optionalAccess', _5 => _5.clients]))
              devServer.sendMessage(devServer.webSocketServer.clients, "static-changed");
          };
          middlewares = mockMiddleware(middlewares, reload) || middlewares;
          waitServerForMockWebSocket(() => devServer.server);
          return middlewares;
        }
      };
      const wsPrefix = _utils.toArray.call(void 0, options.wsPrefix);
      if (_optionalChain([compilerOptions, 'access', _6 => _6.devServer, 'optionalAccess', _7 => _7.proxy, 'optionalAccess', _8 => _8.length])) {
        const proxy = compilerOptions.devServer.proxy;
        compilerOptions.devServer.proxy = proxy.filter((item) => {
          if (typeof item !== "function" && item.ws === true && wsPrefix.length) {
            return !_utils.toArray.call(void 0, item.context).filter(_utils.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) => {
              _optionalChain([onProxyReq, 'optionalCall', _9 => _9(proxyReq, req, ...args)]);
              _chunkHTVJXQRMcjs.rewriteRequest.call(void 0, 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, () => _chunkM7F5AAOFcjs.buildMockServer.call(void 0, 
        options,
        compilerOptions.output.path || _path2.default.resolve(_process2.default.cwd(), "dist")
      ));
    }
  }
};
function resolvePluginOptions2(compiler, options) {
  const compilerOptions = compiler.options;
  const alias = _optionalChain([compilerOptions, 'access', _10 => _10.resolve, 'optionalAccess', _11 => _11.alias]) || {};
  const context = compilerOptions.context;
  const definePluginInstance = _optionalChain([compilerOptions, 'access', _12 => _12.plugins, 'optionalAccess', _13 => _13.find, 'call', _14 => _14(
    (plugin) => plugin instanceof _core2.default.DefinePlugin
  )]);
  const proxies = (_optionalChain([compilerOptions, 'access', _15 => _15.devServer, 'optionalAccess', _16 => _16.proxy]) || []).flatMap((item) => {
    if (typeof item !== "function" && item.context && !item.ws) {
      return item.context;
    }
    return [];
  });
  return _chunkM7F5AAOFcjs.resolvePluginOptions.call(void 0, options, {
    alias,
    context,
    plugins: _utils.toArray.call(void 0, definePluginInstance),
    proxies
  });
}







exports.MockCompiler = _chunkM7F5AAOFcjs.MockCompiler; exports.MockServerPlugin = MockServerPlugin; exports.createMockCompiler = _chunkM7F5AAOFcjs.createMockCompiler; exports.createMockMiddleware = _chunkM7F5AAOFcjs.createMockMiddleware; exports.mockWebSocket = _chunkHTVJXQRMcjs.mockWebSocket; exports.resolvePluginOptions = resolvePluginOptions2;