react-cosmos-plugin-rspack 0.0.1

package/dist/client/reactDevtoolsHook.js

@@ -0,0 +1,8 @@
+// src/client/reactDevtoolsHook.ts
+if (process.env.NODE_ENV === "development") {
+  try {
+    window.__REACT_DEVTOOLS_GLOBAL_HOOK__ = window.parent.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+  } catch (err) {
+    console.warn("Could not access parent React devtools hook");
+  }
+}

package/dist/client/userImports.js

@@ -0,0 +1,13 @@
+// src/client/userImports.ts
+var rendererConfig = {
+  playgroundUrl: "http://localhost:5000"
+};
+var moduleWrappers = {
+  lazy: false,
+  fixtures: {},
+  decorators: {}
+};
+export {
+  moduleWrappers,
+  rendererConfig
+};

package/dist/server/rspackServerPlugin.js

@@ -0,0 +1,691 @@
+// src/server/rspackConfigPlugin.ts
+import * as path from "node:path";
+
+// src/server/rspackConfig/constants.ts
+var RENDERER_FILENAME = "renderer.html";
+
+// src/server/rspackConfigPlugin.ts
+async function rspackConfigPlugin({
+  cosmosConfig
+}) {
+  if (cosmosConfig.rendererUrl) {
+    return cosmosConfig;
+  }
+  return {
+    ...cosmosConfig,
+    rendererUrl: path.join(cosmosConfig.publicUrl, RENDERER_FILENAME)
+  };
+}
+
+// src/server/rspackDevServerPlugin.ts
+import * as path8 from "node:path";
+import { serveStaticDir } from "react-cosmos";
+import webpackHotMiddleware from "webpack-hot-middleware";
+
+// src/server/cosmosConfig/createRspackCosmosConfig.ts
+import * as path3 from "node:path";
+import { fileExists } from "react-cosmos";
+
+// src/server/utils/resolveLoose.ts
+import * as path2 from "node:path";
+
+// src/server/utils/isNodeError.ts
+function isNodeError(err) {
+  return err && err.stack && err.message;
+}
+
+// src/server/utils/resolve.ts
+import { createRequire } from "node:module";
+function resolve(moduleId) {
+  const require2 = createRequire(import.meta.url);
+  return require2.resolve(moduleId);
+}
+function resolveFrom(fromDirectory, moduleId) {
+  const require2 = createRequire(import.meta.url);
+  return require2.resolve(moduleId, { paths: [fromDirectory] });
+}
+
+// src/server/utils/resolveSilent.ts
+function resolveFromSilent(fromDirectory, moduleId) {
+  try {
+    return resolveFrom(fromDirectory, moduleId);
+  } catch (err) {
+    if (!isNodeError(err) || err.code !== "MODULE_NOT_FOUND") console.log(err);
+    return null;
+  }
+}
+
+// src/server/utils/resolveLoose.ts
+function resolveLoose(fromDirectory, moduleId) {
+  return path2.isAbsolute(moduleId) ? moduleId : resolveFromSilent(fromDirectory, moduleId) || // Final attempt: Resolve relative paths that don't either
+  // 1. Don't start with ./
+  // 2. Don't point to an existing file
+  path2.join(fromDirectory, moduleId);
+}
+
+// src/server/cosmosConfig/createRspackCosmosConfig.ts
+function createRspackCosmosConfig(cosmosConfig) {
+  const { rootDir } = cosmosConfig;
+  const configInput = cosmosConfig.rspack || {};
+  return {
+    configPath: getRspackConfigPath(configInput, rootDir),
+    overridePath: getRspackOverridePath(configInput, rootDir),
+    includeHashInOutputFilename: getIncludeHashInOutputFilename(configInput),
+    hotReload: getHotReload(configInput),
+    reloadOnFail: getReloadOnFail(configInput)
+  };
+}
+function getRspackConfigPath({ configPath }, rootDir) {
+  if (typeof configPath === "undefined") {
+    return resolveLoose(rootDir, "rspack.config.js");
+  }
+  if (!configPath) {
+    return null;
+  }
+  const absPath = resolveLoose(rootDir, configPath);
+  if (!fileExists(absPath)) {
+    const relPath = path3.relative(process.cwd(), absPath);
+    throw new Error(`rspack config not found at path: ${relPath}`);
+  }
+  return absPath;
+}
+function getRspackOverridePath({ overridePath }, rootDir) {
+  if (typeof overridePath === "undefined") {
+    return resolveLoose(rootDir, "rspack.override.js");
+  }
+  if (!overridePath) {
+    return null;
+  }
+  const absPath = resolveLoose(rootDir, overridePath);
+  if (!fileExists(absPath)) {
+    const relPath = path3.relative(process.cwd(), absPath);
+    throw new Error(`rspack override module not found at path: ${relPath}`);
+  }
+  return absPath;
+}
+function getIncludeHashInOutputFilename({
+  includeHashInOutputFilename = false
+}) {
+  return includeHashInOutputFilename;
+}
+function getHotReload({ hotReload = true }) {
+  return hotReload;
+}
+function getReloadOnFail({ reloadOnFail = false }) {
+  return reloadOnFail;
+}
+
+// src/server/utils/requireModule.ts
+import { createRequire as createRequire2 } from "node:module";
+import * as path4 from "node:path";
+function requireFrom(fromDirectory, moduleId) {
+  const require2 = createRequire2(path4.resolve(fromDirectory, "noop.js"));
+  return require2(moduleId);
+}
+
+// src/server/utils/requireSilent.ts
+function requireFromSilent(fromDirectory, moduleId) {
+  try {
+    return requireFrom(fromDirectory, moduleId);
+  } catch (err) {
+    if (!isNodeError(err) || err.code !== "MODULE_NOT_FOUND") {
+      console.log(err);
+    }
+  }
+}
+
+// src/server/getRspack.ts
+function getRspack(rootDir) {
+  const userRspack = requireFromSilent(
+    rootDir,
+    "@rspack/core"
+  );
+  if (!userRspack) {
+    console.warn("[Cosmos] rspack dependency missing!");
+    console.log(
+      'Install using "yarn add --dev @rspack/core" or "npm install --save-dev @rspack/core"'
+    );
+    return;
+  }
+  return userRspack.rspack;
+}
+
+// src/server/rspackConfig/getDevRspackConfig.ts
+import * as path7 from "node:path";
+
+// src/server/rspackConfig/getUserRspackConfig.ts
+import * as path5 from "node:path";
+import {
+  getCliArgs,
+  importModule,
+  moduleExists
+} from "react-cosmos";
+
+// src/server/rspackConfig/getRspackNodeEnv.ts
+function getRspackNodeEnv() {
+  return process.env.NODE_ENV === "production" ? "production" : "development";
+}
+
+// src/server/utils/omit.ts
+function omit(o, fields) {
+  const result = { ...o };
+  for (const field of fields) {
+    delete result[field];
+  }
+  return result;
+}
+
+// src/server/rspackConfig/plugins.ts
+function getGlobalsPlugin({ publicUrl }, userRspack, devServerOn) {
+  const cleanPublicUrl = removeTrailingSlash(publicUrl);
+  return new userRspack.DefinePlugin({
+    // "if (__DEV__)" blocks get stripped when compiling a static export build
+    __DEV__: JSON.stringify(devServerOn),
+    "process.env.NODE_ENV": JSON.stringify(getRspackNodeEnv()),
+    "process.env.PUBLIC_URL": JSON.stringify(cleanPublicUrl)
+  });
+}
+function hasPlugin(plugins, pluginName) {
+  return plugins && plugins.filter((p) => isInstanceOfRspackPlugin(p, pluginName)).length > 0;
+}
+function isInstanceOfRspackPlugin(plugin, constructorName) {
+  return plugin.constructor && plugin.constructor.name === constructorName;
+}
+function ignoreEmptyRspackPlugins(plugins = []) {
+  return plugins.filter(Boolean);
+}
+function removeTrailingSlash(url) {
+  return url.replace(/\/$/, "");
+}
+
+// src/server/rspackConfig/htmlPlugin.ts
+function ensureHtmlWebpackPlugin({ rootDir }, plugins) {
+  if (hasPlugin(plugins, "HtmlWebpackPlugin")) {
+    return plugins.map(
+      (plugin) => isHtmlWebpackPlugin(plugin) ? changeHtmlPluginFilename(plugin) : plugin
+    );
+  }
+  const htmlWebpackPlugin = getHtmlWebpackPlugin(rootDir);
+  if (!htmlWebpackPlugin) {
+    return plugins;
+  }
+  return [
+    ...plugins,
+    new htmlWebpackPlugin({
+      title: "React Cosmos",
+      filename: RENDERER_FILENAME
+    })
+  ];
+}
+function getHtmlWebpackPlugin(rootDir) {
+  return requireFromSilent(
+    rootDir,
+    "html-webpack-plugin"
+  );
+}
+function isHtmlWebpackPlugin(plugin) {
+  return isInstanceOfRspackPlugin(plugin, "HtmlWebpackPlugin");
+}
+function changeHtmlPluginFilename(htmlPlugin) {
+  if (!isIndexHtmlWebpackPlugin(htmlPlugin)) {
+    return htmlPlugin;
+  }
+  const options = htmlPlugin.userOptions || htmlPlugin.options;
+  const safeOptions = omit(options, ["chunks"]);
+  return new htmlPlugin.constructor({
+    ...safeOptions,
+    filename: RENDERER_FILENAME
+  });
+}
+function isIndexHtmlWebpackPlugin(htmlPlugin) {
+  const { filename } = htmlPlugin.userOptions || htmlPlugin.options;
+  return filename === "index.html" || typeof filename !== "string" || filename.endsWith("/index.html");
+}
+
+// src/server/rspackConfig/getDefaultRspackConfig.ts
+function getDefaultRspackConfig(rootDir) {
+  const postcssLoaderPath = resolveFromSilent(rootDir, "postcss-loader");
+  const mdxLoaderPath = resolveFromSilent(rootDir, "@mdx-js/loader");
+  const rules = [];
+  const plugins = [];
+  rules.push({
+    test: /\.(j|t)s$/,
+    exclude: [/[\\/]node_modules[\\/]/],
+    loader: "builtin:swc-loader",
+    options: {
+      sourceMap: true,
+      jsc: { parser: { syntax: "typescript" } }
+    },
+    type: "javascript/auto"
+  });
+  rules.push({
+    test: /\.(j|t)sx$/,
+    loader: "builtin:swc-loader",
+    exclude: [/[\\/]node_modules[\\/]/],
+    options: {
+      sourceMap: true,
+      jsc: {
+        parser: {
+          syntax: "typescript",
+          tsx: true
+        },
+        transform: { react: { runtime: "automatic" } }
+      }
+    },
+    type: "javascript/auto"
+  });
+  rules.push({
+    test: /\.css?$/,
+    exclude: [/[\\/]node_modules[\\/]/],
+    use: postcssLoaderPath ? [{ loader: postcssLoaderPath }] : void 0,
+    type: "css"
+  });
+  if (mdxLoaderPath) {
+    rules.push({
+      test: /\.mdx$/,
+      loader: mdxLoaderPath,
+      exclude: [/[\\/]node_modules[\\/]/]
+    });
+  }
+  const htmlWebpackPlugin = getHtmlWebpackPlugin(rootDir);
+  if (htmlWebpackPlugin) {
+    plugins.push(
+      new htmlWebpackPlugin({
+        title: "React Cosmos",
+        filename: RENDERER_FILENAME
+      })
+    );
+  }
+  const config = {
+    // Besides other advantages, cheap-module-source-map is compatible with
+    // React.componentDidCatch https://github.com/facebook/react/issues/10441
+    devtool: "cheap-module-source-map",
+    resolve: {
+      extensionAlias: {
+        ".js": [".ts", ".tsx", ".js"]
+      },
+      extensions: [".js", ".jsx", ".ts", ".tsx"]
+    },
+    module: {
+      rules
+    },
+    plugins,
+    stats: {
+      preset: "errors-only",
+      builtAt: true
+    },
+    infrastructureLogging: { level: "warn" },
+    experiments: {
+      topLevelAwait: true
+    }
+  };
+  return {
+    ...config,
+    mode: getRspackNodeEnv(),
+    optimization: {
+      // Cosmos reads component names at run-time, so it is crucial to not
+      // minify even when building with production env (ie. when exporting)
+      // https://github.com/react-cosmos/react-cosmos/issues/701
+      minimize: false
+    }
+  };
+}
+
+// src/server/rspackConfig/getUserRspackConfig.ts
+async function getUserRspackConfig(cosmosConfig) {
+  const baseRspackConfig = await getBaseRspackConfig(cosmosConfig);
+  const { overridePath } = createRspackCosmosConfig(cosmosConfig);
+  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`
+    );
+    return baseRspackConfig;
+  }
+  const relPath = path5.relative(process.cwd(), overridePath);
+  console.log(`[Cosmos] Overriding rspack config at ${relPath}`);
+  const module = await importModule(overridePath);
+  const rspackOverride = module.default;
+  return rspackOverride(baseRspackConfig, getRspackNodeEnv());
+}
+async function getBaseRspackConfig(cosmosConfig) {
+  const { rootDir } = cosmosConfig;
+  const { configPath } = createRspackCosmosConfig(cosmosConfig);
+  if (!configPath || !moduleExists(configPath)) {
+    console.log("[Cosmos] Using default rspack config");
+    return getDefaultRspackConfig(rootDir);
+  }
+  const relPath = path5.relative(process.cwd(), configPath);
+  console.log(`[Cosmos] Using rspack config found at ${relPath}`);
+  const module = await importModule(configPath);
+  const rspackConfig = module.default;
+  const cliArgs = getCliArgs();
+  return typeof rspackConfig === "function" ? (
+    // When cliargs.env is falsey, react-cosmos-plugin-webpack passes the result
+    // of getRspackNodeEnv() which is the string "production" or "development"
+    // but that doesn't seem to be what webpack does:
+    //
+    // https://github.com/webpack/webpack-cli/blob/79a969fb02c870667d8a3b7035405566d2b4d088/packages/webpack-cli/src/webpack-cli.ts#L1903C35-L1903C43
+    await rspackConfig(cliArgs.env || {}, cliArgs)
+  ) : rspackConfig;
+}
+
+// src/server/rspackConfig/resolveRspackClientPath.ts
+import { createRequire as createRequire3 } from "node: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";
+function resolveRspackLoaderPath() {
+  const require2 = createRequire4(import.meta.url);
+  return require2.resolve("./userImportsLoader.cjs");
+}
+
+// src/server/rspackConfig/getRspackConfigModule.ts
+function getRspackConfigModule(cosmosConfig, rspackConfig) {
+  return {
+    ...rspackConfig.module,
+    rules: getRules(cosmosConfig, rspackConfig)
+  };
+}
+function getRules(cosmosConfig, { module }) {
+  const existingRules = module && module.rules || [];
+  return [...existingRules, getUserImportsLoaderRule(cosmosConfig)];
+}
+function getUserImportsLoaderRule(cosmosConfig) {
+  return {
+    include: resolveRspackClientPath("userImports"),
+    use: {
+      loader: resolveRspackLoaderPath(),
+      options: { cosmosConfig }
+    }
+  };
+}
+
+// src/server/rspackConfig/getRspackConfigResolve.ts
+import * as path6 from "node:path";
+function getRspackConfigResolve(cosmosConfig, rspackConfig) {
+  return resolveLocalReactDeps(cosmosConfig, rspackConfig.resolve);
+}
+function resolveLocalReactDeps(cosmosConfig, resolve6 = {}) {
+  const { rootDir } = cosmosConfig;
+  let alias = resolve6.alias || {};
+  let reactAlias = hasAlias(alias, "react");
+  let reactDomAlias = hasAlias(alias, "react-dom");
+  if (reactAlias && reactDomAlias) {
+    console.log("[Cosmos] React and React DOM aliases found in rspack config");
+    return resolve6;
+  }
+  if (reactAlias) {
+    console.log("[Cosmos] React alias found in rspack config");
+  } else {
+    const reactPath = resolveFromSilent(rootDir, "react");
+    if (!reactPath)
+      throw new Error(`[Cosmos] Local dependency not found: react`);
+    alias = addAlias(alias, "react", path6.dirname(reactPath));
+  }
+  if (reactDomAlias) {
+    console.log("[Cosmos] React DOM alias found in rspack config");
+  } else {
+    const reactDomPath = resolveFromSilent(rootDir, "react-dom");
+    if (!reactDomPath)
+      throw new Error(`[Cosmos] Local dependency not found: react-dom`);
+    alias = addAlias(alias, "react-dom", path6.dirname(reactDomPath));
+  }
+  return { ...resolve6, alias };
+}
+function hasAlias(alias, name) {
+  if (!alias) return false;
+  const exactName = `${name}$`;
+  const keys = Object.keys(alias);
+  return keys.includes(name) || keys.includes(exactName);
+}
+function addAlias(alias, name, value) {
+  return { ...alias, [name]: value };
+}
+
+// src/server/rspackConfig/rspackConfigTopLevelAwait.ts
+function ensureRspackConfigTopLevelAwait(baseWebpackConfig) {
+  const experiments = baseWebpackConfig.experiments || {};
+  if (!experiments.topLevelAwait) {
+    experiments.topLevelAwait = true;
+  }
+  return experiments;
+}
+
+// src/server/rspackConfig/getDevRspackConfig.ts
+async function getDevRspackConfig(cosmosConfig, userRspack) {
+  const baseRspackConfig = await getUserRspackConfig(cosmosConfig);
+  const rspackConfig = {
+    ...baseRspackConfig,
+    entry: getEntry(cosmosConfig),
+    output: getOutput(cosmosConfig),
+    module: getRspackConfigModule(cosmosConfig, baseRspackConfig),
+    resolve: getRspackConfigResolve(cosmosConfig, baseRspackConfig),
+    plugins: getPlugins(cosmosConfig, baseRspackConfig, userRspack),
+    experiments: getExperiments(baseRspackConfig)
+  };
+  if (rspackConfig.optimization?.splitChunks) {
+    const { name } = rspackConfig.optimization.splitChunks;
+    if (name === false) delete rspackConfig.optimization.splitChunks.name;
+  }
+  return rspackConfig;
+}
+function getEntry(cosmosConfig) {
+  const { hotReload, reloadOnFail } = createRspackCosmosConfig(cosmosConfig);
+  const devtoolsHook = resolveRspackClientPath("reactDevtoolsHook");
+  const clientIndex = resolveRspackClientPath("index");
+  return hotReload ? [devtoolsHook, getHotMiddlewareEntry(reloadOnFail), clientIndex] : [devtoolsHook, clientIndex];
+}
+function getOutput({ publicUrl }) {
+  const filename = "[name].js";
+  return {
+    filename,
+    publicPath: publicUrl,
+    // Enable click-to-open source in react-error-overlay
+    devtoolModuleFilenameTemplate: (info) => path7.resolve(info.absoluteResourcePath).replace(/\\/g, "/")
+  };
+}
+function getPlugins(cosmosConfig, baseRspackConfig, userRspack) {
+  const existingPlugins = ignoreEmptyRspackPlugins(baseRspackConfig.plugins);
+  const globalsPlugin = getGlobalsPlugin(cosmosConfig, userRspack, true);
+  let plugins = [...existingPlugins, globalsPlugin];
+  const { hotReload } = createRspackCosmosConfig(cosmosConfig);
+  if (hotReload && !hasPlugin(plugins, "HotModuleReplacementPlugin")) {
+    const hmrPlugin = new userRspack.HotModuleReplacementPlugin();
+    plugins = [...plugins, hmrPlugin];
+  }
+  return ensureHtmlWebpackPlugin(cosmosConfig, plugins);
+}
+function getHotMiddlewareEntry(reloadOnFail) {
+  const clientPath = resolve("webpack-hot-middleware/client");
+  return `${clientPath}?reload=${reloadOnFail}&overlay=false`;
+}
+function getExperiments(baseWebpackConfig) {
+  return ensureRspackConfigTopLevelAwait(baseWebpackConfig);
+}
+
+// src/server/rspackDevServerPlugin.ts
+async function rspackDevServerPlugin({
+  cosmosConfig,
+  platform,
+  expressApp,
+  sendMessage
+}) {
+  if (platform !== "web") {
+    return;
+  }
+  const userRspack = getRspack(cosmosConfig.rootDir);
+  if (!userRspack) {
+    return;
+  }
+  const rspackConfig = await getDevRspackConfig(
+    cosmosConfig,
+    userRspack
+  );
+  if (cosmosConfig.staticPath === null) {
+    const rspackDerivedStaticPath = getRspackStaticPath(rspackConfig);
+    if (rspackDerivedStaticPath !== null) {
+      serveStaticDir(
+        expressApp,
+        path8.resolve(cosmosConfig.rootDir, rspackDerivedStaticPath),
+        cosmosConfig.publicUrl
+      );
+    }
+  }
+  function sendBuildMessage(msg) {
+    sendMessage(msg);
+  }
+  const rspackCompiler = userRspack(rspackConfig);
+  rspackCompiler.hooks.invalid.tap("Cosmos", (filePath) => {
+    if (typeof filePath === "string") {
+      const relFilePath = path8.relative(process.cwd(), filePath);
+      console.log("[Cosmos] rspack build invalidated by", relFilePath);
+    } else {
+      console.log("[Cosmos] rspack build invalidated by unknown file");
+    }
+    sendBuildMessage({ type: "buildStart" });
+  });
+  rspackCompiler.hooks.failed.tap("Cosmos", () => {
+    sendBuildMessage({ type: "buildError" });
+  });
+  const onCompilationDone = new Promise((resolve6) => {
+    rspackCompiler.hooks.done.tap("Cosmos", (stats) => {
+      resolve6();
+      if (stats.hasErrors()) {
+        sendBuildMessage({ type: "buildError" });
+      } else {
+        sendBuildMessage({ type: "buildDone" });
+      }
+    });
+  });
+  console.log("[Cosmos] Building rspack...");
+  const wdmModule = await import("webpack-dev-middleware");
+  const wdmInst = wdmModule.default(
+    // Rspack's Compiler type is pretty close to webpack's Compiler type, but
+    // is missing a few members. Hopefully WDM doesn't need them, however.
+    // @rspack/dev-server itself uses webpack-dev-middleware so it should be
+    // fine.
+    rspackCompiler,
+    {
+      // publicPath is the base path for the rspack assets and has to match
+      // rspack.output.publicPath
+      publicPath: cosmosConfig.publicUrl
+    }
+  );
+  expressApp.use(wdmInst);
+  const { hotReload } = createRspackCosmosConfig(cosmosConfig);
+  if (hotReload) {
+    expressApp.use(
+      webpackHotMiddleware(
+        // As above, rspack's Compiler type is pretty close to webpack's
+        // Compiler type so this should be fine.
+        rspackCompiler
+      )
+    );
+  }
+  await onCompilationDone;
+  return async () => {
+    await new Promise((res) => wdmInst.close(res));
+  };
+}
+function getRspackStaticPath({ devServer }) {
+  return devServer && typeof devServer.contentBase === "string" ? devServer.contentBase : null;
+}
+
+// src/server/rspackConfig/getExportRspackConfig.ts
+import * as path9 from "node:path";
+async function getExportRspackConfig(cosmosConfig, userRspack) {
+  const baseRspackConfig = await getUserRspackConfig(cosmosConfig);
+  return {
+    ...baseRspackConfig,
+    entry: getEntry2(),
+    output: getOutput2(cosmosConfig),
+    module: getRspackConfigModule(cosmosConfig, baseRspackConfig),
+    resolve: getRspackConfigResolve(cosmosConfig, baseRspackConfig),
+    plugins: getPlugins2(cosmosConfig, baseRspackConfig, userRspack),
+    experiments: getExperiments2(baseRspackConfig)
+  };
+}
+function getEntry2() {
+  const devtoolsHook = resolveRspackClientPath("reactDevtoolsHook");
+  const clientIndex = resolveRspackClientPath("index");
+  return [devtoolsHook, clientIndex];
+}
+function getOutput2(cosmosConfig) {
+  const { exportPath, publicUrl } = cosmosConfig;
+  const { includeHashInOutputFilename } = createRspackCosmosConfig(cosmosConfig);
+  return {
+    path: path9.join(exportPath, publicUrl),
+    filename: includeHashInOutputFilename ? "[name].[contenthash].js" : "[name].js",
+    publicPath: publicUrl
+  };
+}
+function getPlugins2(cosmosConfig, baseRspackConfig, userRspack) {
+  const existingPlugins = ignoreEmptyRspackPlugins(baseRspackConfig.plugins);
+  const globalsPlugin = getGlobalsPlugin(cosmosConfig, userRspack, false);
+  return ensureHtmlWebpackPlugin(cosmosConfig, [
+    ...existingPlugins,
+    globalsPlugin
+  ]);
+}
+function getExperiments2(baseWebpackConfig) {
+  return ensureRspackConfigTopLevelAwait(baseWebpackConfig);
+}
+
+// src/server/rspackExportPlugin.ts
+async function rspackExportPlugin({ cosmosConfig }) {
+  const userRspack = getRspack(cosmosConfig.rootDir);
+  if (!userRspack) {
+    return;
+  }
+  const rspackConfig = await getExportRspackConfig(cosmosConfig, userRspack);
+  try {
+    await runRspackCompiler(userRspack, rspackConfig);
+  } catch (err) {
+    const rspackError = err;
+    if (rspackError.rspackErrors) {
+      rspackError.rspackErrors.forEach((error) => {
+        console.error(`${error}
+`);
+      });
+    }
+    throw rspackError;
+  }
+}
+function runRspackCompiler(userRspack, rspackConfig) {
+  return new Promise((resolve6, reject) => {
+    const compiler = userRspack(rspackConfig);
+    compiler.run((err, stats) => {
+      if (err) {
+        reject(err);
+      } else if (stats?.hasErrors()) {
+        const error = new RspackCompilationError();
+        error.rspackErrors = stats.toJson().errors;
+        reject(error);
+      } else {
+        resolve6(stats);
+      }
+    });
+  });
+}
+var RspackCompilationError = class extends Error {
+  rspackErrors;
+  constructor() {
+    super("Rspack errors occurred");
+  }
+};
+
+// src/server/rspackServerPlugin.ts
+var rspackServerPlugin = {
+  name: "rspack",
+  config: rspackConfigPlugin,
+  devServer: rspackDevServerPlugin,
+  export: rspackExportPlugin
+};
+var rspackServerPlugin_default = rspackServerPlugin;
+export {
+  rspackServerPlugin_default as default
+};