react_on_rails 16.4.0.rc.7 → 16.4.0.rc.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a834e70a65aa260461effa652dcea303bc28acb1888b8f81176b190a1234359b
-  data.tar.gz: 11c61171bcc86b52fa4b376550183f28916894f84e212395a6ad88777195bd0b
+  metadata.gz: 8836b6e37dab21e6ee52f045e1f1dbb0ddce044107ce4ff6b48724ac57003bb9
+  data.tar.gz: 3deef582db0eccf9d692813848f8dc0e1f7c610f819497bb563fb6de0b5b2091
 SHA512:
-  metadata.gz: 42b6d70052957bda4047e034a44aaffdafe78fae4190f141b9c624294be1e685f0e4a1833b41db17605771bbca917ca05e78d22bd02090ac8cd56dee77065e0a
-  data.tar.gz: 158a713f868d6563a1f89eb0c4e2ddf355bbda5c6341df447648681588e1164ae93ca1941e8aa8a4844a8a57661bae4cbb31845aa9855229fff5559e134db432
+  metadata.gz: 38982dfff467e79045d3c6017a991f8dedac9c17abee867cb55197e2514cbe238317ec99ef89e5ad0c258a7d306bf8325ea1266926ae85a98111af1f759023fb
+  data.tar.gz: 124b251b8a0ca66b4f38a8d2990012690be96408c768a4f1081ad43f87c6d73b525a5bfd2de56d023a138288a28f5dbf6a6f988bdcbab8dd8bf7f1e2ea585be7

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    react_on_rails (16.4.0.rc.7)
+    react_on_rails (16.4.0.rc.8)
       addressable
       connection_pool
       execjs (~> 2.5)

data/lib/generators/react_on_rails/js_dependency_manager.rb

@@ -53,17 +53,19 @@ module ReactOnRails
     # to handle all JS dependency installation via package_json gem.
     module JsDependencyManager
       # Core React dependencies required for React on Rails
-      # Note: @babel/preset-react and babel plugins are NOT included here because:
-      # - Shakapacker handles JavaScript transpiler configuration (babel, swc, or esbuild)
-      # - Users configure their preferred transpiler via shakapacker.yml javascript_transpiler setting
-      # - SWC is now the default and doesn't need Babel presets
-      # - For Babel users, shakapacker will install babel-loader and its dependencies
+      # Note: @babel/preset-react is handled separately in BABEL_REACT_DEPENDENCIES
+      # and is added only when SWC is not the active transpiler.
       REACT_DEPENDENCIES = %w[
         react
         react-dom
         prop-types
       ].freeze
 
