rspack_rails 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7f84e6f9280bcf6d3fbd54f2a3a267a817e7c333d4c89a70c8e171b477f3e85
-  data.tar.gz: '09e2d5eb77331777f33a1b58478ba1bac7774ffe83308b0f97236653fb80f534'
+  metadata.gz: d5c0f485458181960a59600c16b354bbb260d5856d37200ffaf416e4d6c88222
+  data.tar.gz: a06bf0ec56b0850342ea39c4d461f4d165e8b3c1f046c7c41d6149b5412c5fbe
 SHA512:
-  metadata.gz: 79928a7186a0b752296a5d82cf5e570ce87730a24ce2c1c515c4490be4585fe512790b68b4bdef81f9a76c608a73a615d4db75d7891889092f1a8a56a7a76e66
-  data.tar.gz: 11660d1b0a381e43a789b8b5b2b92593784755cbfda2d00f32f1646b784dd39d959329fa2845febf900e4e6af38e4879c816832ecb5f2c944e1f8d6241ffbe47
+  metadata.gz: 70886ccbe82932f10548639cb3190b4a06ad032fa854c5677c87553c93d4a32feb4a9968a5b72881fa5cfb94833ca02994168a541771c95a33222d51422677f4
+  data.tar.gz: 989663562bc6cd2e8a72ef05872319117c5f21e9b43697fc57874ea6c725370a86118ec3e01bd950f854dddbc57d48a8e9f10b675f2ef0686c1126df93573203

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## [Unreleased]
 
+## [0.4.0] - 2026-11-13
+
+- `rspack:migrate`: moves an importmap-rails or jsbundling-rails (esbuild/webpack/rollup) app to rspack. Requires a clean git tree (or `FORCE=1`)
+- `rspack.config.mjs` resolves bare imports from `app/javascript` (`resolve.modules`), so importmap-style `import "controllers/application"` keeps working
+- `rspack:install:stimulus` also rewrites a bare `import "controllers"`
+- Installers stop when a package install fails instead of carrying on
+
+## [0.3.0] - 2026-11-13
+
+- Multiple entry points: every `app/javascript/entrypoints/*.{js,ts}` becomes a bundle named after the file; `application.ts` works as the main entry
+- `rspack:doctor` lists entry points and reports any that are not built
+- Fix: the dev server no longer writes `*.hot-update.js` files into `app/assets/builds`
+- Existing apps: re-run `bin/rails rspack:install` and accept the new `rspack.config.mjs`
+
 ## [0.2.0] - 2026-11-13
 
 - CSS imported from JavaScript is extracted to `app/assets/builds/<entry>.bundle.css` and hot-reloaded under `rspack serve`; `*.module.css` are CSS modules

data/README.md

@@ -1,8 +1,24 @@
 # rspack_rails
 
