rspack-plugin-mock 0.1.0 → 0.2.0

package/dist/chunk-P6DRAHHI.js

@@ -0,0 +1,90 @@
+import {
+  createMockCompiler,
+  createMockMiddleware,
+  mockWebSocket,
+  resolvePluginOptions,
+  rewriteRequest,
+  waitingFor
+} from "./chunk-UJAKORAH.js";
+
+// src/rspack.ts
+import process from "process";
+import rspack from "@rspack/core";
+import { isString, toArray } from "@pengzhanbo/utils";
+var PLUGIN_NAME = "rspack-plugin-mock";
+var MockServerPlugin = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  apply(compiler) {
+    const compilerOptions = compiler.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;
+      const waitServer = 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;
+          waitServer(() => devServer.server);
+          return middlewares;
+        }
+      };
+      const proxy = compilerOptions.devServer?.proxy || [];
+      const wsPrefix = toArray(options.wsPrefix);
+      if (proxy.length) {
+        compilerOptions.devServer.proxy = proxy.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;
+        }).filter((item) => {
+          if (typeof item !== "function" && item.ws === true && wsPrefix.length) {
+            return !toArray(item.context).filter(isString).some((context) => wsPrefix.includes(context));
+          }
+          return true;
+        });
+      }
+      compiler.hooks.watchRun.tap(PLUGIN_NAME, () => mockCompiler.run());
+      compiler.hooks.watchClose.tap(PLUGIN_NAME, () => mockCompiler.close());
+    }
+  }
+};
+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 {
+  MockServerPlugin,
+  resolvePluginOptions2 as resolvePluginOptions
+};

package/dist/{chunk-4BGDHRTO.cjs → chunk-T4AI3L6R.cjs}

@@ -1,7 +1,11 @@
 "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 _chunkG53QRHGVcjs = require('./chunk-G53QRHGV.cjs');
+
+
+
+
+var _chunk2S4KCTKWcjs = require('./chunk-2S4KCTKW.cjs');
 
 // src/rspack.ts
 var _process = require('process'); var _process2 = _interopRequireDefault(_process);
@@ -15,54 +19,72 @@ var MockServerPlugin = class {
   apply(compiler) {
     const compilerOptions = compiler.options;
     if (_process2.default.env.NODE_ENV !== "production") {
-      const { mockMiddleware, run, close } = _chunkG53QRHGVcjs.createManuallyMockMiddleware.call(void 0, 
-        resolveMiddleOptions(compiler),
-        this.options
-      );
+      const options = resolvePluginOptions2(compiler, this.options);
+      const mockCompiler = _chunk2S4KCTKWcjs.createMockCompiler.call(void 0, options);
+      const mockMiddleware = _chunk2S4KCTKWcjs.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);
+      });
       compilerOptions.devServer = {
         ...compilerOptions.devServer,
         setupMiddlewares: (middlewares, devServer) => {
           middlewares = _optionalChain([setupMiddlewares, 'optionalCall', _3 => _3(middlewares, devServer)]) || middlewares;
-          middlewares = mockMiddleware(middlewares) || 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;
+          waitServer(() => devServer.server);
           return middlewares;
         }
       };
-      const proxy = _optionalChain([compilerOptions, 'access', _4 => _4.devServer, 'optionalAccess', _5 => _5.proxy]) || [];
+      const proxy = _optionalChain([compilerOptions, 'access', _6 => _6.devServer, 'optionalAccess', _7 => _7.proxy]) || [];
+      const wsPrefix = _utils.toArray.call(void 0, options.wsPrefix);
       if (proxy.length) {
         compilerOptions.devServer.proxy = proxy.map((item) => {
           if (typeof item !== "function" && !item.ws) {
             const onProxyReq = item.onProxyReq;
             item.onProxyReq = (proxyReq, req, ...args) => {
-              _optionalChain([onProxyReq, 'optionalCall', _6 => _6(proxyReq, req, ...args)]);
-              _chunkG53QRHGVcjs.rewriteRequest.call(void 0, proxyReq, req);
+              _optionalChain([onProxyReq, 'optionalCall', _8 => _8(proxyReq, req, ...args)]);
+              _chunk2S4KCTKWcjs.rewriteRequest.call(void 0, proxyReq, req);
             };
           }
           return item;
+        }).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;
         });
       }
-      compiler.hooks.watchRun.tap(PLUGIN_NAME, () => run());
-      compiler.hooks.watchClose.tap(PLUGIN_NAME, () => close());
+      compiler.hooks.watchRun.tap(PLUGIN_NAME, () => mockCompiler.run());
+      compiler.hooks.watchClose.tap(PLUGIN_NAME, () => mockCompiler.close());
     }
   }
 };
-function resolveMiddleOptions(compiler) {
+function resolvePluginOptions2(compiler, options) {
   const compilerOptions = compiler.options;
-  const alias = _optionalChain([compilerOptions, 'access', _7 => _7.resolve, 'optionalAccess', _8 => _8.alias]) || {};
+  const alias = _optionalChain([compilerOptions, 'access', _9 => _9.resolve, 'optionalAccess', _10 => _10.alias]) || {};
   const context = compilerOptions.context;
-  const definePluginInstance = _optionalChain([compilerOptions, 'access', _9 => _9.plugins, 'optionalAccess', _10 => _10.find, 'call', _11 => _11(
+  const definePluginInstance = _optionalChain([compilerOptions, 'access', _11 => _11.plugins, 'optionalAccess', _12 => _12.find, 'call', _13 => _13(
     (plugin) => plugin instanceof _core2.default.DefinePlugin
   )]);
-  const proxies = (_optionalChain([compilerOptions, 'access', _12 => _12.devServer, 'optionalAccess', _13 => _13.proxy]) || []).map((item) => {
-    if (typeof item !== "function" && !item.ws && item.context) {
+  const proxies = (_optionalChain([compilerOptions, 'access', _14 => _14.devServer, 'optionalAccess', _15 => _15.proxy]) || []).flatMap((item) => {
+    if (typeof item !== "function" && item.context && !item.ws) {
       return item.context;
     }
     return [];
-  }).flat();
-  return { alias, context, plugins: _utils.toArray.call(void 0, definePluginInstance), proxies };
+  });
+  return _chunk2S4KCTKWcjs.resolvePluginOptions.call(void 0, options, {
+    alias,
+    context,
+    plugins: _utils.toArray.call(void 0, definePluginInstance),
+    proxies
+  });
 }
 
 
 
 
-exports.MockServerPlugin = MockServerPlugin; exports.resolveMiddleOptions = resolveMiddleOptions;
+exports.MockServerPlugin = MockServerPlugin; exports.resolvePluginOptions = resolvePluginOptions2;