react-cosmos-plugin-rspack 1.0.2 → 2.0.0

package/dist/client/userImports.js

@@ -1,6 +1,7 @@
 // src/client/userImports.ts
 var rendererConfig = {
-  playgroundUrl: "http://localhost:5000"
+  webSocketUrl: "ws://localhost:5000",
+  rendererUrl: null
 };
 var moduleWrappers = {
   lazy: false,

package/dist/server/rspackServerPlugin.js

@@ -1,33 +1,33 @@
 // src/server/rspackConfigPlugin.ts
-import * as path from "node:path";
+import * as path from "path";
 
 // src/server/rspackConfig/constants.ts
 var RENDERER_FILENAME = "renderer.html";
 
 // src/server/rspackConfigPlugin.ts
 async function rspackConfigPlugin({
-  cosmosConfig
+  config
 }) {
-  if (cosmosConfig.rendererUrl) {
-    return cosmosConfig;
+  if (config.rendererUrl) {
+    return config;
   }
   return {
-    ...cosmosConfig,
-    rendererUrl: path.join(cosmosConfig.publicUrl, RENDERER_FILENAME)
+    ...config,
+    rendererUrl: path.join(config.publicUrl, RENDERER_FILENAME)
   };
 }
 
 // src/server/rspackDevServerPlugin.ts
-import * as path8 from "node:path";
+import * as path8 from "path";
 import { serveStaticDir } from "react-cosmos";
 import webpackHotMiddleware from "webpack-hot-middleware";
 
 // src/server/cosmosConfig/createRspackCosmosConfig.ts
-import * as path3 from "node:path";
+import * as path3 from "path";
 import { fileExists } from "react-cosmos";
 
 // src/server/utils/resolveLoose.ts
-import * as path2 from "node:path";
+import * as path2 from "path";
 
 // src/server/utils/isNodeError.ts
 function isNodeError(err) {
@@ -35,7 +35,7 @@ function isNodeError(err) {
 }
 
 // src/server/utils/resolve.ts
-import { createRequire } from "node:module";
+import { createRequire } from "module";
 function resolve(moduleId) {
   const require2 = createRequire(import.meta.url);
   return require2.resolve(moduleId);
@@ -116,8 +116,8 @@ function getReloadOnFail({ reloadOnFail = false }) {
 }
 
 // src/server/utils/requireModule.ts
-import { createRequire as createRequire2 } from "node:module";
-import * as path4 from "node:path";
+import { createRequire as createRequire2 } from "module";
+import * as path4 from "path";
 function requireFrom(fromDirectory, moduleId) {
   const require2 = createRequire2(path4.resolve(fromDirectory, "noop.js"));
   return require2(moduleId);
@@ -151,10 +151,10 @@ function getRspack(rootDir) {
 }
 
 // src/server/rspackConfig/getDevRspackConfig.ts
-import * as path7 from "node:path";
+import * as path7 from "path";
 
 // src/server/rspackConfig/getUserRspackConfig.ts
-import * as path5 from "node:path";
+import * as path5 from "path";
 import {
   getCliArgs,
   importModule,
@@ -255,9 +255,9 @@ function getDefaultRspackConfig(rootDir) {
 }
 
 // src/server/rspackConfig/getUserRspackConfig.ts
-async function getUserRspackConfig(cosmosConfig) {
-  const baseRspackConfig = await getBaseRspackConfig(cosmosConfig);
-  const { overridePath } = createRspackCosmosConfig(cosmosConfig);
+async function getUserRspackConfig(config) {
+  const baseRspackConfig = await getBaseRspackConfig(config);
+  const { overridePath } = createRspackCosmosConfig(config);
   if (!overridePath || !moduleExists(overridePath)) {
     console.log(
       `[Cosmos] Learn how to override rspack config for cosmos: https://github.com/react-cosmos/react-cosmos/tree/main/docs#webpack-config-override`
@@ -270,9 +270,9 @@ async function getUserRspackConfig(cosmosConfig) {
   const rspackOverride = module.default;
   return rspackOverride(baseRspackConfig, getRspackNodeEnv());
 }
-async function getBaseRspackConfig(cosmosConfig) {
-  const { rootDir } = cosmosConfig;
-  const { configPath } = createRspackCosmosConfig(cosmosConfig);
+async function getBaseRspackConfig(confg) {
+  const { rootDir } = confg;
+  const { configPath } = createRspackCosmosConfig(confg);
   if (!configPath || !moduleExists(configPath)) {
     console.log("[Cosmos] Using default rspack config");
     return getDefaultRspackConfig(rootDir);
@@ -293,47 +293,47 @@ async function getBaseRspackConfig(cosmosConfig) {
 }
 
 // src/server/rspackConfig/resolveRspackClientPath.ts
-import { createRequire as createRequire3 } from "node:module";
+import { createRequire as createRequire3 } from "module";
 function resolveRspackClientPath(relPath) {
   const require2 = createRequire3(import.meta.url);
   return require2.resolve(`../client/${relPath}`);
 }
 
 // src/server/rspackConfig/resolveRspackLoaderPath.ts
-import { createRequire as createRequire4 } from "node:module";
+import { createRequire as createRequire4 } from "module";
 function resolveRspackLoaderPath() {
   const require2 = createRequire4(import.meta.url);
   return require2.resolve("./userImportsLoader.cjs");
 }
 
 // src/server/rspackConfig/getRspackConfigModule.ts
-function getRspackConfigModule(cosmosConfig, rspackConfig) {
+function getRspackConfigModule(config, rspackConfig, mode) {
   return {
     ...rspackConfig.module,
-    rules: getRules(cosmosConfig, rspackConfig)
+    rules: getRules(config, rspackConfig, mode)
   };
 }
-function getRules(cosmosConfig, { module }) {
+function getRules(config, { module }, mode) {
   const existingRules = module && module.rules || [];
-  return [...existingRules, getUserImportsLoaderRule(cosmosConfig)];
+  return [...existingRules, getUserImportsLoaderRule(config, mode)];
 }
-function getUserImportsLoaderRule(cosmosConfig) {
+function getUserImportsLoaderRule(config, mode) {
   return {
     include: resolveRspackClientPath("userImports"),
     use: {
       loader: resolveRspackLoaderPath(),
-      options: { cosmosConfig }
+      options: { config, mode }
     }
   };
 }
 
 // src/server/rspackConfig/getRspackConfigResolve.ts
-import * as path6 from "node:path";
-function getRspackConfigResolve(cosmosConfig, rspackConfig) {
-  return resolveLocalReactDeps(cosmosConfig, rspackConfig.resolve);
+import * as path6 from "path";
+function getRspackConfigResolve(config, rspackConfig) {
+  return resolveLocalReactDeps(config, rspackConfig.resolve);
 }
-function resolveLocalReactDeps(cosmosConfig, resolve6 = {}) {
-  const { rootDir } = cosmosConfig;
+function resolveLocalReactDeps(config, resolve6 = {}) {
+  const { rootDir } = config;
   let alias = resolve6.alias || {};
   let reactAlias = hasAlias(alias, "react");
   let reactDomAlias = hasAlias(alias, "react-dom");
@@ -463,15 +463,15 @@ function ensureRspackConfigTopLevelAwait(baseWebpackConfig) {
 }
 
 // src/server/rspackConfig/getDevRspackConfig.ts
-async function getDevRspackConfig(cosmosConfig, userRspack) {
-  const baseRspackConfig = await getUserRspackConfig(cosmosConfig);
+async function getDevRspackConfig(config, userRspack) {
+  const baseRspackConfig = await getUserRspackConfig(config);
   const rspackConfig = {
     ...baseRspackConfig,
-    entry: getEntry(cosmosConfig),
-    output: getOutput(cosmosConfig),
-    module: getRspackConfigModule(cosmosConfig, baseRspackConfig),
-    resolve: getRspackConfigResolve(cosmosConfig, baseRspackConfig),
-    plugins: getPlugins(cosmosConfig, baseRspackConfig, userRspack),
+    entry: getEntry(config),
+    output: getOutput(config),
+    module: getRspackConfigModule(config, baseRspackConfig, "dev"),
+    resolve: getRspackConfigResolve(config, baseRspackConfig),
+    plugins: getPlugins(config, baseRspackConfig, userRspack),
     experiments: getExperiments(baseRspackConfig)
   };
   if (rspackConfig.optimization?.splitChunks) {
@@ -480,8 +480,8 @@ async function getDevRspackConfig(cosmosConfig, userRspack) {
   }
   return rspackConfig;
 }
-function getEntry(cosmosConfig) {
-  const { hotReload, reloadOnFail } = createRspackCosmosConfig(cosmosConfig);
+function getEntry(config) {
+  const { hotReload, reloadOnFail } = createRspackCosmosConfig(config);
   const devtoolsHook = resolveRspackClientPath("reactDevtoolsHook");
   const clientIndex = resolveRspackClientPath("index");
   return hotReload ? [devtoolsHook, getHotMiddlewareEntry(reloadOnFail), clientIndex] : [devtoolsHook, clientIndex];
@@ -495,12 +495,12 @@ function getOutput({ publicUrl }) {
     devtoolModuleFilenameTemplate: (info) => path7.resolve(info.absoluteResourcePath).replace(/\\/g, "/")
   };
 }
-function getPlugins(cosmosConfig, baseRspackConfig, userRspack) {
+function getPlugins(config, baseRspackConfig, userRspack) {
   const existingPlugins = ignoreEmptyRspackPlugins(baseRspackConfig.plugins);
-  const globalsPlugin = getGlobalsPlugin(cosmosConfig, userRspack, true);
+  const globalsPlugin = getGlobalsPlugin(config, userRspack, true);
   const noEmitErrorsPlugin = new userRspack.NoEmitOnErrorsPlugin();
   let plugins = [...existingPlugins, globalsPlugin, noEmitErrorsPlugin];
-  const { hotReload } = createRspackCosmosConfig(cosmosConfig);
+  const { hotReload } = createRspackCosmosConfig(config);
   if (hotReload && !hasPlugin(plugins, "HotModuleReplacementPlugin")) {
     const hmrPlugin = new userRspack.HotModuleReplacementPlugin();
     plugins = [...plugins, hmrPlugin];
@@ -517,29 +517,29 @@ function getExperiments(baseWebpackConfig) {
 
 // src/server/rspackDevServerPlugin.ts
 async function rspackDevServerPlugin({
-  cosmosConfig,
+  config,
   platform,
-  expressApp,
+  app,
   sendMessage
 }) {
   if (platform !== "web") {
     return;
   }
-  const userRspack = getRspack(cosmosConfig.rootDir);
+  const userRspack = getRspack(config.rootDir);
   if (!userRspack) {
     return;
   }
   const rspackConfig = await getDevRspackConfig(
-    cosmosConfig,
+    config,
     userRspack
   );
-  if (cosmosConfig.staticPath === null) {
+  if (config.staticPath === null) {
     const rspackDerivedStaticPath = getRspackStaticPath(rspackConfig);
     if (rspackDerivedStaticPath !== null) {
       serveStaticDir(
-        expressApp,
-        path8.resolve(cosmosConfig.rootDir, rspackDerivedStaticPath),
-        cosmosConfig.publicUrl
+        app,
+        path8.resolve(config.rootDir, rspackDerivedStaticPath),
+        config.publicUrl
       );
     }
   }
@@ -580,13 +580,13 @@ async function rspackDevServerPlugin({
     {
       // publicPath is the base path for the rspack assets and has to match
       // rspack.output.publicPath
-      publicPath: cosmosConfig.publicUrl
+      publicPath: config.publicUrl
     }
   );
-  expressApp.use(wdmInst);
-  const { hotReload } = createRspackCosmosConfig(cosmosConfig);
+  app.use(wdmInst);
+  const { hotReload } = createRspackCosmosConfig(config);
   if (hotReload) {
-    expressApp.use(
+    app.use(
       webpackHotMiddleware(
         // As above, rspack's Compiler type is pretty close to webpack's
         // Compiler type so this should be fine.
@@ -604,16 +604,16 @@ function getRspackStaticPath({ devServer }) {
 }
 
 // src/server/rspackConfig/getExportRspackConfig.ts
-import * as path9 from "node:path";
-async function getExportRspackConfig(cosmosConfig, userRspack) {
-  const baseRspackConfig = await getUserRspackConfig(cosmosConfig);
+import * as path9 from "path";
+async function getExportRspackConfig(config, userRspack) {
+  const baseRspackConfig = await getUserRspackConfig(config);
   return {
     ...baseRspackConfig,
     entry: getEntry2(),
-    output: getOutput2(cosmosConfig),
-    module: getRspackConfigModule(cosmosConfig, baseRspackConfig),
-    resolve: getRspackConfigResolve(cosmosConfig, baseRspackConfig),
-    plugins: getPlugins2(cosmosConfig, baseRspackConfig, userRspack),
+    output: getOutput2(config),
+    module: getRspackConfigModule(config, baseRspackConfig, "export"),
+    resolve: getRspackConfigResolve(config, baseRspackConfig),
+    plugins: getPlugins2(config, baseRspackConfig, userRspack),
     experiments: getExperiments2(baseRspackConfig)
   };
 }
@@ -622,18 +622,18 @@ function getEntry2() {
   const clientIndex = resolveRspackClientPath("index");
   return [devtoolsHook, clientIndex];
 }
-function getOutput2(cosmosConfig) {
-  const { exportPath, publicUrl } = cosmosConfig;
-  const { includeHashInOutputFilename } = createRspackCosmosConfig(cosmosConfig);
+function getOutput2(config) {
+  const { exportPath, publicUrl } = config;
+  const { includeHashInOutputFilename } = createRspackCosmosConfig(config);
   return {
     path: path9.join(exportPath, publicUrl),
     filename: includeHashInOutputFilename ? "[name].[contenthash].js" : "[name].js",
     publicPath: publicUrl
   };
 }
-function getPlugins2(cosmosConfig, baseRspackConfig, userRspack) {
+function getPlugins2(config, baseRspackConfig, userRspack) {
   const existingPlugins = ignoreEmptyRspackPlugins(baseRspackConfig.plugins);
-  const globalsPlugin = getGlobalsPlugin(cosmosConfig, userRspack, false);
+  const globalsPlugin = getGlobalsPlugin(config, userRspack, false);
   const noEmitErrorsPlugin = new userRspack.NoEmitOnErrorsPlugin();
   return ensureHtmlPlugin([
     ...existingPlugins,
@@ -646,12 +646,12 @@ function getExperiments2(baseWebpackConfig) {
 }
 
 // src/server/rspackExportPlugin.ts
-async function rspackExportPlugin({ cosmosConfig }) {
-  const userRspack = getRspack(cosmosConfig.rootDir);
+async function rspackExportPlugin({ config }) {
+  const userRspack = getRspack(config.rootDir);
   if (!userRspack) {
     return;
   }
-  const rspackConfig = await getExportRspackConfig(cosmosConfig, userRspack);
+  const rspackConfig = await getExportRspackConfig(config, userRspack);
   try {
     await runRspackCompiler(userRspack, rspackConfig);
   } catch (err) {

package/dist/server/userImportsLoader.cjs

@@ -4,7 +4,7 @@
 // dist folder as part of the build process
 module.exports = async function injectUserImports() {
   const cosmos = await import('react-cosmos');
-  const { cosmosConfig } = this.getOptions();
+  const { config, mode } = this.getOptions();
 
   // This ensures this loader is invalidated whenever a new file is added to or
   // removed from user's project, which in turn triggers findUserModulePaths
@@ -13,17 +13,18 @@ module.exports = async function injectUserImports() {
   // of require.context, which not only watches for file changes but also
   // automatically bundles new files that match the watcher's query.
   // https://github.com/webpack/webpack/issues/222#issuecomment-40691546
-  const watchDirs = cosmosConfig.watchDirs;
+  const watchDirs = config.watchDirs;
   watchDirs.forEach((watchDir) => this.addContextDependency(watchDir));
 
-  const { containerQuerySelector } = cosmosConfig.dom;
-  const modulePaths = await cosmos.findUserModulePaths(cosmosConfig);
+  const { containerQuerySelector } = config.dom;
+  const modulePaths = await cosmos.findUserModulePaths(config);
   const rendererConfig = {
-    playgroundUrl: cosmos.getPlaygroundUrl(cosmosConfig),
+    webSocketUrl: mode === 'dev' ? cosmos.getWebSocketUrl(config) : null,
+    rendererUrl: null,
     containerQuerySelector,
   };
   return cosmos.generateUserImports({
-    cosmosConfig,
+    config,
     modulePaths,
     rendererConfig,
     relativeToDir: null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-cosmos-plugin-rspack",
-  "version": "1.0.2",
+  "version": "2.0.0",
   "description": "rspack plugin for React Cosmos",
   "repository": "https://github.com/birchill/react-cosmos-plugin-rspack/",
   "author": "Birchill, Inc.",
@@ -12,26 +12,26 @@
   ],
   "type": "module",
   "dependencies": {
-    "react-cosmos-dom": ">=6.2.0",
+    "react-cosmos-dom": ">=7.0.0",
     "webpack-dev-middleware": "7.4.2",
     "webpack-hot-middleware": "2.26.1"
   },
   "devDependencies": {
     "@release-it/conventional-changelog": "10.0.1",
-    "@rspack/core": "1.3.7",
-    "@types/node": "22.15.2",
+    "@rspack/core": "1.3.15",
+    "@types/node": "22.15.30",
     "@types/webpack-hot-middleware": "2.25.9",
-    "esbuild": "0.25.3",
+    "esbuild": "0.25.5",
     "husky": "9.1.7",
-    "knip": "5.50.5",
-    "lint-staged": "15.5.1",
+    "knip": "5.60.2",
+    "lint-staged": "16.1.0",
     "prettier": "3.5.3",
-    "react-cosmos": "6.2.3",
-    "react-cosmos-core": "6.2.0",
-    "react-error-overlay": "6.1.0",
+    "react-cosmos": "7.0.0",
+    "react-cosmos-core": "7.0.0",
+    "react-error-overlay": "6.0.9",
     "react-plugin": "3.0.0-alpha.4",
-    "release-it": "19.0.1",
-    "tsup": "8.4.0",
+    "release-it": "19.0.3",
+    "tsup": "8.5.0",
     "typescript": "5.8.3"
   },
   "prettier": {