shakapacker 8.4.0 → 9.0.0

data/lib/shakapacker.rb

@@ -6,7 +6,7 @@ require "active_support/tagged_logging"
 module Shakapacker
   extend self
 
-  DEFAULT_ENV = "production".freeze
+  DEFAULT_ENV = "development".freeze
 
   def instance=(instance)
     @instance = instance
@@ -44,6 +44,7 @@ require_relative "shakapacker/manifest"
 require_relative "shakapacker/compiler"
 require_relative "shakapacker/commands"
 require_relative "shakapacker/dev_server"
+require_relative "shakapacker/doctor"
 require_relative "shakapacker/deprecation_helper"
 
 require_relative "shakapacker/railtie" if defined?(Rails)

data/lib/tasks/shakapacker/doctor.rake

@@ -0,0 +1,8 @@
+require "shakapacker/doctor"
+
+namespace :shakapacker do
+  desc "Checks for common Shakapacker configuration issues and missing dependencies"
+  task doctor: :environment do
+    Shakapacker::Doctor.new.run
+  end
+end

data/lib/tasks/shakapacker/install.rake

@@ -2,10 +2,20 @@ install_template_path = File.expand_path("../../install/template.rb", __dir__).f
 bin_path = ENV["BUNDLE_BIN"] || Rails.root.join("bin")
 
 namespace :shakapacker do
-  desc "Install Shakapacker in this application"
-  task install: [:check_node] do |task|
+  desc "Install Shakapacker in this application (use SHAKAPACKER_ASSETS_BUNDLER=rspack for Rspack, --typescript for TypeScript)"
+  task :install, [:bundler, :typescript] => [:check_node] do |task, args|
     Shakapacker::Configuration.installing = true
 