+      # Babel preset needed by the generated babel.config.js for non-SWC setups.
+      BABEL_REACT_DEPENDENCIES = %w[
+        @babel/preset-react
+      ].freeze
+
       # CSS processing dependencies for webpack
       CSS_DEPENDENCIES = %w[
         css-loader
@@ -144,12 +146,17 @@ module ReactOnRails
         add_react_dependencies
         add_css_dependencies
         add_rspack_dependencies if using_rspack?
-        add_swc_dependencies if using_swc?
+        add_transpiler_dependencies
         add_pro_dependencies if using_pro
         add_rsc_dependencies if using_rsc
         add_dev_dependencies
       end
 
+      def add_transpiler_dependencies
+        add_swc_dependencies if using_swc?
+        add_babel_react_dependencies if !using_swc? && !using_rspack?
+      end
+
       def add_react_on_rails_package
         # Use exact version match between gem and npm package for all versions including pre-releases
         # Ruby gem versions use dots (16.2.0.beta.10) but npm requires hyphens (16.2.0-beta.10)
@@ -289,6 +296,25 @@ module ReactOnRails
         MSG
       end
 
+      def add_babel_react_dependencies
+        puts "Installing Babel React preset dependency..."
+        return if add_packages(BABEL_REACT_DEPENDENCIES, dev: true)
+
+        GeneratorMessages.add_warning(<<~MSG.strip)
+          ⚠️  Failed to add Babel React preset dependency.
+
+          You can install it manually by running:
+            npm install --save-dev #{BABEL_REACT_DEPENDENCIES.join(' ')}
+        MSG
+      rescue StandardError => e
+        GeneratorMessages.add_warning(<<~MSG.strip)
+          ⚠️  Error adding Babel React preset dependency: #{e.message}
+
+          You can install it manually by running:
+            npm install --save-dev #{BABEL_REACT_DEPENDENCIES.join(' ')}
+        MSG
+      end
+
       def add_typescript_dependencies
         puts "Installing TypeScript dependencies..."
         return if add_packages(TYPESCRIPT_DEPENDENCIES, dev: true)

data/lib/react_on_rails/helper.rb

@@ -304,6 +304,8 @@ module ReactOnRails
           end
         end
 
+        add_csp_nonce_to_context(result)
+
         if defined?(request) && request.present?
           # Check for encoding of the request's original_url and try to force-encoding the
           # URLs as UTF-8. This situation can occur in browsers that do not encode the
@@ -341,6 +343,11 @@ module ReactOnRails
       @rails_context.merge(serverSide: server_side)
     end
 
+    def add_csp_nonce_to_context(result)
+      nonce = csp_nonce
+      result[:cspNonce] = nonce if nonce.present?
+    end
+
     def load_pack_for_generated_component(react_component_name, render_options)
       return unless render_options.auto_load_bundle
 

data/lib/react_on_rails/packer_utils.rb

@@ -1,15 +1,10 @@
 # frozen_string_literal: true
 
-require "erb"
 require "pathname"
 require "shakapacker"
-require "yaml"
 
 module ReactOnRails
-  # rubocop:disable Metrics/ModuleLength
   module PackerUtils
-    SHAKAPACKER_CONFIG_PATH = File.join("config", "shakapacker.yml")
-
     def self.dev_server_running?
       Shakapacker.dev_server.running?
     end
@@ -185,20 +180,21 @@ module ReactOnRails
     end
 
     def self.extract_precompile_hook
-      # Prefer using Shakapacker's runtime config when available.
-      # In bin/dev startup before Rails boots, this can raise (e.g., missing Rails.env),
-      # so we rescue and fall back to parsing config/shakapacker.yml directly.
-      hook_value = extract_precompile_hook_from_shakapacker_config
-      return hook_value unless hook_value.nil?
+      # Prefer the public API (available in Shakapacker 9.0+)
+      return ::Shakapacker.config.precompile_hook if ::Shakapacker.config.respond_to?(:precompile_hook)
+
+      # Fallback: access config data using private :data method
+      config_data = ::Shakapacker.config.send(:data)
 
-      extract_precompile_hook_from_yaml
+      # Try symbol keys first (Shakapacker's internal format), then fall back to string keys
+      config_data&.[](:precompile_hook) || config_data&.[]("precompile_hook")
     end
 
     # Regex pattern to detect pack generation in hook scripts
     # Matches both:
     # - The rake task: react_on_rails:generate_packs
-    # - The Ruby methods: generate_packs_if_stale / generate_packs_if_needed
-    GENERATE_PACKS_PATTERN = /\b(react_on_rails:generate_packs|generate_packs_if_stale|generate_packs_if_needed)\b/
+    # - The Ruby method: generate_packs_if_stale (used by generator template)
+    GENERATE_PACKS_PATTERN = /\b(react_on_rails:generate_packs|generate_packs_if_stale)\b/
 
     # Pattern to detect a real self-guard statement that exits early when
     # SHAKAPACKER_SKIP_PRECOMPILE_HOOK is true. This avoids false positives
@@ -221,7 +217,7 @@ module ReactOnRails
 
       # Check if it's a script file path
       script_path = resolve_hook_script_path(hook_value)
-      return false unless script_path
+      return false unless script_path && File.exist?(script_path)
 
       # Read and check script contents
       script_contents = File.read(script_path)
@@ -234,29 +230,20 @@ module ReactOnRails
     def self.resolve_hook_script_path(hook_value)
       return nil if hook_value.blank?
 
-      hook_path = hook_value.to_s.strip
-      return nil if hook_path.empty?
-
-      # Strip interpreter prefix (e.g., "ruby bin/hook" -> "bin/hook")
-      hook_path = extract_script_from_command(hook_path) || hook_path
-
-      # Hook value might be a script path relative to project root.
-      # project_root prefers Rails.root and otherwise derives from BUNDLE_GEMFILE or cwd.
-      potential_path = project_root.join(hook_path)
+      potential_path = project_root.join(hook_value.to_s.strip)
       potential_path if potential_path.file?
     end
 
-    # Extract the script path from an interpreter-prefixed command.
-    # e.g., "ruby bin/shakapacker-precompile-hook" -> "bin/shakapacker-precompile-hook"
-    # Returns nil if the value doesn't look like an interpreter-prefixed command.
-    def self.extract_script_from_command(command)
-      parts = command.strip.split(/\s+/, 2)
-      return nil unless parts.length == 2
+    def self.project_root
+      return Rails.root if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
 
-      interpreter = File.basename(parts[0])
-      return parts[1] if %w[ruby node bash sh].include?(interpreter)
+      bundle_gemfile = ENV.fetch("BUNDLE_GEMFILE", nil)
+      if bundle_gemfile && !bundle_gemfile.strip.empty?
+        gemfile_path = Pathname.new(bundle_gemfile).expand_path
+        return gemfile_path.dirname if gemfile_path.file?
+      end
 
-      nil
+      Pathname.new(Dir.pwd)
     end
 
     # Check if a hook script file contains the self-guard pattern that prevents
@@ -283,79 +270,5 @@ module ReactOnRails
     rescue StandardError
       nil
     end
-
-    def self.extract_precompile_hook_from_shakapacker_config
-      # Prefer the public API (available in Shakapacker 9.0+)
-      return ::Shakapacker.config.precompile_hook if ::Shakapacker.config.respond_to?(:precompile_hook)
-
-      # Fallback: access config data using private :data method
-      config_data = ::Shakapacker.config.send(:data)
-
-      # Try symbol keys first (Shakapacker's internal format), then fall back to string keys
-      if config_data&.key?(:precompile_hook)
-        config_data[:precompile_hook]
-      elsif config_data&.key?("precompile_hook")
-        config_data["precompile_hook"]
-      end
-    rescue StandardError
-      nil
-    end
-
-    def self.extract_precompile_hook_from_yaml
-      config_path = project_root.join(SHAKAPACKER_CONFIG_PATH)
-      return nil unless config_path.file?
-
-      yaml_content = ERB.new(File.read(config_path)).result
-      config_data = YAML.safe_load(yaml_content, permitted_classes: [Symbol], aliases: true) || {}
-
-      env_config = extract_hash_for_environment(config_data, current_shakapacker_environment)
-      return env_config["precompile_hook"] if env_config.key?("precompile_hook")
-      return env_config[:precompile_hook] if env_config.key?(:precompile_hook)
-
-      default_config = extract_hash_for_environment(config_data, "default")
-      return default_config["precompile_hook"] if default_config.key?("precompile_hook")
-      return default_config[:precompile_hook] if default_config.key?(:precompile_hook)
-
-      nil
-    rescue StandardError
-      nil
-    end
-
-    def self.extract_hash_for_environment(config_data, env_name)
-      value = config_data[env_name] || config_data[env_name.to_sym]
-      value.is_a?(Hash) ? value : {}
-    end
-
-    def self.current_shakapacker_environment
-      if defined?(Rails) && Rails.respond_to?(:env)
-        env = begin
-          Rails.env.to_s
-        rescue StandardError
-          nil
-        end
-        return env unless env.to_s.strip.empty?
-      end
-
-      rails_env = ENV.fetch("RAILS_ENV", nil)
-      return rails_env unless rails_env.to_s.strip.empty?
-
-      rack_env = ENV.fetch("RACK_ENV", nil)
-      return rack_env unless rack_env.to_s.strip.empty?
-
-      "development"
-    end
-
-    def self.project_root
-      return Rails.root if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
-
-      bundle_gemfile = ENV.fetch("BUNDLE_GEMFILE", nil)
-      if bundle_gemfile && !bundle_gemfile.strip.empty?
-        gemfile_path = Pathname.new(bundle_gemfile).expand_path
-        return gemfile_path.dirname if gemfile_path.file?
-      end
-
-      Pathname.new(Dir.pwd)
-    end
   end
-  # rubocop:enable Metrics/ModuleLength
 end

data/lib/react_on_rails/system_checker.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
+require "erb"
 require "open3"
+require "yaml"
 
 module ReactOnRails
   # SystemChecker provides validation methods for React on Rails setup
@@ -186,14 +188,13 @@ module ReactOnRails
       return unless File.exist?(package_json_path)
 
       package_json = JSON.parse(File.read(package_json_path))
-      npm_version = package_json.dig("dependencies", "react-on-rails") ||
-                    package_json.dig("devDependencies", "react-on-rails")
+      package_name, npm_version = react_on_rails_npm_package_details(package_json)
 
-      if npm_version
-        add_success("✅ react-on-rails NPM package #{npm_version} is declared")
+      if package_name
+        add_success("✅ #{package_name} NPM package #{npm_version} is declared")
       else
         add_warning(<<~MSG.strip)
-          ⚠️  react-on-rails NPM package not found in package.json.
+          ⚠️  Neither react-on-rails nor react-on-rails-pro NPM package found in package.json.
 
           Install it with:
           npm install react-on-rails
@@ -208,8 +209,7 @@ module ReactOnRails
 
       begin
         package_json = JSON.parse(File.read("package.json"))
-        npm_version = package_json.dig("dependencies", "react-on-rails") ||
-                      package_json.dig("devDependencies", "react-on-rails")
+        package_name, npm_version = react_on_rails_npm_package_details(package_json)
 
         return unless npm_version && defined?(ReactOnRails::VERSION)
 
@@ -221,7 +221,7 @@ module ReactOnRails
         gem_version = ReactOnRails::VERSION
 
         if normalized_npm_version == gem_version
-          add_success("✅ React on Rails gem and NPM package versions match (#{gem_version})")
+          add_success("✅ React on Rails gem and #{package_name} NPM package versions match (#{gem_version})")
           check_version_patterns(npm_version, gem_version)
         else
           # Check for major version differences
@@ -232,7 +232,7 @@ module ReactOnRails
             add_error(<<~MSG.strip)
               🚫 Major version mismatch detected:
               • Gem version: #{gem_version} (major: #{gem_major})
-              • NPM version: #{npm_version} (major: #{npm_major})
+              • #{package_name} version: #{npm_version} (major: #{npm_major})
 
               Major version differences can cause serious compatibility issues.
               Update both packages to use the same major version immediately.
@@ -241,7 +241,7 @@ module ReactOnRails
             add_warning(<<~MSG.strip)
               ⚠️  Version mismatch detected:
               • Gem version: #{gem_version}
-              • NPM version: #{npm_version}
+              • #{package_name} version: #{npm_version}
 
               Consider updating to exact, fixed matching versions of gem and npm package for best compatibility.
             MSG
@@ -341,7 +341,7 @@ module ReactOnRails
 
       begin
         package_json = JSON.parse(File.read("package.json"))
-        all_deps = package_json["dependencies"]&.merge(package_json["devDependencies"] || {}) || {}
+        all_deps = (package_json["dependencies"] || {}).merge(package_json["devDependencies"] || {})
         all_deps["webpack-bundle-analyzer"]
       rescue StandardError
         false
@@ -373,6 +373,14 @@ module ReactOnRails
 
     private
 
+    def react_on_rails_npm_package_details(package_json)
+      all_deps = (package_json["dependencies"] || {}).merge(package_json["devDependencies"] || {})
+      return ["react-on-rails-pro", all_deps["react-on-rails-pro"]] if all_deps["react-on-rails-pro"]
+      return ["react-on-rails", all_deps["react-on-rails"]] if all_deps["react-on-rails"]
+
+      [nil, nil]
+    end
+
     def node_missing?
       command = ReactOnRails::Utils.running_on_windows? ? "where" : "which"
       _stdout, _stderr, status = Open3.capture3(command, "node")
@@ -449,11 +457,53 @@ module ReactOnRails
     end
 
     def required_react_dependencies
-      {
+      deps = {
         "react" => "React library",
-        "react-dom" => "React DOM library",
-        "@babel/preset-react" => "Babel React preset"
+        "react-dom" => "React DOM library"
       }
+
+      deps["@babel/preset-react"] = "Babel React preset" if using_babel_transpiler?
+      deps
+    end
+
+    def using_babel_transpiler?
+      transpiler = detected_javascript_transpiler
+      return true if transpiler.nil?
+
+      transpiler == "babel"
+    end
+
+    def detected_javascript_transpiler
+      config = parsed_shakapacker_config
+      unless config
+        if File.exist?("config/shakapacker.yml")
+          add_info("ℹ️  Unable to parse config/shakapacker.yml — defaulting to Babel assumption")
+        end
+        return nil
+      end
+
+      rails_env = ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+      env_config = config[rails_env] || {}
+      default_config = config["default"] || {}
+      transpiler = env_config["javascript_transpiler"] || default_config["javascript_transpiler"]
+      normalize_transpiler_value(transpiler)
+    end
+
+    def parsed_shakapacker_config
+      shakapacker_config_path = "config/shakapacker.yml"
+      return nil unless File.exist?(shakapacker_config_path)
+
+      raw_content = File.read(shakapacker_config_path)
+      rendered_content = ERB.new(raw_content).result
+      parsed = YAML.safe_load(rendered_content, aliases: true)
+      parsed.is_a?(Hash) ? parsed : nil
+    rescue StandardError, ScriptError
+      nil
+    end
+
+    def normalize_transpiler_value(transpiler)
+      normalized = transpiler.to_s.strip.downcase
+      normalized.empty? ? nil : normalized
     end
 
     def additional_build_dependencies
@@ -468,10 +518,10 @@ module ReactOnRails
       }
     end
 
-    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/CyclomaticComplexity
     def check_build_dependencies(package_json)
       build_deps = additional_build_dependencies
-      all_deps = package_json["dependencies"]&.merge(package_json["devDependencies"] || {}) || {}
+      all_deps = (package_json["dependencies"] || {}).merge(package_json["devDependencies"] || {})
 
       present_deps = []
       missing_deps = []
@@ -496,7 +546,7 @@ module ReactOnRails
       suffix = missing_deps.length > 3 ? "..." : ""
       add_info("ℹ️  Optional build dependencies: #{short_list}#{suffix}")
     end
-    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/CyclomaticComplexity
 
     def parse_package_json
       JSON.parse(File.read("package.json"))
@@ -506,12 +556,12 @@ module ReactOnRails
     end
 
     def find_missing_dependencies(package_json, required_deps)
-      all_deps = package_json["dependencies"]&.merge(package_json["devDependencies"] || {}) || {}
+      all_deps = (package_json["dependencies"] || {}).merge(package_json["devDependencies"] || {})
       required_deps.keys.reject { |dep| all_deps[dep] }
     end
 
     def report_dependency_status(required_deps, missing_deps, package_json)
-      all_deps = package_json["dependencies"]&.merge(package_json["devDependencies"] || {}) || {}
+      all_deps = (package_json["dependencies"] || {}).merge(package_json["devDependencies"] || {})
 
       required_deps.each do |dep, description|
         add_success("✅ #{description} (#{dep}) is installed") if all_deps[dep]
@@ -572,7 +622,7 @@ module ReactOnRails
     end
 
     def report_dependency_versions(package_json)
-      all_deps = package_json["dependencies"]&.merge(package_json["devDependencies"] || {}) || {}
+      all_deps = (package_json["dependencies"] || {}).merge(package_json["devDependencies"] || {})
 
       react_version = all_deps["react"]
       react_dom_version = all_deps["react-dom"]
@@ -643,7 +693,7 @@ module ReactOnRails
 
       begin
         package_json = JSON.parse(File.read("package.json"))
-        all_deps = package_json["dependencies"]&.merge(package_json["devDependencies"] || {}) || {}
+        all_deps = (package_json["dependencies"] || {}).merge(package_json["devDependencies"] || {})
 
         webpack_version = all_deps["webpack"]
         add_info("📦 Webpack version: #{webpack_version}") if webpack_version

data/lib/react_on_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ReactOnRails
-  VERSION = "16.4.0.rc.7"
+  VERSION = "16.4.0.rc.8"
 end

data/rakelib/update_changelog.rake

@@ -1,19 +1,278 @@
 # frozen_string_literal: true
 
+require "date"
 require "English"
 require "bundler"
+require "open3"
 require_relative "task_helpers"
 
 CLAUDE_CODE_TIP = <<~TIP
   ┌─────────────────────────────────────────────────────────────────────────────┐
-  │ TIP: This task only adds version headers and links, not changelog entries. │
-  │ For full automation, run /update-changelog in Claude Code.                 │
+  │ TIP: This task adds version headers and links, not changelog entry text.   │
+  │ For full commit analysis + entry writing, run /update-changelog in Claude. │
   │                                                                             │
   │ After running this task, manually add entries under the new header:        │
   │   #### Fixed / #### Added / #### Changed / etc.                            │
   └─────────────────────────────────────────────────────────────────────────────┘
 TIP
 
+def monorepo_root_for_changelog
+  File.expand_path("../..", __dir__)
+end
+
+def prerelease_version?(version)
+  version.to_s.match?(/\.(test|beta|alpha|rc|pre)\./i)
+end
+
+def normalize_version_string(version_or_tag)
+  version = version_or_tag.to_s.strip
+  version = version.delete_prefix("v")
+  version = version.sub(/-(test|beta|alpha|rc|pre)\./i, '.\1.')
+
+  unless version.match?(/\A\d+\.\d+\.\d+(\.(test|beta|alpha|rc|pre)\.\d+)?\z/i)
+    abort "Failed to parse version from #{version_or_tag.inspect}. Expected format like 16.4.0 or 16.4.0.rc.1."
+  end
+
+  version.downcase
+end
+
+def parse_release_tag_to_version(tag)
+  version_pattern = /\d+\.\d+\.\d+(?:\.(?:test|beta|alpha|rc|pre)\.\d+)?|\d+\.\d+\.\d+-(?:test|beta|alpha|rc|pre)\.\d+/
+  tag_match = tag.to_s.strip.match(/\Av(?<version>#{version_pattern})\z/i)
+  return nil unless tag_match
+
+  normalize_version_string(tag_match[:version])
+rescue SystemExit
+  nil
+end
+
+def fetch_git_tags!(monorepo_root)
+  remotes_output, remotes_status = Open3.capture2e("git", "-C", monorepo_root, "remote")
+  abort "Failed to list git remotes.\n#{remotes_output}" unless remotes_status.success?
+
+  remote_names = remotes_output.lines.map(&:strip).reject(&:empty?)
+  return if remote_names.empty?
+
+  remote_name = remote_names.include?("origin") ? "origin" : remote_names.first
+  fetch_output, fetch_status = Open3.capture2e("git", "-C", monorepo_root, "fetch", remote_name, "--tags", "--quiet")
+  abort "Failed to fetch git tags from #{remote_name}.\n#{fetch_output}" unless fetch_status.success?
+end
+
+def tag_versions(monorepo_root)
+  tags_output, status = Open3.capture2e("git", "-C", monorepo_root, "tag", "-l", "v*")
+  abort "Failed to list git tags.\n#{tags_output}" unless status.success?
+
+  tags_output.lines.map(&:strip).filter_map { |tag| parse_release_tag_to_version(tag) }.uniq
+end
+
+def stable_tag_versions(monorepo_root)
+  tag_versions(monorepo_root).reject { |version| prerelease_version?(version) }
+end
+
+def latest_stable_tag_version(monorepo_root)
+  versions = stable_tag_versions(monorepo_root)
+  abort "Failed to compute latest stable tag: no stable v* tags found." if versions.empty?
+
+  versions.max_by { |version| Gem::Version.new(version) }
+end
+
+def extract_unreleased_section(changelog)
+  lines = changelog.lines
+  start_index = lines.index { |line| line.start_with?("### [Unreleased]") }
+  abort "Failed to find '### [Unreleased]' in CHANGELOG.md" unless start_index
+
+  end_index = ((start_index + 1)...lines.length).find { |idx| lines[idx].start_with?("### [") } || lines.length
+  lines[start_index...end_index].join
+end
+
+def inferred_bump_type_from_unreleased(changelog)
+  section = extract_unreleased_section(changelog)
+  return :major if section.match?(/^####\s+(?:⚠️\s*)?Breaking(?:\s+Changes?)?\b/i)
+  return :minor if section.match?(/^####\s+(Added|New\s+Features?|Features?|Enhancements?)\b/i)
+  return :patch if section.match?(/^####\s+(Fixed|Fixes|Bug\s+Fixes?|Security|Improved|Changed|Deprecated|Removed)\b/i)
+
+  :patch
+end
+
+def bump_stable_version(version, bump_type)
+  match = version.match(/\A(\d+)\.(\d+)\.(\d+)\z/)
+  abort "Failed to bump version: stable version #{version.inspect} is invalid." unless match
+
+  major = match[1].to_i
+  minor = match[2].to_i
+  patch = match[3].to_i
+
+  case bump_type
+  when :major
+    "#{major + 1}.0.0"
+  when :minor
+    "#{major}.#{minor + 1}.0"
+  else
+    "#{major}.#{minor}.#{patch + 1}"
+  end
+end
+
+def prerelease_indices_from_tags(monorepo_root, base_version, channel)
+  tags_output, status = Open3.capture2e("git", "-C", monorepo_root, "tag", "-l", "v#{base_version}*")
+  abort "Failed to list prerelease tags.\n#{tags_output}" unless status.success?
+
+  tags_output.lines.map(&:strip).filter_map do |tag|
+    normalized_version = parse_release_tag_to_version(tag)
+    match = normalized_version&.match(/\A#{Regexp.escape(base_version)}\.#{channel}\.(\d+)\z/i)
+    match&.captures&.first&.to_i
+  end
+end
+
+def prerelease_indices_from_changelog(changelog, base_version, channel)
+  changelog.scan(/^### \[#{Regexp.escape(base_version)}\.#{channel}\.(\d+)\]/i).flatten.map(&:to_i)
+end
+
+def parse_changelog_sections(changelog)
+  lines = changelog.lines
+  headers = []
+  lines.each_with_index do |line, index|
+    match = line.match(/^### \[([^\]]+)\].*$/)
+    headers << { index: index, version: match[1], header: line } if match
+  end
+
+  return { prefix: changelog, sections: [] } if headers.empty?
+
+  prefix = lines[0...headers.first[:index]].join
+  sections = headers.each_with_index.map do |header, section_index|
+    section_end = if section_index + 1 < headers.length
+                    headers[section_index + 1][:index]
+                  else
+                    lines.length
+                  end
+
+    {
+      version: header[:version],
+      header: header[:header],
+      body: lines[(header[:index] + 1)...section_end].join
+    }
+  end
+
+  { prefix: prefix, sections: sections }
+end
+
+def render_changelog_sections(prefix, sections)
+  "#{prefix}#{sections.map { |section| "#{section[:header]}#{section[:body]}" }.join}"
+end
+
+def changelog_versions(changelog)
+  parse_changelog_sections(changelog)[:sections]
+    .map { |section| section[:version] }
+    .reject { |version| version == "Unreleased" }
+    .map { |version| normalize_version_string(version) }
+end
+
+def prerelease_base_version(version)
+  version.to_s.sub(/\.(test|beta|alpha|rc|pre)\.\d+\z/i, "")
+end
+
+def active_prerelease_base_version(monorepo_root, changelog)
+  latest_stable = latest_stable_tag_version(monorepo_root)
+  prerelease_bases = (tag_versions(monorepo_root) + changelog_versions(changelog))
+                     .uniq
+                     .select { |version| prerelease_version?(version) }
+                     .map { |version| prerelease_base_version(version) }
+                     .select do |base_version|
+                       Gem::Version.new(base_version) > Gem::Version.new(latest_stable)
+                     end
+                     .uniq
+
+  prerelease_bases.max_by { |base_version| Gem::Version.new(base_version) }
+end
+
+def collapse_prerelease_series(changelog, base_version)
+  %w[test beta alpha rc pre].reduce(changelog) do |current_changelog, channel|
+    collapse_prerelease_sections(current_changelog, base_version, channel)
+  end
+end
+
+def prepare_changelog_for_auto_version(changelog, monorepo_root)
+  active_base_version = active_prerelease_base_version(monorepo_root, changelog)
+  return changelog unless active_base_version
+
+  collapse_prerelease_series(changelog, active_base_version)
+end
+
+def changelog_section_blocks(section_body)
+  block_lines = []
+  blocks = []
+
+  section_body.lines.each do |line|
+    normalized_line = line.rstrip
+    if normalized_line.match?(/^####+\s+/) && !block_lines.empty?
+      blocks << normalize_changelog_block(block_lines)
+      block_lines = [normalized_line]
+    else
+      block_lines << normalized_line
+    end
+  end
+
+  blocks << normalize_changelog_block(block_lines) unless block_lines.empty?
+  blocks.reject(&:empty?)
+end
+
+def normalize_changelog_block(lines)
+  normalized_lines = lines.map(&:rstrip)
+  normalized_lines.shift while normalized_lines.first == ""
+  normalized_lines.pop while normalized_lines.last == ""
+  normalized_lines.join("\n")
+end
+
+# rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+def collapse_prerelease_sections(changelog, base_version, channel)
+  parsed = parse_changelog_sections(changelog)
+  sections = parsed[:sections]
+  unreleased_section = sections.find { |section| section[:version] == "Unreleased" }
+  return changelog unless unreleased_section
+
+  target_regex = /\A#{Regexp.escape(base_version)}\.#{channel}\.\d+\z/i
+  matching_sections = sections.select { |section| section[:version].match?(target_regex) }
+  return changelog if matching_sections.empty?
+
+  merged_body = matching_sections
+                .flat_map { |section| changelog_section_blocks(section[:body]) }
+                .uniq
+                .join("\n\n")
+                .strip
+  sections.reject! { |section| section[:version].match?(target_regex) }
+
+  unless merged_body.empty?
+    unreleased_body = unreleased_section[:body].rstrip
+    unreleased_section[:body] = if unreleased_body.empty?
+                                  "#{merged_body}\n"
+                                else
+                                  "#{unreleased_body}\n\n#{merged_body}\n"
+                                end
+  end
+
+  render_changelog_sections(parsed[:prefix], sections)
+end
+# rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+def compute_auto_version(changelog, mode, monorepo_root, changelog_for_bump: changelog)
+  bump_type = inferred_bump_type_from_unreleased(changelog_for_bump)
+  latest_stable = latest_stable_tag_version(monorepo_root)
+  base_version = bump_stable_version(latest_stable, bump_type)
+
+  return base_version if mode == "release"
+
+  indices = prerelease_indices_from_tags(monorepo_root, base_version, mode) +
+            prerelease_indices_from_changelog(changelog, base_version, mode)
+  next_index = indices.empty? ? 0 : indices.max + 1
+  "#{base_version}.#{mode}.#{next_index}"
+end
+
+def fetch_git_tag_date(monorepo_root, git_tag)
+  output, status = Open3.capture2e("git", "-C", monorepo_root, "show", "-s", "--format=%cs", git_tag)
+  return nil unless status.success?
+
+  output.split("\n").last&.strip
+end
+
 # Update the compare links at the bottom of the changelog
 # version: version string without 'v' prefix (e.g., "16.2.0.beta.20")
 # anchor: markdown anchor (e.g., "[16.2.0.beta.20]")
@@ -39,26 +298,64 @@ def insert_version_header(changelog, anchor, tag_date)
   false
 end
 
-desc "Updates CHANGELOG.md inserting headers for the new version (headers only, not content).
-Argument: Git tag. Defaults to the latest tag.
+desc "Updates CHANGELOG.md by inserting a version header and compare links.
+Argument: Mode (`release`, `rc`, `beta`) or explicit git tag/version.
+
+Modes:
+  - release: auto-compute next stable version from Unreleased section headings
+  - rc: auto-compute next RC version and collapse prior RC sections of same base version
+  - beta: auto-compute next beta version and collapse prior beta sections of same base version
+
+Explicit argument examples:
+  - v16.4.0.rc.6
+  - 16.4.0.rc.6
+
+No argument: use latest git tag.
 TIP: Use /update-changelog in Claude Code for full automation."
 
-task :update_changelog, %i[tag] do |_, args|
+# rubocop:disable Metrics/BlockLength
+task :update_changelog, %i[mode_or_tag] do |_, args|
   puts CLAUDE_CODE_TIP
 
-  # Git tags use 'v' prefix (e.g., v16.2.0), but CHANGELOG uses versions without it
-  git_tag = args[:tag] || `git describe --tags --abbrev=0`.strip
-  changelog_version = git_tag.delete_prefix("v")
-  anchor = "[#{changelog_version}]"
-  changelog = File.read("CHANGELOG.md")
+  monorepo_root = monorepo_root_for_changelog
+  changelog_path = File.join(monorepo_root, "CHANGELOG.md")
+  changelog = File.read(changelog_path)
+  input = args[:mode_or_tag].to_s.strip
+  auto_mode = %w[release rc beta].find { |mode| mode == input.downcase }
 
-  if changelog.include?(anchor)
-    puts "Tag #{git_tag} is already documented in CHANGELOG.md"
-    next
+  if auto_mode
+    fetch_git_tags!(monorepo_root)
+    prepared_changelog = prepare_changelog_for_auto_version(changelog, monorepo_root)
+    changelog_version = compute_auto_version(
+      changelog,
+      auto_mode,
+      monorepo_root,
+      changelog_for_bump: prepared_changelog
+    )
+    changelog = prepared_changelog
+    tag_date = Date.today.strftime("%Y-%m-%d")
+    puts "Auto-computed #{auto_mode} version: #{changelog_version}"
+  else
+    git_tag = if input.empty?
+                git_output, git_status = Open3.capture2e("git", "-C", monorepo_root, "describe", "--tags", "--abbrev=0")
+                abort "Failed to get latest git tag.\n#{git_output}" unless git_status.success?
+                git_output.strip
+              else
+                input
+              end
+
+    changelog_version = normalize_version_string(git_tag)
+    tag_candidates = [git_tag, git_tag.start_with?("v") ? git_tag : "v#{git_tag}", "v#{changelog_version}"].uniq
+    tag_date = tag_candidates.filter_map { |candidate| fetch_git_tag_date(monorepo_root, candidate) }.first ||
+               Date.today.strftime("%Y-%m-%d")
   end
 
-  tag_date = `git show -s --format=%cs #{git_tag} 2>&1`.split("\n").last&.strip
-  abort("Failed to find tag #{git_tag}") unless $CHILD_STATUS.success? && tag_date
+  anchor = "[#{changelog_version}]"
+  header = "### #{anchor}"
+  if changelog.include?(header)
+    puts "Version #{changelog_version} is already documented in CHANGELOG.md"
+    next
+  end
 
   unless insert_version_header(changelog, anchor, tag_date)
     abort("Failed to insert version header: could not find '### [Unreleased]' " \
@@ -67,7 +364,8 @@ task :update_changelog, %i[tag] do |_, args|
 
   update_changelog_links(changelog, changelog_version, anchor)
 
-  File.write("CHANGELOG.md", changelog)
-  puts "Updated CHANGELOG.md with version header for #{git_tag}"
+  File.write(changelog_path, changelog)
+  puts "Updated CHANGELOG.md with version header for #{changelog_version}"
   puts "NOTE: You still need to write the changelog entries manually."
 end
+# rubocop:enable Metrics/BlockLength

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: react_on_rails
 version: !ruby/object:Gem::Version
-  version: 16.4.0.rc.7
+  version: 16.4.0.rc.8
 platform: ruby
 authors:
 - Justin Gordon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-03-09 00:00:00.000000000 Z
+date: 2026-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable