react-cosmos-plugin-rspack 1.0.3 → 2.0.1

package/dist/server/rspackServerPlugin.js

@@ -1,701 +0,0 @@
-// src/server/rspackConfigPlugin.ts
-import * as path from "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 "path";
-import { serveStaticDir } from "react-cosmos";
-import webpackHotMiddleware from "webpack-hot-middleware";
-
-// src/server/cosmosConfig/createRspackCosmosConfig.ts
-import * as path3 from "path";
-import { fileExists } from "react-cosmos";
-
-// src/server/utils/resolveLoose.ts
-import * as path2 from "path";
-
-// src/server/utils/isNodeError.ts
-function isNodeError(err) {
-  return err && err.stack && err.message;
-}
-
-// src/server/utils/resolve.ts
-import { createRequire } from "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 "module";
-import * as path4 from "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 "path";
-
-// src/server/rspackConfig/getUserRspackConfig.ts
-import * as path5 from "path";
-import {
-  getCliArgs,
-  importModule,
-  moduleExists
-} from "react-cosmos";
-
-// src/server/rspackConfig/getDefaultRspackConfig.ts
-import rspack from "@rspack/core";
-
-// src/server/rspackConfig/getRspackNodeEnv.ts
-function getRspackNodeEnv() {
-  return process.env.NODE_ENV === "production" ? "production" : "development";
-}
-
-// 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: {
-      sourceMaps: true,
-      jsc: { parser: { syntax: "typescript" } }
-    },
-    type: "javascript/auto"
-  });
-  rules.push({
-    test: /\.(j|t)sx$/,
-    loader: "builtin:swc-loader",
-    exclude: [/[\\/]node_modules[\\/]/],
-    options: {
-      sourceMaps: true,
-      jsc: {
-        parser: {
-          syntax: "typescript",
-          tsx: true
-        },
-        transform: { react: { runtime: "automatic" } }
-      }
-    },
-    type: "javascript/auto"
-  });
-  rules.push({
-    test: /\.css$/,
-    use: postcssLoaderPath ? [{ loader: postcssLoaderPath }] : [{ loader: "builtin:lightningcss-loader" }],
-    type: "css/auto"
-  });
-  if (mdxLoaderPath) {
-    rules.push({
-      test: /\.mdx$/,
-      loader: mdxLoaderPath,
-      exclude: [/[\\/]node_modules[\\/]/]
-    });
-  }
-  plugins.push(
-    new rspack.HtmlRspackPlugin({
-      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 "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 "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 "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/htmlPlugin.ts
-import rspack2 from "@rspack/core";
-
-// 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 ensureHtmlPlugin(plugins) {
-  if (hasPlugin(plugins, "HtmlWebpackPlugin")) {
-    return plugins.map(
-      (plugin) => isHtmlWebpackPlugin(plugin) ? changeHtmlPluginFilename(plugin) : plugin
-    );
-  }
-  const htmlRspackPlugin = plugins.find(isHtmlRspackPlugin);
-  if (htmlRspackPlugin) {
-    const options = htmlRspackPlugin._args[0];
-    const safeOptions = omit(options, ["chunks"]);
-    return [
-      ...plugins.filter((plugin) => plugin !== htmlRspackPlugin),
-      new rspack2.HtmlRspackPlugin({
-        ...safeOptions,
-        filename: RENDERER_FILENAME
-      })
-    ];
-  }
-  return [
-    ...plugins,
-    new rspack2.HtmlRspackPlugin({
-      title: "React Cosmos",
-      filename: RENDERER_FILENAME
-    })
-  ];
-}
-function isHtmlWebpackPlugin(plugin) {
-  return isInstanceOfRspackPlugin(plugin, "HtmlWebpackPlugin");
-}
-function isHtmlRspackPlugin(plugin) {
-  return isInstanceOfRspackPlugin(plugin, "HtmlRspackPlugin");
-}
-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/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);
-  const noEmitErrorsPlugin = new userRspack.NoEmitOnErrorsPlugin();
-  let plugins = [...existingPlugins, globalsPlugin, noEmitErrorsPlugin];
-  const { hotReload } = createRspackCosmosConfig(cosmosConfig);
-  if (hotReload && !hasPlugin(plugins, "HotModuleReplacementPlugin")) {
-    const hmrPlugin = new userRspack.HotModuleReplacementPlugin();
-    plugins = [...plugins, hmrPlugin];
-  }
-  return ensureHtmlPlugin(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 "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);
-  const noEmitErrorsPlugin = new userRspack.NoEmitOnErrorsPlugin();
-  return ensureHtmlPlugin([
-    ...existingPlugins,
-    globalsPlugin,
-    noEmitErrorsPlugin
-  ]);
-}
-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
-};