+    if args[:bundler] == "rspack" || ENV["SHAKAPACKER_ASSETS_BUNDLER"] == "rspack"
+      ENV["SHAKAPACKER_ASSETS_BUNDLER"] = "rspack"
+    end
+
+    # Set typescript flag if passed as argument
+    # Accepts: typescript, true, or any truthy value
+    if args[:typescript] && args[:typescript] != "false"
+      ENV["SHAKAPACKER_USE_TYPESCRIPT"] = "true"
+    end
+
     prefix = task.name.split(/#|shakapacker:install/).first
 
     if Rails::VERSION::MAJOR >= 5

data/lib/tasks/shakapacker/migrate_to_swc.rake

@@ -0,0 +1,13 @@
+require "shakapacker/swc_migrator"
+
+namespace :shakapacker do
+  desc "Migrate from Babel to SWC transpiler"
+  task :migrate_to_swc do
+    Shakapacker::SwcMigrator.new(Rails.root).migrate_to_swc
+  end
+
+  desc "Remove Babel packages after migrating to SWC"
+  task :clean_babel_packages do
+    Shakapacker::SwcMigrator.new(Rails.root).clean_babel_packages
+  end
+end

data/lib/tasks/shakapacker.rake

@@ -9,6 +9,7 @@ tasks = {
   "shakapacker:check_binstubs"          => "Verifies that bin/shakapacker is present",
   "shakapacker:binstubs"                => "Installs Shakapacker binstubs in this application",
   "shakapacker:verify_install"          => "Verifies if Shakapacker is installed",
+  "shakapacker:doctor"                  => "Checks for configuration issues and missing dependencies"
 }.freeze
 
 desc "Lists all available tasks in Shakapacker"

data/package/.npmignore

@@ -0,0 +1,4 @@
+# Exclude TypeScript source files from the package directory
+*.ts
+# But keep the TypeScript declaration files
+!*.d.ts

data/package/babel/preset.ts

@@ -0,0 +1,56 @@
+import { moduleExists, packageFullVersion } from "../utils/helpers"
+import type { ConfigAPI, PluginItem } from "@babel/core"
+
+const CORE_JS_VERSION_REGEX = /^\d+\.\d+/
+
+const coreJsVersion = (): string => {
+  try {
+    const version = packageFullVersion("core-js").match(CORE_JS_VERSION_REGEX)
+    return version?.[0] ?? "3.8"
+  } catch (e) {
+    const error = e as NodeJS.ErrnoException
+    if (error.code !== "MODULE_NOT_FOUND") {
+      throw e
+    }
+
+    return "3.8"
+  }
+}
+
+export = function config(api: ConfigAPI): { presets: PluginItem[]; plugins: PluginItem[] } {
+  const validEnv = ["development", "test", "production"]
+  const currentEnv = api.env()
+  const isDevelopmentEnv = api.env("development")
+  const isProductionEnv = api.env("production")
+  const isTestEnv = api.env("test")
+
+  if (!validEnv.includes(currentEnv)) {
+    throw new Error(
+      `Please specify a valid NODE_ENV or BABEL_ENV environment variable. Valid values are "development", "test", and "production". Instead, received: "${currentEnv}".`
+    )
+  }
+
+  const presets: PluginItem[] = [
+    isTestEnv && ["@babel/preset-env", { targets: { node: "current" } }],
+    (isProductionEnv || isDevelopmentEnv) && [
+      "@babel/preset-env",
+      {
+        useBuiltIns: "entry",
+        corejs: coreJsVersion(),
+        modules: "auto",
+        bugfixes: true,
+        exclude: ["transform-typeof-symbol"]
+      }
+    ],
+    moduleExists("@babel/preset-typescript") && "@babel/preset-typescript"
+  ].filter(Boolean) as PluginItem[]
+
+  const plugins: PluginItem[] = [["@babel/plugin-transform-runtime", { helpers: false }]].filter(
+    Boolean
+  ) as PluginItem[]
+
+  return {
+    presets,
+    plugins
+  }
+}

data/package/config.ts

@@ -0,0 +1,175 @@
+import { resolve } from "path"
+import { load } from "js-yaml"
+import { existsSync, readFileSync } from "fs"
+import { merge } from "webpack-merge"
+const { ensureTrailingSlash } = require("./utils/helpers")
+const { railsEnv } = require("./env")
+const configPath = require("./utils/configPath")
+const defaultConfigPath = require("./utils/defaultConfigPath")
+import { Config, YamlConfig, LegacyConfig } from "./types"
+const { isValidYamlConfig, createConfigValidationError, isPartialConfig, isValidConfig } = require("./utils/typeGuards")
+const { isFileNotFoundError, createFileOperationError } = require("./utils/errorHelpers")
+
+const loadAndValidateYaml = (path: string): YamlConfig => {
+  const fileContent = readFileSync(path, "utf8")
+  const yamlContent = load(fileContent)
+  
+  if (!isValidYamlConfig(yamlContent)) {
+    throw createConfigValidationError(path, railsEnv, "Invalid YAML structure")
+  }
+  
+  return yamlContent as YamlConfig
+}
+
+const getDefaultConfig = (): Partial<Config> => {
+  try {
+    const defaultConfig = loadAndValidateYaml(defaultConfigPath)
+    return defaultConfig[railsEnv] || defaultConfig.production || {}
+  } catch (error) {
+    if (isFileNotFoundError(error)) {
+      throw createFileOperationError(
+        'read', 
+        defaultConfigPath, 
+        `Default configuration not found at ${defaultConfigPath}. Please ensure Shakapacker is properly installed. You may need to run 'yarn add shakapacker' or 'npm install shakapacker'.`
+      )
+    }
+    throw error
+  }
+}
+
+const defaults = getDefaultConfig()
+let config: Config
+
+if (existsSync(configPath)) {
+  try {
+    const appYmlObject = loadAndValidateYaml(configPath)
+    
+    const envAppConfig = appYmlObject[railsEnv]
+
+    if (!envAppConfig) {
+      /* eslint no-console:0 */
+      console.warn(
+        `[SHAKAPACKER WARNING] Environment '${railsEnv}' not found in ${configPath}\n` +
+        `Available environments: ${Object.keys(appYmlObject).join(', ')}\n` +
+        `Using 'production' configuration as fallback.\n\n` +
+        `To fix this, either:\n` +
+        `  - Add a '${railsEnv}' section to your shakapacker.yml\n` +
+        `  - Set RAILS_ENV to one of the available environments\n` +
+        `  - Copy settings from another environment as a starting point`
+      )
+    }
+
+    // Merge returns the merged type
+    const mergedConfig = merge(defaults, envAppConfig || {})
+    
+    // Validate merged config before type assertion
+    if (!isPartialConfig(mergedConfig)) {
+      throw createConfigValidationError(
+        configPath, 
+        railsEnv, 
+        `Invalid configuration structure in ${configPath}. Please check your shakapacker.yml syntax and ensure all required fields are properly defined.`
+      )
+    }
+    
+    // After merging with defaults, config should be complete
+    // Use type assertion only after validation
+    config = mergedConfig as Config
+  } catch (error) {
+    if (isFileNotFoundError(error)) {
+      // File not found is OK, use defaults
+      if (!isPartialConfig(defaults)) {
+        throw createConfigValidationError(
+          defaultConfigPath, 
+          railsEnv, 
+          `Invalid default configuration. This may indicate a corrupted Shakapacker installation. Try reinstalling with 'yarn add shakapacker --force'.`
+        )
+      }
+      // Using defaults only, might be partial
+      config = defaults as Config
+    } else {
+      throw error
+    }
+  }
+} else {
+  // No user config, use defaults
+  if (!isPartialConfig(defaults)) {
+    throw createConfigValidationError(
+      defaultConfigPath, 
+      railsEnv, 
+      `Invalid default configuration. This may indicate a corrupted Shakapacker installation. Try reinstalling with 'yarn add shakapacker --force'.`
+    )
+  }
+  // Using defaults only, might be partial
+  config = defaults as Config
+}
+
+config.outputPath = resolve(config.public_root_path, config.public_output_path)
+
+// Ensure that the publicPath includes our asset host so dynamic imports
+// (code-splitting chunks and static assets) load from the CDN instead of a relative path.
+const getPublicPath = (): string => {
+  const rootUrl = ensureTrailingSlash(process.env.SHAKAPACKER_ASSET_HOST || "/")
+  return `${rootUrl}${config.public_output_path}/`
+}
+
+config.publicPath = getPublicPath()
+config.publicPathWithoutCDN = `/${config.public_output_path}/`
+
+if (config.manifest_path) {
+  config.manifestPath = resolve(config.manifest_path)
+} else {
+  config.manifestPath = resolve(config.outputPath, "manifest.json")
+}
+// Ensure no duplicate hash functions exist in the returned config object
+if (config.integrity?.hash_functions) {
+  config.integrity.hash_functions = [...new Set(config.integrity.hash_functions)]
+}
+
+// Ensure assets_bundler has a default value
+if (!config.assets_bundler) {
+  config.assets_bundler = "webpack"
+}
+
+// Allow ENV variable to override assets_bundler  
+if (process.env.SHAKAPACKER_ASSETS_BUNDLER) {
+  config.assets_bundler = process.env.SHAKAPACKER_ASSETS_BUNDLER
+}
+
+// Define clear defaults
+// Keep Babel as default for webpack to maintain backward compatibility
+// Use SWC for rspack as it's a newer bundler where we can set modern defaults
+const DEFAULT_JAVASCRIPT_TRANSPILER = 
+  config.assets_bundler === "rspack" ? "swc" : "babel"
+
+// Backward compatibility: Check for webpack_loader using proper type guard
+function hasWebpackLoader(obj: unknown): obj is Config & { webpack_loader: string } {
+  return (
+    typeof obj === 'object' &&
+    obj !== null &&
+    'webpack_loader' in obj &&
+    typeof (obj as Record<string, unknown>).webpack_loader === 'string'
+  )
+}
+
+// Allow environment variable to override javascript_transpiler
+if (process.env.SHAKAPACKER_JAVASCRIPT_TRANSPILER) {
+  config.javascript_transpiler = process.env.SHAKAPACKER_JAVASCRIPT_TRANSPILER
+} else if (hasWebpackLoader(config) && !config.javascript_transpiler) {
+  console.warn(
+    "[SHAKAPACKER DEPRECATION] The 'webpack_loader' configuration option is deprecated.\n" +
+    "Please use 'javascript_transpiler' instead as it better reflects its purpose of configuring JavaScript transpilation regardless of the bundler used."
+  )
+  config.javascript_transpiler = config.webpack_loader
+} else if (!config.javascript_transpiler) {
+  config.javascript_transpiler = DEFAULT_JAVASCRIPT_TRANSPILER
+}
+
+// Ensure webpack_loader is always available for backward compatibility
+Object.defineProperty(config, 'webpack_loader', {
+  value: config.javascript_transpiler,
+  writable: true,
+  enumerable: true,
+  configurable: true
+})
+
+export = config

data/package/{dev_server.js → dev_server.ts}

@@ -1,23 +1,26 @@
 // These are the raw shakapacker dev server config settings from the YML file with ENV overrides applied.
 const { isBoolean } = require("./utils/helpers")
 const config = require("./config")
+import { DevServerConfig } from "./types"
 
-const envFetch = (key) => {
+const envFetch = (key: string): string | boolean | undefined => {
   const value = process.env[key]
+  if (!value) return undefined
   return isBoolean(value) ? JSON.parse(value) : value
 }
 
-const devServerConfig = config.dev_server
+const devServerConfig: DevServerConfig | undefined = config.dev_server
 
 if (devServerConfig) {
-  const envPrefix = config.dev_server.env_prefix || "SHAKAPACKER_DEV_SERVER"
+  const envPrefix = devServerConfig.env_prefix || "SHAKAPACKER_DEV_SERVER"
 
   Object.keys(devServerConfig).forEach((key) => {
     const envValue = envFetch(`${envPrefix}_${key.toUpperCase()}`)
     if (envValue !== undefined) {
-      devServerConfig[key] = envValue
+      // Use bracket notation to avoid ASI issues
+      (devServerConfig as Record<string, unknown>)[key] = envValue
     }
   })
 }
 
-module.exports = devServerConfig || {}
+export = devServerConfig || {}

data/package/env.ts

@@ -0,0 +1,92 @@
+import { load } from "js-yaml"
+import { readFileSync } from "fs"
+const defaultConfigPath = require("./utils/defaultConfigPath")
+const configPath = require("./utils/configPath")
+const { isFileNotFoundError } = require("./utils/errorHelpers")
+const { sanitizeEnvValue } = require("./utils/pathValidation")
+
+const NODE_ENVIRONMENTS = ["development", "production", "test"] as const
+
+// Sanitize environment variables to prevent injection
+const initialRailsEnv = sanitizeEnvValue(process.env.RAILS_ENV)
+const rawNodeEnv = sanitizeEnvValue(process.env.NODE_ENV)
+
+// Default NODE_ENV based on RAILS_ENV to match bin/shakapacker behavior (see lib/shakapacker/runner.rb:27)
+// - RAILS_ENV=production → DEFAULT="production" (safe for production builds)
+// - RAILS_ENV=development, test, staging, or unset → DEFAULT="development" (good DX for dev server)
+// This ensures the dev server works out of the box without requiring NODE_ENV to be set explicitly
+const DEFAULT = initialRailsEnv === "production" ? "production" : "development"
+
+// Validate NODE_ENV strictly
+const nodeEnv =
+  rawNodeEnv &&
+  NODE_ENVIRONMENTS.includes(rawNodeEnv as (typeof NODE_ENVIRONMENTS)[number])
+    ? rawNodeEnv
+    : DEFAULT
+
+// Log warning if NODE_ENV was invalid
+if (
+  rawNodeEnv &&
+  !NODE_ENVIRONMENTS.includes(rawNodeEnv as (typeof NODE_ENVIRONMENTS)[number])
+) {
+  console.warn(
+    `[SHAKAPACKER WARNING] Invalid NODE_ENV value: ${rawNodeEnv}. ` +
+      `Valid values are: ${NODE_ENVIRONMENTS.join(", ")}. Using default: ${DEFAULT}`
+  )
+}
+
+const isProduction = nodeEnv === "production"
+const isDevelopment = nodeEnv === "development"
+
+interface ConfigFile {
+  [environment: string]: Record<string, unknown>
+}
+
+let config: ConfigFile
+try {
+  config = load(readFileSync(configPath, "utf8")) as ConfigFile
+} catch (error: unknown) {
+  if (isFileNotFoundError(error)) {
+    // File not found, use default configuration
+    try {
+      config = load(readFileSync(defaultConfigPath, "utf8")) as ConfigFile
+    } catch (defaultError) {
+      throw new Error(
+        `Failed to load Shakapacker configuration.\n` +
+          `Neither user config (${configPath}) nor default config (${defaultConfigPath}) could be loaded.\n\n` +
+          `To fix this issue:\n` +
+          `1. Create a config/shakapacker.yml file in your project\n` +
+          `2. Or set the SHAKAPACKER_CONFIG environment variable to point to your config file\n` +
+          `3. Or reinstall Shakapacker to restore the default configuration:\n` +
+          `   npm install shakapacker --force\n` +
+          `   yarn add shakapacker --force`
+      )
+    }
+  } else {
+    throw error
+  }
+}
+
+const availableEnvironments = Object.keys(config).join("|")
+const regex = new RegExp(`^(${availableEnvironments})$`, "g")
+
+const runningWebpackDevServer = process.env.WEBPACK_SERVE === "true"
+
+const validatedRailsEnv =
+  initialRailsEnv && initialRailsEnv.match(regex) ? initialRailsEnv : DEFAULT
+
+if (initialRailsEnv && validatedRailsEnv !== initialRailsEnv) {
+  /* eslint no-console:0 */
+  console.warn(
+    `[SHAKAPACKER WARNING] Environment '${initialRailsEnv}' not found in the configuration.\n` +
+      `Using '${DEFAULT}' configuration as a fallback.`
+  )
+}
+
+export = {
+  railsEnv: validatedRailsEnv,
+  nodeEnv,
+  isProduction,
+  isDevelopment,
+  runningWebpackDevServer
+}

data/package/environments/base.ts

@@ -0,0 +1,138 @@
+/* eslint global-require: 0 */
+/* eslint import/no-dynamic-require: 0 */
+
+const { basename, dirname, join, relative, resolve } = require("path")
+const { existsSync, readdirSync } = require("fs")
+import { Dirent } from "fs"
+const extname = require("path-complete-extname")
+// @ts-ignore: webpack is an optional peer dependency (using type-only import)
+import type { Configuration, Entry } from "webpack"
+const config = require("../config")
+const { isProduction } = require("../env")
+
+const pluginsPath = resolve(
+  __dirname,
+  "..",
+  "plugins",
+  `${config.assets_bundler}.js`
+)
+const { getPlugins } = require(pluginsPath)
+const rulesPath = resolve(
+  __dirname,
+  "..",
+  "rules",
+  `${config.assets_bundler}.js`
+)
+const rules = require(rulesPath)
+
+// Don't use contentHash except for production for performance
+// https://webpack.js.org/guides/build-performance/#avoid-production-specific-tooling
+const hash = isProduction || config.useContentHash ? "-[contenthash]" : ""
+
+const getFilesInDirectory = (dir: string, includeNested: boolean): string[] => {
+  if (!existsSync(dir)) {
+    return []
+  }
+
+  return readdirSync(dir, { withFileTypes: true }).flatMap((dirent: Dirent) => {
+    const filePath = join(dir, dirent.name)
+
+    if (dirent.isDirectory() && includeNested) {
+      return getFilesInDirectory(filePath, includeNested)
+    }
+    if (dirent.isFile()) {
+      return filePath
+    }
+    return []
+  })
+}
+
+const getEntryObject = (): Entry => {
+  const entries: Entry = {}
+  const rootPath = join(config.source_path, config.source_entry_path)
+  if (config.source_entry_path === "/" && config.nested_entries) {
+    throw new Error(
+      `Invalid Shakapacker configuration detected!\n\n` +
+      `You have set source_entry_path to '/' with nested_entries enabled.\n` +
+      `This would create webpack entry points for EVERY file in your source directory,\n` +
+      `which would severely impact build performance.\n\n` +
+      `To fix this issue, either:\n` +
+      `1. Set 'nested_entries: false' in your shakapacker.yml\n` +
+      `2. Change 'source_entry_path' to a specific subdirectory (e.g., 'packs')\n` +
+      `3. Or use both options for better organization of your entry points`
+    )
+  }
+
+  getFilesInDirectory(rootPath, config.nested_entries).forEach((path) => {
+    const namespace = relative(join(rootPath), dirname(path))
+    const name = join(namespace, basename(path, extname(path)))
+    const assetPath: string = resolve(path)
+
+    // Allows for multiple filetypes per entry (https://webpack.js.org/guides/entry-advanced/)
+    // Transforms the config object value to an array with all values under the same name
+    const previousPaths = entries[name]
+    if (previousPaths) {
+      const pathArray = Array.isArray(previousPaths)
+        ? previousPaths as string[]
+        : [previousPaths as string]
+      pathArray.push(assetPath)
+      entries[name] = pathArray
+    } else {
+      entries[name] = assetPath
+    }
+  })
+
+  return entries
+}
+
+const getModulePaths = (): string[] => {
+  const result = [resolve(config.source_path)]
+
+  if (config.additional_paths) {
+    config.additional_paths.forEach((path: string) => result.push(resolve(path)))
+  }
+  result.push("node_modules")
+
+  return result
+}
+
+const baseConfig: Configuration = {
+  mode: "production",
+  output: {
+    filename: `js/[name]${hash}.js`,
+    chunkFilename: `js/[name]${hash}.chunk.js`,
+
+    // https://webpack.js.org/configuration/output/#outputhotupdatechunkfilename
+    hotUpdateChunkFilename: "js/[id].[fullhash].hot-update.js",
+    path: config.outputPath,
+    publicPath: config.publicPath,
+
+    // This is required for SRI to work.
+    crossOriginLoading: config.integrity && config.integrity.enabled
+      ? (config.integrity.cross_origin as "anonymous" | "use-credentials" | false)
+      : false
+  },
+  entry: getEntryObject(),
+  resolve: {
+    extensions: [".js", ".jsx", ".mjs", ".ts", ".tsx", ".coffee"],
+    modules: getModulePaths()
+  },
+
+  plugins: getPlugins(),
+
+  resolveLoader: {
+    modules: ["node_modules"]
+  },
+
+  optimization: {
+    splitChunks: { chunks: "all" },
+    runtimeChunk: "single"
+  },
+
+  module: {
+    rules
+  }
+}
+
+export = baseConfig
+

data/package/environments/development.ts

@@ -0,0 +1,90 @@
+/**
+ * Development environment configuration for webpack and rspack bundlers
+ * @module environments/development
+ */
+
+const { merge } = require("webpack-merge")
+const config = require("../config")
+const baseConfig = require("./base")
+const webpackDevServerConfig = require("../webpackDevServerConfig")
+const { runningWebpackDevServer } = require("../env")
+const { moduleExists } = require("../utils/helpers")
+import type { 
+  WebpackConfigWithDevServer,
+  RspackConfigWithDevServer,
+  ReactRefreshWebpackPlugin,
+  ReactRefreshRspackPlugin
+} from "./types"
+
+/**
+ * Base development configuration shared between webpack and rspack
+ */
+const baseDevConfig = {
+  mode: "development" as const,
+  devtool: "cheap-module-source-map" as const
+}
+
+/**
+ * Generate webpack-specific development configuration
+ * @returns Webpack configuration with dev server settings
+ */
+const webpackDevConfig = (): WebpackConfigWithDevServer => {
+  const webpackConfig: WebpackConfigWithDevServer = {
+    ...baseDevConfig,
+    ...(runningWebpackDevServer && { devServer: webpackDevServerConfig() })
+  }
+
+  const devServerConfig = webpackDevServerConfig()
+  if (
+    runningWebpackDevServer &&
+    devServerConfig.hot &&
+    moduleExists("@pmmmwh/react-refresh-webpack-plugin")
+  ) {
+    // eslint-disable-next-line global-require
+    const ReactRefreshWebpackPlugin = require("@pmmmwh/react-refresh-webpack-plugin")
+    webpackConfig.plugins = [
+      ...(webpackConfig.plugins || []),
+      new ReactRefreshWebpackPlugin()
+    ]
+  }
+
+  return webpackConfig
+}
+
+/**
+ * Generate rspack-specific development configuration
+ * @returns Rspack configuration with dev server settings
+ */
+const rspackDevConfig = (): RspackConfigWithDevServer => {
+  const devServerConfig = webpackDevServerConfig()
+  const rspackConfig: RspackConfigWithDevServer = {
+    ...baseDevConfig,
+    devServer: {
+      ...devServerConfig,
+      devMiddleware: {
+        ...(devServerConfig.devMiddleware || {}),
+        writeToDisk: (filePath: string) => !filePath.includes(".hot-update.")
+      }
+    }
+  }
+
+  if (
+    runningWebpackDevServer &&
+    devServerConfig.hot &&
+    moduleExists("@rspack/plugin-react-refresh")
+  ) {
+    // eslint-disable-next-line global-require
+    const ReactRefreshPlugin = require("@rspack/plugin-react-refresh")
+    rspackConfig.plugins = [
+      ...(rspackConfig.plugins || []),
+      new ReactRefreshPlugin()
+    ]
+  }
+
+  return rspackConfig
+}
+
+const bundlerConfig =
+  config.assets_bundler === "rspack" ? rspackDevConfig() : webpackDevConfig()
+
+module.exports = merge(baseConfig, bundlerConfig)