-Bundle your Rails app's JavaScript with [Rspack](https://rspack.rs), the Rust-powered, webpack-compatible bundler.
+[![Gem Version](https://img.shields.io/gem/v/rspack_rails)](https://rubygems.org/gems/rspack_rails)
+[![CI](https://github.com/tungnt1203/rspack_rails/actions/workflows/main.yml/badge.svg)](https://github.com/tungnt1203/rspack_rails/actions/workflows/main.yml)
 
-rspack_rails follows the `jsbundling-rails` model: rspack writes bundles to `app/assets/builds`, and Propshaft (or Sprockets) serves and fingerprints them.
+Bundle your Rails app's JavaScript and CSS with [Rspack](https://rspack.rs), the Rust-powered, webpack-compatible bundler, and get **hot module replacement** in development.
+
+![Editing CSS and a Stimulus controller while the page keeps its state](docs/hmr.gif)
+
+*Above: CSS and a Stimulus controller are edited while the page is open. Both update in place, and the counter keeps its value because the page never reloads.*
+
+- **One command setup**: `bin/rails rspack:install`, then `bin/dev`
+- **HMR for JavaScript, CSS and Stimulus controllers**, with an automatic fallback to the asset pipeline when the dev server is not running
+- **Stimulus autoloading**: drop a `*_controller.js` (or `.ts`) in `app/javascript/controllers`, no manifest to maintain
+- **TypeScript and CSS modules** out of the box, through Rspack's built-in SWC and native CSS
+- **Multiple entry points** from `app/javascript/entrypoints/`
+- **`rspack:migrate`** moves an importmap or jsbundling app over in one command
+- **`rspack:doctor`** checks Node.js, packages, config and layout, and says what to fix
+- Works with **Propshaft and Sprockets**; CI runs a real app on Rails 7.2 and 8.1
+
+rspack_rails follows the `jsbundling-rails` model: rspack writes bundles to `app/assets/builds`, and Propshaft (or Sprockets) serves and fingerprints them in production.
 
 ## Installation
 
@@ -19,6 +35,28 @@ The installer:
 - adds a `js:` process running the dev server to `Procfile.dev` and sets up `bin/dev`
 - installs `@rspack/cli`, `@rspack/core` and `@rspack/dev-server` with your package manager (bun, yarn, pnpm or npm, detected from the lockfile)
 
+## Migrating from importmap or jsbundling
+
+```bash
+git commit -am "Before rspack"     # rspack:migrate refuses to run on a dirty tree (FORCE=1 to override)
+bin/rails rspack:migrate
+git diff                           # review
+bin/dev
+```
+
+**From importmap-rails**
+- Every `pin` in `config/importmap.rb` becomes an npm dependency. Versions recorded by importmap (`# @1.2.3` or jspm URLs) are kept. Gem-served pins such as Turbo install the latest npm release.
+- `javascript_importmap_tags` is replaced with `rspack_javascript_tag`, and `import "controllers"` with the Stimulus autoloader.
+- `config/importmap.rb`, `bin/importmap`, vendored packages, the `importmap-rails` gem, `stale_when_importmap_changes` and the `bin/importmap audit` CI step are removed.
+- Bare imports of app code (`import "controllers/application"`) keep working through `resolve.modules`.
+
+**From jsbundling-rails** (esbuild, webpack, rollup)
+- The `jsbundling-rails` gem, the old bundler package and its config file are removed. `Procfile.dev` runs the rspack dev server.
+- `javascript_include_tag "application"` becomes `rspack_javascript_tag`, and the generated `controllers/index.js` gives way to the autoloader.
+- Extra entry files in the root of `app/javascript/` are listed so you can move them to `app/javascript/entrypoints/`.
+
+The task finishes by listing any remaining lines that mention importmap or jsbundling. Shakapacker/Webpacker apps are not supported yet.
+
 ## Usage
 
 Run `bin/dev` to start Rails and the rspack dev server (with hot module replacement) together.
@@ -63,6 +101,23 @@ Under `rspack serve`, editing a controller or adding a new one hot-swaps it in t
 
 If `application.js` imported `./controllers` (the stimulus-rails index), the installer switches it to `./controllers/autoload`. stimulus-rails may still rewrite `controllers/index.js` when you run `bin/rails generate stimulus`, but nothing imports that file any more.
 
+### Multiple entry points
+
+Besides `app/javascript/application.js` (or `.ts`), every file in `app/javascript/entrypoints/` becomes its own bundle, named after the file:
+
+```
+app/javascript/application.js           -> application.js
+app/javascript/entrypoints/admin.ts     -> admin.js
+app/javascript/entrypoints/checkout.js  -> checkout.js (+ checkout.bundle.css if it imports CSS)
+```
+
+```erb
+<%# app/views/layouts/admin.html.erb %>
+<%= rspack_javascript_tag "admin" %>
+```
+
+Each bundle is self-contained, so load one entry per page (for example one per layout). Restart the dev server after adding a new entry point.
+
 ### CSS
 
 Import CSS from your JavaScript and rspack extracts it to `app/assets/builds/<entry>.bundle.css`:
@@ -95,6 +150,7 @@ npm run typecheck
 |---|---|
 | `bin/rails rspack:install:stimulus` | Sets up Stimulus with controller autoloading |
 | `bin/rails rspack:install:typescript` | Adds tsconfig.json, typescript and a `typecheck` script |
+| `bin/rails rspack:migrate` | Moves an importmap or jsbundling app to rspack |
 | `bin/rails rspack:doctor` | Checks Node.js, packages, config, layout, Procfile and dev server |
 | `bin/rails rspack:build` | Installs JS dependencies, then runs `build` |
 | `bin/rails rspack:clobber` | Removes rspack output from `app/assets/builds` |
@@ -124,6 +180,9 @@ The required Node.js version comes from the `engines` field of the installed `@r
 ```bash
 bin/setup
 bundle exec rake   # specs + rubocop
+bin/integration    # new Rails app + every installer, build, doctor and precompile
+bin/integration "~> 7.2.0"   # against a specific Rails version
+bin/integration-migrate importmap    # rails new + rspack:migrate (or: jsbundling)
 ```
 
 ## License

data/lib/install/install.rb

@@ -68,6 +68,6 @@ unless File.exist?("bin/dev") && File.read("bin/dev").include?("Procfile.dev")
 end
 
 say "Installing @rspack/cli, @rspack/core and @rspack/dev-server"
-run pm.add_dev_command("@rspack/cli", "@rspack/core", "@rspack/dev-server")
+run pm.add_dev_command("@rspack/cli", "@rspack/core", "@rspack/dev-server"), abort_on_failure: true
 
 say "rspack_rails installed. Run bin/dev to start developing.", :green

data/lib/install/migrate.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+# Rails application template run by `bin/rails rspack:migrate`.
+# Moves an app from importmap-rails or jsbundling-rails to rspack_rails.
+require "json"
+
+migration = RspackRails::Migration.new(Rails.root)
+pm = RspackRails::PackageManager.detect(Rails.root)
+layout = "app/views/layouts/application.html.erb"
+stimulus = File.exist?("app/javascript/controllers/application.js")
+
+def remove_gem(name)
+  gem_line = /^[ \t]*gem[ \t]+["']#{Regexp.escape(name)}["'].*\n/
+  gsub_file "Gemfile", /^[ \t]*#.*\n(?=#{gem_line.source})/, "" # the comment describing it
+  gsub_file "Gemfile", gem_line, ""
+end
+
+case migration.source
+when :rspack
+  say "This app already uses rspack_rails. Run `bin/rails rspack:doctor` to check it.", :green
+  exit
+when :shakapacker
+  say "Shakapacker/Webpacker apps are not supported by rspack:migrate yet.", :red
+  exit 1
+when :none
+  say "No importmap-rails or jsbundling-rails setup found. Running rspack:install instead."
+when :importmap
+  say "Migrating from importmap-rails"
+  packages = migration.npm_install_args
+  vendored = migration.vendored_files
+
+  gsub_file layout, /^\s*<%= javascript_importmap_tags.*%>\n/, "" if File.exist?(layout)
+  if File.exist?("app/assets/config/manifest.js")
+    gsub_file "app/assets/config/manifest.js", %r{^//= link_tree \.\./\.\./javascript .js\n}, ""
+    gsub_file "app/assets/config/manifest.js", %r{^//= link_tree \.\./\.\./\.\./vendor/javascript .js\n}, ""
+  end
+  if File.exist?("app/javascript/application.js")
+    gsub_file "app/javascript/application.js", %r{^// Configure your import map in config/importmap.rb.*\n}, ""
+  end
+  Dir.glob("app/controllers/**/*.rb").each do |controller|
+    next unless File.read(controller).include?("stale_when_importmap_changes")
+
+    gsub_file controller, /^[ \t]*# Changes to the importmap will invalidate the etag.*\n/, ""
+    gsub_file controller, /^[ \t]*stale_when_importmap_changes.*\n/, ""
+  end
+  gsub_file "config/ci.rb", %r{^[ \t]*step .*bin/importmap audit.*\n}, "" if File.exist?("config/ci.rb")
+  remove_file "config/importmap.rb"
+  remove_file "bin/importmap"
+  vendored.each { |path| remove_file path }
+  remove_gem "importmap-rails"
+when :jsbundling
+  say "Migrating from jsbundling-rails"
+  bundlers = migration.bundler_packages
+  migration.bundler_configs.each { |path| remove_file path }
+  gsub_file "Procfile.dev", /^js: .*\n/, "js: #{pm.run_command("dev")}\n" if File.exist?("Procfile.dev")
+  remove_gem "jsbundling-rails"
+end
+
+apply "#{__dir__}/install.rb"
+
+if migration.source == :importmap && packages.any?
+  say "Installing packages that were pinned in config/importmap.rb: #{packages.join(", ")}"
+  run pm.add_command(*packages), abort_on_failure: true
+end
+
+if migration.source == :jsbundling && bundlers.any?
+  say "Removing the previous bundler: #{bundlers.join(", ")}"
+  package = JSON.parse(File.read("package.json"))
+  bundlers.each do |name|
+    package["dependencies"]&.delete(name)
+    package["devDependencies"]&.delete(name)
+  end
+  File.write("package.json", "#{JSON.pretty_generate(package)}\n")
+end
+
+apply "#{__dir__}/stimulus.rb" if stimulus
+
+controllers_index = "app/javascript/controllers/index.js"
+if migration.source == :importmap && File.exist?(controllers_index) &&
+   File.read(controllers_index).include?("@hotwired/stimulus-loading")
+  remove_file controllers_index # replaced by controllers/autoload.js
+end
+
+if migration.source == :jsbundling
+  migration.extra_root_entries.each do |path|
+    say "#{path} was an entry point under jsbundling. Move it to app/javascript/entrypoints/ " \
+        "so rspack builds it.", :yellow
+  end
+end
+
+leftovers = Dir.glob("{app,config,lib}/**/*.{rb,erb,js,ts,yml}").flat_map do |path|
+  File.readlines(path).each_with_index.filter_map do |line, index|
+    next if line.strip.start_with?("#", "//", "<%#")
+
+    "#{path}:#{index + 1}: #{line.strip}" if line.match?(/importmap|jsbundling/i)
+  end
+end
+if leftovers.any?
+  say "These lines still mention importmap/jsbundling and may need a manual change:", :yellow
+  leftovers.each { |line| say "  #{line}", :yellow }
+end
+
+say "Migration finished. Review the changes with `git diff`, then run `bin/rails rspack:doctor`.", :green

data/lib/install/rspack.config.mjs

@@ -1,3 +1,4 @@
+import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { defineConfig } from "@rspack/cli";
@@ -12,51 +13,69 @@ const isProduction =
 const host = process.env.RSPACK_DEV_SERVER_HOST || "localhost";
 const port = Number(process.env.RSPACK_DEV_SERVER_PORT || 3036);
 
+// Entries: app/javascript/application.{js,ts} plus every file in
+// app/javascript/entrypoints/, named after the file (admin.js -> "admin").
+// Restart the dev server after adding an entrypoint.
+const entry = {};
+for (const ext of ["js", "ts"]) {
+  const file = `./app/javascript/application.${ext}`;
+  if (!entry.application && fs.existsSync(path.resolve(root, file))) entry.application = file;
+}
+const entrypointsDir = path.resolve(root, "app/javascript/entrypoints");
+if (fs.existsSync(entrypointsDir)) {
+  for (const file of fs.readdirSync(entrypointsDir).sort()) {
+    const match = file.match(/^(.+)\.(js|ts)$/);
+    if (match) entry[match[1]] = `./app/javascript/entrypoints/${file}`;
+  }
+}
+
 export default defineConfig({
   mode: isProduction ? "production" : "development",
   devtool: "source-map",
-  entry: {
-    application: "./app/javascript/application.js",
-  },
+  entry,
   output: {
     path: path.resolve(root, "app/assets/builds"),
     filename: "[name].js",
     // ".digested" tells Propshaft the file is already fingerprinted.
-chunkFilename: "[name]-[contenthash].digested.js",
-// CSS imported from JavaScript. ".bundle" avoids clashing with
-// app/assets/stylesheets/application.css in Propshaft.
-cssFilename: "[name].bundle.css",
-cssChunkFilename: "[name]-[contenthash].digested.css",
+    chunkFilename: "[name]-[contenthash].digested.js",
+    // CSS imported from JavaScript. ".bundle" avoids clashing with
+    // app/assets/stylesheets/application.css in Propshaft.
+    cssFilename: "[name].bundle.css",
+    cssChunkFilename: "[name]-[contenthash].digested.css",
     // Under `rspack serve`, chunks and hot updates load from the dev server.
     publicPath: isDevServer ? `http://${host}:${port}/` : "/assets/",
   },
-resolve: {
-  extensions: ["...", ".ts"],
-},
-module: {
-  rules: [
-    {
-      // Transpile TypeScript with Rspack's built-in SWC (no type checking).
-      test: /\.ts$/,
-      exclude: /node_modules/,
-      loader: "builtin:swc-loader",
-      options: { jsc: { parser: { syntax: "typescript" } } },
-      type: "javascript/auto",
-    },
-    {
-      // Native CSS; *.module.css files become CSS modules.
-      test: /\.css$/,
-      type: "css/auto",
-    },
-  ],
-},
+  resolve: {
+    extensions: ["...", ".ts"],
+    // Bare imports of app code work as they did with importmap
+    // (import "controllers/application", import "lib/utils").
+    modules: ["node_modules", path.resolve(root, "app/javascript")],
+  },
+  module: {
+    rules: [
+      {
+        // Transpile TypeScript with Rspack's built-in SWC (no type checking).
+        test: /\.ts$/,
+        exclude: /node_modules/,
+        loader: "builtin:swc-loader",
+        options: { jsc: { parser: { syntax: "typescript" } } },
+        type: "javascript/auto",
+      },
+      {
+        // Native CSS; *.module.css files become CSS modules.
+        test: /\.css$/,
+        type: "css/auto",
+      },
+    ],
+  },
   devServer: {
     host,
     port,
     hot: true,
     // Keep app/assets/builds current while the dev server runs, so Propshaft
-    // (and `stylesheet_link_tag :app`) never serve a stale bundle.
-    devMiddleware: { writeToDisk: true },
+    // (and `stylesheet_link_tag :app`) never serve a stale bundle. Hot update
+    // files stay in memory so they never reach public/assets.
+    devMiddleware: { writeToDisk: (file) => !/\.hot-update\./.test(file) },
     allowedHosts: "all",
     headers: { "Access-Control-Allow-Origin": "*" },
     client: {

data/lib/install/stimulus.rb

@@ -16,9 +16,9 @@ end
 
 if !File.exist?(entry)
   create_file entry, %(import "./controllers/autoload"\n)
-elsif File.read(entry).match?(%r{^import ["']\./controllers(/index(\.js)?)?["'];?$})
-  say "Replacing the controllers/index.js import with controllers/autoload"
-  gsub_file entry, %r{^import ["']\./controllers(/index(\.js)?)?["'];?$}, %(import "./controllers/autoload")
+elsif File.read(entry).match?(%r{^import ["'](?:\./)?controllers(/index(\.js)?)?["'];?$})
+  say "Replacing the controllers import with controllers/autoload"
+  gsub_file entry, %r{^import ["'](?:\./)?controllers(/index(\.js)?)?["'];?$}, %(import "./controllers/autoload")
 elsif !File.read(entry).include?("./controllers/autoload")
   append_to_file entry, %(import "./controllers/autoload"\n)
 end
@@ -28,6 +28,6 @@ if File.exist?("app/javascript/controllers/index.js")
 end
 
 say "Installing @hotwired/stimulus"
-run pm.add_command("@hotwired/stimulus")
+run pm.add_command("@hotwired/stimulus"), abort_on_failure: true
 
 say "Stimulus installed. Controllers in app/javascript/controllers are registered automatically.", :green

data/lib/install/typescript.rb

@@ -14,6 +14,6 @@ package = JSON.parse(File.read("package.json"))
 File.write("package.json", "#{JSON.pretty_generate(package)}\n")
 
 say "Installing typescript"
-run pm.add_dev_command("typescript")
+run pm.add_dev_command("typescript"), abort_on_failure: true
 
 say "TypeScript ready. Rspack compiles .ts files; run `#{pm.run_command("typecheck")}` to type-check.", :green

data/lib/rspack_rails/doctor.rb

@@ -4,6 +4,7 @@ require "json"
 require "open3"
 require "pathname"
 require_relative "node_version"
+require_relative "entrypoints"
 
 module RspackRails
   # Inspects a Rails app's rspack setup and reports what is missing.
@@ -91,17 +92,17 @@ module RspackRails
     end
 
     def entry_check
-      return Check.new(:ok, "Entry point", "app/javascript/application.js") if exist?("app/javascript/application.js")
+      return Check.new(:ok, "Entry points", entrypoints.keys.join(", ")) if entrypoints.any?
 
-      Check.new(:error, "Entry point", "app/javascript/application.js is missing",
-                "Create it, or point `entry` in rspack.config.mjs at your entry file")
+      Check.new(:error, "Entry points", "none found",
+                "Create app/javascript/application.js or a file in app/javascript/entrypoints/")
     end
 
     def build_check
-      built = @root.join("app/assets/builds/application.js")
-      return Check.new(:ok, "Build output", "app/assets/builds/application.js (#{built.size} bytes)") if built.exist?
+      missing = entrypoints.keys.reject { |name| exist?("app/assets/builds/#{name}.js") }
+      return Check.new(:ok, "Build output", "app/assets/builds has #{entrypoints.keys.join(", ")}") if missing.empty?
 
-      Check.new(:warn, "Build output", "app/assets/builds/application.js not built yet",
+      Check.new(:warn, "Build output", "not built yet: #{missing.join(", ")}",
                 "Run `bin/rails rspack:build` (only needed without the dev server)")
     end
 
@@ -186,6 +187,10 @@ module RspackRails
       nil
     end
 
+    def entrypoints
+      @entrypoints ||= Entrypoints.discover(@root)
+    end
+
     def package_manager
       @package_manager ||= PackageManager.detect(@root)
     end

data/lib/rspack_rails/entrypoints.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module RspackRails
+  # Mirrors the entry discovery in the generated rspack.config.mjs:
+  # app/javascript/application.{js,ts} plus every
+  # app/javascript/entrypoints/*.{js,ts}, named after the file.
+  module Entrypoints
+    EXTENSIONS = %w[js ts].freeze
+
+    module_function
+
+    # => { "application" => "app/javascript/application.js", "admin" => "app/javascript/entrypoints/admin.js" }
+    def discover(root)
+      root = Pathname(root)
+      entries = {}
+      main = EXTENSIONS.map { |ext| "app/javascript/application.#{ext}" }.find { |path| root.join(path).file? }
+      entries["application"] = main if main
+
+      Dir.glob("app/javascript/entrypoints/*.{#{EXTENSIONS.join(",")}}", base: root).sort.each do |path|
+        entries[File.basename(path, ".*")] = path
+      end
+      entries
+    end
+  end
+end

data/lib/rspack_rails/migration.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "json"
+require "pathname"
+
+module RspackRails
+  # Detects how an app bundles JavaScript today and works out what
+  # `rspack:migrate` has to change. Pure inspection: nothing here writes files.
+  class Migration
+    Pin = Struct.new(:name, :to, :version, keyword_init: true)
+
+    # importmap-only helpers with no npm equivalent.
+    IMPORTMAP_ONLY = %w[@hotwired/stimulus-loading].freeze
+
+    BUNDLER_PACKAGES = %w[esbuild webpack webpack-cli rollup @rollup/plugin-node-resolve
+                          @rollup/plugin-commonjs @rollup/plugin-terser].freeze
+    BUNDLER_CONFIGS = %w[webpack.config.js rollup.config.js rollup.config.mjs].freeze
+
+    attr_reader :root
+
+    def initialize(root)
+      @root = Pathname(root)
+    end
+
+    # :rspack, :shakapacker, :importmap, :jsbundling or :none
+    def source
+      @source ||= if file?("rspack.config.mjs") then :rspack
+                  elsif file?("config/shakapacker.yml") || file?("config/webpacker.yml") then :shakapacker
+                  elsif file?("config/importmap.rb") then :importmap
+                  elsif jsbundling? then :jsbundling
+                  else
+                    :none
+                  end
+    end
+
+    def pins
+      @pins ||= parse_pins(read("config/importmap.rb").to_s)
+    end
+
+    # { "package" => "version or nil" } for every pin that comes from npm. The version is
+    # known only when importmap recorded it (vendored "# @1.2.3" pins or jspm URLs); gem-served
+    # pins such as turbo-rails install the latest npm release.
+    def npm_packages
+      pins.reject { |pin| local_pin?(pin) || IMPORTMAP_ONLY.include?(pin.name) }
+          .to_h { |pin| [package_name(pin.name), pin.version] }
+    end
+
+    # The argument list for `npm install` / `yarn add`, versions pinned when known.
+    def npm_install_args
+      npm_packages.map { |name, version| version ? "#{name}@#{version}" : name }
+    end
+
+    # Vendored copies of packages that now come from npm.
+    def vendored_files
+      pins.reject { |pin| local_pin?(pin) }.filter_map do |pin|
+        path = "vendor/javascript/#{pin.to || "#{pin.name}.js"}"
+        path if file?(path)
+      end
+    end
+
+    def bundler_packages
+      dev = package_json.fetch("devDependencies", {}).keys + package_json.fetch("dependencies", {}).keys
+      dev & BUNDLER_PACKAGES
+    end
+
+    def bundler_configs
+      BUNDLER_CONFIGS.select { |path| file?(path) }
+    end
+
+    # jsbundling's esbuild default builds every file in app/javascript; rspack
+    # only builds application.* and entrypoints/*.
+    def extra_root_entries
+      Dir.glob("app/javascript/*.{js,ts}", base: root).sort.grep_v(%r{/application\.[jt]s\z})
+    end
+
+    def parse_pins(source)
+      source.each_line.filter_map do |line|
+        match = line.match(/^\s*pin\s+["']([^"']+)["'](.*)$/)
+        next unless match
+
+        rest = match[2]
+        to = rest[/to:\s*["']([^"']+)["']/, 1]
+        version = rest[/#\s*@(\S+)/, 1] || to.to_s[%r{npm:(?:@[^/]+/)?[^@/]+@([^/]+)/}, 1]
+        Pin.new(name: match[1], to: to, version: version)
+      end
+    end
+
+    private
+
+    def jsbundling?
+      read("Gemfile").to_s.match?(/^\s*gem\s+["']jsbundling-rails["']/) ||
+        package_json.dig("scripts", "build").to_s.match?(/\b(esbuild|webpack|rollup|bun build)\b/)
+    end
+
+    # A pin is app code when it, or the file it points to, lives in app/javascript.
+    def local_pin?(pin)
+      return true if pin.name == "application"
+
+      target = pin.to || "#{pin.name}.js"
+      return false if target.match?(%r{\Ahttps?://})
+
+      file?("app/javascript/#{target}")
+    end
+
+    # "@rails/actioncable/src" -> "@rails/actioncable", "lodash/debounce" -> "lodash"
+    def package_name(specifier)
+      parts = specifier.split("/")
+      specifier.start_with?("@") ? parts.first(2).join("/") : parts.first
+    end
+
+    def package_json
+      @package_json ||= file?("package.json") ? JSON.parse(read("package.json")) : {}
+    rescue JSON::ParserError
+      @package_json = {}
+    end
+
+    def file?(path)
+      root.join(path).file?
+    end
+
+    def read(path)
+      root.join(path).read if file?(path)
+    end
+  end
+end

data/lib/rspack_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RspackRails
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 end

data/lib/rspack_rails.rb

@@ -4,6 +4,8 @@ require_relative "rspack_rails/version"
 require_relative "rspack_rails/package_manager"
 require_relative "rspack_rails/configuration"
 require_relative "rspack_rails/dev_server"
+require_relative "rspack_rails/entrypoints"
+require_relative "rspack_rails/migration"
 
 # Rspack integration for Rails: rake tasks, installer and view helpers.
 module RspackRails

data/lib/tasks/rspack_rails.rake

@@ -24,6 +24,20 @@ namespace :rspack do
     end
   end
 
+  desc "Migrate from importmap-rails or jsbundling-rails to rspack (FORCE=1 to skip the clean git check)"
+  task :migrate do
+    dirty = system("git", "rev-parse", "--is-inside-work-tree", out: File::NULL, err: File::NULL) &&
+            !`git status --porcelain`.strip.empty?
+    if dirty && ENV["FORCE"].to_s.empty?
+      raise RspackRails::Error,
+            "rspack:migrate removes and rewrites files. Commit or stash your changes first, or run with FORCE=1."
+    end
+
+    template = File.expand_path("../install/migrate.rb", __dir__)
+    system(RbConfig.ruby, "./bin/rails", "app:template", "LOCATION=#{template}") ||
+      raise(RspackRails::Error, "rspack:migrate failed")
+  end
+
   desc "Check the rspack setup of this app"
   task doctor: :environment do
     require "rspack_rails/doctor"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspack_rails
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - tungnt
@@ -45,6 +45,7 @@ files:
 - lib/install/application.js
 - lib/install/dev
 - lib/install/install.rb
+- lib/install/migrate.rb
 - lib/install/package.json
 - lib/install/rspack.config.mjs
 - lib/install/stimulus.rb
@@ -57,7 +58,9 @@ files:
 - lib/rspack_rails/configuration.rb
 - lib/rspack_rails/dev_server.rb
 - lib/rspack_rails/doctor.rb
+- lib/rspack_rails/entrypoints.rb
 - lib/rspack_rails/helper.rb
+- lib/rspack_rails/migration.rb
 - lib/rspack_rails/node_version.rb
 - lib/rspack_rails/package_manager.rb
 - lib/rspack_rails/railtie.rb